From 77e34b2ecb5f9de271ceb9ccaa176bb5494e1f37 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Tue, 26 Jul 2022 13:23:52 -0700 Subject: [PATCH 01/24] init PR for trajectory based model --- mbrl/models/traj_based_mlp.py | 396 ++++++++++++++++++++ mbrl/planning/linear_feedback.py | 66 ++++ notebooks/traj_based_model.ipynb | 598 +++++++++++++++++++++++++++++++ 3 files changed, 1060 insertions(+) create mode 100644 mbrl/models/traj_based_mlp.py create mode 100644 mbrl/planning/linear_feedback.py create mode 100644 notebooks/traj_based_model.ipynb diff --git a/mbrl/models/traj_based_mlp.py b/mbrl/models/traj_based_mlp.py new file mode 100644 index 00000000..366d286c --- /dev/null +++ b/mbrl/models/traj_based_mlp.py @@ -0,0 +1,396 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +import pathlib +from typing import Any, Dict, List, Optional, Sequence, Tuple, Union + +import hydra +import omegaconf +import torch +from torch import nn as nn +from torch.nn import functional as F + +import mbrl.util.math +from .gaussian_mlp import GaussianMLP +from .util import EnsembleLinearLayer, truncated_normal_init + + +class TrajBasedMLP(GaussianMLP): + """Implements an [optionally] ensemble of multi-layer perceptrons each modeling a Gaussian distribution, with the trajectory based parametrization. + + This model corresponds to a trajectory-based model in the Lambert et al., + CDC 2021 paper https://arxiv.org/abs/2012.09156. The core functionality is to change the prediction paradigm from + + s' = f(s,a) to s' = f(s0, t, theta) + + It predicts per output mean and log variance, and its weights are updated using a Gaussian + negative log likelihood loss. The log variance is bounded between learned ``min_log_var`` + and ``max_log_var`` parameters, trained as explained in Appendix A.1 of the paper. + + This class can also be used to build an ensemble of GaussianMLP models, by setting + ``ensemble_size > 1`` in the constructor. Then, a single forward pass can be used to evaluate + multiple independent MLPs at the same time. When this mode is active, the constructor will + set ``self.num_members = ensemble_size``. + + For the ensemble variant, uncertainty propagation methods are available that can be used + to aggregate the outputs of the different models in the ensemble. + Valid propagation options are: + + TODO(NOL) look into these propagation methods for traj-based model (they at least don't need steps, whcih is different) + + - "random_model": for each output in the batch a model will be chosen at random. + This corresponds to TS1 propagation in the PETS paper. + - "fixed_model": for output j-th in the batch, the model will be chosen according to + the model index in `propagation_indices[j]`. This can be used to implement TSinf + propagation, described in the PETS paper. + - "expectation": the output for each element in the batch will be the mean across + models. + + The default value of ``None`` indicates that no uncertainty propagation, and the forward + method returns all outputs of all models. + + Args: + in_size (int): size of model input. + out_size (int): size of model output. + device (str or torch.device): the device to use for the model. + num_layers (int): the number of layers in the model + (e.g., if ``num_layers == 3``, then model graph looks like + input -h1-> -h2-> -l3-> output). + ensemble_size (int): the number of members in the ensemble. Defaults to 1. + hid_size (int): the size of the hidden layers (e.g., size of h1 and h2 in the graph above). + deterministic (bool): if ``True``, the model will be trained using MSE loss and no + logvar prediction will be done. Defaults to ``False``. + propagation_method (str, optional): the uncertainty propagation method to use (see + above). Defaults to ``None``. + learn_logvar_bounds (bool): if ``True``, the logvar bounds will be learned, otherwise + they will be constant. Defaults to ``False``. + activation_fn_cfg (dict or omegaconf.DictConfig, optional): configuration of the + desired activation function. Defaults to torch.nn.ReLU when ``None``. + """ + + def __init__( + self, + in_size: int, + out_size: int, + device: Union[str, torch.device], + num_layers: int = 4, + ensemble_size: int = 1, + hid_size: int = 200, + deterministic: bool = False, + propagation_method: Optional[str] = None, + learn_logvar_bounds: bool = False, + activation_fn_cfg: Optional[Union[Dict, omegaconf.DictConfig]] = None, + ): + super().__init__( + ensemble_size, device, propagation_method, deterministic=deterministic + ) + + self.in_size = in_size + self.out_size = out_size + + def create_activation(): + if activation_fn_cfg is None: + activation_func = nn.ReLU() + else: + # Handle the case where activation_fn_cfg is a dict + cfg = omegaconf.OmegaConf.create(activation_fn_cfg) + activation_func = hydra.utils.instantiate(cfg) + return activation_func + + def create_linear_layer(l_in, l_out): + return EnsembleLinearLayer(ensemble_size, l_in, l_out) + + hidden_layers = [ + nn.Sequential(create_linear_layer(in_size, hid_size), create_activation()) + ] + for i in range(num_layers - 1): + hidden_layers.append( + nn.Sequential( + create_linear_layer(hid_size, hid_size), + create_activation(), + ) + ) + self.hidden_layers = nn.Sequential(*hidden_layers) + + if deterministic: + self.mean_and_logvar = create_linear_layer(hid_size, out_size) + else: + self.mean_and_logvar = create_linear_layer(hid_size, 2 * out_size) + self.min_logvar = nn.Parameter( + -10 * torch.ones(1, out_size), requires_grad=learn_logvar_bounds + ) + self.max_logvar = nn.Parameter( + 0.5 * torch.ones(1, out_size), requires_grad=learn_logvar_bounds + ) + + self.apply(truncated_normal_init) + self.to(self.device) + + self.elite_models: List[int] = None + + def _maybe_toggle_layers_use_only_elite(self, only_elite: bool): + if self.elite_models is None: + return + if self.num_members > 1 and only_elite: + for layer in self.hidden_layers: + # each layer is (linear layer, activation_func) + layer[0].set_elite(self.elite_models) + layer[0].toggle_use_only_elite() + self.mean_and_logvar.set_elite(self.elite_models) + self.mean_and_logvar.toggle_use_only_elite() + + def _default_forward( + self, x: torch.Tensor, only_elite: bool = False, **_kwargs + ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]: + self._maybe_toggle_layers_use_only_elite(only_elite) + x = self.hidden_layers(x) + mean_and_logvar = self.mean_and_logvar(x) + self._maybe_toggle_layers_use_only_elite(only_elite) + if self.deterministic: + return mean_and_logvar, None + else: + mean = mean_and_logvar[..., : self.out_size] + logvar = mean_and_logvar[..., self.out_size :] + logvar = self.max_logvar - F.softplus(self.max_logvar - logvar) + logvar = self.min_logvar + F.softplus(logvar - self.min_logvar) + return mean, logvar + + def _forward_from_indices( + self, x: torch.Tensor, model_shuffle_indices: torch.Tensor + ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]: + _, batch_size, _ = x.shape + + num_models = ( + len(self.elite_models) if self.elite_models is not None else len(self) + ) + shuffled_x = x[:, model_shuffle_indices, ...].view( + num_models, batch_size // num_models, -1 + ) + + mean, logvar = self._default_forward(shuffled_x, only_elite=True) + # note that mean and logvar are shuffled + mean = mean.view(batch_size, -1) + mean[model_shuffle_indices] = mean.clone() # invert the shuffle + + if logvar is not None: + logvar = logvar.view(batch_size, -1) + logvar[model_shuffle_indices] = logvar.clone() # invert the shuffle + + return mean, logvar + + def _forward_ensemble( + self, + x: torch.Tensor, + rng: Optional[torch.Generator] = None, + propagation_indices: Optional[torch.Tensor] = None, + ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]: + if self.propagation_method is None: + mean, logvar = self._default_forward(x, only_elite=False) + if self.num_members == 1: + mean = mean[0] + logvar = logvar[0] if logvar is not None else None + return mean, logvar + assert x.ndim == 2 + model_len = ( + len(self.elite_models) if self.elite_models is not None else len(self) + ) + if x.shape[0] % model_len != 0: + raise ValueError( + f"GaussianMLP ensemble requires batch size to be a multiple of the " + f"number of models. Current batch size is {x.shape[0]} for " + f"{model_len} models." + ) + x = x.unsqueeze(0) + if self.propagation_method == "random_model": + # passing generator causes segmentation fault + # see https://github.com/pytorch/pytorch/issues/44714 + model_indices = torch.randperm(x.shape[1], device=self.device) + return self._forward_from_indices(x, model_indices) + if self.propagation_method == "fixed_model": + if propagation_indices is None: + raise ValueError( + "When using propagation='fixed_model', `propagation_indices` must be provided." + ) + return self._forward_from_indices(x, propagation_indices) + if self.propagation_method == "expectation": + mean, logvar = self._default_forward(x, only_elite=True) + return mean.mean(dim=0), logvar.mean(dim=0) + raise ValueError(f"Invalid propagation method {self.propagation_method}.") + + def forward( # type: ignore + self, + x: torch.Tensor, + rng: Optional[torch.Generator] = None, + propagation_indices: Optional[torch.Tensor] = None, + use_propagation: bool = True, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """Computes mean and logvar predictions for the given input. + + When ``self.num_members > 1``, the model supports uncertainty propagation options + that can be used to aggregate the outputs of the different models in the ensemble. + Valid propagation options are: + + - "random_model": for each output in the batch a model will be chosen at random. + This corresponds to TS1 propagation in the PETS paper. + - "fixed_model": for output j-th in the batch, the model will be chosen according to + the model index in `propagation_indices[j]`. This can be used to implement TSinf + propagation, described in the PETS paper. + - "expectation": the output for each element in the batch will be the mean across + models. + + If a set of elite models has been indicated (via :meth:`set_elite()`), then all + propagation methods will operate with only on the elite set. This has no effect when + ``propagation is None``, in which case the forward pass will return one output for + each model. + + Args: + x (tensor): the input to the model. When ``self.propagation is None``, + the shape must be ``E x B x Id`` or ``B x Id``, where ``E``, ``B`` + and ``Id`` represent ensemble size, batch size, and input dimension, + respectively. In this case, each model in the ensemble will get one slice + from the first dimension (e.g., the i-th ensemble member gets ``x[i]``). + + For other values of ``self.propagation`` (and ``use_propagation=True``), + the shape must be ``B x Id``. + rng (torch.Generator, optional): random number generator to use for "random_model" + propagation. + propagation_indices (tensor, optional): propagation indices to use, + as generated by :meth:`sample_propagation_indices`. Ignore if + `use_propagation == False` or `self.propagation_method != "fixed_model". + use_propagation (bool): if ``False``, the propagation method will be ignored + and the method will return outputs for all models. Defaults to ``True``. + + Returns: + (tuple of two tensors): the predicted mean and log variance of the output. If + ``propagation is not None``, the output will be 2-D (batch size, and output dimension). + Otherwise, the outputs will have shape ``E x B x Od``, where ``Od`` represents + output dimension. + + Note: + For efficiency considerations, the propagation method used by this class is an + approximate version of that described by Chua et al. In particular, instead of + sampling models independently for each input in the batch, we ensure that each + model gets exactly the same number of samples (which are assigned randomly + with equal probability), resulting in a smaller batch size which we use for the forward + pass. If this is a concern, consider using ``propagation=None``, and passing + the output to :func:`mbrl.util.math.propagate`. + + """ + if use_propagation: + return self._forward_ensemble( + x, rng=rng, propagation_indices=propagation_indices + ) + return self._default_forward(x) + + def _mse_loss(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tensor: + assert model_in.ndim == target.ndim + if model_in.ndim == 2: # add model dimension + model_in = model_in.unsqueeze(0) + target = target.unsqueeze(0) + pred_mean, _ = self.forward(model_in, use_propagation=False) + return F.mse_loss(pred_mean, target, reduction="none").sum((1, 2)).sum() + + def _nll_loss(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tensor: + assert model_in.ndim == target.ndim + if model_in.ndim == 2: # add ensemble dimension + model_in = model_in.unsqueeze(0) + target = target.unsqueeze(0) + pred_mean, pred_logvar = self.forward(model_in, use_propagation=False) + if target.shape[0] != self.num_members: + target = target.repeat(self.num_members, 1, 1) + nll = ( + mbrl.util.math.gaussian_nll(pred_mean, pred_logvar, target, reduce=False) + .mean((1, 2)) # average over batch and target dimension + .sum() + ) # sum over ensemble dimension + nll += 0.01 * (self.max_logvar.sum() - self.min_logvar.sum()) + return nll + + def loss( + self, + model_in: torch.Tensor, + target: Optional[torch.Tensor] = None, + ) -> Tuple[torch.Tensor, Dict[str, Any]]: + """Computes Gaussian NLL loss. + + It also includes terms for ``max_logvar`` and ``min_logvar`` with small weights, + with positive and negative signs, respectively. + + This function returns no metadata, so the second output is set to an empty dict. + + Args: + model_in (tensor): input tensor. The shape must be ``E x B x Id``, or ``B x Id`` + where ``E``, ``B`` and ``Id`` represent ensemble size, batch size, and input + dimension, respectively. + target (tensor): target tensor. The shape must be ``E x B x Id``, or ``B x Od`` + where ``E``, ``B`` and ``Od`` represent ensemble size, batch size, and output + dimension, respectively. + + Returns: + (tensor): a loss tensor representing the Gaussian negative log-likelihood of + the model over the given input/target. If the model is an ensemble, returns + the average over all models. + """ + if self.deterministic: + return self._mse_loss(model_in, target), {} + else: + return self._nll_loss(model_in, target), {} + + def eval_score( # type: ignore + self, model_in: torch.Tensor, target: Optional[torch.Tensor] = None + ) -> Tuple[torch.Tensor, Dict[str, Any]]: + """Computes the squared error for the model over the given input/target. + + When model is not an ensemble, this is equivalent to + `F.mse_loss(model(model_in, target), reduction="none")`. If the model is ensemble, + then return is batched over the model dimension. + + This function returns no metadata, so the second output is set to an empty dict. + + Args: + model_in (tensor): input tensor. The shape must be ``B x Id``, where `B`` and ``Id`` + batch size, and input dimension, respectively. + target (tensor): target tensor. The shape must be ``B x Od``, where ``B`` and ``Od`` + represent batch size, and output dimension, respectively. + + Returns: + (tensor): a tensor with the squared error per output dimension, batched over model. + """ + assert model_in.ndim == 2 and target.ndim == 2 + with torch.no_grad(): + pred_mean, _ = self.forward(model_in, use_propagation=False) + target = target.repeat((self.num_members, 1, 1)) + return F.mse_loss(pred_mean, target, reduction="none"), {} + + def sample_propagation_indices( + self, batch_size: int, _rng: torch.Generator + ) -> torch.Tensor: + model_len = ( + len(self.elite_models) if self.elite_models is not None else len(self) + ) + if batch_size % model_len != 0: + raise ValueError( + "To use GaussianMLP's ensemble propagation, the batch size must " + "be a multiple of the number of models in the ensemble." + ) + # rng causes segmentation fault, see https://github.com/pytorch/pytorch/issues/44714 + return torch.randperm(batch_size, device=self.device) + + def set_elite(self, elite_indices: Sequence[int]): + if len(elite_indices) != self.num_members: + self.elite_models = list(elite_indices) + + def save(self, save_dir: Union[str, pathlib.Path]): + """Saves the model to the given directory.""" + model_dict = { + "state_dict": self.state_dict(), + "elite_models": self.elite_models, + } + torch.save(model_dict, pathlib.Path(save_dir) / self._MODEL_FNAME) + + def load(self, load_dir: Union[str, pathlib.Path]): + """Loads the model from the given path.""" + model_dict = torch.load(pathlib.Path(load_dir) / self._MODEL_FNAME) + self.load_state_dict(model_dict["state_dict"]) + self.elite_models = model_dict["elite_models"] diff --git a/mbrl/planning/linear_feedback.py b/mbrl/planning/linear_feedback.py new file mode 100644 index 00000000..10cf4331 --- /dev/null +++ b/mbrl/planning/linear_feedback.py @@ -0,0 +1,66 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np + +from .core import Agent + + +class PIDAgent(Agent): + """ + Agent that reacts via an internal set of PID controllers. + """ + + def __init__(self, dX, dU, P, I, D, target): + """ + :param dX: unused + :param dU: dimensionality of state and control signal + :param P: proportional control coeff + :param I: integral control coeff + :param D: derivative control coeff + :param target: setpoint + """ + super().__init__() + self.n_dof = dU + # TODO: fix dimensionality with P + if isinstance(P, int): + self.Kp = np.tile(P, self.n_dof) + else: + self.Kp = P + if isinstance(I, int): + self.Ki = np.tile(I, self.n_dof) + else: + self.Ki = I + if isinstance(D, int): + self.Kd = np.tile(D, self.n_dof) + else: + self.Kd = D + self.target = target + self.prev_error = 0 + self.error = 0 + # self.cum_error = 0 + # self.I_count = 0 + + def act(self, obs: np.array) -> np.ndarray: + q_des = self.target + q = obs + + self.error = q_des - q + P_value = self.Kp * self.error + I_value = 0 # TODO: implement I and D part + D_value = self.Kd * (self.error - self.prev_error) # + self.D*(qd_des-qd) + self.prev_error = self.error + action = P_value + I_value + D_value + return action + + def _get_P(self): + return self.Kp + + def _get_I(self): + return self.Ki + + def _get_D(self): + return self.Kd + diff --git a/notebooks/traj_based_model.ipynb b/notebooks/traj_based_model.ipynb new file mode 100644 index 00000000..66025f10 --- /dev/null +++ b/notebooks/traj_based_model.ipynb @@ -0,0 +1,598 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "#### Note: This example is compatible with versions v0.2.1dev or higher (i.e., up to date with GitHub). For instructions on how to run with latest pip stable versions (<=v0.1.5), see [this](https://github.com/facebookresearch/mbrl-lib/blob/main/notebooks/pets_example_v0.1.5.ipynb) notebook." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Preview\n", + "\n", + "In this example, we are going to use our toolbox to train and evaluate the [Trajectory-based Dynamics Model](https://arxiv.org/abs/2012.09156) in the reacher environment." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "is_executing": true, + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from IPython import display\n", + "%matplotlib inline\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "import omegaconf\n", + "\n", + "import mbrl.env.cartpole_continuous as cartpole_env\n", + "import mbrl.env.reward_fns as reward_fns\n", + "import mbrl.env.termination_fns as termination_fns\n", + "import mbrl.models as models\n", + "import mbrl.planning as planning\n", + "import mbrl.util.common as common_util\n", + "\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "mpl.rcParams.update({\"font.size\": 16})\n", + "\n", + "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "is_executing": true, + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "print(1+1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Creating the environment\n", + "\n", + "First we instantiate the environment and specify which reward function and termination function to use with the gym-like environment wrapper, along with some utility objects. The termination function tells the wrapper if an observation should cause an episode to end or not, and it is an input used in some algorithms, like [MBPO](https://github.com/JannerM/mbpo/blob/master/mbpo/static/halfcheetah.py). The reward function is used to compute the value of the reward given an observation, and it's used by some algorithms, like [PETS](https://github.com/kchua/handful-of-trials/blob/77fd8802cc30b7683f0227c90527b5414c0df34c/dmbrl/controllers/MPC.py#L65)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "seed = 0\n", + "env = cartpole_env.CartPoleEnv()\n", + "env.seed(seed)\n", + "rng = np.random.default_rng(seed=0)\n", + "generator = torch.Generator(device=device)\n", + "generator.manual_seed(seed)\n", + "obs_shape = env.observation_space.shape\n", + "act_shape = env.action_space.shape\n", + "\n", + "# This functions allows the model to evaluate the true rewards given an observation \n", + "reward_fn = reward_fns.cartpole\n", + "# This function allows the model to know if an observation should make the episode end\n", + "term_fn = termination_fns.cartpole" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Hydra configuration\n", + "\n", + "MBRL-Lib uses [Hydra](https://github.com/facebookresearch/hydra) to manage configurations. For the purpose of this example, you can think of the configuration object as a dictionary with key/value pairs--and equivalent attributes--that specify the model and algorithmic options. Our toolbox expects the configuration object to be organized as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "trial_length = 200\n", + "num_trials = 10\n", + "ensemble_size = 5\n", + "\n", + "# Everything with \"???\" indicates an option with a missing value.\n", + "# Our utility functions will fill in these details using the \n", + "# environment information\n", + "cfg_dict = {\n", + " # dynamics model configuration\n", + " \"dynamics_model\": {\n", + " \"_target_\": \"mbrl.models.GaussianMLP\",\n", + " \"device\": device,\n", + " \"num_layers\": 3,\n", + " \"ensemble_size\": ensemble_size,\n", + " \"hid_size\": 200,\n", + " \"in_size\": \"???\",\n", + " \"out_size\": \"???\",\n", + " \"deterministic\": False,\n", + " \"propagation_method\": \"fixed_model\",\n", + " # can also configure activation function for GaussianMLP\n", + " \"activation_fn_cfg\": {\n", + " \"_target_\": \"torch.nn.LeakyReLU\",\n", + " \"negative_slope\": 0.01\n", + " }\n", + " },\n", + " # options for training the dynamics model\n", + " \"algorithm\": {\n", + " \"learned_rewards\": False,\n", + " \"target_is_delta\": True,\n", + " \"normalize\": True,\n", + " },\n", + " # these are experiment specific options\n", + " \"overrides\": {\n", + " \"trial_length\": trial_length,\n", + " \"num_steps\": num_trials * trial_length,\n", + " \"model_batch_size\": 32,\n", + " \"validation_ratio\": 0.05\n", + " }\n", + "}\n", + "cfg = omegaconf.OmegaConf.create(cfg_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Creating a dynamics model\n", + "\n", + "Given the configuration above, the following two lines of code create a wrapper for 1-D transition reward models, and a gym-like environment that wraps it, which we can use for simulating the real environment. The 1-D model wrapper takes care of creating input/output data tensors to the underlying NN model (by concatenating observations, actions and rewards appropriately), normalizing the input data to the model, and other data processing tasks (e.g., converting observation targets to deltas with respect to the input observation)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# Create a 1-D dynamics model for this environment\n", + "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n", + "\n", + "# Create a gym-like environment to encapsulate the model\n", + "model_env = models.ModelEnv(env, dynamics_model, term_fn, reward_fn, generator=generator)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Create a replay buffer\n", + "\n", + "We can create a replay buffer for this environment an configuration using the following method" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "replay_buffer = common_util.create_replay_buffer(cfg, obs_shape, act_shape, rng=rng)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "We can now populate the replay buffer with random trajectories of a desired length, using a single function call to `util.rollout_agent_trajectories`. Note that we pass an agent of type `planning.RandomAgent` to generate the actions; however, this method accepts any agent that is a subclass of `planning.Agent`, allowing changing exploration strategies with minimal changes to the code. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# samples stored 200\n" + ] + } + ], + "source": [ + "common_util.rollout_agent_trajectories(\n", + " env,\n", + " trial_length, # initial exploration steps\n", + " planning.RandomAgent(env),\n", + " {}, # keyword arguments to pass to agent.act()\n", + " replay_buffer=replay_buffer,\n", + " trial_length=trial_length\n", + ")\n", + "\n", + "print(\"# samples stored\", replay_buffer.num_stored)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# CEM Agent\n", + "\n", + "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "agent_cfg = omegaconf.OmegaConf.create({\n", + " # this class evaluates many trajectories and picks the best one\n", + " \"_target_\": \"mbrl.planning.TrajectoryOptimizerAgent\",\n", + " \"planning_horizon\": 15,\n", + " \"replan_freq\": 1,\n", + " \"verbose\": False,\n", + " \"action_lb\": \"???\",\n", + " \"action_ub\": \"???\",\n", + " # this is the optimizer to generate and choose a trajectory\n", + " \"optimizer_cfg\": {\n", + " \"_target_\": \"mbrl.planning.CEMOptimizer\",\n", + " \"num_iterations\": 5,\n", + " \"elite_ratio\": 0.1,\n", + " \"population_size\": 500,\n", + " \"alpha\": 0.1,\n", + " \"device\": device,\n", + " \"lower_bound\": \"???\",\n", + " \"upper_bound\": \"???\",\n", + " \"return_mean_elites\": True,\n", + " \"clipped_normal\": False\n", + " }\n", + "})\n", + "\n", + "agent = planning.create_trajectory_optim_agent_for_model(\n", + " model_env,\n", + " agent_cfg,\n", + " num_particles=20\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Running PETS" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Having a model and an agent, we can now run PETS with a simple loop and a few function calls. The first code block creates a callback to pass to the model trainer to accumulate the training losses and validation scores observed. The second block is just a utility function to update the agent's visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "train_losses = []\n", + "val_scores = []\n", + "\n", + "def train_callback(_model, _total_calls, _epoch, tr_loss, val_score, _best_val):\n", + " train_losses.append(tr_loss)\n", + " val_scores.append(val_score.mean().item()) # this returns val score per ensemble model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "def update_axes(_axs, _frame, _text, _trial, _steps_trial, _all_rewards, force_update=False):\n", + " if not force_update and (_steps_trial % 10 != 0):\n", + " return\n", + " _axs[0].imshow(_frame)\n", + " _axs[0].set_xticks([])\n", + " _axs[0].set_yticks([])\n", + " _axs[1].clear()\n", + " _axs[1].set_xlim([0, num_trials + .1])\n", + " _axs[1].set_ylim([0, 200])\n", + " _axs[1].set_xlabel(\"Trial\")\n", + " _axs[1].set_ylabel(\"Trial reward\")\n", + " _axs[1].plot(_all_rewards, 'bs-')\n", + " _text.set_text(f\"Trial {_trial + 1}: {_steps_trial} steps\")\n", + " display.display(plt.gcf()) \n", + " display.clear_output(wait=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "The following lines implement the PETS algorithm. First, we create a model trainer and pass some hyperparameters for the optimizer (Adam), along with references to the model instance to use. Then we start a loop where we execute actions of ``agent`` in the environment and train the model at the beginning of the episode (by calling ``model_trainer.train()``. At every step in the loop, we execute an agent action in the environment and populate the replay buffer by calling ``util.step_env_and_add_to_buffer()``. Importantly, at the beginning of each episode we also call ``agent.reset()`` to clear any episode dependent cache; in the case of a ``TrajectoryOptimizerAgent``, this means clearing the previous action sequence found, which is shifted at every call to obtain an initial solution for the optimizer. \n", + "\n", + "The rest of the code is mostly bookkeeping to keep track of the total reward observed during each episode, and to make sure episodes terminate after some desired length. After running this code, you should see the agent reaching the maximum reward of 200 after a few episodes." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "pycharm": { + "name": "#%%\n" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create a trainer for the model\n", + "model_trainer = models.ModelTrainer(dynamics_model, optim_lr=1e-3, weight_decay=5e-5)\n", + "\n", + "# Create visualization objects\n", + "fig, axs = plt.subplots(1, 2, figsize=(14, 3.75), gridspec_kw={\"width_ratios\": [1, 1]})\n", + "ax_text = axs[0].text(300, 50, \"\")\n", + " \n", + "# Main PETS loop\n", + "all_rewards = [0]\n", + "for trial in range(num_trials):\n", + " obs = env.reset() \n", + " agent.reset()\n", + " \n", + " done = False\n", + " total_reward = 0.0\n", + " steps_trial = 0\n", + " update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n", + " while not done:\n", + " # --------------- Model Training -----------------\n", + " if steps_trial == 0:\n", + " dynamics_model.update_normalizer(replay_buffer.get_all()) # update normalizer stats\n", + " \n", + " dataset_train, dataset_val = common_util.get_basic_buffer_iterators(\n", + " replay_buffer,\n", + " batch_size=cfg.overrides.model_batch_size,\n", + " val_ratio=cfg.overrides.validation_ratio,\n", + " ensemble_size=ensemble_size,\n", + " shuffle_each_epoch=True,\n", + " bootstrap_permutes=False, # build bootstrap dataset using sampling with replacement\n", + " )\n", + " \n", + " model_trainer.train(\n", + " dataset_train, \n", + " dataset_val=dataset_val, \n", + " num_epochs=50, \n", + " patience=50, \n", + " callback=train_callback,\n", + " silent=True)\n", + "\n", + " # --- Doing env step using the agent and adding to model dataset ---\n", + " next_obs, reward, done, _ = common_util.step_env_and_add_to_buffer(\n", + " env, obs, agent, {}, replay_buffer)\n", + " \n", + " update_axes(\n", + " axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n", + " \n", + " obs = next_obs\n", + " total_reward += reward\n", + " steps_trial += 1\n", + " \n", + " if steps_trial == trial_length:\n", + " break\n", + " \n", + " all_rewards.append(total_reward)\n", + "\n", + "update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards, force_update=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Finally, below we check the results of the trainer callback, which show the training loss and validation score across all calls to ``model_trainer.train()``." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvMAAAJWCAYAAADV1AiKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAADLHklEQVR4nOzdd5hkVbX38e+q0DnP9OQcYJghz5CRpAImEAFRERW8YL56zfkiitfwmhUFEwgYERWM5ByHMMDA5JxD93ROVbXfP86p6uqaDqenq6ZD/T7PU091n3PqnF1dPT2rVq29tjnnEBERERGR0Sc03AMQEREREZEDo2BeRERERGSUUjAvIiIiIjJKKZgXERERERmlFMyLiIiIiIxSkeEewGg2fvx4N2vWrOEehoiIiIiMcc8888we51xt5nYF80Mwa9Ysli5dOtzDEBEREZExzsw29rZdZTYiIiIiIqOUgnkRERERkVFKwbyIiIiIyCilYF5EREREZJRSMC8iIiIiMkopmBcRERERGaUUzIuIiIiIjFIK5kVERERERikF8yIyIsTiCV7Z3jjcwxARERlVxmQwb2YXmdmfzWyjmbWZ2Uoz+z8zK884rtrMfmFme8ysxczuMbMjhmvcIvnsrpd38oYfPsye5o7hHoqIiMioMSaDeeCTQBz4PHAu8FPgA8DdZhYCMDMD7vT3fwS4EIgC95vZtOEYtEg+a2rvIuGgtSM+3EMREREZNSLDPYAceZNzbnfa9w+aWR1wE3AGcB9wHnAKcJZz7n4AM3scWA98GvjvgzpikTyXcN59LJEY3oGIiIiMImMyM58RyCc97d9P9e/PA7YlA3n/cQ142frzcztCEcmUcK7HvYiIiAxsTAbzfTjdv3/Fv18EvNTLccuBGWZWdlBGJSIAJGP4uBLzIiIigeVFMG9mU4FrgHucc0v9zTVAfS+H1/n31X2c6yozW2pmS3fv7u0DABE5EM6P5lVmIyIiEtyYD+b9DPvfgBhw+VDP55y7wTm3xDm3pLa2dsjjExFPsmZesbyIiEhwY3UCLABmVoxXAz8HON05tyVtdz29Z99r0vaLyEGSzMzHVTMvIiIS2JjNzJtZFLgNWAK83jn3YsYhy/Hq5jMtBDY555pzPEQRSZNI1cwrNS8iIhLUmAzm/V7ytwJnAW92zj3Ry2F3AFPN7PS0x1UAb/L3ichBlOxiowmwIiIiwY3VMpufABcD1wItZnZi2r4tfrnNHcDjwC1m9im8sprPAQZ86yCPV0R88YTKbERERIIak5l54HX+/RfwAvb0238BOOcSwBuBu4HrgL/grRp7pnNu88EesEi+687MK5gXEREJakxm5p1zswIeVwdc4d9EZBilauY1AVZERCSwsZqZF5FRxqVaUyqYFxERCUrBvIiMCInUolEK5kVERIJSMC8iI4JTzbyIiMigKZgXkREhVWajmnkREZHAFMyLyIiQTMirzEZERCQ4BfMiMiI4vCBeE2BFRESCUzAvIiNCqjWlgnkREZHAFMyLyIigCbAiIiKDp2BeREYEp0WjREREBi0nK8Ca2VTgtcCJwBSgGNgDrAQeBB50ziVycW0RGZ0SysyLiIgMWlYz82Z2upn9HdgA/Ap4PTAVL5g/CvgkcC+w2cyuNrOKbF5fREYv1cyLiIgMXtaCeTP7B/AvoAV4KzDBOTfDObfYOXeqc24hUAEcDVwHXAysNbNzsjUGERm9kt1sFMyLiIgEl80ym1XAe51zO/o6wC+tecG/XWtm5wGVWRyDiIxSWjRKRERk8LIWzDvn/ucAHnNHtq4vIqNbsr+8Fo0SEREJ7qB3szGz15jZCwf7uiIysiVDeJXZiIiIBDccrSkrgUXDcF0RGcGS5TVaAVZERCQ49ZkXkREhWSqvMhsREZHgFMyLyIiQXAFWE2BFRESCUzAvIiOC+syLiIgMXta62ZjZnICHTsrWNUVk7FCfeRERkcHLZp/5NXQ3pOiPBTxORPKIMvMiIiKDl81g/vIsnktE8kyyZj6umnkREZHAsrlo1E3ZOpeI5B+nzLyIiMigDceiUeebWePBvq7IaLKzsZ1v/ntFXgW2yS42+fScRUREhmo4utlEgNJhuK7IqPH521/kpw+s5cl1e4d7KAdNMoZXa0oREZHg1JpSZARKhrOtnfFhHcfBlFo0Kq5gXkREJCgF8yIjUFHU+6fZHsunYF4TYEVERAZLwbzICFQUCQPQ3pUY5pEcPMnymoRq5kVERALL5qJRZwU89IhsXVNkrCoq8IL5tq48ysz79zEF8yIiIoFls8/8PXj/H1s/xyT3639rkX4kM/MdeRTMawKsiIjI4GUzmD8zi+cSyWupmvm8CubVmlJERGSwsrlo1IPZOpdIviuK5l+ZDVo0SkREZNA0AVZkBIqGk5n5/JsAq2BeREQkuGxOgP3yYI53zl2TrWuLjDXJwDYvy2wUy4uIiASWzZr5qwMck/7ftIJ5kT64VDCfP5l5lyqzyZ/nLCIiMlTZLLOJDnA7DrgLr5vNmixeV2TMifvxbH5l5r17ldmIiIgEl7Vg3jkX7+0GzAFuAZ4EFgJX+fci0ofkKqh5NQGW5KJRwzwMERGRUSSbZTY9mNl04H+BdwH1wCeB65xznbm6pshYkSyzae2MDfNIDp5kQj6maF5ERCSwrAfzZlYLfBEvA9+OVxv/PedcS7avJTJWJUtN2jrzJzOvCbAiIiKDl81uNpXAZ4CP4NXF/wD4pnOuPlvXEMkXySx1Sx4F88kJsAnVzIuIiASWzcz8eqASb5Lr14DtQLWZVfd2sHNuXRavLTKmJLPUrR35VGbjPeeYgnkREZHAshnMV/n35wBnBzg+nMVri4wpyey0MvMiIiLSn2wG85dn8VwieS2ehxNgHcmaeQXzIiIiQWUtmHfO3ZStc4nku2Q82xV3dMYSFESyuSTEyJRsYqM+8yIiIsGN/QhBZBRKD2jzpaNNqpuNgnkREZHAFMyLjECJtFKTljwptUk+YwXzIiIiwSmYFxmB0oP5fKmbd8rMi4iIDJqCeZERKD2gbenIlzIb714TYEVERIJTMC8yAqUnp/OmzMYP4tWaUkREJDgF8yIjUCIvJ8B691o0SkREJLiDHsyb2XQzm3Gwr9sXfzy3mVmDmTWa2e0jaXySn3pOgM2PYF6ZeRERkcHL5qJRQa0DbJiu3YOZlQD3AR3Au/EaanwNuN/MjnTOtQzn+CR/xR2EQ0Y84eiKJYZ7OAdFqpuNauZFREQCG46A+qt4wfxIcCUwBzjUObcGwMxeAFYD7wO+O4xjkzyWcI6iSIiWzjhd8fwI5pOfRqjMRkREJLiDXmbjnLvGOfeVg33dPpwHPJEM5AGcc+uBR4Hzh21UkvcSCUdhNAyQN8F8MiGvMhsREZHg8n0C7CLgpV62LwcWHuSxiKQkM/MAXfH8CG7VmlJERGTwclJmY2an9bM7ATQAK5xzXbm4/iDUAPW9bK8Dqnt7gJldBVwFMGOG5slKbsQT5GFm3vn3XnY+FBop1XgiIiIjV65q5h+gez5bX1rN7IfOuS/kaAw54Zy7AbgBYMmSJUohSk4knKMwlZnPl2C+++u4c4RGzNQaERGRkStXwfz5wI+AZcBtwE5gIvBW4EjgS8DxwKfNrN459/9yNI6B1NN7Br6vjL3IQZFwjgI/mO/MmzKb7ucZTzj8DyZERESkH7kK5t8M/Ns59/6M7Teb2fXAmc65y80sAbwXGK5gfjle3XymhcDLB3ksIinxhCNkRkE4lDeZ+cxgXkRERAaWqwmwFwB/7mPfbXR3ivk3MDtHYwjiDuBEM5uT3GBms4BT/H0iw8L5feajYcu7PvOgSbAiIiJB5SqYDwNz+9g3z98P3mJNHTkaQxA/BzYAfzOz883sPOBvwGbg+mEcl+Q5LzMP0Uj+ZObT43e1pxQREQkmV8H8P4Gvm9mFZhYGMLOwmV0EXAv8wz9uEbA2R2MYkL/C61nAKuBm4FZgPXCWc655uMbVn2Wb9/Glv75Ee1d8uIciOZRwXplNNBzKy5p5LRwlIiISTK6C+Y/g1aP/CWgzs51AG/BHf/tH/OMagK/naAyBOOc2OecudM5VOOfKnXNvds5tGM4x9WfbvjZufmIjq3eOyPcakiXJYL4gHCKmzLyIiIj0IScTYJ1ze4BXmdnZwAnAZGA73mqrd6cdd1Murj+WLZhcAcArOxo5YlrlAZ+nM5bgkhse51PnHMrJc8dna3iSJYn0mvk8CeZ7TIBVzbyIiEgguepmA4Bz7i7grlxeI9/MqCmhOBpmxfamIZ1nX2snz23ax7LNDQrmR6B4wmEGkXAob1aATY/fY3nynEVERIYqJ2U2ZvacmX3MzCbm4vz5LBwyDplUzoodjUM6T5tfc9+m2vsRKeGcn5kP0ZknmXnnP2fomaUXERGRvuWqZn478G1gs5n9y8zeZmZFObpW3lkwsZwVO5pwQwh4UsF8Zyxbw5Is6q6Zz6cyG4iGvWBefeZFRESCyUkw75x7PTAV+DRQC/wW2GlmvzKzM3NxzXyyYHI5dS2d7G4+8K6ebZ1eMN/aqcz8SBRPkOpmkz/BvCMa8v4kKZgXEREJJleZeZxzu5xz33fOLcFrQfkTvDaQ95jZxlxdNx8smORPgh1C3bzKbEY2r+QEL5iP5Udg64BwMjOvMhsREZFAchbMp3POvQJcA3wB2AZMOxjXHatmjCsBYEdD2wGfoz1VZqNgfiTyFo0yopH8qpmPhpWZFxERGYycB/NmdpaZ/RrYCfwG2EJ3n3k5AOVFXhOixrYDr3dv6/QCxKGW2dzyxEbW7FLP+2xLOEco5NXMxxL5EsxDNKSaeRERkcHIVTebw83sG2a2CbgHOB34AbDAOXeSc+66XFw3X5QVRDCDpvauAz5HNspsEgnHF//6Erc/u+WAzyG9SzivZj4Syp8ym4Rz3WU2CuZFREQCyVWf+RfwVnf9E/Ab59wjObpOXgqFjPLCCI3tQ8jMZ6HMpiOW6HEuyZ6Ec4QNiOTTBFhSZTZqTSkiIhJMroL5twJ3OucOvN2K9Ku8KEpj24Fn5ts7h56ZT9bdt3flR7B5MCVr5kMh8qtm3u9mo0WjREREgslJMO+cuy0X55VuFcXRYc/Mt8e8x3YoM591znmfwERC+dNn3jlSi0apm42IiEgwucrMY2YFwOuAQ4HMBaOcc+6rubp2PqgoitCYhZr51iEsGpV8I5AM6jO9tLWBupZOTjuk9oCvka+8zLzfmjJPstQJ51KLRuXJnF8REZEhy0kwb2ZTgEeAWXjto83flR6VKJgfgoriKJvrWlMTBZMZzaDaslJmk+hxrkw/vm8Nq3Y2cd8nzzjga+SruHOEQ/6iUbH8iGwdEPFr5vOlg4+IiMhQ5ao15beB3cAMvED+BGAOcC2wxv9ahqC8KEJTe4zP3/4i77t5aZ/HJRKOXz6yfr8sfnq9e+IAO4ckM/J91cy3dsWH9OlBPnMu2Wfe8qZmPuEcEf9NqSbAioiIBJOrYP5VwHfwFogCSDjnNjjnvgzcBvwwR9fNGxVFURrbu3hpWwOr++nzvmzLPr7695f55B+X9dienpE/0Ox8+wBlNu1d8SH1ws9nqUWjQiFiedKmMb2bTZ68fxERERmyXAXz44BtzrkE0AJUp+27DzgjR9fNGxXFUZo7Ymzb10Z9S2efxyUDwbtf2dlje3ppzAEH8wNk5ju64nTGE6lPASS4hD8ZNBoOEU+4/Oi77iCS6jOvaF5ERCSIXAXzW4Dx/tdrgbPT9h0PtOfounmjoiiCc1Df2kVje4xYH6nM5g4vM+4cPYLqHpn5A+xokwzi++pmk7xG0xC67uSrRMJhBtGIF9zmQ0cbr8xGmXkREZHByFUwfz/eqq8A1wOfNLO7zOwfeBNf1bpyiCqKoj2+b+ij53xrR3eg/fSGutTX6YF96wEG8wNNok0G+0NZqTZfeYtGGQV+2Um+BPOFEU2AFRERGYxcBfNfBH4K4Jz7KfBRoASYDHwL+ESOrps3Kop7NiLa10cw39LRnRV/Yt3e1NdtXXGSDXCGXmbTd808MKR++Pkq7hwhv8wGyIv2lA5SwXxHnnTwERERGapcLRq1B9iT9v2PgB/l4lr5qjwjM7+vtfe6+WSZTWEkxO6m7gV52zrjVJcUsLel84B7zScz733VzLenymyUmR+shMObAJsnmXnnHM5BYTQMQKeCeRERkUBylZmXHMsss6lv6aPMxg/Up1QV9yjFae9KUF1aAAylZr67m43rpZVgeyxZZqPM/GAlUotGeR+fjPXgNvnrUxT1/iSN9ecrIiKSLVkL5s3sh2Y2aZCPeYuZvS1bY8gnmWU29X1m5uMUhEOMLyvoEcy3dcWpSQbzB1pm4z/Ouf3LIuIJlwrIlJkfvPRFoyA7mfnH1+7lj0s3D/k8uZB8K1gY8TPzY/yTCBERkWzJZmZ+FrDOzP5gZueZWU3mAWYWMrOjzexLZrYSr66+LvM4GViyzKa2vBDoewJsS0eMksIwlcVRGtJ6vrd1xhnnB/MHOgE2vVa+I6PUpiOt97x6zQ9OsuQkvcwmG73mf/fUJn5wz+ohnycXkotEKTMvIiIyOFmrmXfOnWdmpwGfBP4MhMxsG95KsB14veanA0XAduDnwPecc43ZGkM+KS/yXrr5E8qoa+nsMzPf0hmjtCBCRXGUV7Y3AV6w2NYVz0KZTXfA1R6LU0m0133KzA9OMm73gvnsldl0xRMjtvY+WWYTDYcwG/tzBERERLIlqxNgnXMPAQ+Z2WS83vInAFPwAvh1wK3AQ8DD/oJScoCi4RAlBWEmVxZTVRylvrXvzHxZYcTPzHvHJEtixgUss+mKJ/jgrc/y32fN54hplant6Y/L7GiT/r262QxOMksdDkE0kr0ym5EczCefsxkUhEPKzIuIiASUq24224Gb/JvkyCfPPpSjplfy/Ob6PrvZtHTEKfXLbJo7vMWlkpn4qpJgZTY7Gtq5++WdLJhU3iOYb+8RzPcMvtL3aQLs4CRXe7UefeaHXmbTGXcjtsVlMjNvGAWRkFpTioiIBKRuNqPYFafOZvHMGqpKCtjXV2a+M0apn5kHL0uezKiXFoQpjoZpG6A1ZTIYX7enpcf29AA+M7ufvq8xYJnNjoZ2bn92S6Bjx7JkYJvtCbCxeGLETix1/hTYkHltVEfqOEVEREYaBfNjQHVJ/2U2pQXdwXxDW1cq8C4uCFNcEE59v6+1k3f/6ik27u0ZtCdr3tftzgzm+y6zaeuRmQ8WzP/52S18/I/LAgf/Y1XcdQe2qZr5LJbZ9NZGdLilzxNQmY2IiEhwCubHAC8z31+ZTUYw75fVFEW9zPzW+jZi8QQPrd7Dg6t2c9+KXT3OkVx4av2eZhJpXVXau+IU+4v8ZAbzHWnZ/6BlNsnrpC9ulY8SqWA+LTOfheC2M+51yclGZ5xs61EzH1EwLyIiEpSC+THAy8x39ppxbe6IpWrmwQvmk4F3cTTMKfPGcf/K3bz710/xzAavS+gKv+tNUjIYb+9KsKOxPbW9PRanuiSa2peu3W9NOaGiKHAwn3yTsSffg/lEL8F8Fmrdk28IRuIk2FTNvJmCeRERkUFQMD8GzJ9YTntXgo/+/vn9gqDWjJr5hrau1ITX4oIw37zwSD766vk8umYvf39hOwArdmYG891lL+mlNm2dcSr9SbT7d7PxxlFbVhi4bCa5Wu3u5vwO5pMTYL2aea/MJpbITpkNQFds5GXmXVppUYFq5kVERAJTMD8GXLx4Gp8651DuWLaNXz6yPrW9IxanK+5SrSnBC+af3lBHyGDmuBLMjMtOmkk4ZOxt6SQSMlbtaOpRTpPeWnL9nubU1+1dCaqKk5n53ltT1lYU0tQeC1SnnXyToTIb796rmc/eIkrJYH4kBsqJVDcbtaYUEREZjJwE82Z2vpldnvb9TDN73MyazOw2MyvLxXXzlZnxoTPn8dqFE/nRfavZ0eCVwrR0dNetVySD+dZO/vb8Nk6eO54J5UUAjC8r5FXzxwNwzqJJtHXF2VTXmjp/c0eMaNgoLQizNi0z3xGLU13aezCfnAA7obyQeML12W2nx2OSZTZ5nplP1cyHvJITyFKZjX+OkRjMu4znrGBeREQkmFxl5r8I1KZ9/11gGnADcBpwdY6um9e+9IaFxBKOb/zrFcDrZANQUhihKBqmMBLiwVW72VTXyvlHT+nx2CtOmc2hE8u59IQZAKzY0V1q09TeRXlRlBnjStmcFuS3dcapLPbLbGKZfea97087xPs1uDdjUm1vkm8AlJn3y2wsu60pu8tsRl6gnOhRMx+mYwS+4RARERmJchXMzwVeADCzYuD1wMedc58APg9ckKPr5rUZ40q46lVz+Ovz23h6Qx0tfg16WaG3NlhlcZSnN9RTFA1x7uGTejz2tENq+c//nMbRM6owg1e2N6b2NbXHKC+KMK26mC31bant7bEEVSX9l9mcOHsc06qLuXPZtgHH35rKzPfemSdfxHtMgPVq5rMazI/AQDmZmVeZjYiIyODkKpgvApJR38l4K83e5X+/EpjS24Nk6D545lymVBZxxa+f5vdPbQag1A/mk5nvS5ZMp7wo2uvjSwoiHDqxnKUb61LbmttjlBUmg/lWnHN0xRPEE46SaJiCSGi/RaOSrSmLoiHedNQUHlmzh70DlM+0qWYe6O7sEkpbNCo7feZHcJmNfx8yozASGpFvOEREREaiXAXzG4BT/a/PB55xzjX4308AGnp7kAxdSUGE3191EvMmlnHjYxsAKCv0esEnW0T+16vm9HuOk+aOY+mGejr89pLdmfkSWjrj7Gvtbm9ZFA1TFAnRsV9rygRF0RBmxgXHTCWecNz65KZ+r9va5Y0v32vmuzPzpPWZH3rNfDKIH4lZ70TGQlkjcYwiIiIjUa6C+euBq81sKfBB4Jdp+04CXs7RdQWv3OaHbzsm9X1JgZeZ//oFR/DZ1y1gek1Jv48/ac44OmIJnt+0D4BGv2Z+WnUxAJvqWtm2z5tkW1QQpiga7rXMpshfUOqQieW85rAJ/PKR9amFoXqTPgE2MQIXNhrInuaOVHvNoUjVzIeMcMgIWXZKY2KpMpuR97PtrpnXolEiIiKDkZNg3jn3A+A9wOPAFc65n6ftLgd+nYvrSrfpNSWp4DtZM/+OE2bw/tPnDvjYE2aPwwyeWOeV2qTXzAN8+z8rOef7DwFQFAlRXNAdzNe3ePXubZ1xiiLh1Dk/ctZ8Gtq6+F0/2fnWzjjRsNEVdzS0BetNP5Jccv3jfP+e1UM+T/dqqF69fDQcomuIfebjCZcKmEdiCYtLe87qMy8iIhJczvrMO+dudc59xDn3m4zt73PO3Zyr60q3Oz58KtdecHgqCA+qsiTKwskVPLVhL+C1piwv9MpsAB5Zsyd1rFdmE6a9K8G9r+xkybX3sGZXc6rMJumo6VUcNb2Kvz6/lQdW7uK7d6/qcU3nHG1d8dQ1BlNqc9NjG9i2r23gA3PIOcfm+jZ2pa2Qe6CSQXfYD+YLIiH2DnFScHoAPxID5dQ8ATMKwmFl5kVERALKVZ/5Q8zs+LTvi83s/8zsTjP7cC6uKfurKS3g0hNmpjK8g7FoSgUrdzTjnPOC+aIolcVRyosiPY4LmVEUDdHaFeefL+4gnnDcv2JXjzKbpDcdOZnl2xr56O+f5yf3r0mVfQB0xBI4BzP8EqBdASfBNrR28b93LOdvzw/cLSeX2rridMYSdGQhCE2vmQc4d9Ek/vb8Vtbtbu7nUf1LD+BHYmtKl75olMpsREREAstVZv7HwEVp318LfAKvi833zOxDObquZMm8CWXsae5ge0M78YRLBfHJzPlNVxzPN95yBK8+bAKHTCxn6YY67l/p9ZJ/aPXu3oP5o6Zg5q1CG084dqRlsZNtKWePLwVge0OwDHey/WZzx/CW5dT7i2Jlzh04EKlg3o/mP3XuoRRGwnz7PysP+JzpAfxIzMx3L5RFqswmyKrBIiIi+S5XwfxRwKMAZhYC3gV8xjm3GPgacFWOritZMn9COQDP+ZNgk60sp1cXU1YY4aQ543jb8TMoioZ598mzaO2MU9fSyaSKIp5aX0djW1ePMhuAiRVFvP6Iycyf4C0AvLmuuzQmOXF0Tq0XzO9oCFY2k3wTkFzttj/OOb579yo27W0d8NjB2tfqlcG0dw09UHYZZTYTyou4eMk07l2xKzVJeLDSJ72OxJr51DwBvNaUMDLfdIiIiIw0uQrmK4G9/tfHANXAbf73DwD990aUYTfPD7if21QPQJmfmf/Yaw7hx+84hoJI96/O4VMrOX5WDQAfP/sQOmIJlm1p2C8zD/CTdxzLz9+1BIAt9T1XkwWoKimgprSAbQEz88nH9dclJ2lHYzs/vHc1/3xpe6BzD8a+ZGY+loXMfFqWOunMQyfQGUvw+Lo9fTyqf109ymxGXsY7OSIzb9EoGJktNEVEREaaXAXzO4F5/tdnA2udc5v978uAoffvk5yaWlVMUTTEs34wnyyzWTilgjMOnbDf8de8eRHfuuhI3njkZGpKCwB6dLNJN6WqGDN6rCabXHSqJBpmcmUR2wNOaE2W2bQECObrW7yAOxedcur9zHxmv/0D0d1zvXuuw/GzayiOhnlg5e4DOufInwDb/ZyTbxQVzIuIiAwsV8H8HcD/mdn/w6uV/1PaviOAdTm6rmRJKGTMm1DGS1sbAajImPiaacGkCt66ZDolBRE+efahADy3ub7XYwsiISZVFLE5LTOfLJcpKfCD+UFm5lsClJ/sa/MC7mQWPZuymZlPJPYP5ouiYU6eO477Vuw6oFry9DKbkRgkZ/aZh5H5pkNERGSkyVUw/1ng78A5eIH919P2nQfclaPrShbNqy2jM55gfFkh8/wa+iAuOW46J8yu4SNnze/zmGnVxT0z834wXlQQZnJl8aAnwAbJzCcD7sYcZOb3ZTUz792HQz27EJ1xaC1b6tvYeAA1/z3KbEZgkNyzNWX2Vr0VEREZ6/pPtx4g51wLcGUf+07OxTUl+9501BT2tXXxtTcfTmVxNPDjwiHjD+87qd9jpleX8OT6utT36Zn5SZVFNLR10doZS61e25fuCbABymz8gDuZoc+mZDebjmzUzCeSCyj13H7yvPEAPLp2D7P8rj9BdY7wYL67tCg9Mz/0n6WIiMhYl7NFowDMrMbM3mBml/n3Nbm8nmTXqw+byI2XH59qR5lN06qL2d7Qlgosk91sSqIRplQVAcHaU7Z2JFtTBs/M57TMJivdbLzANpwRzc8ZX8qkiiIeW7O3t4f1q2drypGX8U6kSoe6a+az0bNfRERkrMtZMG9mXwO2AncCN/n3W83sq7m6powe06pLSDjY6pfaJCfAFheEmVThrVi7I0gw3zWIzHyLl5HPxQTY7taU2exm0zOYNzNOnjeOx9buSdXVBxVLjOzWlN1lNupmIyIiMhi5WgH2Y8DngVuAM4HD/PtbgM+b2X/n4rr+tQ8xsx+Y2Qtm1mxm283sDjM7qo/jrzSzFWbWYWYrzez9uRqbdJs/0Wt9uWKHN8G2La3MJpmZ3xago03bIPrM7/OD+IZWr4Rnb3OwVWaDSJ47lnC0dMRYuaPpgM8V72UCbNIpc8dT39rFql09zz/QpNj0MpuRGCT3qJlXNxsREZHAcpWZfz/wA+fclc65B51zK/37K4EfAh/M0XXBa4V5Jt6nAW/yr1ULPGFmi9MPNLMrgeuBPwPn4nXduc7MPpDD8Qle95uQwfJtXjCfrH0vino184WREA+s6m7D6Jzjtme2pMpxkpJBfGc8MWDwl8yeN3XEuObOl3n7z5/I2vNJ1uMD/ObxjbzpR48E+rSgN66PCbAACyZ7E5HX725JbXtg5S6O+erd/b45SS+zGYmZ+dSiUepmIyIiMii5CuZnAf/oY98//P258nvgKOfcd5xz9zvn/oIXqLcDH00eZGYR4FrgZufcF/xjvwjcCHzVzILP+JRBKy4IM7e2jJf9YL6tK05hJEQ4ZBRGwnzgjLn844XtPLLaWyRp6cZ6PvmnZfz1uW09ztPW1R0wDxQ816fVyj+5vo7Vu5qzMmEVvJr5ZCJ9c30rnfEEew4w89+dmd9/X3L+QnonoNU7m9nX2sVja/uupR/pK8AmR5fezUaZeRERkYHlKpjfCxzex75FdK8Om3XOuT0uo+bAOdcArAKmpm0+CS9jf0vGKW4GxgGn5mqM4lk0pSItMx+jpKB7kan3nz6X2eNL+cCtz/Dw6t2pSZ+rdvYsL0kvrxloEmx9a2cq4F6/pwXnYHNdsMWp+pNIOPa1djK+rBCAPU1eEL+35cC65vS2aFRSZXGU8qIIW9NKkBrbvTcpj6/rL5hPL7MZuRNge2TmFcyLiIgMKFfB/F/wstuX+RlwzCxiZm8HrsErazlo/C46hwOvpG1e5N+/lHH4cv9+Ya7Hle8WTalkR2M7e5s7aO2M92hDWRQNc/N7j2dqVTHvv/kZ7np5BwCrM2rFW9MWi2odYOGofa1dTK0q7rFt496W/Y7b0dDOh259NlCHHPDKdhIOJld6tf7JIL6uOfvBPHir825JW3ArOaH3iX4z815gXBAOjcjyFZcK5k1lNiIiIoOQq2D+c8DzeHXrbWa2E2gDbgWW4U2OPZh+BBjw/bRtyTaZmcuU1mXs78HMrjKzpWa2dPfu3b0dIgEtmlIBeHXz7V1xiqI9fx2nVZfwvUuOpqUznsrgr9rZ3OOY9Br6/oLvZPZ81rie/dk39LIA09Mb6vjHi9t5aWtDoOfR4JfvTCj3g/nmZGb+wMps+lo0KmladUmPMpvkIljr9rSws7H3DkDJMpvignCP+vmRorduNmpNKSIiMrCcBPPOuSbgNLzVXr+Ltwrsd4E3Aqc755r7eXgPZvYaM3MBbg/08fjPAe8APuycW5OF53aDc26Jc25JbW3tUE+X1w6b7AXzK3c0saOhPVWmknnMmYd6P+cTZtewu6kjNZEVvGx8qV+e01/NfDJ7Pmt8z575vWXmkx1y+gqMMyXLXGrLvfHv9TPyB1pm01/NPHSvnpvMZje2xyj0s9lP9FFqk8zMlxaER2TNfCKtm02hymxEREQCy8kKsAB+3frf/dtQPIbX2nIg+6VY/TaTXwe+6Jz7VcbuZEa+Gtietj2Zka9Dcqq6tIDxZYWs2tnE6p3NnH/MlF6P+9Q5C4iEQ1xwzNTUxNXjZnkvU1tnnNryQlr2tvYbzCffAKRn5qdWFfeamU/2vA8azDe1e9ed4AfzTf44hlxm02dmvpjmjhiNbTEqS6I0tnVx1PQqXtzSwHOb9nH+0VP3e0wqmC+MjMjylVSZDd018yPxTYeIiMhIk7NgPlucc63AisE+zswuA64DvuOcu7aXQ5K18YvoGcwna+VfHuw1ZfAOmVjGI2v20NQR45CJ5b0es3BKBT9/15JUnfiqnU2pYL6lM8aUSi8o76/MJtnJZkaNl5kvK4xw9IyqXktpkrX3OxqClck0+Zn58eU9P1moy8EEWPCCefC65lSWVNLY3sWc8WUcOa2S5zZlVo15kgF8SWFkRGa8k5l5U595ERGRQclamY2ZJcwsHvB2YA24g4/lAuDXwC+cc5/s47DHgT3ApRnb34mXlX80dyOUpPkTytjur/Q6f0LvwXzSlMpiSgvCrE6rm09m5qH/MptNdd4bgdryQsqLIkyvKWH2uFK21LftlwFu8+vwg5fZeMfXZpQJHXiZjXcf7jOY79mesrEtRkVxhGNnVqfmH2Tq8jvYlERHZpmNS+9mo9aUIiIigWUzM38N3e2ih42ZnQb8Dm+i7Y1mdmLa7g7n3HMAzrkuM/sS3iJRW4F7gLOAK4CPOOcOLBKTQZmflo1Prgrbl1DIWDC5gpe3N6a2tXTGuoP5PrrZOOf4+UPrmF5TzOFTK6ktK2T2+BLm1JYSTzg27GnpMY7Bl9n0rJlPOvAJsN2BbW+SmfnkJxWN7V1UFEU5ZnoVsYTjpa0NLJnVc/52LJEgHDKKoqHAXXoOpvQ+85FwiJCpm42IiEgQWQvmnXNXZ+tcQ3QWUAgcy/7Z9Y2kLVjlnPuZmTngE8CngE14E2WvOzhDlWRpTY1fPz+QhZMr+OtzW0kkHA5o70pQWRwlGrY+g9QHVu7mxa0NfPPCI4iGQ/zw7cdQWRylxc/AL9/W2COYT5XZDLJmPjMzP9ia+dU7m5heU0LCrznpq5tNVUkBVSVR1u1poSueoLUzTkVxlGNnVgPw9Ib6/YL5zniCSMgrYRmJmfnu0iLv+4JISJl5ERGRAHLVmnLYOOeuds5ZH7dZvRx/vXPuEOdcoXNuvgL5g2v+hLIe9wNZOKWCpo4YW+rbUhn00sIwpYURNuxpYc2u/RslPbx6D0XREG85dhoAh0+tZHpNCXNryyiIhFi+rWfdfLKbza7GDpxzNLV3pdpN9qaxrYviaJjSwu5Fr8IhY29LZ6p8ZCDtXXHe8KNHuPnxjQO2pgSYM76UdbubU28kKooijC8r5KjpVfzuqU3EMgL2rpijIBwiOkL7zHfXzHv3ZYWRVP98ERER6duYC+ZldKkuLWBubSmL/azyQBb67Sxf3t6Q6jFfXBBhX2sX/3ppBxf85NFU2UvSzsZ2JlcWEw33/HWPhkMsmFSe6mGflMzMd8YT1Ld2cc2dL/OuXz3V55ia2mOUF0UoinYH81OqiuiIJQZcyCr9mp2xBKt3NREfoMwGYPb4Mtbtbkn1mK8ojgLw4TPnsamulTuWbetxfFc8QTQS8haNGoEZ7/RFo8DrOrR+z/5tQ0VERKQnBfMy7P7x36/i4689JNCxh04qJ2Tw8rbGVAa9JBrm5LnjKI6GaeqI8ZfntvZ4zI7GdiZW9F7Cs2hKBcu3NfbIoLelTSDd0dDO8m2NrN3dvF+W/bE1e/jmv1fQ1NFFeVEk1R8dYGaN1wJzb8BSm+Sk1c113f3j+5oACzCntpRdTR1s2+dNgq0o8oL51xw2gUMmlvHbJzf1OL4rniAaHrllNi6tzzzA7PEK5kVERIJQMC/DrigaJhIO9qtYFA0zt7aM5dsaaenoLrO58fLjWf6VczhqWiU3PbahR+C9o6GdSRVFvZ5v4eQKGtq62NbQXR/f1hlPBeY7G9vZsLeF9q7EfmUf/3hxOz97cC11LZ2UF0WJhENE/NKYGeO8jjNBJ8Em30BsqmtNWzSq72B+bq33ZmHZFq9EKJmZNzOWzKph9a6ebz464wmifplNcjXYkSSR1mceYLb/ZmUkTtYVEREZSRTMy6hz7IxqnlpflwquiwsiFERChELGu0+exdrdLTy4ajfglW/sampnYmUfwfyUSgCWp/Wbb+2KMXu8Fyw/t6m+zwmxje0xnIM1u1pSwXSy1Ga2vzjVrqZgwXwyM7+9oS1VBtPXolEAc2q9OQbPb/b6ylcUd89lnzO+lIa2rh597mNx1x3Mj8gyG+8++QZmjv/zX79b2XkREZH+KJiXUefsRRNp6ojx26e8UpJKP5AGeOORU5hcWcT1D64DvIWbuuKuz8z8YZPLMaNH3XxbZ5w5taXUlBbwl+e7S3a2N2QE8/6biT3NHZQXecF0UdT7J3XIJK87zla/F/xA2ru8ADvhvMWgoLuzS29m1JRgBs9v3gd0l9kAzPUD/XVpZSrJMptoxOgYgWU2me04Z49PPof9JzSLiIhIt5ysAGtm7+pndwJoAJ5zzm3JxfVlbDtl3nhKC8LcuWwbCyaVc+TUytS+gkiI9546m6/94xWWbd5HJOxFh30F8yUFEeaML90vmC8piLBkZjV3vbwztX1HZjCfNtG2wg/mCyNeZn5GTQlF0RBb9wUN5rvr9Dfu9YL5/rrZFEXDzKgpSR1bkfaGZo5fgrNud3Nqpdwuv8ymMOzVzDvnUpNNR4LMbjYzx3lvVlQ3LyIi0r9cZeZvxFuB9df+1zembbsJ+BuwwcxuNbOCHI1BxqiiaJgzDp0AwMdec8h+5ShvO34G5UURbnhoXWrhpwl9BPMAi6ZU8vK29DKbOMXRMMfP9gLhgoi3iFFmZj69hr7cz4wX+pn5ssIIU6uKB5GZ7w7mN+z1Atj+auYBLjhmaurr0oLuTjrTqksoCIdYl1ai0plWZuMcxBOOts54qj5/+PWcJ1AUDTO1qljBvIiIyAByFcyfgrdA04+B04EF/v11eAszvQH4LHABcHWOxiBj2AfOmMuHz5zHOYsm7revrDDCZSfO5F8vbefJ9XUATOqjZh683vXbGtqp92vMvcx8OJXVnjWuhNryQnY09AzMG9u6J2eWF/plNn5mvqwwwtTqksCZ+fQOOpvrvMcMFMy/5+RZqa/Ts+zhkDFrfAlr04L5rljC6zPvT+xtjyU44//dz68fXR9ofLmWyKiZB29ewModTcM0IhERkdEhV8H8J4HfO+c+6px72Dm3yr//CPA74Crn3P8DvgO8LUdjkDHs8KmVfPKcQ/ssFXnPKbOIhEP8+tENmMGE8r5Xl100xetdv3xbI/GEoyOWoLggzKIpFZQUhJk9vpRJlcWs3NnMF//6YmpiaXqZTbJmvjAaIhwyiqIhLzMfuMzGq2MvSOvq01+ZDXgrwX7h9YdxyZLp++2bM76sR715LJEgErZUr/0V2xvZ2djByxk99odLZs08wNHTq1i1s0kdbURERPqRq2D+bODePvbdB7za//ohYGofx4kcsAnlRbz7pJl0xhKMKy3cb8GodIuSHW22NaQy5MV+u8zvXXI0HzlrPpMrili2eR+3PLGJ+1fsor0r3mPxpVQ3m0iY0oIwZsa06mLqWjpTi1v1J1lmM2t8SWrbALE8AFeeNodvXnTkftvn1JayaW93m8tkmU11iTfOu/25AFsCvtnIte5uNt3blsysJuG8jkIiIiLSu1wF8x3A4j72LQaSPfNCgIpiJSc+fOZ8qkqiTO6nxAagprSAqVXFvLCle1XZEr8G/ZxFkzh8amWPMp11e5pTnWySfeWTNfNF0VDq66lVxQCphZ36kwzm5/hdXMwY0gTVadUlxBIuNWegK+ZNgD1hzjiA1KJSQcZ2MCRSPfG7n/PRM6owg2c2KpgXERHpS0662QB/Ar5iZnHgNmAXMAG4GK9G/lf+cUcDK3M0BslzlSVRfvGuJQSZ4nnMjCqe3VhPe6eXbS8u6PlPIxmYF0VDrN3VkiqxmVNbyqqdzakym0mVxbT4femnVnuPeXxdHRXFUSaU9/2mIhnMz/Y70bghzkudUuVda+u+NqZUFdMVT1AQMaZWFfdYXXVHQzvxhBuwpOdgSR9GRVGUQyeWK5gXERHpR66C+Y8D5cC3/Fu63wKf8L9+CXg8R2MQYYk/iXUgx8yo5u8vbE91kimOhnvsv3jJNGaOK+GPSzezbk8zDf7k18MmV7BqZ3Oq1/2X37iQWMJ7Q5B8A/Clv77Ebx7bwL8++qo+V7pt70oQMphZU9Lr/sGaVt39qYBzjoa2rtTk3FPnjWf9nhZKC8K0dMbZ1dTO5MrirFz3QCUz85mTfhfPrOZvz28jkXD9LqIlIiKSr3JSZuOca3POvRM4DHgP8Dn/fqFz7jLnXLt/3D+ccw/lYgwig3HMjCoAHl27B+gus0mqKing7EWTmFtbxoY9rexr9SrFLjluOl+/4AgW+ItEFReEU2U2EyuKWDSlguNn17B6VzO/e3ozXfEEP7p3NbszVoZt64pTFA0zpSo7QXXyPFvq23h+8z52NXVw0lyvxOaUeeMBUu09R0Kpjf/+h8zKooVTKmjuiLGtYfjHKCIiMhLlKjMPgHNuFbAql9cQyYZFUyooCId4fO1ewAvKezOntpTOeCLVBWZiRREnzx3f67HhkPGP/34Vzjne/vMn+P7dq4iGjO/cvYqyogiXnzI7dWx7loP5koIINaUFbN3Xxh3LtlEQCXHO4ZMAOGvBBD51zqGcPHcc/3hxO1vq21g8E5rau7jwp4/x5Tcu4tT5vT+nXElWFWVm5pNzCNbtbmFadXY+tRARERlLcjUBFgAzm2Rmx5vZaZm3XF5XZLAKI2EOm1LBS1u9xaMyM/NJc2u94PK5zfsAr657IGbGp845lL0tnXz5juXA/iubtnclKI6GU7Xu2TClqojNda3844XtnHlobWqsBZEQHzpzHodM9D5N2LbPmyT79IY6Vu1s5ndPbcraGILqrTUlwNy01WxFRERkfznJzJvZVOBmvIWiwGtR4TK+7j1aEhkmx0yvYpkfpGfWzCfNSQbzfrvE5MTXgSyeWcOp88bzyBqvjGf/YD5OYTRESUH2/klOrSrmvhW76Io73nTUlP32lxZGqCqJ8tfntrKzsZ0i/zk/sHJX6pOCg8Wlgvme0XxteSHlhRHWaSVYERGRXuWqzOanwBHAp4EX8VpVioxox8yo4sbHvK/7KrOpKS1gWnUxW+rbKIyEBhXwfvZ1C/j2f1YSMli1s2emub0r3ucbiAM1taqErrijtCDMqxfsv1Kud0wxy7c1snJnE9UlUYqj3qTYx9bu4aw+HpMLvfWZBy+4n1NbyrrdCuZFRER6k6sym1cBH3fOfcc5d5dz7sHMW46uK3LAjp1Rnfq6vwz5GYfWAqQ62AR1+NRKbrrieI6eXs3WfW2pdpQA7bHsZ8KTJTuvXTixzzcnnz53Ad+68Egqi6PUt3bxtuOnU14Y4YaH1tERi/f6mFxIpIL5/TvWzKktY63KbERERHqVq2C+Da+3vMioMa26mPFlBUDfZTYAZ/pdYCoGGcwnJXvJJ9tgArR1ximKev8cX+dPVB2qWeO865x39P4lNkmnH1LLW4+bzsWLpwFwytzxfPlNC3liXR1f+utLWRlHEKma+V72za0tZXtDe6CVdEVERPJNrspsfg5cBvwnR+cXyToz4+jp1dy7YmcqsO7NSXPHURAOURGwXj7TnPHJSZ0tLJhUAXgTYGtKvTcS11167JBWf006c8EEfnPF8bwqQGea950+l3DIOHX+eIqiYZ7dVM9fntvKtRccQbSP3vjZlJpQ00dmHryf1+FTK3M+FhERkdEkV8H8VuAyM7sX+BdQl3mAc+5X+z1KZJhdtHgqhdFQv8F0SUGEi5ZMC9TJpjez/WA+fRKsNwHW+zQgG4E8eK0xTzukNtCxteWFfO71h6W+P3nueH731GZWbG/iiGm5D6BdatGo/fcdNtl7w/PytkYF8yIiIhlyFcz/zL+fBZzZy34HKJiXEefcwydz7uGTBzzu6xccccDXKC2MMLe2lL88t5UrXzWHgkjI6x4TGTkNno6d6c0feHZT/UEJ5hOJ3rvZgLcqbllhhJe2NfBWpud8LCIiIqNJrj4/nz3AbU6OrisyKnzhDYexZlczP394HQDtsQTFBbkvZwlqSmURE8oLedZvwZlr3YtG7b8vFDIWTqngRX8NABEREemWk8y8c25jLs4rMlactWAir104kZ89sJZ3nTTTmwA7gjLzZsaxM6oPWjCf7GbTV4nREVMrufXJjcTiCSIHoYZfRERktND/iiLD5ENnzqOpI8Yfnt5MeyzeZ/vI4XLU9Co217XR0NqV82u5PlaATTp8agXtXQnWqt+8iIhID1nLzJvZOuAC59wyM1tP9yfnvXHOubnZurbIaHT09CqOm1XNDQ+twzkO6oqrQUyrLgZge2MblSUHNtk3KNdPn3mAw6d4dftPrNvLoZPKczoWERGR0SSbZTYPAo1pX/cXzIsIcOGx0/js7S8CUBgZWR+UTar0Fp3a3tDOt/69kkuOm845iwbugV/f0kl5UWRQ5TD99ZkHmFtbxrEzqvjGv1aweGa1utqIiIj4shY9OOcud86t979+j/99n7dsXVdkNDsmbdXZkVZmM6nCC+aXb23gvhW7+NUj6wd8TFtnnNO+fT+/e2rToK7VPQG293A+FDJ+dtliSgsjfO/uVb0e868Xt3PZL59MdcYRERHJByMrFSiSZ+ZNKEt9PZImwAJMqCgE4KkN9f59HbubOvp9zIodjTS1x1izq3lQ10oMUDMPMKG8iLMW1PLspvpUjX26x9ft5eHVe1i5s2lQ1xYRERnNctVnHjOrAF4PzACKMnY759xXc3VtkdEiHDKqSqLsa+0acZn5wkiYmtICnt3oBfPOwV0v7+DSE2b2+ZiXtnmVdrt6Cfqf3lDHtOpiJlcW77fPpbrZ9D+mY2ZU88elW9i4t5VZ/uJbSfX+RN3H1u5NLTQlIiIy1uUkM29mpwAbgN8C3wCu7uUmIsAhE70JnX2VmAyniRVFNHfEAG9C7H+W7+zzWOccL2/zesH3lsG/6jdL+fF9a/p8LAz8Mzh2RvdiVpn2tXYC8PjaPf2eQ0REZCzJVZnN9/GC+eOAIudcKOM2slKQIsPohNk1AHTE4sM8kv1N8kttJlUUcdaCCTy9vo6ueGK/4/763FaO//q9PLZ2L7B/Zr4rnqC+tYudje29XicxQDebpHkTyigrjPDcpn377dvnZ+afXFdHrJcxioiIjEW5CuYPA77onHvGOdeZo2uIjAkfOWs+Xz1/EW84YvJwD2U/yY42M2pKOHHOONq64rywpYHG9i5e94OHeWZjHQCPrNnD7qYONu5tBWBXU3uPuvZ6P2veW/kNDNzNJikcMo6aXslzm/fPzNe3dlJWGKGpI8bL2xt7ebSIiMjYk6tgfhNQmKNzi4wpBZEQl500a0SubDrR72gz3Q/mwev1/vT6Ol7Z3shDq7ySllfSgufkAk/J8hyA+hYva97XBNqgNfPgldq8sr2J1s5Yj+37WrtSY3xpq4J5ERHJD7mKHr4CfNafBCsio1SyPeWMmhJqSgtYMKmcJ9btZak/KXbdnha64glW72zm7cfP4MNnzuNtx80Aembhk5n5Pc0dvbaOdM5hBhYgmj9mRhXxhOPFLQ2pbZ0x783DEVMrKS+K8PL2hn7OICIiMnbkqpvNG4GJwHozexyoy9jvnHPvztG1RSRLJibLbMZ5HWhOnjueW57cmMqwr9vdzLrdLXTGE5w4p4bzj57Ko2u8bP2uxg7m1nqtN+tbvGC+K+5oaOuiurSgx3USbuASm6Sjp3uTYJ/bvI8T/Ez8vjbv/NWlURZOrmD5NmXmRUQkP+QqM38q3jowjcAi4FW93ERkhDt2RjWvO3wSp8wbD8Dbj59OZyzBih1eL/d1u1tSWfBkO8gJ5V6F3e7m7sx8XWv31Jne6uYdLnA3n5rSAmaPL021zARo8Ce/VpUUsHBKBSu2NxHX4lEiIpIHchLMO+dmD3Cbk4vrikh2VRZH+ek7FzOh3MvQz59YzhmH1gJwkj8h9v4VuymIhJjj932v9YP5XWmda5KdZqD3uvmEG1xrzmOmV/Hc5n2pSbbJHvPVJVEWTamkrSvO+j2DW7hKRERkNBp5M+5EZET72GsO4fCpFbzzRG/xqH8v38HhUypSE3gri6MUREI9gva6lu7M/O7m/dtTJtwg6myAxbOq2d3UkfqEIFmTX11SwKIp3icEKrUREZF8kLVg3sxmmFk07et+b9m6rogcXEdPr+LvH3kVi2d6teudsQRXndb9YZuZUVtW2COYr2/tpLI4CvTR0cZBaBDB/OsPn0xBJMRvn9wEdC8YVVUSZW5tGSGDtbuUmRcRkbEvmxNg1wMnAU/hLRg1UMGqFo4SGcUmVhRSVhhhWnUxZy+c1GPf1Opi1u1pSX1f39LJtOpiOmOJPspsgtfMA1SXFvDGIyfzl+e28tnXLUgrsymgIBJiek1Jj+uLiIiMVdkM5q8A1qZ9rdlnImOYmfGjtx/D9JpiQhlp9WOmV/HrRzfQ3hWnKBqmrrWLmtICmtpjvU6AHUw3m6RLT5jJ7c9u5e8vbKO+tZNo2Cgp8HIEs8aVsl7BvIiI5IGsBfPOuZvSvr4xW+cVkZHrzAUTet1+zIxqrn9oHcu3NbB4Zg37WjuZNa6E1s44uxp76WYzyAmwAMfOqGLO+FJuf3Yrs8eXUlVSkOpTP3t8KUs31Pn96wf7NkFERGT00ARYEcm6Y2dWAfDsxn2ANwG2uqSAhZMrWLqxjjW7mnocP9gJsOB9MnDBMVN5cn0dL21roLokmto3p7aUls54nyvOioiIjBU5C+bNbIKZfdTMrjOzX2Xcfpmr64rI8JtQXsT0mmLufmUntz+7hab2GNUlBXz0NfMpLYzw+dtfwjnHjoZ2vnvXSu5dsXPQmXmANx8zFYCXtjYyvboktX223yYzs25fRERkrMnJCrBmdijwuH/+UmAPUIM36bUe0FrrImPc4hnV/PX5bTy13lsAuro0yviyQj7+2kP48t+Wc//KXXzs98/T2B4DvE40gzW9poRvX3QkITPOObx7Eu6scV4wv2FPCyfOGcfKHU287gcP8cf3ncSSWTVZeHYiIiIjQ64y898GngYm4n14/jqgGPgvoBW4IEfXFZER4pPnHMoP3nY037vkKA6dWJ5qZXnBMVMpiob4qB/Iv/NEr1Nt+sJSg3HxkulcuHgaZYXduYkpVcUUREI87y8s9djaPSQcqb70IiIiY0VOMvPAccD7gWTBasg5FwN+ZWa1wPeBM3N0bREZAaZVlzDNL3254Jhpqe3lRVFed7jXVvLVCybw36+ezy1PbMrqtcMh47T5tfz+6c00tncRDnl5i+0NbVm9joiIyHDLVWa+DKhzziXwSmrGp+17Gi/YF5E8dekJM4iGjQ+cMZcJ5UU5ucbP3nks7z11Nv98cQcPrNgFwPZ9+68+KyIiMprlKpjfACQLWFcCF6fteyOwL0fX3Y+Zvc3MnJlt6WP/lWa2wsw6zGylmb3/YI1NJF8tmVXDi1efk6pf//MHTuKbFx6R1WtEwiHef/pcwiGjqcOry9+mzLyIiIwxuQrm7wZe63/9XeByP1BeDnwU+FWOrtuDmVXhlfTs6GP/lcD1wJ+Bc4E/AdeZ2QcOxvhE8llRtHsR6MUza7jkuBlZv0ZteSFnHur1wp9aVcyOBmXmRURkbMlVzfzngEIA59wfzawNuAQoAX4A/DxH1830LWAZsB14TfoOM4sA1wI3O+e+4G++38ymAF81s1845w5sRp6IjBgfOnMu0bAxsaKI3z21SQtJiYjImJL1zLyZhYEF+ME8gHPuTufcO51zb3HO3eCcc9m+bi/jOAV4J/ChPg45CagFbsnYfjMwDjg1d6MTkYPlmBnV/PSdi5k5roSOWII69ZsXEZExJBdlNg5YChyTg3MHYmZR4Abg2865NX0ctsi/fylj+3L/fmEuxiYiw2NyZTEA21VqIyIiY0jWg3m/g81mvMWihstn8D4Z+L9+jkmuHFOfsb0uY38PZnaVmS01s6W7d+8e2ihF5KCZXOl1zdm2T5NgRURk7MjVBNjrgY+ZWcFQT2Rmr/G70Qx0e8A/fh7wBeDDzrmsp+D8MqElzrkltbW12T69iOTI5CovmN/R2E5bZ7zXoH79nha+f88q0isBdzW18+ymzPf8IiIiI0OuJsCWA3OBdWb2b7wJqOl18s45978Bz/UYcFiA41r9+x8C9wFP+N1sAAoA87/vcM610Z2Rr/bHl5TMyNchImPG+NJCqkqi3Pz4Rn775Ca21LfxxOdf3WPl2N8+uZGfP7ye846aQmtnnFnjS/nuXau4Y9k2Xrz6HMIhY09zB+VFEQoj4X6uJiIicnBkLZg3s3XABc65ZcDn03Zd0cvhDggUzDvnWoEVgxjKQmAm+5fP4G/7AfAxumvjF9EzmE/Wyr88iGuKyAgXChnXXXosV9z4NF1xRzzhuPeVnZx/9NTUMcs2NwDw2Nq9fOXO5Vxx6mye27SPVj+TP72mhLdc9xjTqou5+b0nEA6pK46IiAyvbJbZzKK7HWVogFsuU1pvA87MuP0H2ON//WP/uMf9bZdmPP6deFn5R3M4RhEZBifPHc9fP3QK//zvVzGpoog7l21L7YvFE7y41Qvmb3psA11xx90v72T1riYA1uxuprkjxqa6Vh5bu5f33vQ037lrJUNpzrWrqZ0f37eaRCLnDb5ERGSMylWZzbBxzj2Ruc3M3oNXXvNA2nFdZvYlvEWitgL3AGfhfZLwEeec+teJjEELJlUA8MYjJ3PT4xuoa+mkprSAVTubaeuKA7B6VzMA63a3pB63dlczE8u9uvsjplby9Po6Hli5m7cdP4OpVcUHNJZ/vbiD/3fXKs49fBLzJpQP5WmJiEieynYwP6rSS865n5mZAz4BfArYhDdx9rrhHZmI5Nolx03nxsc28OnblrGlvi0VyJ80ZxyPr9tLeVGEpvYYAMXRMGt3NzOt2gva/+8tR9DWFefinz3Oqh1NBxzM72nuAGBHQ4eCeREROSDZDua/YmZ7AhznnHPvzvK1+7vYe/rZdz1e9x0RySPzJ5bzoTPn8YN7V1NWGKGlM0ZVSZTXHzGJx9ft5R3Hz+CmxzcwrrSQKVVFrN3VwsxxXsfdGeNKcAnvPCt3NnHmggmp8z63qZ7P/PkFbvvAyVQURfsdw55m7wPA7Q1qlykiIgcm28H80UBHgONGVQZfRMamD505j4JIiLMXTmTrvjY6Yglmjy8lEjLOXjSJrrijvCjCzsZ27n55J3MnlFFTWpAK0idVFLFqR1OPc96/cjerdjazemcTi2f2ulxFyt5UZl4LWYmIyIHJdjD/ZufcU1k+p4hIThREQnzozHmAl6lPevHqcyguCLN4ZjUAP39oHb9v2czzm/cxo6Ykddwhk8pZkRHMr9jeCMCW+jYWz+z/+ntbvMz8jkYF8yIicmBytWiUiMioVVzQs+HW8bO9DPsr2xuZOa47mF8wqZw1u5uJxROpbSt3esH95rrWHudwzvHcpvoexyozLyIiQzXmutmIiGTbUdOreM1hE7jnlV2punmAQyaW0xlLsGFvKy9u3UckFGLjXi+I31Lfsw7+sbV7ufQXT3L09Cr+57WHcPLccexN1cwrmBcRkQOjYF5EJIBPn7uAh1fv4ciplalti2dWYwY/fWAtdy7bRjyt53xmML98m9fDfsPeFt79q6d4+/HTaerwuuXsVJmNiIgcoKyV2fiLQaleXkTGpEMmlrPsf8/mNQsnprbNHl/K64+YzJ+f3UIskSDuL/501LRKttT3LLNZvbOZ2vJCnvjcq3nV/PHcucxbeHpqVTF7Wzpp91tjDkZ7l7cyrYiI5C/VzIuIBFQU3X/x6o+9ej4h8/rWnzx3HOVFEU6cO46t+9p6rOy6alcz8yeUURT1JtY2+1n5w6d6i1jtagzSCKyn6x9cxznff4jOWGLgg0VEZExSmY2IyBDMn1jOHR8+lTm1pTS3x9je0M5L2xroijt2NXUwqbII5xxrdjZx8ZLpABw2uSL1+EVTKvnP8p1sb2hjRtrk2iBW7WqiqT3Gih2NHDmtKptPS0RERgll5kVEhujwqZWUFESYUFHEUdOrmFbtBeXJUpvtDe20dMaZN6EMgIVpwfwSv/3lfSt3Dfq6W/26/GWb9w1l+AdVLJ7gFb99p4iIDJ2CeRGRLJsz3ut48+vHNvDxPzzPlb9ZCsB8P5ifVl1MeZH3wejRM6q4ePE0fvnwev714nYa2roCXyc5yfa5LAfz/3xxO5+57YWsnjPp9me38oYfPsxW1fqLiGSFgnkRkSybXlPCp889lH+8sJ07lm1j9c5moHthKjPjsMkVFEfDlBRE+NzrD6OmtIAP3Posp33rfv60dDPOOf7+wja2N/Qe9LZ3xdnj96nPdmb+jue38Yelm9nX2pnV84LX1Sfh4MUtDVk/t4hIPlLNvIhIDnzwjHnMGV/K9JoSnIOVO5qoKS1I7X/d4ZMY539fU1rAvZ84nWWbG/jhvav51G0vsGZ3M9c/uI4J5YX85r3Hs2BSRY/zJzPbc2pLWbu7hcb2LiqKolkZ+5rd3puP5dsaOWXe+KycM/Pcr2xv5NzDJ2X13CIi+UiZeRGRHDn38MksmlLJ4VMruXDxtB77Lj9lNj995+LU9+VFUU6dP55fX34ckyqKuP7BdcwZX4oDPnf7i/udO1li85ZjpgLwwMrd/Y7lvhU7+cJfXsSl9cLvTVc8wYY9LQC8uDX72fPkpxQrdqhuXkQkGxTMi4iMIKWFEb78poUURkJcc/7hfOD0uTy3aR8v+YH1ut3NPL2hjo17vYD7/KOnMrWqmNue2dLnOZ1zfP2fK7j1yU3c/fLOfq+/cW8rMb+l5ktZDuYb2rrY1eSVBr2yvSmr5x7JEgmnOQIikjMK5kVERpjXHzGZ5798NqfOH8+Fi6dRFA1x02Mb+PsL2zjrOw9y8c8e56t/f5lIyJhcWcSFx07l4dW7+6yvf3zdXtbsaiYaNr53z+oe/e8zrdnlZc6nVhXz2Nq9nPHt+/nXi9uH/Jy27mtj6YY6AI6ZUcWmulaa2oNP9h3Nbnt2C6d/637W+594iIhkk4J5EZERqLjAW6CqsjjKW5dM50/PbOHjf1jG0dOreN9pc+iKOyZVFhEJh7hosde//pcPr+9xjlg8weduf4GP/v55qkqifOW8w3lleyMPruq7JGetX9N+3tFTqGvpZMPeVj795xeGlFlu64xz/o8fTXX1edORUwBYsSM/svNPrN1LLOH4cz+fnoiIHCgF8yIiI9yX3riQ958+lylVRfzwbcfwqXMO5ejpVal+9TPGlXDx4mnc9PgG3v2rp7jop4+xs7Gdm5/YyO+e2syiKRV8761Hc/GSaUysKOTXj23o9TrOOVbuaGJSRREXHDOV0w6p5Zb3nkAi4bjk+scDl93c9swW3nLdo7zuBw9z1W+W8o1/vcKe5g7MjIJIiDcdNYVo2PjHC0PP+Oeac472rnjg49s64/zm8Q3saGhPbUu2Dv3Lc1v7/VRExibnHJvrWod7GDKG2UCToaRvS5YscUuXLh3uYYhIHuqIxQmZEQ17OZldTe2c9f8eJJ5wmEEkZHTEEpwwZxw3XX4cZgbAj+5dzXfuXsVd/3Mah0wsp6UjxiNr9nDfK7u4f+UudjV1cMahtdx4+fGpaz23qZ4P3vos8YTjwU+dmfrU4P4VuygrinDcrJrUsZv2tvKa7z7IjHElzKwp4bnN+6hr6eSE2TW866RZrNvdzEdePZ+P/+F5/rN8B49//tW9duH5v3++wt2v7OSMQybw2dctoCASLPeUSDh+eN9qXr1gIkdMq+yxb3tDG7/wP734zLnBzvnzh9bx7btW8tFXz+ewyeWcNGd86vn35if3r+Hb/1lJYSTED952NMfPHsexX72bRVMqWL6tke9fcjRv9ictHyx/fW4rje1dvOukWYGOX7Wzib+/sJ0Pnzkv8M89m7riCcJmhEJ20K+dC397fisf/f3z3P7Bkzl2RvVwD0dGMTN7xjm3JHO7WlOKiIxChZGeAeWE8iL++qFTKC0MU9fSyS8fWU9Te4wvv3FhKpAHePsJM/j5w+u48jdLOWJqJXct30lnPEF5YYTTDqnlxLnjeO1hE3uc+5gZ1fzo7cdw0c8e51ePrudDZ85je0Mb77vlGcJmXH/ZYtbubuaxtXvZsKeFcMi45b0nMKmyiN1NHfzovtW8/fgZHJa28u3lp8zm9ue28oW/vERVcZQn1+9lzvgyXnfEJLbUt3H9Q+s4bHIFv3p0PbFEgmvOP7zHmNq74tz42AZOmjOOmtICCiIhJlYU8bunN/H9e1Zzx7Jt/Odjp6Xe7Nzz8k4+9ofnaeuKE084Xt7WyGdft4BYIsFT6+tZMKmcMxdM6HGNWDzBrx5dTzRkfPs/KwE4dkYVN7/3BAojIVbsaGLRlAoeWLmbO1/YxviyQm5/dgvHz6qhIxbnU396gU+cfQgAn33dAr539yo+ddsyEs5x/tFTufnxDfzm8Y2844QZlBREOGZGVY+fUVJDaxcPrt7Ntn1tvOWYqTS2d1FVUsD4ssJefzfau+LsbupgWnUxtz+7lU/8aRkhg9Pm1zLLX9AMvIxxV9ztF7B/6a8v8eT6Orbta+PbFx3Z4/cnqHW7m7npsQ1cdtKs1MrHQTjnuOyXT9LWleB3V55AScHoCVPiCceW+lZmjuv5M77+wXUA/GnpljEXzDvneGFLAy2dMU6YPY7wGHkDNtooMz8EysyLyGj07KZ6LvvFk5gZFy2extmLJnLcrJpU4NuX/7ppKQ+t2s2ZC2pp60rwxNq9VBRH2NPsLS41c1wJAFecMpt3nzxrwHF8898r+PlDXqBz0txxrNnVzHa/POWUeeO46fLjvWMeXs+Jc2qIxR1rdzcTDYeoKS3oUXNfGAnxwTPm8YtH1lFZHGVLfRsXHjuNU+aNo66lk2v/+QpHTK3kx28/lqc21HH1Hctp7oj1GM97Tp7Fm46awrjSApo7Yjy7qZ4v/205P3vnYubUlvL85n187vYXOW5WNVMqi7n9ua3Mm1DGml3NVJVEaWjrwjn43ZUnMq26mNf/8GGa2mOEQ8aLV59NLOG44tdPs3RjPQWREJ2xBFOrilPzEYqjYT7/hsOYXl3MKfPGc9szW3hs7V7ueXknbX6pT8gg4aAgHOKCY6byyXMOpbbcC+rbu+Jc8/eX+cPTm4knHFUlUfa1dnHMjCqWb2vkzUdP4VsXHQXAxr0tfOKPy9iwt4XrLl3McbOqMTOe3VTPW657jMOnVvDS1kY+9pr5XHHqbB5cuZvOWII3HTWFfW2dLNvcwB+Xbqa0IMyX3riQcWlvLJxzXHLDEzy1vo5IyHjniTO5eMk0IqEQy7bs4+VtjVQUR6kqjnLnC9vY2dDORYun8cEz5/HI6j38lz+34qhplSyZVcOHzpzHf5bv4OHVu6koivLeU2enFmA7UNsb2lixvYmHV++huiTKWYdNYOHkil7fuLR1xomEjXW7W5hRU9LnJzOfue0F/rB0M198w2H816vm8OiaPdz98k5ufGwDNaUFxOIJnvrCayiK9v3JzmDc/uwWvvnvFXzjwiM589AJfR6XSDjaY/GcvDH67t2r+OG9qwH4wBlz+cy5C7J+jWxoaO3igVW7iIZDnLVgAiG/5G+06Sszr2B+CBTMi8hotauxnaKC8KAWmtrV1M6P71vDXct3sqOxnctPmcVFi6fx1Po6zjh0ArPTsr5B7Whox+GYXFlMPOF4fnM9hZEwCyaVEwmH6Ion+PnD67j92a2UFUZYOKWCnQ3tPLm+jv9900L2NHcSDsE/XtjOsi0NzJ9Qxi/ffRzf+s8K/p5Wk/+awyby43cckwqk9rV2ctfLO6kuKeDwqRX88N7V/P7pzWT+lzi5soiHP30mEf+Nzl+f28r//PF5nIOzFkzg+c37eMfxM/jYa+azdGM9L21t4L2nzsbMWL2ziV8+sp6K4iiff/1hgJe9/e1Tm9iwp4XjZlVzzqJJvLClgXDI+OSflqXeoJQXRWhqjzGlsohT54/n7cfPoLwoyh+XbmZGTQmrdzbx26c2EQmFOOuwCdQ1d7J8WwON7TEuPWEG8yaU8eymfZwwu4aLFk/jG/9awY2PbeDYGVWUFkZ4bO1eSqJhqkqjbK5royAc4pBJZWytbyPh4NHPnsXVdyzntme2YEbq51IYCdERSwAwrrSApo4YhZEQpx9SS2lBhPtW7iIaMrY1tPOpcw5le0Mbv31yE+lTBUoKwrR1xXEOplQWccikch5YuZtDJpbR1O6d78rT5vDLh9ezub6VwkiY5o4Y02uK2dvcSWtnnNcunMhxs6rZWt9GYTTMnPGlbNvXxo7GdiZVFDGpspilG+pYtauJS5ZMZ1JlMTc/sZGQQTQcSrVoTX8+M2pK+NCZc5k9vowdje3E4gnueWUn/3xxR2rss8eX8s0Lj2RqdTEb97QwvryQJ9fX8fT6Ou5Yto0ZNSVsqmvllHnjeHztXhL+c/zf8xbxvpuf4T0nz+Kq0+awvaGNF7c0cNzsGtbtbuHJ9XuZUF7E246bTmc8wb7WLtbv8d48HDmtktbOOC9vb2R3Uwd7WzrZ1djOzx5cC3ivzTtPnMl5R0+h3H9tH1y1mxk1JSycXMGvH9vAqp1NnDpvPMfPrqGs0AvqywojzBhXwoyaEmrLCtnR2E484U2s74oneHbjPg6ZWMa4skKaO2I0d8To6PLeFLyyvZH61k4+8+cXeO3CiRRFwvzl+a1csmQ6ZkZlcZST5o6jrTPOn5/dQmHEC6IPn1rJ3uZOPv+XF5k/oSz15nnexDJaO+KMKyugvChKPOHYVNfKjoZ2yosi1JYXUlkcpTASwsxwzttfWRylqqTA/zl4b/aLomEmVxanPiV4fvM+3vPrp9jX2t09KxIyPnjmPA6bVM7U6mKOmFoZ6BOolo4Ym+tb91vE72BRMJ8DCuZFJB8lEo41u5uZNa502LJbzrke//m2dcZ5eXsDx0yvTtVad8YSrNrZxKa6Vl67cOKAnzzsae7g2Y31NLXHKC2MEDKYN6GMObU9y0TuXLaNl7c38qmzD8WMAypD6U1HLM76PS28sr2R3z25mUtPnMF5R03p8/zr/FWC71u5iylVxSycXMEbjpjMqfP3X7U3WZb0rxe3E0s4Tpk3nstPmUVxNMztz25le0Mbr2xvYlxZAZedOJMls2rojCW43g8YT5gzjtbOGPe8spPZ48tYNKWCo6dXsWFvCzc8tI4n1u6lpTPOcbNqqG/tpCAc4ub3Hk8kHGJLfSvPbdpHwjkWTKrgkIllxBOOutZOqksKiIZD3PvKTr757xUUR8N89nWHcdLccQAs3VDHp//8Ahcvns77T5/DvtYufv3oen771Cb2NHdSUhAmFnd0xhOEDMaVFbK3uYOE8940zKgpSb1BGl9WgJnR3B7jfafP4fjZNRw7o5rG9i4eWLmbmx/fuN9CaYWREJedOJOSgjC15YX84N417Gnu2O/nW1NawKsXTODaC47gZw+u5cf3r+GE2TVcd+mxFEfDmBmf+fMLfa4HUVoQpqWz94nWJQVh2rviZM6dPnJaJdddeizfv2c1f31ua2p9CIBZ40rY2dhBW1ecmtIC3nTkZB5evYd1fbRHDYeMuP/45JybrvjA8WFFUYR7P3EGxQVhrrjxadbsaiZkRmNbF51x702SVw7mUp/ggdf6trGti6aMT8cAqkuixOKu132RkFFaGCESMva2dBIymFpdDEBLR5y6Fu8aBeEQU6uLKS0Ms2pHM5Mqi/juW4/yP3Hbx9rdzT0m4E+uLKKkIEx9axchMwojIQoiIQrCIQqjIaLhEK2dcdbsamJSZREPf/qsAX82uaBgPgcUzIuIiBx8zjka2rooK4zQGU+wt7mTSZVFRMMh2rvi7GvtorwoQklBmBU7mtjX2sUR0yopCIdIONdrqUsi4XhxawON7V3UlhdSFAlTXhTpUUK0r7WTR9fspa6lg1njS9nZ2MHhUyv2y9Q2tHVRXhjZbxLvK9sbWbqhjsJomMUzq3l2Yz3zJ5Zz+JQKVuxo4ol1e6koilJRHGV6TTEvbGlg9c5myosiHD29islVRdSUFFBVUtDjjfSe5g6WbqinvSvOwikVHDKxnFg8wbo9LUwsL6KyxPsErrkjRmcskfr5baprZXN9G1vr25hSVURhJMTWfe20d8U5YXYNa3Y1096VoLTQ+1kUREI0t8eYO6GMkoII1SXRHnMEkpo7YryweR+RcIijplcSCYVYvauJFdubaOqIcd5RUwiHjK31bexsbGfd7mbKiqLsae5g495WwiE4cloVU6uKaWqPsae5g4a2Llo6YrR0xGjvSrBoagV7mjrYVNfqdcoKhzh2ZhXxBGysa2FLXRtNHTHmTyjjqtPmMLGiqMcYn9tUTzhkLNvSwDMb6uiMJ6guKcABHV0JOuMJOmNxOmPe18XRMHNryzjtkFpOnjsua2/iB0PBfA4omBcRERGRg6GvYH70Vf+LiIiIiAigYF5EREREZNRSMC8iIiIiMkopmBcRERERGaUUzIuIiIiIjFIK5kVERERERikF8yIiIiIio5SCeRERERGRUUrBvIiIiIjIKKUVYIfAzHYDG4fh0uOBPcNwXTm49DrnB73O+UGvc37Q65wfhut1numcq83cqGB+FDKzpb0t5ytji17n/KDXOT/odc4Pep3zw0h7nVVmIyIiIiIySimYFxEREREZpRTMj043DPcA5KDQ65wf9DrnB73O+UGvc34YUa+zauZFREREREYpZeZFREREREYpBfMiIiIiIqOUgvlRwsymm9ltZtZgZo1mdruZzRjucUkwZjbNzH5kZo+bWauZOTOb1ctxRWb2bTPbbmZt/vGn9XJcyMw+Z2YbzKzdzJaZ2YUH5clIr8zsIjP7s5lt9F+7lWb2f2ZWnnFctZn9wsz2mFmLmd1jZkf0cr5AvwtycJnZOWZ2n5ntMLMOM9tiZn80s4UZxwX6mx3090GGn5n92//b/bWM7fo3PUqZ2Rn+a5p525dx3Ih+jRXMjwJmVgLcBywA3g1cBswH7jez0uEcmwQ2D3grUA883M9xvwSuBL4MvBHYDvzHzI7OOO6rwNXAj4HXAU8AfzKz12d11DIYnwTiwOeBc4GfAh8A7jazEICZGXCnv/8jwIVAFO/f8rSM8wX9XZCDqwZ4BvgwcDbwOWAR8ISZzYTgf7MH+fsgw8jM3g4c1ct2/ZseG/4bOCnt9prkjlHxGjvndBvhN+CjeEHCvLRts4EY8PHhHp9ugV7DUNrX/wU4YFbGMUf52y9P2xYBVgJ3pG2bAHQAX8l4/L3AC8P9XPP1BtT2su1d/mt6lv/9+f73Z6YdUwnUAT8c7O+CbiPjBhzqv16f8L8P9Dc76O+DbsP++lYDO4C3+6/X1wb7Gurf9Mi8AWf4r8tr+jlmxL/GysyPDucBTzjn1iQ3OOfWA4/i/ZLJCOecSwQ47DygC/hD2uNiwO+Bc8ys0N98DlAA3JLx+FuAI8xs9tBHLIPlnNvdy+an/fup/v15wDbn3P1pj2vAy/qk/1sO+rsgI8Ne/z7m3wf9mx3090GG1zeBl5xzv+tln/5Nj30j/jVWMD86LAJe6mX7cmBhL9tldFoErHfOtWZsX44XvM9LO64DWNPLcaDfiZHkdP/+Ff++v3/LM8ysLO24IL8LMkzMLGxmBWY2H7geL3ObDPaC/s0O+vsgw8TMTsX7hO1DfRyif9Njw61mFjezvWb224z5LSP+NVYwPzrU4NVaZ6rD+/hPxob+Xufk/uT9Pud/htfPcTKMzGwqcA1wj3Nuqb95oNe4OuBxeo2H35N4b6pXAUfilVLt8vcF/Zsd9PdBhoGZFeC9Uft/zrmVfRymf9OjWwPwHbzy17Pw5qO9BnjczCb4x4z41ziSqxOLiOQrP1PzN7yyi8uHeTiSG5cBFcAcvMnPd5vZqc65DcM6KsmmTwPFwLXDPRDJDefcc8BzaZseNLOHgKfwJsV+cVgGNkjKzI8O9fSeoenrXaCMTv29ztD97r4eqPJn2Pd3nAwDMyvGq6WcA5zjnNuStnug17g+4HF6jYeZc+4V59yTfh31q4Ey4LP+7qB/s4P+PshB5pdZfAH4ElBoZlVmVuXvTn4fRv+mxxzn3LN4n7gd528a8a+xgvnRYTleLVamhcDLB3kskjvLgdl+W7t0C4FOumvklwOFwNxejgP9TgwbM4sCtwFLgNc7517MOKS/f8ubnHPNaccF+V2QEcA5tw/vNUnWxAb9mx3090EOvjlAEV5jgfq0G3ifxNQDR6B/02NZspR1xL/GCuZHhzuAE81sTnKDeQsOneLvk7HhTrzetRcnN5hZBLgEuMs51+Fv/jfejPlLMx7/TryOC+sPwlglg99L/la8uss3O+ee6OWwO4CpZnZ62uMqgDfR899y0N8FGQHMbCJeT/m1/qagf7OD/j7Iwfc8cGYvN/AC/DPxgjP9mx5jzGwJXrvZp/xNI/41tv3n0MlI4y8ysgxow6vfcniTNMqBI5W9GR3M7CL/y1cD7wc+COwGdjvnHvSP+T1e68lPAevxFh16I3Cy/9Ff8lzfAD6Gt0DRs3h/LN4HnOec+/vBeD7Sk5n9FO91vRbIfA22OOe2+AH/I8B0vNe4Hm/RoSOBo5xzm9POF+h3QQ4uM/sL3r+5F4BG4BDgf4BJwPHOuVVB/2YP5vdBRgYzc8C1zrkv+t/r3/QoZma34r0WzwL7gGPwXr9W4Fjn3J5R8Rrnsom9btm7ATOAP+P959EE/JWMRYd0G9k3vP/Qe7s9kHZMMfBdvDZ37XgdM87o5VxhvCBhI15HjReAi4b7OebzDdjQz2t8ddpxNcCv8OonW/EW+zqql/MF+l3Q7aC/zp/BWwF2n//6rcTreDIr47hAf7OD/j7oNjJuZCwaNZjXUP+mR94NLyh/Aa+rTRewGbgBmDyaXmNl5kVERERERinVzIuIiIiIjFIK5kVERERERikF8yIiIiIio5SCeRERERGRUUrBvIiIiIjIKKVgXkRERERklFIwLyIyADNzAW4bApznPWZ2xRDGcbW/aE2Q48460OsMcG5nZlcfwOPO8B97RtYHNUolX09/lUgRkQOiPyAiIgM7KeP7v+Ct8Hl12rYgS3W/B+/v7q+yMqq+/S/eSrT35eDcJwFbDuBxz/qPfTm7wxERyW8K5kVEBuCceyL9ezPrAPZkbh+NzKzQORfkjQiw/89iEI9rBEb9z0tEZKRRmY2ISBaY2fFmdo+ZNZtZi5nda2bHp+1/ADgdOCWtNOcBf1+tmV1vZqvMrNXMNpvZb81s6gGMI1mG84W061zt77vRzLaY2Ulm9piZtQHf8ve9zczuM7Pd/nN4zsze3dv508ts0kpF5pvZP/zHbjSzL5tZKO24/cpszOwBM3vEzF5jZs/6z/0lM7ugl+u+3cxWmFm7mb1oZuf5j38gwM+kxMy+aWbrzazTv/9CH+O70P851ZtZo5ndambjMs5XYWY/NrNtZtZhZivN7H/MzDKOqzWz6/zXs8O/v9nMCjOGOHuAn12Zmf3IzDb559nl/64tGOi5i8jYp8y8iMgQmdmRwIN4JSTvARzwWeBBMzvRObcM+CBwCxAG3uc/tNG/rwHagc8Bu4EpwCeAR81sgXOufRDDOQl4HLgRuN7fll4WUwn8Hvh/wOeBNn/7HOA24BtAAjgN+IWZFTvnfhbgun8Bfg18D3gT8BVgs7+tP3OBHwD/B+zBe95/8p/3GgAzey1wK3AH8HGgFvg+UASs6u/kfj36f4CFwFeBF4ETgS/h/dw/kfGQ7wP3AG8H5gNfx3s9zvTPFwL+ARwLfNk/3xuA7/rj+rx/XDXwmH+NrwEvABOA84ECepZlDfSz+x5wnn/u1cA44BSgqr/nLiJ5wjmnm2666abbIG7ABuCWtO9vA/YBVWnbKoA64Pa0bQ8AjwQ4fxiYjvem4IK07Vd7f7YHfLwDvtbL9hv9fecP8PgQXrLn58CyXs59deaYgMszjnsRuCvt+zP8487I+Hl0AfPTtk0A4sDn07Y9BrwEWNq2xf75HhjguVzmH3daxvYvAJ3AhIzx/TvjuEv97a/2v3+j//17Mo77BV6APt7//hr/eRzTz9iC/uxeAr473L/3uumm28i8qcxGRGToTgP+7pzbl9zgvBrxO/BKawZkZh8ws2Vm1gzEgE3+rkOzPNYu4O+9XH++mf3OzLb6x3QB/zWI6/8j4/uXgBkBHrfaObc6+Y1zbhewK/lYMwsDS4A/O+dc2nHPAOsDnP9cYCPwmJlFkjfgLiCKl6VP98eM7/+E90lFchL0af73v8047ha8jHvyuLOBp51zzwUY40A/u6eB95jZ581sif8zEREBVDMvIpINNcD2XrbvAKoHerCZfQS4Dq+84y3A8XQHmUVZGmPSbudcPOP6ZcDdwFF45UGvAo7D67qTWd/dl7qM7zsINvbMx2U+djxe0L2rl+N2Bjj/BGAm3W9Qkren/P3jMo7vcU7nXCdQDyTnL9QAdf72dDvS9ifPG7Trz0A/u4/glUxdgRfY7zKz75lZScDzi8gYppp5EZGhqwMm9bJ9El4gOJC3Afc651L122Y2O0tjy9Rbn/qT8ALeVznnHkkbw0j4P2IPXvA9oZd9E+n+BKMve/Ey+G/tY/+GXs6ZYmYFeG/Itvqb6oAaMyvICOgnpe1PjnvQE5h745xrxptP8TkzmwlchDe3oRP4TDauISKjlzLzIiJD9yDwejMrT27wv34TXl14UgdQ3MvjS/AC1nSXD2E8nX1cpy/JDG9qDP4EzvOHMIas8D9FWApcmN4txswWA0He8Pwbb/5Bs3NuaS+3PRnHZwb9F+P9X/m4//2D/vcXZxx3Kd7PPXncXcDxZnZUgDEG5pzb6Jz7Dl5d/eHZPLeIjE4jIesiIjLafRVvYuS9ZvZNvOz3Z/CC5GvSjnsZ+KCZXQKsBZqccyvxAs7PmNnn8co/zsLLvh6ol4E3mNm/8T4Z2Oac29bP8Y/hddb5iZn9L1AKfBEvu1w5hHFky//iBcd/MbMb8EpvrsYrbUkM8Nhb8d4Y3Wtm38Fb7KsAr4vOecCbnXOtaccvMrNf43X8OQRv8a0HnHP3+vv/BTwC/MzMaoHlwOvx5hf8X9qbg+8B7wDuMbOv4QXf4/HeIL3fOdcU9Mmb2eN48y9eBJrx5mEcBdwU9BwiMnYpmBcRGSLn3At+//Rr8QIsw1sg6XTntaVM+ibehNJfAGV4Wd4z8AL+KuB/8GqlHwTOAdYd4JA+DPwQuBOv5v0r9FytNnP8u/3e7t/B68yzDa9dZA1eID2snHN3m9ml/lj+AqzBayn5ZaBhgMd2mdk5eHMBrsLL5rfgvZn6B142Pd1H8YL8P+B1FboT+O+08yXM7A14LSs/g1cbvwGvZeb3047bZ2an4LWl/Kx/3E68VXkzrzmQh/A+Mfgs3v/b64D/cc79cJDnEZExyNKaA4iIiIwKZjYNL6i/1jn31Syc7wzgfuC1zrl7hno+EZGDRZl5EREZ0cysGG9RpnvwSn/mAJ8GWvE+5RARyVsK5kVEZKSL43WL+TFeuUoL8DBwsXOut5agIiJ5Q2U2IiIiIiKjlFpTioiIiIiMUgrmRURERERGKQXzIiIiIiKjlIJ5EREREZFRSsG8iIiIiMgopWBeRERERGSUUjAvIiIiIjJKadGoIRg/frybNWvWcA9DRERERMa4Z555Zo9zrjZzu4L5IZg1axZLly4d7mGIiIiIyBhnZht7264yGxERERGRUUrBvIiIiIjIKKVgXkRERERklFIwLyIiIiIySimYFxEREREZpRTMi4iIiIiMUgrmRURERERGKQXzIiIiIiKjlIJ5ERkx2rvifOCWZ9hc1zrcQxERERkVFMyLyIixcW8r/3ppB89uqh/uoYiIiIwKCuZFZMSIJ1yPexEREemfgnkRGTGSQXxMwbyIiEggCuZFZMSIO2XmRUREBkPBvIiMGPFEAlBmXkREJCgF8yIyYsQT/n3yCxEREelXJMhBZnYicC5wIjAFKAb2ACuBB4G/OufUfkJEhiSmzLyIiMig9JuZN7N3m9mLwGPA/wAlwGrgSaAeOAH4BbDVzG40s9k5Hq+IjGGJZGZewbyIiEggfWbmzewFoBb4DfAu4Hnn3H7/w5pZJfBG4FLgZTN7j3PuDzkar4iMYcrMi4iIDE5/ZTa/BK53zrX3dwLnXANwK3CrmR0FTMri+EQkjyTUzUZERGRQ+gzmnXM/GOzJnHPLgGVDGpGI5K1YXH3mRUREBkPdbERkxOjOzKubjYiISBB9BvNm9qyZLUr73szsh2Y2LeO4JWbWmMtBikh+iGkFWBERkUHpLzN/NFCaceyHgAkZx4UzjhMROSDJWvl4XMG8iIhIEIMts7GcjEJEhO5gXpl5ERGRYFQzLyIjRiozr2BeREQkEAXzIjJiKDMvIiIyOP31mQcImVky4A/3si19u4jIkMTVzUZERGRQBgrmH+1l25O5GIiIiDLzIiIig9NfMP+VgzYKERFUMy8iIjJY/a0Am5Ng3symA98DXovXHece4GPOuU0BHlsEfBV4J1AFPA98xjn3UNoxh+C10DwTmAM0AU8DX/JXqM0855XAJ4DZwAbge865nx3wExSRA6bMvIiIyOAc1AmwZlYC3AcsAN4NXAbMB+43syC96n8JXAl8GXgjsB34j5kdnXbM2XiB/E3Am4APArXAE2a2OGM8VwLXA38GzgX+BFxnZh84wKcoIkOgPvMiIiKD02dm3szmAgudc3dmbD8L+AawEC+Y/rZz7oaA17sSL1t+qHNujX++F4DVwPuA7/YznqOAdwBXOOd+7W97EFgOXAOc5x/6e+AnzjmX9tj78LLuHwXe5W+LANcCNzvnvuAfer+ZTQG+ama/cM51BXxeIpIFWgFWRERkcPrLzH8J+Gz6BjM7FPg7cBjwH6Ad+KmZXRDweucBTyQDeQDn3Hq8ibbnB3hsF/CHtMfG8IL3c8ys0N+2Jz2Q97c1AKuAqWmbT8LL2N+ScZ2bgXHAqQGfk4hkSSIVzKubjYiISBD9BfMn4JWdpPswUAC82jl3IXAUcK+/PYhFwEu9bF+Ol+kf6LHrnXOtvTy2AJjX1wPNrAY4HHgl43z0Mp7l/v1A4xGRLItpAqyIiMig9BfMT6Fn8AvwOuA559xTAM65BPAL4OiA16sB6nvZXgdUD+Gxyf19+RHeZNvvZ5yPXs7Z7/nM7CozW2pmS3fv3t3vgEVkcBL+h2ox1cyLiIgE0l8wb0A89Y3ZBLx698ze89uAsuwPLTvM7HN4tfYfTi/vOVDOuRucc0ucc0tqa2uHPkARSVFmXkREZHD6C+bX4ZXaJL0WcMD9GcdNAPYEvF49vWfg+8q6B30sdGfUU8zs/cDXgS86537Vy/no5Zx9nk9Ecks18yIiIoPT36JRNwFfMbMGYCdef/c9wF0Zx52B140miOV016qnWwi8HOCxF5hZSUbd/EKgE+iRdTezy4DrgO84567t43z449mecT4CjEdEskyZeRERkcHpLzP/E7wFnX6I10GmBq8tZFvyAL9v/Nv944K4AzjRzOaknWMWcIq/rz93AlHg4rTHRoBLgLuccx1p2y8Afg38wjn3yT7O9zjem5NLM7a/Ey8rn1lOJCI5pkWjREREBqe/FWA7gbeY2Wy8QH6Fc64l47AQ3mJLQWvRf47X+eZvZvZFvLKdrwKb8RZvAsDMZgJrgWucc9f443nOzP4AfN/MosB64AN4K7demvbY04DfAcuAG83sxLTrdzjnnvPP12VmX8JbJGor3huSs4ArgI/4z19EDqK4MvMiIiKD0l+ZDZDqA7++j33NwDNBL+aca/EXnfoeXj93w2tt+TH/XEkGhNn/k4PL8RZ6+hpQhRewn+ucezbtmLOAQuBY9s+ubwRmpY3nZ2bmgE8AnwI24U2UvS7ocxKR7Ik7ZeZFREQGo78VYOf0ta83zrl1AY/bBFw4wDEb8AL6zO1twMf9W1+PvRq4OshY/OOvJ+1TAREZPvG4MvMiIiKD0V9mfg1eGUxQ4SGORUTyXHdmXt1sREREghiozKYJ+DPwMIML7EVEBi1VM69Fo0RERALpL5i/HHgX8B689pO3AL9xzq3N/bBEJB+pm42IiMjg9Nma0jl3k3Pu1cBM4Jd4LSFXmdmjZnaVmVUerEGKSH5QNxsREZHB6a/PPADOuS3Oua875xYCJwHP4nWU2WFmX871AEUkfygzLyIiMjgDtqZM55x7yszi/uOuBI7KyahEJC9pBVgREZHBGTAzD2Bm083ss2a2HHgKOAL4EPDeXA5ORPJLQt1sREREBqW/PvPlwEXAZcDpwAY0CVZEckiZeRERkcHpr8xmB9AF3A5cQ1p7SjPbL6PvnFMqTUSGJKGaeRERkUHpL5gv9m/v9m/9cQOcS0RkQMnyGue8wD4U2m8haBEREUnTXwD+lYM2ChERIL1UPpZwFCiYFxER6VefwbxzTsG8iBxU6RNfVTcvIiIysEDdbEREDoZ4WvyujjYiIiIDUzAvIiNGXJl5ERGRQVEwLyIjRjyjZl5ERET6p2BeREYMZeZFREQGR8G8iIwY6QG8MvMiIiIDUzAvIiNGejAfjyuYFxERGYiCeREZMeLOEfZ7y6ubjYiIyMCGHMybWZeZxbIxGBHJb/G4ozDi/VlSzbyIiMjA+lsBNqjfoAy/iGRB3DkKIiFaO+OqmRcREQlgyMG8c+692RiIiEg8ocy8iIjIYCijLiIjRjzhZeZB3WxERESCCJSZN7MZ/exOAA3OuabsDElE8lUs4SiMhIGePedFRESkd0HLbDYA/abJzGwd8C3n3M+HOigRyU+JhKMg7GXmu9SaUkREZEBBg/n3A58H9gF/BnYCk4ALgUrgOuA04Gdm1uWcuzHrIxWRMS+WcBRGVTMvIiISVNBg/hBgqXPuoozt15jZn4FJzrk3mtnNwEeBG7M4RhHJEwnXnZlXzbyIiMjAgk6AfSfwiz72/QK41P/6T8ChQx2UiOQnLzOvmnkREZGgggbz5cD4PvbVAmX+141AfKiDEpH8k0g4nKM7M6+aeRERkQEFDeYfBL5uZovTN5rZEuBa4H5/03xgU/aGJyL5Iu684F018yIiIsEFDeY/BHQBT5nZejN70szWA08CHcBH/OPKgJ9kf5giMtYlg/dC1cyLiIgEFmgCrHNuvZktAC4HTgAmAy8BTwA3Oue6/OO+l6uBisjYlgrmlZkXEREJLGg3G/yA/Qb/JiKSVckyG3WzERERCS5QmY2Z/cXM3mxm0VwPSETyUzyezMyrm42IiEhQQWvmDwVuB3aY2XVmdmIOxyQieUiZeRERkcELFMw75xYCxwE3A28BHjWz1Wb2ZTObk8sBikh+SNXMR1QzLyIiElTQzDzOuWeccx8DpgJvAp4GPgOsNrOHczM8EckXyeC9IKI+8yIiIkEFDuaTnHNx59w/nXPvAC4AtgEnB328mU03s9vMrMHMGs3sdjObEfCxRWb2bTPbbmZtZva4mZ3Wy3EfN7M7/eOcmV3dx/lu9Pdn3r4f9PmISHYoMy8iIjJ4gbvZJPllNZcBlwJzge3AdwI+tgS4D683/bsBB3wNuN/MjnTOtQxwil8CbwA+BazD63//HzM7yTn3fNpxV+KtRvtX4P0DnHM3cF7Gtu0DPhkRyaruzLw3AVY18yIiIgMLFMybWTVwCV4QfyLQCvwF+CBwr3Mu6P+6VwJzgEOdc2v8c78ArAbeB3y3nzEcBbwDuMI592t/24PAcuAaegbki5xzCTOLMHAw3+mceyLg+EUkR2L7ZebVzUZERGQgQctsdgA/BlrwMuoTnXPvcs7dM4hAHryA+4lkIA/eglTAo8D5AR7bBfwh7bEx4PfAOWZWmLZdUYDIKJNwGTXzysyLiIgMKGgw/wVghnPubOfcLc651gO83iK8lWMzLQcWBnjs+l6uvRwoAOYd4JgmmNkeM4uZ2Soz+4yZhQ/wXCJygJITXqNhI2SqmRcREQkiUJmNc+7/Zel6NUB9L9vrgOohPDa5f7CeB57Be0NQhDeh9/+A+cB/9fYAM7sKuApgxoxA83ZFJIBkZj5kRiQUUmZeREQkgEFNgPXr1g/FC3x7cM79JluDOlicc9/P2PRPM2sGPmZm33TOre7lMTcANwAsWbJE0YZIliSD90jYCIdMmXkREZEAgk6ArQL+gTf5FcD8+/T/bYME8/X0noHvK+ue+diZfTwWujP0Q/U74GPAEryJuSJyECSDdy8zb3TGNPVFRERkIEFr5r8OjANOwwvkLwDOAm7FaxF5fMDzLMerfc+0EHg5wGNn++0tMx/bCazZ/yFDorSgyEGUDOYjoRCF0RCdcQXzIiIiAwkazJ+DF9AnWzhucc494Jx7F3AP8NGA57kDONHvVQ+Amc0CTvH39edOIApcnPbYCF7LzLuccx0BxzCQS/EC+aezdD4RCSCVmQ9BYSSszLyIiEgAQWvmJwPrnHNxM2sHytP23Y7XHjKInwMfBv5mZl/EC5q/CmwGrk8eZGYzgbXANc65awCcc8+Z2R+A75tZFFgPfACYjReAk/b4JcAsut+sLDSzi/yv/+mca/WvcbM/9jVAId4nDu8BrnfOrQ34nEQkC3pk5iMhOhTMi4iIDChoML8DqPK/3gicBDzgfx+4JaRzrsXMzgK+hxdIG3Av8DHnXHPaoQaE2f+Tg8uBa/FWja0ClgHnOueezTjuw3j98JMupjujPxvYADTh1dl/BpgIJIAVwH8D1wV9TiKSHXG/m0045PWa7+iKD/OIRERERr6gwfwjeJNf/44XhP+vXx4TwwuaByqRSXHObQIuHOCYDXRPsk3f3gZ83L/19/j34GXY+zumDnhzf8eIyMGTXPE1rMy8iIhIYEGD+a8AU/yvv403GfYSoAQvkP9I9ocmIvkkOd81bEZhJExHTJl5ERGRgQRdNGotXg07zrku4BP+TUQkK7oz80ZhNERzR2yYRyQiIjLyBe1mIyKSU6nMfMgojITUzUZERCSAPoN5M/u4me230mt/zOxYMzt36MMSkXwTS8/MR8KqmRcREQmgv8z8ZcB6M/uGmR3V10FmVm1ml5nZXXgTZSuyPUgRGfsSqW425k+AVc28iIjIQPqrmT8WL6D/BPBpM2sEXgR2Ax1ANTAHmOt//wdgod+JRkRkUGLxZJ9581tTKjMvIiIykD6DeeecA34D/MbMTgDOBU7AC+CLgL3Aw3h93//mnNuX89GKyJiVzMybodaUIiIiAQXtZvMk8GSOxyIiecxfANbvZqPWlCIiIkGom42IjAipmnnr7mbj/G0iIiLSOwXzIjIiJBLJMhsvmE84iCUUzIuIiPRHwbyIjAjJuD1kUBgJA6huXkREZAAK5kVkREhvTVkQ8f40dXSpbl5ERKQ/CuZFZESIZ5TZgDLzIiIiA1EwLyIjgksvs4l6f5o6FcyLiIj0K3Awb2alZvbfZnabmd1vZvP97W8zswW5G6KI5IOeK8CqZl5ERCSIQH3mzWw68AAwDVgBHA6U+7vPBF4D/FcOxicieSLuB/OhHmU2qpkXERHpT9DM/HeADuAQYDFgafseBF6V5XGJSJ5JltmYutmIiIgEFigzD7wWuMo5t9HMwhn7tgJTszssEck3yT7zYUvvZqNgXkREpD9BM/MFQFMf+yqBWHaGIyL5qrvPvMpsREREggoazL8AXNjHvtcBz2RnOCKSr5I186ZuNiIiIoEFLbP5NnCbmQH81t+20MzOB94LnJeDsYlIHnHOEbJkn3nVzIuIiAQRKJh3zt1uZh8EvgFc4W/+DV7pzYedc//O0fhEJE8knCPkJQxUZiMiIhJQ0NaUlcCvgZuBk4AJwF7gMedcX7X0IiKBxRP0EswrMy8iItKfAYN5M4vgBe4XOOfuBO7J+ahE8pxzjpbOOGWFQSvhRj/nHCF/Fo+62YiIiAQz4ARY51wM2Ano826Rg+TBVbtZ8rW7qW/pHO6hHDQ9y2ySNfP6syMiItKfoN1sbkErvIocNDsb22nvSrC3pWO4h3LQpJfZRMOGmbrZiIiIDCToZ/gbgHeY2dPA34DtgEs/wDn3q+wOTSR/xf0Ytq0zf4LZhN/NBpIdbUKqmRcRERlA0GD+J/79VGBxL/sdoGBeJEuSPdfbuvKnzMSrmbfU94WRsIJ5ERGRAQQN5mfndBQi0kMikX/BfDytZh7wM/P58/xFREQORNA+8xtzPRAR6ZZIZuY78yeYTTh6BPMFkZC62YiIiAxgUH3vzOxw4HSgBqgDHnDOLc/FwETyWdzPzLfnUWbepdXMg5+ZjyuYFxER6U/QRaMiwI3A24G0/25xZvZb4D3OufyJOkRyLJFWM//JPy3jrAUTeP0Rk4d5VLkVT2SW2YSVmRcRERlA0NaU/wu8FfgyXv18sX//ZeAS/15EsqS7m02cO57fxsOr9wzvgA6ChINw+gTYqGrmRUREBhK0zOadwNecc9embdsIXGtmYeByvIBfRLIgmZlvaOuiM56gtTM2zCPKvYRzWGaZjbrZiIiI9CtoZn4K8Fgf+x7z98tBtmzzPnY3ddDcEWPZ5n3DPRzJomQ3mz3N3qJRLR1jP0Od6K3MRsG8iIhIv4IG89uAU/rYd7K/Xw6y83/yKKd9635ueGgdF/3ssbyaLDnWJfvMJ4P5/MjM9yyz8brZ6HdaRESkP0HLbG4FvmBmCf/r7cAk4G3AF4Bv5mZ4MpC2rjgvbW2gK+7Y1djBjHElwz0kyYLuzHwnAC150KKytzKbTnWzERER6VfQzPzVwG3AV4DVQDOwBrjW335N0Aua2XQzu83MGsys0cxuN7MZAR9bZGbfNrPtZtZmZo+b2Wm9HPdxM7vTP86Z2dX9nPPNZvacmbWb2UYz+6I/D2DUWL6tAYAdje3DPBLJFj+WTyuzyYfMvLrZiIiIDFagYN45F3POvQM4AvgwXveaDwNHOOcudc4FijTMrAS4D1gAvBu4DJgP3G9mpQFO8UvgSv/6b8T7hOA/ZnZ0xnFXAhOAvw4wnnOAPwNPA68DfgB8Efh6kOczUuxs7PDvFcyPFckym91NfplNPgTzCQhbZjcbBfMiIiL9GdSiUf4CUUNZJOpKYA5wqHNuDYCZvYCX7X8f8N2+HmhmRwHvAK5wzv3a3/agP55rgPPSDl/knEv4/fHf3894vgE84py7yv/+fjMrA75oZt9zzu04kCc5XBTMjx3JMptWv7wmX8ts1JpSRESkf4Ey82Z2eV+lKmZ2tZm9O+D1zgOeSAbyAM659cCjwPkBHtsF/CHtsTHg98A5ZlaYtn3AdJ6ZTQeOBm7J2HUzEMXL1I9YyWAvKWQK5seSZGvKpPyYAKtuNiIiIoMVtGb+o8DePvbtAj4W8DyLgJd62b4cWBjgseudc629PLYAmBdwDOnnI3M8/puL1gDjGVbxtGCvprSA6TUlqXIbGf0y5312xR2dYzyw7a2bTWcsgct4YyMiIiLdggbz8+i7vOYVYG7A89QA9b1srwOqh/DY5P7BSB7f2znr+zqfmV1lZkvNbOnu3bsHecnsicW9AGdCeSGXnjCDiRVFmgA7hmRm5mHsZ+e9zHz394UR78+TOtqIiIj0LWgwHwPG97GvNktjGRWcczc455Y455bU1g7fU48lvADnqtPm8ImzD2ViRRG7FMyPGfHE/sF88xifBBtPOKxHmY3350mlNiIiIn0LGsw/Rd8TSd+P1w0miHp6z8D3lXUP+ljoztAHlbxeb+esPoDzHVTJYC9ZljCpopAdje0qSRgjes/Mj+3JoC6jzKYw6nWIVXtKERGRvgXtZnMtcI+ZPQn8AtgKTAX+CzgWeG3A8yynu1Y93ULg5QCPvcDMSjLq5hcCnf+/vfuOk6sqHz/+eaZur8lueg8JoYTQBOlBQb8giIiKFVTs3a8FFEGK5WcBVPBrxQKKiiAigvQgvYckQHpvu9nep53fH+fe2dnZKXeT7fu8X6957c6dc++cmTubPPfMc56DrXs/EG7a0CHAU+5GEZkDFHnoz4iKOcF8wAl+assK6I4maO2OUV4YHMmuqUGQKZgf77Xms6XZaEUbpZRSKjuvdeZXAO/E1m7/BfAv5+dk4HxjzKMen++fwHEiMs/d4ATPJziP5XI3tsrMBSn7BoB3A/cbYwY0+9MYsw1YCbwv7aH3Y6vm3DuQ4w233pF5ewprygoArWgzXmRKsxnvI/OaZqOUUkoNnOc688aYu4C7RGQRUA3sM8asG+Dz/Qq72NRdIvJNwABXA9uxFwcAiMhsYCNwlTHmKuf5XxKRvwDXi0gQ2Ax8EphLWkAuIkcDc+i9WFkiIu90fv93ysj+ZcC/ROQXwJ+BZdhFo24Y7TXm00fmJxWHAGjsiIxYn9TgSZ3zWRj00xWNj/uR+X5pNm4wr2k2SimlVFYDWjQKwBiz1v1dRKqNMdlKVmbat0NElgPXYeu5C/AQ8AVjTHtKUwH89P/m4GJsys81QAV2ZP0txpgX09p9BrvCrOsCekf05wJbnP782wnyrwAuAvZiV3+91utrGinxeN+c+XDQqfyho5jjQurch5qyMFsbOumYANVsgr6+deZBq9kopZRSuXgK5kXkEqDCGPMD5/5h2DSUqSLyEnC215FsJ73l/DxttmAD+vTtXcCXnFuu/S/CBude+nMHcIeXtqOJW80m4LdvU8jvTBbUYH5cSF1HoKbUCeZ7xnmaTb9Fo9yR+fH9upVSSqkD4bWazWeBrpT7PwaasYtFlQNXDWqvVF7p1Wx0ZH58Sc2Zd+dDjP868/TNmQ9qzrxSSimVj9c0m9nA6wAiUg6cArzdSVNpAL47RP1TWaTnzGvlj/EltZrN5JIwwLgfmTfG4O9TzUa/bVJKKaXy8Toy7wPc/1FPxE5cfdS5vx1b5UYNo/RqNqGAjsyPJ4mU01hWEKAw6B/3I/PxRJY0G71AVUoppbLyGsyvB85yfn8P8GRKRZhpjPIFlsaj/iPzOoo5nqTmzBeHAxSHA3SM89KU6Wk2eoGqlFJK5ec1zeaHwB9F5EPY1VEvSHnsNOCVwe6Yyi2ePgFWRzHHlURKznxJQYDisH8ClKY0+FOGF/QCVSmllMrPUzBvjPmTiGwD3gA8Z4x5LOXhveRf8EkNslh6aUodxRxX4sZQURSkuTNKVVGIolBg3OfMZ02z0Wo2SimlVFYDWTTqceDxDNuvGNQeKU/iyTQbn/NTENFRzPEiYWB2dTE3vXcRx8yt4jePbx73OfOJ9NKUWs1GKaWUymvAi0ap0SGWVppSRAgHfDoyP04kErayyxsXTAKgKByguXN8r+5rDPhSFo0K+TWYV0oppfLxOgFWjTLxtAmwYHOMNfAZH+IJk7xQA6goDNLaFR3BHg09u2hU7/2A30fAJzoPRCmllMpBg/kxKn1kHuwkWA18xof01VDLC4M0j/NgPj3NBuxnWr9tUkoppbLTYH6MSq9mA3bCoI7Mjw8mLbCtKArS0hXtU+VmvEkk6BfM62daKaWUyk2D+TEqvc48uCPzGviMB+lpNuWFQYyBtu7xOwk2kZZmA07qWFQ/00oppVQ2Aw7mRaRGRGal34aicyq73tKUvacwHPB7TklIJAzfums16/a2DUn/1IGJp00GrSgKAdDcNX4nwWZKswkHNXVMKaWUysVTNRsRKQNuAN4NhLM08w9Wp1R+mUbmB5KS0NQZ4Q9PbWVmZREH1ZYOSR/V/jPGVrNxVRQGAWgZx3nzibQLGNA0G6WUUiofr6UpbwTOB34DrAJ6hqxHyhM3Z77fBFiPC+y4FwPduiDPqJS+gFJFkQ3mmzvHcTCf6J9mo6ljSimlVG5eg/m3AF8xxtw4lJ1R3mUbmW/v8ZZT7abjaKA0OsUTJi3Nxgnmx/XIfIY0mwGkjimllFIT0UBy5tcOWS/UgMUzlKYMB3yeJwtG47adjsyPTglj8KcEtmVums04XjgqYfp+nsFNs9HPqFJKKZWN12D+NuBtQ9kRNTDuBNhA+gTYuNdg3kmz0UBpVLL54733ywsnRpqN9Ktmo2k2SimlVC5e02zuB64XkVLg30BjegNjzMOD2TGVW3Jk3r9/i0a5I/Na9m90SqTlzIcDfopC/gmZZqOfUaWUUio7r8H8Xc7PucBFKdsNIM5PrWYzjLJWs/EY+Lgj+N066jkqxY3pl3JSURgc99Vs+qXZaGlKpZRSKievwfxpQ9oLNWCZqtmEAz7PaTZumo7X6jdqeMUTfXPmAcqLQuM6zSZu+qfZhPw+nQCrlFJK5eApmDfGrBjqjihvXtjaxO0vbCfktwnVqQFfaH8mwGqgNCoZAyKZRubH7wRYk3XRKP2MKqWUUtkMaAVYEakSkbNE5APOz6qh6pjKbHtjJ39+djsNHRF80neRnYFMgI0kc+Z1ZH40iicM/rS/zoqi4LgemU8Y+n0bEQ74NZhXSimlcvCaZoOIXAN8GQhh8+QBekTkh8aYy4eic6q/UMBGeJ2ReJ9KNu5j8YQhFk8QSI8E00RjOjI/mmXKmS8vDI7rCbDxDItGaWlKpZRSKjdPI/Mi8gXgMuAWYDlwMDaP/hbgMhH53FB1UPUVTgbzsYw1ucHbQlDRYcqZ31jfzg//s5aEM2FXeZNezQagvChIS2cUY8bfe+m+pvTUonDATzRuktWblFJKKdWX15H5TwA3GGO+mLJtLbBCRNqBTwE/GezOqf7CAVs0yI7MZw7mI7EExeHcx0mWphzikfmr7n6VFevqOW1xDUfNrhzS5xpPMpVprC4OEYknaOuJUVYQHKGeDQ03Vs9UzQbsZ7owpAWzlFJKqXRec+bnAPdkeewe53E1DNw0m46eWJ8a8/YxG+x4G5kfnhVgp1UUAPD8ln5LE6gcbM583/NbW2bfy7rWnpHo0pByR97T02zcid5a0UYppZTKzGsw3wAcmuWxQ5zH1TBwR9+78ozM55NMsxniIMkdQX5yo35EBiJh6DcyP7nUft1S19o9El0aUolsaTZBN3VM8+aVUkqpTLwG83cCVztVbAIAIhIQkQuBq4C/D1UHVV9ucNMRifcbuQ0FvAc+wzUy7x7/2c2NOro6AJmq2bgj83vbxl8wb7Kl2Qzg2yallFJqIvIazF8KvAz8HugSkb1AF3ArsBI7OVYNAzftoDMS61fNZmATYIcnZ77bqXvfFY2zamfLkD7XeJIpZ35cp9mYzGk24QFcoCqllFITkddFo9pE5GTgLOAkoApoBFYA95rxWF5jlAoH7UhlNN4/pzo0gGDerTMfTxii8QTBPKUs91d3ShDW0D7+gtChkjCmzxoCACXhAEUhP3vHYTCfSAbzmVPHuj0uhqaUUkpNNJ7rzDsB+7+cmxohbnADZMiZd1MSPKTZxHqvv3piQxfMd0XiTq3wBJ0RHV31Kp4w/RZQAjs6Xzce02ycWL3/CrCaZqOUUkrlMjQRnBoyoZRgPlcZv3xiid42XvLmtzV0EvO4umyq7liC6uIQAB2R2ID3n4iMMXYCbHrOCXYS7ERKs9FqNkoppVRuWYN5EYmLyLHO7wnnfrabRmnDJJwjmHcDn4Gk2Xhp39IV5U0/XsE/V+4aSFcBe6FQXWKrsHT06MfECzdpLUMsT21ZwbicAJtMs8lygao580oppVRmudJsrgJ2pPyuefGjQCglHSaQVme+IDiACbApaTb5RuZbu6JE4gl2NnUNpKu2L9E4le7IfI8GZF64o9QZ02yckXljTL8yjmNZvpx5TbNRSimlMssazBtjvp3y+5XD0huVl4gQCviIxBL406rZhPw2v9hbnXnvaTZdzuPNXdGBdpeuaJypQT+FQT+dmmbjSXIBpQxD8zVlYbqi8XG3CmwiW868lqZUSimlcvKUMy8ivxWRuVkemy0ivx3cbqlc3NHKfhNgB5CSEB1Amo07cbW5c+DBfHc0QUHQR3HYT4dOgPUkW811GL/lKRP5SlMO8XoISiml1FjldQLsRcDkLI9NAj7k9QlFZKaI3C4iLSLSKiJ3iMgsj/sWiMgPRGS3iHSJyFNOycz0dj4RuVREtohIt4isFJHzM7R7VERMhtsXvL6ekeCOVvZfYGfgK8CCh5F5Jwhv6YoMqJ/usQtDfopCATo1Z96TbJNBAaZVFAKwvalzOLs05PLnzOvIvFJKKZXJQKrZZMuZn4JdQCovESkCHgYWYy8APgAsBB4RkWIPh/gNcAnwLeBsYDfwHxE5Iq3d1cCVwM+AtwJPA38Tkf/JcMxXgOPTbrd5eT0jJevIvBPkd3kYxRzIyLwb7O/fyHyccMBPUUhH5r1KptlkyIlfWFMCwPq9bcPap6GWNc1mAKljSiml1ESUNWdeRM4DzkvZ9G0R2ZfWrBC7iNQLHp/vEmAesMgYs8F5nleA9cDHgR/n6M9S4L3Ah40xNzvbVgBrsBN0z3G21QD/C3zPGPNDZ/dHRGQB8D3g32mHbjPGPO2x/6OCG8ynj8wXBH34feKpakyfYH4Ic+Ztmo2f4nBAc+Y9SjjBfKY0m4qiEJNLw6zb2z7c3RpSWdNsdGReKaWUyilXNZtZ2EAd7Kj8EUB6om4P8CRwqcfnOwd42g3kAYwxm0XkCeBccgTzzr5R4C8p+8ZE5Dbg6yISNsb0AGcCIeCWtP1vAX4rInONMZs99ndUCmUZmRcRSsIB2ru9BfOFQT9d0XjeQKlrP3Pm4wlDJG5z5otCfto89Ev1BraZgnmAg2pLxt/IfJZqNr3lVvVbHaWUUiqTrGk2xpgbjDFzjTFzgW3AW937KbfFxph3GGPWeny+Q4DVGbavAZZ42HezMSY9WXgNNnhfkNKuB9iQoR0ZnmeZk78fFZFXROQjefox4npH5vufvpJwgDYPI/ORuKG0wF7L5cuZ74z25sz//sktfOPOVZ766QZgBUE/xSEdmffKzZnPVnpyYU0p6+vakyP440G2nHmfTwj5fToyr5RSSmXhKWfeCdxXDsLzVQFNGbY3ApUHsK/7uPuz2RiTHumktwN4DPgCdtT/ndh0n1+LyDezdUJEPiYiz4vI8/X19Xm6PDTc3Pj0kXmA0oKApxHwaCxBiRPM582Zd0bmo3HD31/cwZ0v7aT/25thv6g9bmHQT1HYr3XmPXLzxzPVmQc4qLaUzkicnc0Dr/s/WiVyLJQVDvjoiWowr5RSSmWSK82mHxGpxE5YLUh/zBjz2GB1argYY76VtukuEbkT+IaIXG+M6ZeYbIz5JfBLgKOPPnpEhkbdPGK/P3Mw7yXNJpZIUOrUKfdaZx7gtd2tROOGfe0RJpeGPe1XEPTpyPwAJBeNynKpfVCtMwm2ro2ZVUXD1a0hlS3NBuznPRLXC0GllFIqE6915gtE5E9APfAU8EiGmxdNZB6Bzzbq7nVf6B15bwIqpH+OQnq7bP6MvVg5LE+7EePmEWcamS8JB2j3mmYTdtNs8uTMpwTzbknLbY0deZ+jO5qSZhMO6Mi8R4kc1WwAFtaWAvD6nv5587e/sIN1WfLp73p5J1f+c82oTM/JVcEn5NeReaWUUiobr6UpLwdOxZaTFOAzwEeBx4GN2DKRXqzB5rSnWwK86mHfuU55y/R9I/TmyK8BwsD8DO3w8Dyu0RfxOJIj85mC+YKgp2A+GrNVZvw+yTu5sCtDSckt+/LXOXeD+XDAT3HITySe0BKDHuQapQYoLwwyvaKQV3e19tneHY3z1dtX8olbXsh4Tu98aSe/e3ILv3l89M3/NrnSbIJ+zZlXSimlsvAazJ+PLf/o1l9/xhhzszHmFGAl8BaPx/kncJyIzHM3iMgc4ATnsVzuBoLABSn7BoB3A/c7lWwA7sNWvXlf2v7vB1Z7qGTzPmzdfG+zPEeAmzMfzDYB1mM1m1BAKAj48o7MZ0rD2droJZh3cuZDfoqcbwEyXRiovuI5SlO6Dp1e1i+Y31jfTsLApvoOfvXYpn777GyyOfbfv+91XtyW74uw4ZUzzSbg02o2SimlVBZeg/lZwBpjTBwbKKcu8PRbbEDtxa+ALdjc9HNF5BzgLmA78Au3kYjMFpGYiCRz2o0xL2HLUl4vIh8VkdOxFxdzgStS2tVhS1xeKiJfEpFTReTnwHJSSmiKyEkico+IfERETheRd4jIXdjJsN82xuTPIxkhbppN1pz5nvwlJKPxBEG/zxn1zFPNJhKnINj7USkJB9jaMIA0m4CP4pC9AOnQvPm8slV2SXXItHI27evo8y3Meqf2/LTyAv69ak+f9sYYdjR1ccFRM5hSXsBn//QSLfuxbsBQyXUBY4N5HZlXSimlMvEazDcAJc7v24GlKY9Nwi4elZcTIC8H1gF/BG4FNgPL0yabCuDP0L+LgZuBa4B7gJnAW4wxL6a1+4bT5vPAf7Aj/+8yxvwrpc1u5/hXYReS+gMwGXivMeb7Xl7PSHHTbDJWswkH6I4m+iwKlUk0bgj6fZ5G5ruicaaW21NcGPRz+IxytjZ4T7MpCPaOzOsk2PxyVXZxHTKtDLATkl3r9rYR8AknLZzMrpa+lW4aOyJ0ReMsmVbGDe85gp3NXfzjpZ2D3vf95b7mTJlF4YBfc+aVUkqpLLxWs3kaWAbcC/wduFpESoEY8GVs7rwnxpht2LSdXG22YAP69O1dwJecW67949hg/pocbTYAb83f49En2wqwQLLcZHt3jMriUNZjuCPzReEAbd25R2i7o3EqioKEAz5mVRUxZ1Ix967anbef7kWCrTPvjMzrJNi8kqPUWXLmwY7MA6zZ2cIxc+zc7nV725k7qZjZk4po7ozS0ROj2LmI2uGk2EyvKOSo2VXMm1zMA6/u5UNvnDOEr8Q7k6eaTaemZymllFIZeR2Z/z7wuvP7NcDD2BHt7wObgE8OftdUNtlWgAWbAgPknQRrg3nhoNoSXtudezXRrkicopCfiqIgs6qLmFNdRFNnlJY8K8J2p5SmLArZfmmaTX7Jyi45huZry8JUF4dYk5I3v76ujYNqS5leYb9F2Z0yOu/WpJ9RaeePv3lJLU9vahg1qTa50mzsolEazCullFKZeF006nljzB3O723GmPOxaTcVxpg3OqPtapi4E2AzrQDrruqaPgn2d09sZvXOluR9N83m0OnlbGvspLkzkvX5uqJxCoN+Lj97CZ86dX6yNOLaLCUQU/cDm5pTHLZ97tSR+bzcnPlcI/MiwoKaEjbvs3MXuiJxtjV2srC2hGlOML+zuTvZfkeTTYuaXmkfO2PJFGIJw6Nr64bkNQxUzjSboJamVEoppbLxOjLfjzGmxxjTmr+lGmzhnCPzdiGo1JH5V3Y0c+Xdr3LpHb0FeiJOms3h0ysAWL0z+6nsisQpCPo5+/BpLJtVycFTbL7263tyn/5kacqgX0fmByCZM5/nr3N2dVGyqtCWhg6MgQU1JcmR+V0pK8TuaOqitCBAeaH9fCybWcGsqiJueHB93kXDhkPONJuAlqZUSimlssmaMy8iHxzIgYwxfzjw7igvQl5y5lMq2vzfio0ATC23C/caY2xpSr9w2HSbe71qZwsnLpyU8fnckXlXbVmYyqJgn8mXmbgBWEHQ1zsyr7nPeeVaQCnV7Opi6tt20NETY0+rHYWfWl5ITWkYv0/6BfNuig3YFJ5rzzuUD/zmWW58ZANfPmPRELwS73pXvdXSlEoppdRA5JoA+7u0++4iSpJhG9hqMGoYuGk2GavZpKXZ1LV2c+/qvmUK4wmDMRD0+ygvCjKrqohXdjRnfb6uaJzCUG8wLyIsnlKWN9e+OxpHxOY8J0fmPSxoNdElcgS2qWZX2+B8W2MndU4wX1MaJuD3MaWsIFlXHmyN+ZlVfddbO2nhZN68pJbbntvOl958EP0XTR4+uSr4aGlKpZRSKrtcX+TPTbmdBOzA1oI/FTjY+flLbKnKE4eyk6qvZDWbTHXmw32D+Z3NXcnVNd0Ul5gTOQWd4xwxs4J7V+/hbT99vE9evasr0jeYB1g8tZS1e9qSo8iZdEXsiL6IJKvZeFmddqLzUs0GYHaVXe5ha0MHe1vtmmk1ZWEAplUUJCe9gp0MO62ioN8xzjxkCvVtPX0m0o4E9wIm0wVFOOjXlYOVUkqpLLIG88aYre4N+ApwmzHmU8aYx4wxa52fnwT+Cnx1uDqs8lSzKehbzabVCepLwwHand8jTg16d/9vnHUwX3vLYurbenjHTU/2yYVPJAw9sUSfNBuAg6eW0RW1ky6z6Y7ZXHuAgN8uHNXapcF8PrkC21SznJH5rQ2d7G3tprIomPzWZlpFYbLWfFckTmt3jNqy/sH8qYsmA/DI6yM7ETaR4wLGVrPRYF4ppZTKxOsE2NOBB7I8dr/zuBomvXXm+5++wqAfn5AM3Fud0oNTKwpocwL8qBMYuRcFtWUFfPLU+fztE8cTiSd4emND8njdsd6KNKncSbBrc0yC7Y4mKAj09rGiKERzV/aqOcpKOHFrvjSb8sIglUVBtjZ2UtfW0ydYn15RyO7mbiKxBHVtvSk46SaVhFk6o5yHR7iqTW+aTeac+XjCEMuzEJpSSik1EXkN5nuAo7M8dgygEdowCgez58yLCCXhQMrIvA3mp1UUJvPVo3Enzcbf9/TPqCyktCDAJqfcIfROWE1Ps5lfY1M8NtS1k8mOpk7W7GpNjsyDDT5bR0ld89GsdzJo/razq4vZ2tBBXWs3NSnB/KIppcQSho317ckUnEwj8wCnLKrh5e3Nyc/KSOj9NqL/Y+6Kxzo6r5RSSvXnNZj/K3CliHxFROaISKHz86vAFcBfhq6LKl3In72aDUBpQTAZmLlpLdMqCpOj9VFnhDM9mBcR5k0uYWN9b4DeFXEXfuobzBeFAkyvKMwYzBtjeO+vnmFTfTsfO3lecnt5YZDmPAtNqd7ANl81G4A51UVsqrc586kj74dMs9+cvLqrlb3O5Nhswfxx86owBl7Y0nSgXd9viRyLRrmpQxrMK6WUUv15Dea/DPwN+C6wEWh3fn4HG+h/eUh6pzJyRyozjcwDTC4Ns9EJslu7owT9wqSSMB2ROImESebMBzNMoJ0/qZhN9b0j824N8qK0kXmA+TUlbKjvH8y/vqeNbY2dXH3uobzn2FnJ7RVFwVGz4uholvBYmhLs5OXdLd3sae2mtqw3mJ87qYSCoI81fYL5/mk2AMtmVhL0C89sbhyE3u+ffGk2gE6CVUoppTLwugJslzHmA8AS4CLgUufnEmPMB40x3Tl2V4MsnKPOPMDZh09l5Y4W1u1to7UrSllBMFnlpiMSI5YlzQZg3uRidrd00+lUvkldxTXdgsklbKzrSAafrhXr6gE4xZlc6SovDNKswXxe8Ryj1OneMK86+XvqyLvfZ8uHvrq7hbq2HkIBX3LBqHSFIT+Hz6jgmc0NGR8fDr3fRvR/rDfNRmvNK6WUUukGtAKsMWadMeaPxpj/5/xcN1QdU9kl68xnGFkHeMeRMwj6hb88t53W7hhlhcE+VW6ypdkAzJtcApAcnXfTbDIG8zUldEXjyaoprhVr61k8pbRfWke5MzLvrvapMhtIms2i2tJkkF5T2vf9XjKtjFd3tbKnxY7a56qOc+zcKlbtaElexA235GvOEM2H/Jpmo5RSSmWTNZgXkVkiEkz5Pedt+Lqs5k0q5ktvPohTD6rJ+HhVcYjli2u4d9VuZ2Q+QIkzMt/eHcudZuME827evDsyX5AhzWZBjW27PiVvvr0nxvNbG/uNyoMdmY/EEnRHNSjLxf2iw8vIvM8nHDOnCuitMe86ZFoZrd0xXtzWRG1p5nx519IZFcQSJuuE5qGW6wLG/SaqRz83SimlVD+5RuY3A8uc37c493Pd1DDx+YTPnb6QyuJQ1jaLppSxu7Wbho4eOzIfThmZd0tTZhiZn11dhEjvyLyb415W0H+x4GQwv7d3JdhHXq8jGjecvri2X/uKwlCfY6ZLJEwyR38iiyeyp5xkcuKCakRgRkVhn+1vnD8JgB1NXVknv7omO5NnGztGpjCVW44z02t252t0jNC3BkoppdRo1j9C6/Vh7CRX93fNjRhDppUXYAxsrOtg+eLiPmk2go2YgoH+wXxB0M/kkjB7Wuw0iPo2W9ZwcoaR3ariEItqS7n9hR189MR5+HzCfav3MKkkzFGzK/u1d9NBmrsiTCnvf7zbX9zB9+59nSe/vrxf9ZyJJFfKSSbvO242R86u7FOaEmDupGJOOWgyK9bV9xu1T1flXBg2dY5QMJ9jZL7M+dzo5GmllFKqv6zBvDHm9ym//25YeqMGzVRnlLYrGqessG+ajVvHPFMePNiJlHudhYb2tnYTDvgyjswDfPLU+XzhLy/z68c3cVBtKY+sreO8ZdMzpohUFDlBWZbylOv2tNHYEWFHUycLakoH8GrHl3iO1VAzCfp9HD6jIuNjF50whxXr6vOOzLvBfEP7CAfzGT437kVgts+NUkopNZHlGplXY9i0lJHvsoK+aTZrdrVSGPSzaErmgLm2LMzOZhvMuyuLZps8efbhU7nuwXV859+vJ7e99dCpGdv2jsxnDsr2tdtvATbv6+TRtfWcfnAtcycV53qZ49JAcubzOWXhZK582xLeeljmc+IqKwjg98kIjszbn5lecvIiUEfmlVJKqX6yBvMi8tsBHMcYYz4yCP1Rg2RqSv50aeoE2J4YT21s4Og5lRmr2QDUlBXw0rZmAOrSFiNKF/D7+NMlx7HVWTW2sTPCCQuqM7Ytz5Musc8ZFX5y4z5ufmILL29v5mfvPTLHqxyf3FKfHgfmc/L5hItOmJu3nYhQWRQauZx5k/3biJKwvdDQYF4ppZTqL9fI/HK858lrPv0oUxIOUFoQoM0pTVnsBPPbGjtZu7eNc46YlnXf2tICGjoiRGIJ9rZ1c/CUspzPNb2ikOlpky8zyZdm447M/3vVbgDuX7OX5s4IFUXZJ/ruj7q2bgqDfkoLMtddH2luGtRgjMwPRHXxCAbzyQuY/q9ZRCgrCGgwr5RSSmWQK2d+zjD2Qw2BqeUFtHW3U1YQJBTwEQ74ePj1OgCOm5d59Bx6Vwqtb++hvrWHkxfmnjzpVb4RVndkfm+rDeoj8QQ/un8dFx47iyXTcl9QeBWLJzjvxic5bl41P3rX0kE55mAbaM78YKksDtLUMTIBc640G9AFx5RSSqlsBrRolBpbppbb0fKyQnvNVhIOsLWhk+KQn8NnlGfdz50suWVfB209sbyVULwSESco6z/6G08YGjt6kvcXTynliJkV/PHprVz4q6f7rTK7vx5dW8/O5i5W7mgelOMNBTPAajaDpbo4TEPKORhOiTzfRpQXhXRkXimllMpgwMG8iNToolFjw7QKG5SXOekkbrnHNy+pzZovD72LD63a2QKQd8GhgSgvDNLS1b9eeFNnhITpTcU5bHo5f/n4cVzxtiW0dEVZV9fWb59U3dE4EQ8rhN723DYANu/roCc2uDXtX97ezK7mrvwN8+itMz8CI/MjVDEmniPNBtzPjQbzSimlVDpPwbyI+ETkOyLSAOxGF40aE3pH5m2AvNMJNM86PHu+PPSOzLvB/GCNzIO9wHhpWxORWIKOnt6g3i2JeNQsW5/+0OnlhAP+5OJTz29pynncC3/1NN+6a3XONi1dUR5+vY65k4qJJwwb6zoO5KX0YYzhopuf5ccPrDvgY8XdajbDHMxXFYVo6owkA+vhZDyk2bSMUKUdpZRSajTzOjL/BeDTwI8AAb4DXIMN4jcClwxF59SBOWxGOcUhf78a4yctnJRzv6qiEAGfsGqHMzKfp0b5QHz0xHnsaOri3Buf4MirH0heYLiTX884pJZJJSFOWGD7OLOqkEklYV7Ymj2Yb+mM8tK2Zp7e1JDzudfvbSNh4MJjZwKwdm/rYLwkAHa3dNPcGWVbQ+cBH8tNKfINcxJcVXEIY0amBGTeNJtCnQCrlFJKZeI1XLgYuAr4vnP/TmPMFcDBwE5A02xGodMW1bDyijOSJSF/euEyvveOw/KururzCZNLw2xrtIFprtKUA3XqoskcM6eS13a30hNL8Mr2ZqA3mD9qdhXPf/PNLKgpAWzaxVGzK3IG8y9us49taeikrTt7wLe+rh2ANy+ZQtAvvL4nd+rOQKx1jrWjaRCC+RyroQ6lSmfhqJGoaBPP85orCm3O/GDNnVBKKaXGC6/B/DzgeWNMHIgBhQDGmChwPfDhIemdOmCBlNz4ty2dxnuO9Xbd5Y7GlxUEkhcDg0FEuPG9R3LzRcfgE5IBdX2bDeYnl/S/cDh6dhXbGjvZsi9zWkxqoP/a7uwB+vq97RQG/cyuKmL+5BLWDWIw776OPa3dnnL3cxmp0pRVIxjMu2k22a5fyguDJAy0R/rPt1BKKaUmMq/BfAvg5lrsAhalPBYAqgazU2rkfe0ti7n87CXc87mTsk5K3F81ZQWctriGOdXFyRHtho4IQb8kK++kOueIaRQG/fzg/rV9tscThvtW7+GJjfuSK96u2dWS9XnX17WxoKYEn09YNKWUdXvbB+01rdtrX0fCwJ6W7gM6VmKEJsCOZDCfyFOOM7ng2AhN0FVKKaVGK6/B/EvAEuf3/wDfFpELReQC4LvAi0PROTVyjp9fzUdOnMvMqqIhe45FU0pZ6wTB+9p6qC4OZ7xwqC0r4JKT53HPK7t5JaWk5GPr6vnELS/w0rZmzjhkCpNKQqzZlT0PfkNdOwud9J15k0rY2dxFd3RwKtq8vqctucrugaTarN7ZwsZ6+w3E8C8a1bu+wHDLl2ZTlmf1YKWUUmqi8hrMXw+4EcoVwB7gVuAvQBD4zKD3TI17i6aUsqWhg85IjO1NndSWZ59oe8lJcwn4hHtX70lu21hvR9YvPHYm7z9uFkumlbN6Z+aR+bbuKLtbullQa4P5uZOLAdg6CBNWo/EEG+vaOfkgO2l3R9P+lac0xvCR3z/HnS/tBLJXdhkqNaVhSsKBQU0/8iqRJ80muXqwBvNKKaVUH1mDeRH5rYicDGCMecAY8wvn9z3AscBBwBHAQcaYV4ahr2qcWTylFGPsqPYrO1pYNrMia9vSgiDLZlXwxIZ9yW3bGjspLQjwnfMOY0FNKUfPrmTt3rZk/n0qN5d+YU0pAPMm2WB+874DS7VJJAyX3bGKSDzBOUun4ZP9H5l/dXdrcvVbkew114eKzyccPLWU13YPXpUfr4wx+HK85nIdmVdKKaUyyjUy/27gERHZLCLfFpH57gPG2mCMecWZBKvUgC2ZalehvfXpbXRG4hw5uzJn+xMWTGLVzhaanXrjWxs6mV1dlAwAly+uwRh4ZG1dn/06IzEu/8dqKoqCHOU8xxwnmN+UZVKtV3et3MnfXtjB509fyFsOncrU8sL9Hpl/dG198vdhHpRPOnhqGa/vaRv2qjHxhMk5R0CDeaWUUiqzXMF8LfBRYAvwTWCdiDwhIpeISPlwdE6Nb7Oqi1gytYy/v7gDgCNnVeRsf+KCSRgDT2209eS3NnQwu6o4+fgh08qYWl7AQ6/t7bPfDQ+uZ11dGz95z7LkJM+ScIDJpWE21x9YMH/3yt1MryjkC29aCMD0ykK2ZxiZv/GRDZx74xMYkz1IfjTlImSkKjAePLWM9p5YxtcwlBIm94Tf6pIQoYAvOdFYKaWUUlbWYN4Y026MudkYcxowB7gcqAR+AewWkdtE5K0iMsxL26jx5J1HzQCgtizM9IrCnG2XzqygJBzg8Q37iMUT7GjqYlZ17wRdEWH54hr+u34fnU4Jw/aeGH96ZhtnHz6Nkw+a3Od4cycVs6Vh/4P5ls4o/11fz1mHT01+O7B4SilrdrXSE+udWBuLJ7j5iS2s3N7MriyVbjp6Yry4rZmlOVKNhsPBU8sA9ivVxhjD6p0tOS9Ycu2bK6soHPDzxvnVPPx63X4dXymllBqvPAXixpjtxpjvGGOWAMcBvwWWA/8CdorID4ewj2oce/uy6QT9wlGzK/PmiAf9Po6bV8UTG/axu6WbWMIwp7pvtZ3zj5pBZyTOdQ+sA+Cvz22nrSfGR06c2+948yYVszlLmk1LV5QLf/k0F9/8LM9kWVn2/lf3EI0bzjpsanLbaYtq6IzEeWZTY3LbY+vrk4tiZVv86vU9rcQThnOXTsvxDgy9RbWl+ARezVEVKJuHXqvj7J8+zt9e2NFne11bN6f/6NHkNyqZxBMmb/We0xfXsLWh84BTo5RSSqnxZMCj6saYZ40xnwGmA9cBNcAXB7tjamKoKg7xiw8cxf+esSh/Y2ze/JaGTh53JsLOSkmzAThyViXvfcMsfvP4Zu56eSc/e2QDx86p4ogMI97zJhezrz3C3St39RlJB7jpkQ08vbmB1bta+dxtL9EV6V/CcsW6eqaUFXD4jN6ss+PnVxMO+JIjyImE4fdPbqWqOERh0M+LW5vY29rdb3TZLan55iW1nt6HoVIY8nPEzAr+9Oz25AWIV7c8sxWA6x9Y16fk51+f287G+g5uenRD1n3zpdkAnLa4BoCHX6vL2U4ppZSaSAYczIvIAhG5ClgLfAloA34z2B1TE8fyxbXMm1ziqe2JC2z5x1uetoHj7Or+dfC//tbFLKwp5fO3vUx7T4xrzzs047HOP3IGS2dW8Nk/v8Tiy+/j1//dBNh69Dc/sYV3LJvBzy5cxt7WHm5+cnOffY0xPLelkWPnVvX5RqEgaNNBbntuG/Mv+zdvueExVqyr5xOnzOPwGeX84+WdvOE7D/F/Kzb1Od6ana1UFgWZUZk71Wg4fOcdh9HaFeXyf6zO2qa9J8Zn/vQir+1u5e6Vu7jszlWsWFfPCQuq2dXSzR+fsucnnjD8+dntBP3Cf9fvY0Nd5upBiTxpNgAzKotYOqOcnzy8nsfW1We8wFJKKaUmGk/BvIhUisgnReQpbBB/mfPzvcAUY8zHvD6hiMwUkdtFpEVEWkXkDhGZ5XHfAhH5gYjsFpEuEXnKLZ+Z1s4nIpeKyBYR6RaRlSJyfpZjXiIir4tIj4isFZFPeH0tavgtqCmhtizMml2tzJ9czJSy/rXpywqC/Pljx3H64hquffuhLKwtzXis6pIwf/v48Vz37qUcP6+a//eftTzw6l4++JtnKCkI8JUzF/GGedW86eAafviftdz4yIZklZcdTV3sbe3hmDn9K/C886iZlBYEOW/ZDJo6o3z6tPlcctI8jpxdSXNnFBH4yUPr2d3SW/Vmze4WDplWPuzlKDNZPKWMzyxfwL2r97BqR+a6/T9/dAP/emU3V939Kt+4cxV/emYbfhG+f/7hnHzQZG58dAMvb2/mK39byc7mLi4/ewkhvy/r6HzC5E+zAbjp/UdRVRzig799lqVX3c+ld7zC3tZu6pybUkopNdEEsj0gIkHgbOCDwFuBEPAq8HXgFmPM7oE+mYgUAQ8DPcCHAANcgy2BebgxJl8y7G+As4CvAJuATwP/EZHjjTEvp7S7Gvhf4BvAC8B7gL+JyNnGmH+n9OcS7ITe7wIPAqcDN4mIGGN+PtDXp4aeiHDJSfN4bXcbl599ML4sAWBVcYjfXHRM3uOFAj7OWzaD4+ZVc/qPVnDJH56noijIrR99A1OcRayuf88yLr1jFT/4z1qe3dzIZ5cvSC42dfScqn7HPOvwqZx1+NR+289YUstDr+3lm2ct4ZI/PM8lf3ien114JNMrC1m3p52LTpgD2Em0r4/Awk2pLj5hDr/+7yZueGg9v/7Q0XRH44T8Ph54bS93vLiDR9fWU14Y5ClnPsEtH7Hv14zKIr565iLO/unjvP3GJygI+vjg8bO58NhZ7G7p5uePbuSdR83gjfMn9Xm+hMldmtI1vaKQf376RB5bX8+TGxv4+4s7uHvlbrqicQS44OgZfPq0BcyoHLqVi5VSSqnRRLJVhhCRRqAcaAT+DPzeGPPCAT2ZyOeBHwOLjDEbnG1zgfXAV40xP86x71LgZeDDxpibnW0BYA2w1hhzjrOtBtgOfM8Yc0XK/g8Bk40xh6fsuwu41xjzoZR2vwXOAabmq6F/9NFHm+eff35gb4IatVasq2d7YydnHTaVSqeEpcsYwy3PbOOaf71KTyxBKOAjHPDx8rfO8DSinO6h1/byuT+/REckTnHIT0ckzg3vOYJzj5hOVyROZyRGdUl4sF7afvnpQ+v50QPrOG5eFS9sbWJ2tZ0wXFUcorQgwM8uPJJ3/+Ipjpxdye8/fGyffX/y0HqaO6N86rT5THJeR3c0zhnXPcau5i6On1/NcfOqWbunjdnVRTy3pZENde08/803D6iPm+rbue7B9dSWhonEE9z27HYMhnceNZOlM8p5ZWcLT29qoDsS59p3HMapB02mKxrH7xPCAX/yOJFYgoBP+lwc9sTifP3vqygK+bnq3EM9nedEwhBLGEKBvl96bm3o4LktTZx7xDSCfi0AppRSauBE5AVjzNH9tucI5u8Efg/cM1gLQzkBdYEx5oS07SsAjDGn5Nj3cmx5zApjTGfK9m9jvy0oM8b0iMgHgD9gV6Zdn9LuYmwVnnnGmM0ichLwGHCGMeaBlHanYb89WG6MeSTX69FgfuJp7Y5y36o9/NgJcq9/z7L9Pta2hk4eWVvHxvp2GjoiXHPuof0uIkZSLJ7gJw9v4KZHNnDmIVN4aVsTteUF/PEjb6AkbL/U21TfTmVRyHO/tzd2cusz27hv9W62NHQyqSRMY0cPCQNHzKzgH58+If9BctjV3MWNj2zgr89vJxo3FIXsHIbtjV2s3duGCBgDPrE5+FPKCtjZ3MWuli5Cfh+1ZQWEAj6qikK098R41SnRedLCSUyvKGRfe4T69h7qW7spCgc4enYlU8oL2N3cjcHw5MYG9rX3cNZh0zh+fjUtXVHq23q49emttPXEmDepmCnlBUwqCTOnuoiKohDdsThBn49QwEdHJEYiYQj4fXT2xOiMxKksDjGtooCKolDyYqGjJ8Ztz25nX0cPx8yuYtmsCkoKAoT8PoIBH/G4oSeWoDDk47Xd9nW7+x5UW0ph0I/fJwR8Qk8sQVtPjKKgn6Kwn1jcsKelm85IjCnlhbT3xCgvDFIU8uP+d2Ho/X/D7xNicUNzV5SCgH3+l7c1094T49DpZdSUFtAZiScrFhlj+xEO+Chw+jFQ2aqTRuIJWrqiVBWFKAgO/KJpf4qeGmPnhiSMIZ4wdEXjtHRFKQ4FKC0I9Luwy7R//n7laeSl4wIBnw/3WtIYO/HcGHt0Y+zzGGN/F4GATwg4Oxhjku1Tf/rEfsPpXqQmksczfZ4jkXZ8t537rVw44MMnwq7mLgqCPkoLgraNIXk8v08I+n3OTZA8y+vlfd+Sr7u3jzh9BJLzeBLG/v24/U32P+WnwZBI2H0KQ36KQgE6emJ0R+OEA35CAfs3nv5xT30N2b6cNAaiiQTRWIJYwhCNJ4jFbX/CzsBSOOjHn+fbTa/vR942+Zvsdwnh1FRT6bM95fcM75n7HsXi9v1x36NYIkE05WdxKMCU8nDyefo+R99tmZ5TnM/7QVnSd4fagIP5IerEHuAuY8zH07bfBFxgjJmceU8QkduAZcaYRWnb3wX8BTjUGLNGRL4HfAEoNCkvTkSOBZ4BzjbG3OPkxv8cmJaaMuSM7O8FPmOMuTHX69FgfuJy/6PKluYznkScbyLiznyB/Qm+0hljaOyIUFUcorU7RlckTnVJaNBGrdt7YjR3RphUEqYg6KcrEue257bR2BGhMOSnOxJn074O6lp7mFpRwOzqYjp7Yuxr7yEST9DYEaGlK8ZFb5zNvvYIv39yCwaoLg4xuTTM5NIwjR0RVm5vpqkzyqSSECLC/MnFzKoq4t5Ve2jrsWsdiMBRsyp51zEzuf35HSSMYW9bNzubunIuDiYCBQE/XdHME32nVxSyeEopz29t8rwyrnsxM9R8YkvJ9sQSQ/9kSik1jGZVFfHYV08bkefOFsxnzZkfIlVApkLbjdgFqfZ3X/dx92ez6X+VkqkdGY6Z3q4PEfkY8DGAWbM8zdtV45CI5K2+Ml64I4uDEcS7RCSZRlReGKS8MDhoxwa7wq/77QHYkbKLT+i/1oBXnz5tQdbHemLxPik7AN857zC2NHRQWRSiqjiUHPF519Ezk20isQQdPTEKgn5iiQSRWIKiUAC/T4jGExQG/fh8Qlckzq6WLpo7owT9gk/s6OTcScWEAj4SCcOOpi66Y3EiMTsi5RMhHPTR3h1jYU0pwYDdzxjYWN9ONJ4gnrAjycGAj7KCAJ2ROO09MUJ+H5NKwhSF/ext6aG0IEBLVzQZmLufe/fTEI0bfGLnqfTEEnRH48yZVEx5YZCtDR3sa49QHArg85EcuQz4hZ6obRvf3xG8DKOyQb9QVhiksSNCNL5/FxL5Rnsz8fl6R73DAT/lhUE6I3Fau6Oe+pHvOb38W5OvScIZRY45V5A+sc8r4uwrtjysYP8+jfNNQySeQESS7X1C730REsYkP3eSesy0fVKP7/P1Po+9wLTfJMUThqnlhXRH43RG4sm+idNBY2x/onFD1OOFoqf3zulvsk8pjxnAL+5rsq/B59z3peznbk8YQ6eTKlkSDlAQ9BOJJ+iJJojE430upvv8nvqcaX8TIkLQb//u3W9LQs7ARyQep9v5W/Lyp+T1/cjbxsvfyUD/lPq8H713vLxnYP9dCfp89qdfCCR/t+9b0O+jrTtGXVt33/0zPG+m53Q3FQb7/ns/Ggx3MD/mGWN+CfwS7Mj8CHdHKTXC0gN5gIDfx4Ka3F/D2q/d3fQkf7/HXIUhP/NzlG71+aTPSsj5HDq9PH8jR01p/2pRA7GgppQFNQd0CKWUGlRLKBvpLgy64Z6J1UTmEfhso+5e94XeEfUmoEL61/jL1I4Mx0xvp5RSSiml1Kg03MH8GuCQDNuXYMte5tt3rlPeMn3fCLAhpV0YmJ+hHSnPs8b5md6f9HZKKaWUUkqNSsMdzP8TOE5E5rkbRGQOcILzWC53A0HggpR9A8C7gfuNMe7a8/cBUeB9afu/H1htjHGX8nwK2JelXSPwhLeXpJRSSiml1MgY7pz5XwGfAe4SkW9i5xNcja0L/wu3kYjMBjYCVxljrgIwxrwkIn8BrncWtNoMfBKYS0pAboypE5EfA5eKSBvwIjbgX46tH++2izrlLm8SkZ3YRaOWAx8GPmuMiQzRe6CUUkoppdSgGNZg3hjTISLLgeuAP2LnOj8EfMEY057SVLAzwtK/ObgYuBa7amwFsBJ4izHmxbR23wDagc8DU4C1wLuMMf9K68//iYgBvoxdVXYbtiTlTQf4UpVSSimllBpyw1pnfrzROvNKKaWUUmo4ZKszr+uKK6WUUkopNUZpMK+UUkoppdQYpcG8UkoppZRSY5TmzB8AEakHto7AU0/CltVU45ue54lBz/PEoOd5YtDzPDGM1HmebYyZnL5Rg/kxSESezzQBQo0vep4nBj3PE4Oe54lBz/PEMNrOs6bZKKWUUkopNUZpMK+UUkoppdQYpcH82PTLke6AGhZ6nicGPc8Tg57niUHP88Qwqs6z5swrpZRSSik1RunIvFJKKaWUUmOUBvNKKaWUUkqNURrMjxEiMlNEbheRFhFpFZE7RGTWSPdLeSMiM0TkpyLylIh0iogRkTkZ2hWIyA9EZLeIdDntT87Qzicil4rIFhHpFpGVInL+sLwYlZGIvFNE/i4iW51zt1ZEvisipWntKkXk1yKyT0Q6RORBETksw/E8fRbU8BKRM0XkYRHZIyI9IrJDRP4qIkvS2nn6N9vr50GNPBG5z/m3+5q07fo3PUaJyKnOOU2/Nae1G9XnWIP5MUBEioCHgcXAh4APAAuBR0SkeCT7pjxbALwLaAL+m6Pdb4BLgG8BZwO7gf+IyBFp7a4GrgR+BrwVeBr4m4j8z6D2Wg3E/wJx4DLgLcDPgU8CD4iID0BEBLjbefyzwPlAEPu3PCPteF4/C2p4VQEvAJ8BzgAuBQ4BnhaR2eD93+wBfh7UCBKRC4GlGbbr3/T48Dng+JTbm9wHxsQ5NsbobZTfgM9jg4QFKdvmAjHgSyPdP715Ooe+lN8/ChhgTlqbpc72i1O2BYC1wD9TttUAPcC30/Z/CHhlpF/rRL0BkzNs+6BzTpc798917p+W0qYcaAR+MtDPgt5Gxw1Y5JyvLzv3Pf2b7fXzoLcRP7+VwB7gQud8XTPQc6h/06PzBpzqnJc35Wgz6s+xjsyPDecATxtjNrgbjDGbgSewHzI1yhljEh6anQNEgb+k7BcDbgPOFJGws/lMIATckrb/LcBhIjL3wHusBsoYU59h83POz+nOz3OAXcaYR1L2a8GO+qT+LXv9LKjRocH5GXN+ev032+vnQY2s7wOrjTF/zvCY/k2Pf6P+HGswPzYcAqzOsH0NsCTDdjU2HQJsNsZ0pm1fgw3eF6S06wE2ZGgH+pkYTU5xfr7m/Mz1tzxLREpS2nn5LKgRIiJ+EQmJyELgF9iRWzfY8/pvttfPgxohInIi9hu2T2dpon/T48OtIhIXkQYR+VPa/JZRf441mB8bqrC51ukasV//qfEh13l2H3d/NhvnO7wc7dQIEpHpwFXAg8aY553N+c5xpcd2eo5H3jPYi+p1wOHYVKo65zGv/2Z7/TyoESAiIeyF2g+NMWuzNNO/6bGtBfgRNv11OXY+2puAp0Skxmkz6s9xYKgOrJRSE5UzUnMXNu3i4hHujhoaHwDKgHnYyc8PiMiJxpgtI9orNZi+ChQC1450R9TQMMa8BLyUsmmFiDwGPIudFPvNEenYAOnI/NjQROYRmmxXgWpsynWeoffqvgmocGbY52qnRoCIFGJzKecBZxpjdqQ8nO8cN3lsp+d4hBljXjPGPOPkUZ8OlABfdx72+m+218+DGmZOmsU3gMuBsIhUiEiF87B734/+TY87xpgXsd+4HeNsGvXnWIP5sWENNhcr3RLg1WHuixo6a4C5Tlm7VEuACL058muAMDA/QzvQz8SIEZEgcDtwNPA/xphVaU1y/S1vM8a0p7Tz8llQo4Axphl7TtycWK//Znv9PKjhNw8owBYWaEq5gf0mpgk4DP2bHs/cVNZRf441mB8b/gkcJyLz3A1iFxw6wXlMjQ93Y2vXXuBuEJEA8G7gfmNMj7P5PuyM+fel7f9+bMWFzcPQV5XGqSV/Kzbv8u3GmKczNPsnMF1ETknZrwx4G33/lr1+FtQoICK12JryG51NXv/N9vp5UMPvZeC0DDewAf5p2OBM/6bHGRE5Gltu9lln06g/x9J/Dp0abZxFRlYCXdj8LYOdpFEKHK6jN2ODiLzT+fV04BPAp4B6oN4Ys8Jpcxu29ORXgM3YRYfOBt7ofPXnHut7wBewCxS9iP3H4uPAOcaYfw3H61F9icjPsef1WiD9HOwwxuxwAv7HgZnYc9yEXXTocGCpMWZ7yvE8fRbU8BKRO7F/c68ArcBBwBeBKcCxxph1Xv/NHsjnQY0OImKAa40x33Tu69/0GCYit2LPxYtAM7AMe/46gSONMfvGxDkeyiL2ehu8GzAL+Dv2P4824B+kLTqkt9F9w/6Hnun2aEqbQuDH2DJ33diKGadmOJYfGyRsxVbUeAV450i/xol8A7bkOMdXprSrAn6LzZ/sxC72tTTD8Tx9FvQ27Of5a9gVYJud87cWW/FkTlo7T/9me/086G103EhbNGog51D/pkffDRuUv4KtahMFtgO/BKaOpXOsI/NKKaWUUkqNUZozr5RSSiml1BilwbxSSimllFJjlAbzSimllFJKjVEazCullFJKKTVGaTCvlFJKKaXUGKXBvFJKKaWUUmOUBvNKKZWHiBgPty0ejnORiHz4APpxpbNojZd2y/f3efIc24jIlfux36nOvqcOeqfGKPd8OqtEKqXUftF/QJRSKr/j0+7fiV3h88qUbV6W6r4I++/ubwelV9ldgV2J9uEhOPbxwI792O9FZ99XB7c7Sik1sWkwr5RSeRhjnk69LyI9wL707WORiISNMV4uRID+78UA9msFxvz7pZRSo42m2Sil1CAQkWNF5EERaReRDhF5SESOTXn8UeAU4ISU1JxHnccmi8gvRGSdiHSKyHYR+ZOITN+PfrhpON9IeZ4rncd+JyI7ROR4EXlSRLqA/+c89h4ReVhE6p3X8JKIfCjT8VPTbFJSRRaKyD3OvltF5Fsi4ktp1y/NRkQeFZHHReRNIvKi89pXi8h5GZ73QhF5XUS6RWSViJzj7P+oh/ekSES+LyKbRSTi/PxGlv6d77xPTSLSKiK3ikh12vHKRORnIrJLRHpEZK2IfFFEJK3dZBG5yTmfPc7PP4pIOK2Lc/O8dyUi8lMR2eYcp875rC3O99qVUuOfjswrpdQBEpHDgRXYFJKLAAN8HVghIscZY1YCnwJuAfzAx51dW52fVUA3cClQD0wDvgw8ISKLjTHdA+jO8cBTwO+AXzjbUtNiyoHbgB8ClwFdzvZ5wO3A94AEcDLwaxEpNMb8n4fnvRO4GbgOeBvwbWC7sy2X+cANwHeBfdjX/TfndW8AEJE3A7cC/wS+BEwGrgcKgHW5Du7ko/8HWAJcDawCjgMux77vX07b5XrgQeBCYCHwHez5OM05ng+4BzgS+JZzvLOAHzv9usxpVwk86TzHNcArQA1wLhCib1pWvvfuOuAc59jrgWrgBKAi12tXSk0Qxhi96U1vetPbAG7AFuCWlPu3A81ARcq2MqARuCNl26PA4x6O7wdmYi8KzkvZfqX9Zzvv/ga4JsP23zmPnZtnfx92sOdXwMoMx74yvU/AxWntVgH3p9w/1Wl3atr7EQUWpmyrAeLAZSnbngRWA5Ky7SjneI/meS0fcNqdnLb9G0AEqEnr331p7d7nbD/duX+2c/+itHa/xgbok5z7VzmvY1mOvnl971YDPx7pz73e9Ka30XnTNBullDpwJwP/MsY0uxuMzRH/Jza1Ji8R+aSIrBSRdiAGbHMeWjTIfY0C/8rw/AtF5M8istNpEwU+OoDnvyft/mpglof91htj1rt3jDF1QJ27r4j4gaOBvxtjTEq7F4DNHo7/FmAr8KSIBNwbcD8QxI7Sp/pr2v2/Yb+pcCdBn+zc/1Nau1uwI+5uuzOA54wxL3noY7737jngIhG5TESOdt4TpZQCNGdeKaUGQxWwO8P2PUBlvp1F5LPATdj0jncAx9IbZBYMUh9d9caYeNrzlwAPAEux6UEnAcdgq+6k53dn05h2vwdvfU/fL33fSdiguy5Du70ejl8DzKb3AsW9Pes8Xp3Wvs8xjTERoAlw5y9UAY3O9lR7Uh53j+u16k++9+6z2JSpD2MD+zoRuU5EijweXyk1jmnOvFJKHbhGYEqG7VOwgWA+7wEeMsYk87dFZO4g9S1dpjr1x2MD3pOMMY+n9GE0/B+xDxt812R4rJbebzCyacCO4L8ry+NbMhwzSURC2Auync6mRqBKREJpAf2UlMfdfg94AnMmxph27HyKS0VkNvBO7NyGCPC1wXgOpdTYpSPzSil14FYA/yMipe4G5/e3YfPCXT1AYYb9i7ABa6qLD6A/kSzPk407wpvsgzOB89wD6MOgcL5FeB44P7VajIgcBXi54LkPO/+g3RjzfIbbvrT26UH/Bdj/K59y7q9w7l+Q1u592PfdbXc/cKyILPXQR8+MMVuNMT/C5tUfOpjHVkqNTaNh1EUppca6q7ETIx8Ske9jR7+/hg2Sr0pp9yrwKRF5N7ARaDPGrMUGnF8Tkcuw6R/LsaOv++tV4CwRuQ/7zcAuY8yuHO2fxFbWuVFErgCKgW9iR5fLD6Afg+UKbHB8p4j8Ept6cyU2tSWRZ99bsRdGD4nIj7CLfYWwVXTOAd5ujOlMaX+IiNyMrfhzEHbxrUeNMQ85j98LPA78n4hMBtYA/4OdX/DdlIuD64D3Ag+KyDXY4HsS9gLpE8aYNq8vXkSews6/WAW0Y+dhLAV+7/UYSqnxS4N5pZQ6QMaYV5z66ddiAyzBLpB0irFlKV3fx04o/TVQgh3lPRUb8FcAX8TmSq8AzgQ27WeXPgP8BLgbm/P+bfquVpve/3qntvuPsJV5dmHLRVZhA+kRZYx5QETe5/TlTmADtqTkt4CWPPtGReRM7FyAj2FH8zuwF1P3YEfTU30eG+T/BVtV6G7gcynHS4jIWdiSlV/D5sZvwZbMvD6lXbOInIAtS/l1p91e7Kq86c+Zz2PYbwy+jv1/exPwRWPMTwZ4HKXUOCQpxQGUUkqpMUFEZmCD+muNMVcPwvFOBR4B3myMefBAj6eUUsNFR+aVUkqNaiJSiF2U6UFs6s884KtAJ/ZbDqWUmrA0mFdKKTXaxbHVYn6GTVfpAP4LXGCMyVQSVCmlJgxNs1FKKaWUUmqM0tKUSimllFJKjVEazCullFJKKTVGaTCvlFJKKaXUGKXBvFJKKaWUUmOUBvNKKaWUUkqNUf8f8xr/NSz6zswAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2, 1, figsize=(12, 10))\n", + "ax[0].plot(train_losses)\n", + "ax[0].set_xlabel(\"Total training epochs\")\n", + "ax[0].set_ylabel(\"Training loss (avg. NLL)\")\n", + "ax[1].plot(val_scores)\n", + "ax[1].set_xlabel(\"Total training epochs\")\n", + "ax[1].set_ylabel(\"Validation score (avg. MSE)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Where to learn more about MBRL?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "To learn about the other features of the library, please check out our [documentation](https://facebookresearch.github.io/mbrl-lib/). Also take a look at our provided implementations of [PETS](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/pets.py), [MBPO](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/mbpo.py), and [PlaNet](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/planet.py), and their configuration [files](https://github.com/facebookresearch/mbrl-lib/tree/main/mbrl/examples/conf)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file From 9c6a241c0284bf4d3480c17900f9874b35bf06cc Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Tue, 26 Jul 2022 14:33:30 -0700 Subject: [PATCH 02/24] clean model file, add replay buffer class --- mbrl/models/traj_based_mlp.py | 228 ++----------------------------- mbrl/planning/linear_feedback.py | 28 ++-- mbrl/types.py | 52 ++++++- mbrl/util/replay_buffer.py | 209 +++++++++++++++++++++++++++- 4 files changed, 288 insertions(+), 229 deletions(-) diff --git a/mbrl/models/traj_based_mlp.py b/mbrl/models/traj_based_mlp.py index 366d286c..95295827 100644 --- a/mbrl/models/traj_based_mlp.py +++ b/mbrl/models/traj_based_mlp.py @@ -2,18 +2,12 @@ # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. -import pathlib -from typing import Any, Dict, List, Optional, Sequence, Tuple, Union +from typing import Dict, Optional, Tuple, Union -import hydra import omegaconf import torch -from torch import nn as nn -from torch.nn import functional as F -import mbrl.util.math from .gaussian_mlp import GaussianMLP -from .util import EnsembleLinearLayer, truncated_normal_init class TrajBasedMLP(GaussianMLP): @@ -83,108 +77,26 @@ def __init__( activation_fn_cfg: Optional[Union[Dict, omegaconf.DictConfig]] = None, ): super().__init__( - ensemble_size, device, propagation_method, deterministic=deterministic + in_size, + out_size, + device, + num_layers=num_layers, + ensemble_size=ensemble_size, + hid_size=hid_size, + deterministic=deterministic, + propagation_method=propagation_method, + learn_logvar_bounds=learn_logvar_bounds, + activation_fn_cfg=activation_fn_cfg, ) - self.in_size = in_size - self.out_size = out_size - - def create_activation(): - if activation_fn_cfg is None: - activation_func = nn.ReLU() - else: - # Handle the case where activation_fn_cfg is a dict - cfg = omegaconf.OmegaConf.create(activation_fn_cfg) - activation_func = hydra.utils.instantiate(cfg) - return activation_func - - def create_linear_layer(l_in, l_out): - return EnsembleLinearLayer(ensemble_size, l_in, l_out) - - hidden_layers = [ - nn.Sequential(create_linear_layer(in_size, hid_size), create_activation()) - ] - for i in range(num_layers - 1): - hidden_layers.append( - nn.Sequential( - create_linear_layer(hid_size, hid_size), - create_activation(), - ) - ) - self.hidden_layers = nn.Sequential(*hidden_layers) - - if deterministic: - self.mean_and_logvar = create_linear_layer(hid_size, out_size) - else: - self.mean_and_logvar = create_linear_layer(hid_size, 2 * out_size) - self.min_logvar = nn.Parameter( - -10 * torch.ones(1, out_size), requires_grad=learn_logvar_bounds - ) - self.max_logvar = nn.Parameter( - 0.5 * torch.ones(1, out_size), requires_grad=learn_logvar_bounds - ) - - self.apply(truncated_normal_init) - self.to(self.device) - - self.elite_models: List[int] = None - - def _maybe_toggle_layers_use_only_elite(self, only_elite: bool): - if self.elite_models is None: - return - if self.num_members > 1 and only_elite: - for layer in self.hidden_layers: - # each layer is (linear layer, activation_func) - layer[0].set_elite(self.elite_models) - layer[0].toggle_use_only_elite() - self.mean_and_logvar.set_elite(self.elite_models) - self.mean_and_logvar.toggle_use_only_elite() - - def _default_forward( - self, x: torch.Tensor, only_elite: bool = False, **_kwargs - ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]: - self._maybe_toggle_layers_use_only_elite(only_elite) - x = self.hidden_layers(x) - mean_and_logvar = self.mean_and_logvar(x) - self._maybe_toggle_layers_use_only_elite(only_elite) - if self.deterministic: - return mean_and_logvar, None - else: - mean = mean_and_logvar[..., : self.out_size] - logvar = mean_and_logvar[..., self.out_size :] - logvar = self.max_logvar - F.softplus(self.max_logvar - logvar) - logvar = self.min_logvar + F.softplus(logvar - self.min_logvar) - return mean, logvar - - def _forward_from_indices( - self, x: torch.Tensor, model_shuffle_indices: torch.Tensor - ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]: - _, batch_size, _ = x.shape - - num_models = ( - len(self.elite_models) if self.elite_models is not None else len(self) - ) - shuffled_x = x[:, model_shuffle_indices, ...].view( - num_models, batch_size // num_models, -1 - ) - - mean, logvar = self._default_forward(shuffled_x, only_elite=True) - # note that mean and logvar are shuffled - mean = mean.view(batch_size, -1) - mean[model_shuffle_indices] = mean.clone() # invert the shuffle - - if logvar is not None: - logvar = logvar.view(batch_size, -1) - logvar[model_shuffle_indices] = logvar.clone() # invert the shuffle - - return mean, logvar - def _forward_ensemble( self, x: torch.Tensor, rng: Optional[torch.Generator] = None, propagation_indices: Optional[torch.Tensor] = None, ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]: + + # TODO(NOL) get time index from inputs, which is used at propagation (can be a batch of time) if self.propagation_method is None: mean, logvar = self._default_forward(x, only_elite=False) if self.num_members == 1: @@ -202,6 +114,8 @@ def _forward_ensemble( f"{model_len} models." ) x = x.unsqueeze(0) + + # TODO(NOL) Test these, I think only expectation really makes sense given the model if self.propagation_method == "random_model": # passing generator causes segmentation fault # see https://github.com/pytorch/pytorch/issues/44714 @@ -282,115 +196,3 @@ def forward( # type: ignore x, rng=rng, propagation_indices=propagation_indices ) return self._default_forward(x) - - def _mse_loss(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tensor: - assert model_in.ndim == target.ndim - if model_in.ndim == 2: # add model dimension - model_in = model_in.unsqueeze(0) - target = target.unsqueeze(0) - pred_mean, _ = self.forward(model_in, use_propagation=False) - return F.mse_loss(pred_mean, target, reduction="none").sum((1, 2)).sum() - - def _nll_loss(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tensor: - assert model_in.ndim == target.ndim - if model_in.ndim == 2: # add ensemble dimension - model_in = model_in.unsqueeze(0) - target = target.unsqueeze(0) - pred_mean, pred_logvar = self.forward(model_in, use_propagation=False) - if target.shape[0] != self.num_members: - target = target.repeat(self.num_members, 1, 1) - nll = ( - mbrl.util.math.gaussian_nll(pred_mean, pred_logvar, target, reduce=False) - .mean((1, 2)) # average over batch and target dimension - .sum() - ) # sum over ensemble dimension - nll += 0.01 * (self.max_logvar.sum() - self.min_logvar.sum()) - return nll - - def loss( - self, - model_in: torch.Tensor, - target: Optional[torch.Tensor] = None, - ) -> Tuple[torch.Tensor, Dict[str, Any]]: - """Computes Gaussian NLL loss. - - It also includes terms for ``max_logvar`` and ``min_logvar`` with small weights, - with positive and negative signs, respectively. - - This function returns no metadata, so the second output is set to an empty dict. - - Args: - model_in (tensor): input tensor. The shape must be ``E x B x Id``, or ``B x Id`` - where ``E``, ``B`` and ``Id`` represent ensemble size, batch size, and input - dimension, respectively. - target (tensor): target tensor. The shape must be ``E x B x Id``, or ``B x Od`` - where ``E``, ``B`` and ``Od`` represent ensemble size, batch size, and output - dimension, respectively. - - Returns: - (tensor): a loss tensor representing the Gaussian negative log-likelihood of - the model over the given input/target. If the model is an ensemble, returns - the average over all models. - """ - if self.deterministic: - return self._mse_loss(model_in, target), {} - else: - return self._nll_loss(model_in, target), {} - - def eval_score( # type: ignore - self, model_in: torch.Tensor, target: Optional[torch.Tensor] = None - ) -> Tuple[torch.Tensor, Dict[str, Any]]: - """Computes the squared error for the model over the given input/target. - - When model is not an ensemble, this is equivalent to - `F.mse_loss(model(model_in, target), reduction="none")`. If the model is ensemble, - then return is batched over the model dimension. - - This function returns no metadata, so the second output is set to an empty dict. - - Args: - model_in (tensor): input tensor. The shape must be ``B x Id``, where `B`` and ``Id`` - batch size, and input dimension, respectively. - target (tensor): target tensor. The shape must be ``B x Od``, where ``B`` and ``Od`` - represent batch size, and output dimension, respectively. - - Returns: - (tensor): a tensor with the squared error per output dimension, batched over model. - """ - assert model_in.ndim == 2 and target.ndim == 2 - with torch.no_grad(): - pred_mean, _ = self.forward(model_in, use_propagation=False) - target = target.repeat((self.num_members, 1, 1)) - return F.mse_loss(pred_mean, target, reduction="none"), {} - - def sample_propagation_indices( - self, batch_size: int, _rng: torch.Generator - ) -> torch.Tensor: - model_len = ( - len(self.elite_models) if self.elite_models is not None else len(self) - ) - if batch_size % model_len != 0: - raise ValueError( - "To use GaussianMLP's ensemble propagation, the batch size must " - "be a multiple of the number of models in the ensemble." - ) - # rng causes segmentation fault, see https://github.com/pytorch/pytorch/issues/44714 - return torch.randperm(batch_size, device=self.device) - - def set_elite(self, elite_indices: Sequence[int]): - if len(elite_indices) != self.num_members: - self.elite_models = list(elite_indices) - - def save(self, save_dir: Union[str, pathlib.Path]): - """Saves the model to the given directory.""" - model_dict = { - "state_dict": self.state_dict(), - "elite_models": self.elite_models, - } - torch.save(model_dict, pathlib.Path(save_dir) / self._MODEL_FNAME) - - def load(self, load_dir: Union[str, pathlib.Path]): - """Loads the model from the given path.""" - model_dict = torch.load(pathlib.Path(load_dir) / self._MODEL_FNAME) - self.load_state_dict(model_dict["state_dict"]) - self.elite_models = model_dict["elite_models"] diff --git a/mbrl/planning/linear_feedback.py b/mbrl/planning/linear_feedback.py index 10cf4331..1ab3ba58 100644 --- a/mbrl/planning/linear_feedback.py +++ b/mbrl/planning/linear_feedback.py @@ -3,6 +3,8 @@ # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. +from typing import Union + import numpy as np from .core import Agent @@ -13,7 +15,15 @@ class PIDAgent(Agent): Agent that reacts via an internal set of PID controllers. """ - def __init__(self, dX, dU, P, I, D, target): + def __init__( + self, + dX: int, + dU: int, + P_value: Union[int, float], + I_value: Union[int, float], + D_value: Union[int, float], + target: float, + ): """ :param dX: unused :param dU: dimensionality of state and control signal @@ -25,18 +35,9 @@ def __init__(self, dX, dU, P, I, D, target): super().__init__() self.n_dof = dU # TODO: fix dimensionality with P - if isinstance(P, int): - self.Kp = np.tile(P, self.n_dof) - else: - self.Kp = P - if isinstance(I, int): - self.Ki = np.tile(I, self.n_dof) - else: - self.Ki = I - if isinstance(D, int): - self.Kd = np.tile(D, self.n_dof) - else: - self.Kd = D + self.Kp = np.tile(P_value, self.n_dof) + self.Ki = np.tile(I_value, self.n_dof) + self.Kd = np.tile(D_value, self.n_dof) self.target = target self.prev_error = 0 self.error = 0 @@ -63,4 +64,3 @@ def _get_I(self): def _get_D(self): return self.Kd - diff --git a/mbrl/types.py b/mbrl/types.py index fca4253c..4ab4be0a 100644 --- a/mbrl/types.py +++ b/mbrl/types.py @@ -64,4 +64,54 @@ def add_new_batch_dim(self, batch_size: int): ) -ModelInput = Union[torch.Tensor, TransitionBatch] +@dataclass +class TrajTransitionBatch: + """Represents a batch of transitions""" + + obs: Optional[TensorType] + act: Optional[TensorType] + next_obs: Optional[TensorType] + horizon: Optional[TensorType] + rewards: Optional[TensorType] + dones: Optional[TensorType] + + def __len__(self): + return self.obs.shape[0] + + def astuple(self) -> Transition: + return self.obs, self.act, self.next_obs, self.horizon, self.rewards, self.dones + + def __getitem__(self, item): + return TransitionBatch( + self.obs[item], + self.act[item], + self.next_obs[item], + self.horizon[item], + self.rewards[item], + self.dones[item], + ) + + @staticmethod + def _get_new_shape(old_shape: Tuple[int, ...], batch_size: int): + new_shape = list((1,) + old_shape) + new_shape[0] = batch_size + new_shape[1] = old_shape[0] // batch_size + return tuple(new_shape) + + def add_new_batch_dim(self, batch_size: int): + if not len(self) % batch_size == 0: + raise ValueError( + "Current batch of transitions size is not a " + "multiple of the new batch size. " + ) + return TransitionBatch( + self.obs.reshape(self._get_new_shape(self.obs.shape, batch_size)), + self.act.reshape(self._get_new_shape(self.act.shape, batch_size)), + self.next_obs.reshape(self._get_new_shape(self.obs.shape, batch_size)), + self.horizon.reshape(self._get_new_shape(self.horizon.shape, batch_size)), + self.rewards.reshape(self._get_new_shape(self.rewards.shape, batch_size)), + self.dones.reshape(self._get_new_shape(self.dones.shape, batch_size)), + ) + + +ModelInput = Union[torch.Tensor, TransitionBatch, TrajTransitionBatch] diff --git a/mbrl/util/replay_buffer.py b/mbrl/util/replay_buffer.py index 32c2d2bb..592e827f 100644 --- a/mbrl/util/replay_buffer.py +++ b/mbrl/util/replay_buffer.py @@ -8,7 +8,7 @@ import numpy as np -from mbrl.types import TransitionBatch +from mbrl.types import TransitionBatch, TrajTransitionBatch def _consolidate_batches(batches: Sequence[TransitionBatch]) -> TransitionBatch: @@ -689,3 +689,210 @@ def get_all(self, shuffle: bool = False) -> TransitionBatch: @property def rng(self) -> np.random.Generator: return self._rng + + +class TrajBasedReplayBuffer(ReplayBuffer): + """A replay buffer with support for storing control parameters and time horizion from initial state. Note that next_obs in this case is a time + horizon, rather than plus one. + + This buffer can be pushed to and sampled from as a typical replay buffer. + + Args: + capacity (int): the maximum number of transitions that the buffer can store. + When the capacity is reached, the contents are overwritten in FIFO fashion. + obs_shape (Sequence of ints): the shape of the observations to store. + action_shape (Sequence of ints): the shape of the actions to store. + obs_type (type): the data type of the observations (defaults to np.float32). + action_type (type): the data type of the actions (defaults to np.float32). + reward_type (type): the data type of the rewards (defaults to np.float32). + rng (np.random.Generator, optional): a random number generator when sampling + batches. If None (default value), a new default generator will be used. + max_trajectory_length (int, optional): if given, indicates that trajectory + information should be stored and that trajectories will be at most this + number of steps. Defaults to ``None`` in which case no trajectory + information will be kept. The buffer will keep trajectory information + automatically using the done value when calling :meth:`add`. + + .. warning:: + When using ``max_trajectory_length`` it is the user's responsibility to ensure + that trajectories are stored continuously in the replay buffer. + """ + + def __init__( + self, + capacity: int, + obs_shape: Sequence[int], + param_shape: Sequence[int], + obs_type: Type = np.float32, + hor_type: Type = np.int_, + param_type: Type = np.float32, + reward_type: Type = np.float32, + rng: Optional[np.random.Generator] = None, + max_trajectory_length: Optional[int] = None, + ): + super().init( + capacity=capacity, + obs_shape=obs_shape, + action_shape=param_shape, + obs_type=obs_type, + action_type=param_type, + reward_type=reward_type, + rng=rng, + max_trajectory_length=max_trajectory_length, + ) + self.horizon = np.empty((capacity, 1), dtype=hor_type) + + def add( + self, + obs: np.ndarray, + params: np.ndarray, + next_obs: np.ndarray, + horizon: Union[np.int_, np.float32], + reward: float, + done: bool, + ): + """Adds a transition (s, a, s', h, r, done) to the replay buffer. + + Args: + obs (np.ndarray): the observation at time t. + params (np.ndarray): the policy parameters at time t. + next_obs (np.ndarray): the observation at time t + h. + horizon (int for float): the timestep between current obs and the next obs + reward (float): the reward at time t. + done (bool): a boolean indicating whether the episode ended or not. + """ + self.obs[self.cur_idx] = obs + self.next_obs[self.cur_idx] = next_obs + self.action[self.cur_idx] = params + self.horizon[self.cur_idx] = horizon + self.reward[self.cur_idx] = reward + self.done[self.cur_idx] = done + + if self.trajectory_indices is not None: + self._trajectory_bookkeeping(done) + else: + self.cur_idx = (self.cur_idx + 1) % self.capacity + self.num_stored = min(self.num_stored + 1, self.capacity) + + def add_batch( + self, + obs: np.ndarray, + params: np.ndarray, + next_obs: np.ndarray, + horizon: np.ndarray, + reward: np.ndarray, + done: np.ndarray, + ): + """Adds a transition (s, a, s', r, done) to the replay buffer. + + Expected shapes are: + obs --> (batch_size,) + obs_shape + act --> (batch_size,) + action_shape + reward/done/horizon --> (batch_size,) + + Args: + obs (np.ndarray): the observation at time t. + params (np.ndarray): the policy parameters at time t. + next_obs (np.ndarray): the observation at time t + h. + horizon (int for float): the timestep between current obs and the next obs + reward (float): the reward at time t. + done (bool): a boolean indicating whether the episode ended or not. + """ + + def copy_from_to(buffer_start, batch_start, how_many): + buffer_slice = slice(buffer_start, buffer_start + how_many) + batch_slice = slice(batch_start, batch_start + how_many) + np.copyto(self.obs[buffer_slice], obs[batch_slice]) + np.copyto(self.action[buffer_slice], params[batch_slice]) + np.copyto(self.horizon[buffer_slice], horizon[batch_slice]) + np.copyto(self.reward[buffer_slice], reward[batch_slice]) + np.copyto(self.next_obs[buffer_slice], next_obs[batch_slice]) + np.copyto(self.done[buffer_slice], done[batch_slice]) + + _batch_start = 0 + buffer_end = self.cur_idx + len(obs) + if buffer_end > self.capacity: + copy_from_to(self.cur_idx, _batch_start, self.capacity - self.cur_idx) + _batch_start = self.capacity - self.cur_idx + self.cur_idx = 0 + self.num_stored = self.capacity + + _how_many = len(obs) - _batch_start + copy_from_to(self.cur_idx, _batch_start, _how_many) + self.cur_idx = (self.cur_idx + _how_many) % self.capacity + self.num_stored = min(self.num_stored + _how_many, self.capacity) + + def _batch_from_indices(self, indices: Sized) -> TransitionBatch: + obs = self.obs[indices] + next_obs = self.next_obs[indices] + action = self.action[indices] + horizon = self.horizon[indices] + reward = self.reward[indices] + done = self.done[indices] + + return TrajTransitionBatch(obs, action, next_obs, horizon, reward, done) + + def __len__(self): + return self.num_stored + + def save(self, save_dir: Union[pathlib.Path, str]): + """Saves the data in the replay buffer to a given directory. + + Args: + save_dir (str): the directory to save the data to. File name will be + replay_buffer.npz. + """ + path = pathlib.Path(save_dir) / "replay_buffer.npz" + np.savez( + path, + obs=self.obs[: self.num_stored], + next_obs=self.next_obs[: self.num_stored], + horizon=self.horizon[: self.num_stored], + action=self.action[: self.num_stored], + reward=self.reward[: self.num_stored], + done=self.done[: self.num_stored], + trajectory_indices=self.trajectory_indices or [], + ) + + def load(self, load_dir: Union[pathlib.Path, str]): + """Loads transition data from a given directory. + + Args: + load_dir (str): the directory where the buffer is stored. + """ + path = pathlib.Path(load_dir) / "replay_buffer.npz" + data = np.load(path) + num_stored = len(data["obs"]) + self.obs[:num_stored] = data["obs"] + self.next_obs[:num_stored] = data["next_obs"] + self.horizon[:num_stored] = data["horizon"] + self.action[:num_stored] = data["action"] + self.reward[:num_stored] = data["reward"] + self.done[:num_stored] = data["done"] + self.num_stored = num_stored + self.cur_idx = self.num_stored % self.capacity + if "trajectory_indices" in data and len(data["trajectory_indices"]): + self.trajectory_indices = data["trajectory_indices"] + + def get_all(self, shuffle: bool = False) -> TransitionBatch: + """Returns all data stored in the replay buffer. + + Args: + shuffle (int): set to ``True`` if the data returned should be in random order. + Defaults to ``False``. + """ + if shuffle: + permutation = self._rng.permutation(self.num_stored) + return self._batch_from_indices(permutation) + else: + return TransitionBatch( + self.obs[: self.num_stored], + self.action[: self.num_stored], + self.next_obs[: self.num_stored], + self.horizon[: self.num_stored], + self.reward[: self.num_stored], + self.done[: self.num_stored], + ) + + @property + def rng(self) -> np.random.Generator: + return self._rng From 64e5245e97df782b0ec77e247a5e9bdd8b811c99 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Tue, 9 Aug 2022 14:55:15 -0700 Subject: [PATCH 03/24] setup data collection in notebook, will do precommits soon --- .pre-commit-config.yaml | 2 +- mbrl/planning/__init__.py | 1 + mbrl/planning/linear_feedback.py | 42 +- notebooks/traj_based_model.ipynb | 44535 ++++++++++++++++++++++++++++- 4 files changed, 44291 insertions(+), 289 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 1a57593b..4d1ac866 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ repos: hooks: - id: black files: 'mbrl' - language_version: python3.7 + language_version: python3 - repo: https://gitlab.com/pycqa/flake8 rev: 3.9.2 diff --git a/mbrl/planning/__init__.py b/mbrl/planning/__init__.py index 772afcfb..463bbadc 100644 --- a/mbrl/planning/__init__.py +++ b/mbrl/planning/__init__.py @@ -3,6 +3,7 @@ # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. from .core import Agent, RandomAgent, complete_agent_cfg, load_agent +from .linear_feedback import PIDAgent from .trajectory_opt import ( CEMOptimizer, ICEMOptimizer, diff --git a/mbrl/planning/linear_feedback.py b/mbrl/planning/linear_feedback.py index 1ab3ba58..a937c803 100644 --- a/mbrl/planning/linear_feedback.py +++ b/mbrl/planning/linear_feedback.py @@ -3,8 +3,6 @@ # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. -from typing import Union - import numpy as np from .core import Agent @@ -17,27 +15,35 @@ class PIDAgent(Agent): def __init__( self, - dX: int, - dU: int, - P_value: Union[int, float], - I_value: Union[int, float], - D_value: Union[int, float], - target: float, + dim: int, + Kp: np.ndarray, + Ki: np.ndarray, + Kd: np.ndarray, + target: np.ndarray, ): """ - :param dX: unused - :param dU: dimensionality of state and control signal + :param dim: dimensionality of state and control signal :param P: proportional control coeff :param I: integral control coeff :param D: derivative control coeff :param target: setpoint """ super().__init__() - self.n_dof = dU + assert len(Kp) == dim + assert len(Ki) == dim + assert len(Kd) == dim + assert len(target) == dim + + self.n_dof = dim + + # TODO: add helper functions for setting and using state_mapping + self.state_mapping = None # can set to run PID on specific variables + + # TODO: fix dimensionality with P - self.Kp = np.tile(P_value, self.n_dof) - self.Ki = np.tile(I_value, self.n_dof) - self.Kd = np.tile(D_value, self.n_dof) + self.Kp = Kp #np.tile(P_value, self.n_dof) + self.Ki = Ki #np.tile(I_value, self.n_dof) + self.Kd = Kd #np.tile(D_value, self.n_dof) self.target = target self.prev_error = 0 self.error = 0 @@ -45,6 +51,8 @@ def __init__( # self.I_count = 0 def act(self, obs: np.array) -> np.ndarray: + if len(obs) > self.n_dof: + obs = obs[:self.n_dof] q_des = self.target q = obs @@ -64,3 +72,9 @@ def _get_I(self): def _get_D(self): return self.Kd + + def _get_targets(self): + return self.target + + def get_parameters(self): + return np.stack((self._get_P(), self._get_I(), self._get_D(), self._get_targets())).flatten() diff --git a/notebooks/traj_based_model.ipynb b/notebooks/traj_based_model.ipynb index 66025f10..6b1988d2 100644 --- a/notebooks/traj_based_model.ipynb +++ b/notebooks/traj_based_model.ipynb @@ -1,16 +1,5 @@ { "cells": [ - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "#### Note: This example is compatible with versions v0.2.1dev or higher (i.e., up to date with GitHub). For instructions on how to run with latest pip stable versions (<=v0.1.5), see [this](https://github.com/facebookresearch/mbrl-lib/blob/main/notebooks/pets_example_v0.1.5.ipynb) notebook." - ] - }, { "cell_type": "markdown", "metadata": { @@ -43,6 +32,7 @@ "import torch\n", "import omegaconf\n", "\n", + "import mbrl.env.pets_reacher as reacher_env\n", "import mbrl.env.cartpole_continuous as cartpole_env\n", "import mbrl.env.reward_fns as reward_fns\n", "import mbrl.env.termination_fns as termination_fns\n", @@ -91,12 +81,12 @@ "source": [ "# Creating the environment\n", "\n", - "First we instantiate the environment and specify which reward function and termination function to use with the gym-like environment wrapper, along with some utility objects. The termination function tells the wrapper if an observation should cause an episode to end or not, and it is an input used in some algorithms, like [MBPO](https://github.com/JannerM/mbpo/blob/master/mbpo/static/halfcheetah.py). The reward function is used to compute the value of the reward given an observation, and it's used by some algorithms, like [PETS](https://github.com/kchua/handful-of-trials/blob/77fd8802cc30b7683f0227c90527b5414c0df34c/dmbrl/controllers/MPC.py#L65)." + "First we instantiate the environment." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "pycharm": { "name": "#%%\n" @@ -105,18 +95,13 @@ "outputs": [], "source": [ "seed = 0\n", - "env = cartpole_env.CartPoleEnv()\n", + "env = reacher_env.Reacher3DEnv()\n", "env.seed(seed)\n", "rng = np.random.default_rng(seed=0)\n", "generator = torch.Generator(device=device)\n", "generator.manual_seed(seed)\n", "obs_shape = env.observation_space.shape\n", - "act_shape = env.action_space.shape\n", - "\n", - "# This functions allows the model to evaluate the true rewards given an observation \n", - "reward_fn = reward_fns.cartpole\n", - "# This function allows the model to know if an observation should make the episode end\n", - "term_fn = termination_fns.cartpole" + "act_shape = env.action_space.shape\n" ] }, { @@ -134,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "pycharm": { "name": "#%%\n" @@ -152,7 +137,7 @@ "cfg_dict = {\n", " # dynamics model configuration\n", " \"dynamics_model\": {\n", - " \"_target_\": \"mbrl.models.GaussianMLP\",\n", + " \"_target_\": \"mbrl.models.TrajBasedMLP\",\n", " \"device\": device,\n", " \"num_layers\": 3,\n", " \"ensemble_size\": ensemble_size,\n", @@ -170,7 +155,7 @@ " # options for training the dynamics model\n", " \"algorithm\": {\n", " \"learned_rewards\": False,\n", - " \"target_is_delta\": True,\n", + " \"target_is_delta\": False, # trajectory based model predicts states directly\n", " \"normalize\": True,\n", " },\n", " # these are experiment specific options\n", @@ -199,7 +184,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "pycharm": { "name": "#%%\n" @@ -208,10 +193,10 @@ "outputs": [], "source": [ "# Create a 1-D dynamics model for this environment\n", - "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n", + "# dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n", "\n", "# Create a gym-like environment to encapsulate the model\n", - "model_env = models.ModelEnv(env, dynamics_model, term_fn, reward_fn, generator=generator)" + "# model_env = models.ModelEnv(env, dynamics_model, term_fn, reward_fn, generator=generator)" ] }, { @@ -222,14 +207,14 @@ } }, "source": [ - "# Create a replay buffer\n", + "# PID Agent\n", "\n", - "We can create a replay buffer for this environment an configuration using the following method" + "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 26, "metadata": { "pycharm": { "name": "#%%\n" @@ -237,112 +222,23 @@ }, "outputs": [], "source": [ - "replay_buffer = common_util.create_replay_buffer(cfg, obs_shape, act_shape, rng=rng)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "We can now populate the replay buffer with random trajectories of a desired length, using a single function call to `util.rollout_agent_trajectories`. Note that we pass an agent of type `planning.RandomAgent` to generate the actions; however, this method accepts any agent that is a subclass of `planning.Agent`, allowing changing exploration strategies with minimal changes to the code. " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "# samples stored 200\n" - ] - } - ], - "source": [ - "common_util.rollout_agent_trajectories(\n", - " env,\n", - " trial_length, # initial exploration steps\n", - " planning.RandomAgent(env),\n", - " {}, # keyword arguments to pass to agent.act()\n", - " replay_buffer=replay_buffer,\n", - " trial_length=trial_length\n", - ")\n", - "\n", - "print(\"# samples stored\", replay_buffer.num_stored)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "# CEM Agent\n", + "def create_pid_agent(action_dim):\n", + " P = np.random.rand(action_dim) * 5\n", + " I = np.zeros(action_dim)\n", + " D = np.random.rand(action_dim)\n", + " target = np.random.rand(action_dim) * 2 - 1\n", "\n", - "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper." + " agent = planning.PIDAgent(dim=action_dim, Kp=P, Ki=I, Kd=D, target=target)\n", + " return agent" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, + "execution_count": 36, + "metadata": {}, "outputs": [], "source": [ - "agent_cfg = omegaconf.OmegaConf.create({\n", - " # this class evaluates many trajectories and picks the best one\n", - " \"_target_\": \"mbrl.planning.TrajectoryOptimizerAgent\",\n", - " \"planning_horizon\": 15,\n", - " \"replan_freq\": 1,\n", - " \"verbose\": False,\n", - " \"action_lb\": \"???\",\n", - " \"action_ub\": \"???\",\n", - " # this is the optimizer to generate and choose a trajectory\n", - " \"optimizer_cfg\": {\n", - " \"_target_\": \"mbrl.planning.CEMOptimizer\",\n", - " \"num_iterations\": 5,\n", - " \"elite_ratio\": 0.1,\n", - " \"population_size\": 500,\n", - " \"alpha\": 0.1,\n", - " \"device\": device,\n", - " \"lower_bound\": \"???\",\n", - " \"upper_bound\": \"???\",\n", - " \"return_mean_elites\": True,\n", - " \"clipped_normal\": False\n", - " }\n", - "})\n", - "\n", - "agent = planning.create_trajectory_optim_agent_for_model(\n", - " model_env,\n", - " agent_cfg,\n", - " num_particles=20\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "# Running PETS" + "agent = create_pid_agent(env.action_space.shape[0])" ] }, { @@ -353,30 +249,14 @@ } }, "source": [ - "Having a model and an agent, we can now run PETS with a simple loop and a few function calls. The first code block creates a callback to pass to the model trainer to accumulate the training losses and validation scores observed. The second block is just a utility function to update the agent's visualization." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "train_losses = []\n", - "val_scores = []\n", + "# Create a replay buffer\n", "\n", - "def train_callback(_model, _total_calls, _epoch, tr_loss, val_score, _best_val):\n", - " train_losses.append(tr_loss)\n", - " val_scores.append(val_score.mean().item()) # this returns val score per ensemble model" + "We can create a replay buffer for this environment an configuration using the following method, where `collect_trajectories` is on for easier plotting of results." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 61, "metadata": { "pycharm": { "name": "#%%\n" @@ -384,21 +264,14 @@ }, "outputs": [], "source": [ - "def update_axes(_axs, _frame, _text, _trial, _steps_trial, _all_rewards, force_update=False):\n", - " if not force_update and (_steps_trial % 10 != 0):\n", - " return\n", - " _axs[0].imshow(_frame)\n", - " _axs[0].set_xticks([])\n", - " _axs[0].set_yticks([])\n", - " _axs[1].clear()\n", - " _axs[1].set_xlim([0, num_trials + .1])\n", - " _axs[1].set_ylim([0, 200])\n", - " _axs[1].set_xlabel(\"Trial\")\n", - " _axs[1].set_ylabel(\"Trial reward\")\n", - " _axs[1].plot(_all_rewards, 'bs-')\n", - " _text.set_text(f\"Trial {_trial + 1}: {_steps_trial} steps\")\n", - " display.display(plt.gcf()) \n", - " display.clear_output(wait=True)" + "param_shape = (len(agent.get_parameters())+1,)\n", + "collect_full_trajectories = True\n", + "replay_buffer = common_util.create_replay_buffer(cfg, \n", + " obs_shape, \n", + " param_shape, \n", + " rng=rng, \n", + " collect_trajectories=collect_full_trajectories)\n", + "\n" ] }, { @@ -409,135 +282,44239 @@ } }, "source": [ - "The following lines implement the PETS algorithm. First, we create a model trainer and pass some hyperparameters for the optimizer (Adam), along with references to the model instance to use. Then we start a loop where we execute actions of ``agent`` in the environment and train the model at the beginning of the episode (by calling ``model_trainer.train()``. At every step in the loop, we execute an agent action in the environment and populate the replay buffer by calling ``util.step_env_and_add_to_buffer()``. Importantly, at the beginning of each episode we also call ``agent.reset()`` to clear any episode dependent cache; in the case of a ``TrajectoryOptimizerAgent``, this means clearing the previous action sequence found, which is shifted at every call to obtain an initial solution for the optimizer. \n", - "\n", - "The rest of the code is mostly bookkeeping to keep track of the total reward observed during each episode, and to make sure episodes terminate after some desired length. After running this code, you should see the agent reaching the maximum reward of 200 after a few episodes." + "We can now populate the replay buffer with random trajectories of a desired length, using a modified function based on `util.rollout_agent_trajectories`. The changes are that the tuples are only added to the buffer at the end of the trajectory to add every sub-trajectory for supervised learning." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 69, "metadata": { "pycharm": { "name": "#%%\n" - }, - "scrolled": true + } }, "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "adding: mem time0, current time 1, horizon 1\n", + "adding: mem time0, current time 2, horizon 2\n", + "adding: mem time1, current time 2, horizon 1\n", + "adding: mem time0, current time 3, horizon 3\n", + "adding: mem time1, current time 3, horizon 2\n", + "adding: mem time2, current time 3, horizon 1\n", + "adding: mem time0, current time 4, horizon 4\n", + "adding: mem time1, current time 4, horizon 3\n", + "adding: mem time2, current time 4, horizon 2\n", + "adding: mem time3, current time 4, horizon 1\n", + "adding: mem time0, current time 5, horizon 5\n", + "adding: mem time1, current time 5, horizon 4\n", + "adding: mem time2, current time 5, horizon 3\n", + "adding: mem time3, current time 5, horizon 2\n", + "adding: mem time4, current time 5, horizon 1\n", + "adding: mem time0, current time 6, horizon 6\n", + "adding: mem time1, current time 6, horizon 5\n", + "adding: mem time2, current time 6, horizon 4\n", + "adding: mem time3, current time 6, horizon 3\n", + "adding: mem time4, current time 6, horizon 2\n", + "adding: mem time5, current time 6, horizon 1\n", + "adding: mem time0, current time 7, horizon 7\n", + "adding: mem time1, current time 7, horizon 6\n", + "adding: mem time2, current time 7, horizon 5\n", + "adding: mem time3, current time 7, horizon 4\n", + "adding: mem time4, current time 7, horizon 3\n", + "adding: mem time5, current time 7, horizon 2\n", + "adding: mem time6, current time 7, horizon 1\n", + "adding: mem time0, current time 8, horizon 8\n", + "adding: mem time1, current time 8, horizon 7\n", + "adding: mem time2, current time 8, horizon 6\n", + "adding: mem time3, current time 8, horizon 5\n", + "adding: mem time4, current time 8, horizon 4\n", + "adding: mem time5, current time 8, horizon 3\n", + "adding: mem time6, current time 8, horizon 2\n", + "adding: mem time7, current time 8, horizon 1\n", + "adding: mem time0, current time 9, horizon 9\n", + "adding: mem time1, current time 9, horizon 8\n", + "adding: mem time2, current time 9, horizon 7\n", + "adding: mem time3, current time 9, horizon 6\n", + "adding: mem time4, current time 9, horizon 5\n", + "adding: mem time5, current time 9, horizon 4\n", + "adding: mem time6, current time 9, horizon 3\n", + "adding: mem time7, current time 9, horizon 2\n", + "adding: mem time8, current time 9, horizon 1\n", + "adding: mem time0, current time 10, horizon 10\n", + "adding: mem time1, current time 10, horizon 9\n", + "adding: mem time2, current time 10, horizon 8\n", + "adding: mem time3, current time 10, horizon 7\n", + "adding: mem time4, current time 10, horizon 6\n", + "adding: mem time5, current time 10, horizon 5\n", + "adding: mem time6, current time 10, horizon 4\n", + "adding: mem time7, current time 10, horizon 3\n", + "adding: mem time8, current time 10, horizon 2\n", + "adding: mem time9, current time 10, horizon 1\n", + "adding: mem time0, current time 11, horizon 11\n", + "adding: mem time1, current time 11, horizon 10\n", + "adding: mem time2, current time 11, horizon 9\n", + "adding: mem time3, current time 11, horizon 8\n", + "adding: mem time4, current time 11, horizon 7\n", + "adding: mem time5, current time 11, horizon 6\n", + "adding: mem time6, current time 11, horizon 5\n", + "adding: mem time7, current time 11, horizon 4\n", + "adding: mem time8, current time 11, horizon 3\n", + "adding: mem time9, current time 11, horizon 2\n", + "adding: mem time10, current time 11, horizon 1\n", + "adding: mem time0, current time 12, horizon 12\n", + "adding: mem time1, current time 12, horizon 11\n", + "adding: mem time2, current time 12, horizon 10\n", + "adding: mem time3, current time 12, horizon 9\n", + "adding: mem time4, current time 12, horizon 8\n", + "adding: mem time5, current time 12, horizon 7\n", + "adding: mem time6, current time 12, horizon 6\n", + "adding: mem time7, current time 12, horizon 5\n", + "adding: mem time8, current time 12, horizon 4\n", + "adding: mem time9, current time 12, horizon 3\n", + "adding: mem time10, current time 12, horizon 2\n", + "adding: mem time11, current time 12, horizon 1\n", + "adding: mem time0, current time 13, horizon 13\n", + "adding: mem time1, current time 13, horizon 12\n", + "adding: mem time2, current time 13, horizon 11\n", + "adding: mem time3, current time 13, horizon 10\n", + "adding: mem time4, current time 13, horizon 9\n", + "adding: mem time5, current time 13, horizon 8\n", + "adding: mem time6, current time 13, horizon 7\n", + "adding: mem time7, current time 13, horizon 6\n", + "adding: mem time8, current time 13, horizon 5\n", + "adding: mem time9, current time 13, horizon 4\n", + "adding: mem time10, current time 13, horizon 3\n", + "adding: mem time11, current time 13, horizon 2\n", + "adding: mem time12, current time 13, horizon 1\n", + "adding: mem time0, current time 14, horizon 14\n", + "adding: mem time1, current time 14, horizon 13\n", + "adding: mem time2, current time 14, horizon 12\n", + "adding: mem time3, current time 14, horizon 11\n", + "adding: mem time4, current time 14, horizon 10\n", + "adding: mem time5, current time 14, horizon 9\n", + "adding: mem time6, current time 14, horizon 8\n", + "adding: mem time7, current time 14, horizon 7\n", + "adding: mem time8, current time 14, horizon 6\n", + "adding: mem time9, current time 14, horizon 5\n", + "adding: mem time10, current time 14, horizon 4\n", + "adding: mem time11, current time 14, horizon 3\n", + "adding: mem time12, current time 14, horizon 2\n", + "adding: mem time13, current time 14, horizon 1\n", + "adding: mem time0, current time 15, horizon 15\n", + "adding: mem time1, current time 15, horizon 14\n", + "adding: mem time2, current time 15, horizon 13\n", + "adding: mem time3, current time 15, horizon 12\n", + "adding: mem time4, current time 15, horizon 11\n", + "adding: mem time5, current time 15, horizon 10\n", + "adding: mem time6, current time 15, horizon 9\n", + "adding: mem time7, current time 15, horizon 8\n", + "adding: mem time8, current time 15, horizon 7\n", + "adding: mem time9, current time 15, horizon 6\n", + "adding: mem time10, current time 15, horizon 5\n", + "adding: mem time11, current time 15, horizon 4\n", + "adding: mem time12, current time 15, horizon 3\n", + "adding: mem time13, current time 15, horizon 2\n", + "adding: mem time14, current time 15, horizon 1\n", + "adding: mem time0, current time 16, horizon 16\n", + "adding: mem time1, current time 16, horizon 15\n", + "adding: mem time2, current time 16, horizon 14\n", + "adding: mem time3, current time 16, horizon 13\n", + "adding: mem time4, current time 16, horizon 12\n", + "adding: mem time5, current time 16, horizon 11\n", + "adding: mem time6, current time 16, horizon 10\n", + "adding: mem time7, current time 16, horizon 9\n", + "adding: mem time8, current time 16, horizon 8\n", + "adding: mem time9, current time 16, horizon 7\n", + "adding: mem time10, current time 16, horizon 6\n", + "adding: mem time11, current time 16, horizon 5\n", + "adding: mem time12, current time 16, horizon 4\n", + "adding: mem time13, current time 16, horizon 3\n", + "adding: mem time14, current time 16, horizon 2\n", + "adding: mem time15, current time 16, horizon 1\n", + "adding: mem time0, current time 17, horizon 17\n", + "adding: mem time1, current time 17, horizon 16\n", + "adding: mem time2, current time 17, horizon 15\n", + "adding: mem time3, current time 17, horizon 14\n", + "adding: mem time4, current time 17, horizon 13\n", + "adding: mem time5, current time 17, horizon 12\n", + "adding: mem time6, current time 17, horizon 11\n", + "adding: mem time7, current time 17, horizon 10\n", + "adding: mem time8, current time 17, horizon 9\n", + "adding: mem time9, current time 17, horizon 8\n", + "adding: mem time10, current time 17, horizon 7\n", + "adding: mem time11, current time 17, horizon 6\n", + "adding: mem time12, current time 17, horizon 5\n", + "adding: mem time13, current time 17, horizon 4\n", + "adding: mem time14, current time 17, horizon 3\n", + "adding: mem time15, current time 17, horizon 2\n", + "adding: mem time16, current time 17, horizon 1\n", + "adding: mem time0, current time 18, horizon 18\n", + "adding: mem time1, current time 18, horizon 17\n", + "adding: mem time2, current time 18, horizon 16\n", + "adding: mem time3, current time 18, horizon 15\n", + "adding: mem time4, current time 18, horizon 14\n", + "adding: mem time5, current time 18, horizon 13\n", + "adding: mem time6, current time 18, horizon 12\n", + "adding: mem time7, current time 18, horizon 11\n", + "adding: mem time8, current time 18, horizon 10\n", + "adding: mem time9, current time 18, horizon 9\n", + "adding: mem time10, current time 18, horizon 8\n", + "adding: mem time11, current time 18, horizon 7\n", + "adding: mem time12, current time 18, horizon 6\n", + "adding: mem time13, current time 18, horizon 5\n", + "adding: mem time14, current time 18, horizon 4\n", + "adding: mem time15, current time 18, horizon 3\n", + "adding: mem time16, current time 18, horizon 2\n", + "adding: mem time17, current time 18, horizon 1\n", + "adding: mem time0, current time 19, horizon 19\n", + "adding: mem time1, current time 19, horizon 18\n", + "adding: mem time2, current time 19, horizon 17\n", + "adding: mem time3, current time 19, horizon 16\n", + "adding: mem time4, current time 19, horizon 15\n", + "adding: mem time5, current time 19, horizon 14\n", + "adding: mem time6, current time 19, horizon 13\n", + "adding: mem time7, current time 19, horizon 12\n", + "adding: mem time8, current time 19, horizon 11\n", + "adding: mem time9, current time 19, horizon 10\n", + "adding: mem time10, current time 19, horizon 9\n", + "adding: mem time11, current time 19, horizon 8\n", + "adding: mem time12, current time 19, horizon 7\n", + "adding: mem time13, current time 19, horizon 6\n", + "adding: mem time14, current time 19, horizon 5\n", + "adding: mem time15, current time 19, horizon 4\n", + "adding: mem time16, current time 19, horizon 3\n", + "adding: mem time17, current time 19, horizon 2\n", + "adding: mem time18, current time 19, horizon 1\n", + "adding: mem time0, current time 20, horizon 20\n", + "adding: mem time1, current time 20, horizon 19\n", + "adding: mem time2, current time 20, horizon 18\n", + "adding: mem time3, current time 20, horizon 17\n", + "adding: mem time4, current time 20, horizon 16\n", + "adding: mem time5, current time 20, horizon 15\n", + "adding: mem time6, current time 20, horizon 14\n", + "adding: mem time7, current time 20, horizon 13\n", + "adding: mem time8, current time 20, horizon 12\n", + "adding: mem time9, current time 20, horizon 11\n", + "adding: mem time10, current time 20, horizon 10\n", + "adding: mem time11, current time 20, horizon 9\n", + "adding: mem time12, current time 20, horizon 8\n", + "adding: mem time13, current time 20, horizon 7\n", + "adding: mem time14, current time 20, horizon 6\n", + "adding: mem time15, current time 20, horizon 5\n", + "adding: mem time16, current time 20, horizon 4\n", + "adding: mem time17, current time 20, horizon 3\n", + "adding: mem time18, current time 20, horizon 2\n", + "adding: mem time19, current time 20, horizon 1\n", + "adding: mem time0, current time 21, horizon 21\n", + "adding: mem time1, current time 21, horizon 20\n", + "adding: mem time2, current time 21, horizon 19\n", + "adding: mem time3, current time 21, horizon 18\n", + "adding: mem time4, current time 21, horizon 17\n", + "adding: mem time5, current time 21, horizon 16\n", + "adding: mem time6, current time 21, horizon 15\n", + "adding: mem time7, current time 21, horizon 14\n", + "adding: mem time8, current time 21, horizon 13\n", + "adding: mem time9, current time 21, horizon 12\n", + "adding: mem time10, current time 21, horizon 11\n", + "adding: mem time11, current time 21, horizon 10\n", + "adding: mem time12, current time 21, horizon 9\n", + "adding: mem time13, current time 21, horizon 8\n", + "adding: mem time14, current time 21, horizon 7\n", + "adding: mem time15, current time 21, horizon 6\n", + "adding: mem time16, current time 21, horizon 5\n", + "adding: mem time17, current time 21, horizon 4\n", + "adding: mem time18, current time 21, horizon 3\n", + "adding: mem time19, current time 21, horizon 2\n", + "adding: mem time20, current time 21, horizon 1\n", + "adding: mem time0, current time 22, horizon 22\n", + "adding: mem time1, current time 22, horizon 21\n", + "adding: mem time2, current time 22, horizon 20\n", + "adding: mem time3, current time 22, horizon 19\n", + "adding: mem time4, current time 22, horizon 18\n", + "adding: mem time5, current time 22, horizon 17\n", + "adding: mem time6, current time 22, horizon 16\n", + "adding: mem time7, current time 22, horizon 15\n", + "adding: mem time8, current time 22, horizon 14\n", + "adding: mem time9, current time 22, horizon 13\n", + "adding: mem time10, current time 22, horizon 12\n", + "adding: mem time11, current time 22, horizon 11\n", + "adding: mem time12, current time 22, horizon 10\n", + "adding: mem time13, current time 22, horizon 9\n", + "adding: mem time14, current time 22, horizon 8\n", + "adding: mem time15, current time 22, horizon 7\n", + "adding: mem time16, current time 22, horizon 6\n", + "adding: mem time17, current time 22, horizon 5\n", + "adding: mem time18, current time 22, horizon 4\n", + "adding: mem time19, current time 22, horizon 3\n", + "adding: mem time20, current time 22, horizon 2\n", + "adding: mem time21, current time 22, horizon 1\n", + "adding: mem time0, current time 23, horizon 23\n", + "adding: mem time1, current time 23, horizon 22\n", + "adding: mem time2, current time 23, horizon 21\n", + "adding: mem time3, current time 23, horizon 20\n", + "adding: mem time4, current time 23, horizon 19\n", + "adding: mem time5, current time 23, horizon 18\n", + "adding: mem time6, current time 23, horizon 17\n", + "adding: mem time7, current time 23, horizon 16\n", + "adding: mem time8, current time 23, horizon 15\n", + "adding: mem time9, current time 23, horizon 14\n", + "adding: mem time10, current time 23, horizon 13\n", + "adding: mem time11, current time 23, horizon 12\n", + "adding: mem time12, current time 23, horizon 11\n", + "adding: mem time13, current time 23, horizon 10\n", + "adding: mem time14, current time 23, horizon 9\n", + "adding: mem time15, current time 23, horizon 8\n", + "adding: mem time16, current time 23, horizon 7\n", + "adding: mem time17, current time 23, horizon 6\n", + "adding: mem time18, current time 23, horizon 5\n", + "adding: mem time19, current time 23, horizon 4\n", + "adding: mem time20, current time 23, horizon 3\n", + "adding: mem time21, current time 23, horizon 2\n", + "adding: mem time22, current time 23, horizon 1\n", + "adding: mem time0, current time 24, horizon 24\n", + "adding: mem time1, current time 24, horizon 23\n", + "adding: mem time2, current time 24, horizon 22\n", + "adding: mem time3, current time 24, horizon 21\n", + "adding: mem time4, current time 24, horizon 20\n", + "adding: mem time5, current time 24, horizon 19\n", + "adding: mem time6, current time 24, horizon 18\n", + "adding: mem time7, current time 24, horizon 17\n", + "adding: mem time8, current time 24, horizon 16\n", + "adding: mem time9, current time 24, horizon 15\n", + "adding: mem time10, current time 24, horizon 14\n", + "adding: mem time11, current time 24, horizon 13\n", + "adding: mem time12, current time 24, horizon 12\n", + "adding: mem time13, current time 24, horizon 11\n", + "adding: mem time14, current time 24, horizon 10\n", + "adding: mem time15, current time 24, horizon 9\n", + "adding: mem time16, current time 24, horizon 8\n", + "adding: mem time17, current time 24, horizon 7\n", + "adding: mem time18, current time 24, horizon 6\n", + "adding: mem time19, current time 24, horizon 5\n", + "adding: mem time20, current time 24, horizon 4\n", + "adding: mem time21, current time 24, horizon 3\n", + "adding: mem time22, current time 24, horizon 2\n", + "adding: mem time23, current time 24, horizon 1\n", + "adding: mem time0, current time 25, horizon 25\n", + "adding: mem time1, current time 25, horizon 24\n", + "adding: mem time2, current time 25, horizon 23\n", + "adding: mem time3, current time 25, horizon 22\n", + "adding: mem time4, current time 25, horizon 21\n", + "adding: mem time5, current time 25, horizon 20\n", + "adding: mem time6, current time 25, horizon 19\n", + "adding: mem time7, current time 25, horizon 18\n", + "adding: mem time8, current time 25, horizon 17\n", + "adding: mem time9, current time 25, horizon 16\n", + "adding: mem time10, current time 25, horizon 15\n", + "adding: mem time11, current time 25, horizon 14\n", + "adding: mem time12, current time 25, horizon 13\n", + "adding: mem time13, current time 25, horizon 12\n", + "adding: mem time14, current time 25, horizon 11\n", + "adding: mem time15, current time 25, horizon 10\n", + "adding: mem time16, current time 25, horizon 9\n", + "adding: mem time17, current time 25, horizon 8\n", + "adding: mem time18, current time 25, horizon 7\n", + "adding: mem time19, current time 25, horizon 6\n", + "adding: mem time20, current time 25, horizon 5\n", + "adding: mem time21, current time 25, horizon 4\n", + "adding: mem time22, current time 25, horizon 3\n", + "adding: mem time23, current time 25, horizon 2\n", + "adding: mem time24, current time 25, horizon 1\n", + "adding: mem time0, current time 26, horizon 26\n", + "adding: mem time1, current time 26, horizon 25\n", + "adding: mem time2, current time 26, horizon 24\n", + "adding: mem time3, current time 26, horizon 23\n", + "adding: mem time4, current time 26, horizon 22\n", + "adding: mem time5, current time 26, horizon 21\n", + "adding: mem time6, current time 26, horizon 20\n", + "adding: mem time7, current time 26, horizon 19\n", + "adding: mem time8, current time 26, horizon 18\n", + "adding: mem time9, current time 26, horizon 17\n", + "adding: mem time10, current time 26, horizon 16\n", + "adding: mem time11, current time 26, horizon 15\n", + "adding: mem time12, current time 26, horizon 14\n", + "adding: mem time13, current time 26, horizon 13\n", + "adding: mem time14, current time 26, horizon 12\n", + "adding: mem time15, current time 26, horizon 11\n", + "adding: mem time16, current time 26, horizon 10\n", + "adding: mem time17, current time 26, horizon 9\n", + "adding: mem time18, current time 26, horizon 8\n", + "adding: mem time19, current time 26, horizon 7\n", + "adding: mem time20, current time 26, horizon 6\n", + "adding: mem time21, current time 26, horizon 5\n", + "adding: mem time22, current time 26, horizon 4\n", + "adding: mem time23, current time 26, horizon 3\n", + "adding: mem time24, current time 26, horizon 2\n", + "adding: mem time25, current time 26, horizon 1\n", + "adding: mem time0, current time 27, horizon 27\n", + "adding: mem time1, current time 27, horizon 26\n", + "adding: mem time2, current time 27, horizon 25\n", + "adding: mem time3, current time 27, horizon 24\n", + "adding: mem time4, current time 27, horizon 23\n", + "adding: mem time5, current time 27, horizon 22\n", + "adding: mem time6, current time 27, horizon 21\n", + "adding: mem time7, current time 27, horizon 20\n", + "adding: mem time8, current time 27, horizon 19\n", + "adding: mem time9, current time 27, horizon 18\n", + "adding: mem time10, current time 27, horizon 17\n", + "adding: mem time11, current time 27, horizon 16\n", + "adding: mem time12, current time 27, horizon 15\n", + "adding: mem time13, current time 27, horizon 14\n", + "adding: mem time14, current time 27, horizon 13\n", + "adding: mem time15, current time 27, horizon 12\n", + "adding: mem time16, current time 27, horizon 11\n", + "adding: mem time17, current time 27, horizon 10\n", + "adding: mem time18, current time 27, horizon 9\n", + "adding: mem time19, current time 27, horizon 8\n", + "adding: mem time20, current time 27, horizon 7\n", + "adding: mem time21, current time 27, horizon 6\n", + "adding: mem time22, current time 27, horizon 5\n", + "adding: mem time23, current time 27, horizon 4\n", + "adding: mem time24, current time 27, horizon 3\n", + "adding: mem time25, current time 27, horizon 2\n", + "adding: mem time26, current time 27, horizon 1\n", + "adding: mem time0, current time 28, horizon 28\n", + "adding: mem time1, current time 28, horizon 27\n", + "adding: mem time2, current time 28, horizon 26\n", + "adding: mem time3, current time 28, horizon 25\n", + "adding: mem time4, current time 28, horizon 24\n", + "adding: mem time5, current time 28, horizon 23\n", + "adding: mem time6, current time 28, horizon 22\n", + "adding: mem time7, current time 28, horizon 21\n", + "adding: mem time8, current time 28, horizon 20\n", + "adding: mem time9, current time 28, horizon 19\n", + "adding: mem time10, current time 28, horizon 18\n", + "adding: mem time11, current time 28, horizon 17\n", + "adding: mem time12, current time 28, horizon 16\n", + "adding: mem time13, current time 28, horizon 15\n", + "adding: mem time14, current time 28, horizon 14\n", + "adding: mem time15, current time 28, horizon 13\n", + "adding: mem time16, current time 28, horizon 12\n", + "adding: mem time17, current time 28, horizon 11\n", + "adding: mem time18, current time 28, horizon 10\n", + "adding: mem time19, current time 28, horizon 9\n", + "adding: mem time20, current time 28, horizon 8\n", + "adding: mem time21, current time 28, horizon 7\n", + "adding: mem time22, current time 28, horizon 6\n", + "adding: mem time23, current time 28, horizon 5\n", + "adding: mem time24, current time 28, horizon 4\n", + "adding: mem time25, current time 28, horizon 3\n", + "adding: mem time26, current time 28, horizon 2\n", + "adding: mem time27, current time 28, horizon 1\n", + "adding: mem time0, current time 29, horizon 29\n", + "adding: mem time1, current time 29, horizon 28\n", + "adding: mem time2, current time 29, horizon 27\n", + "adding: mem time3, current time 29, horizon 26\n", + "adding: mem time4, current time 29, horizon 25\n", + "adding: mem time5, current time 29, horizon 24\n", + "adding: mem time6, current time 29, horizon 23\n", + "adding: mem time7, current time 29, horizon 22\n", + "adding: mem time8, current time 29, horizon 21\n", + "adding: mem time9, current time 29, horizon 20\n", + "adding: mem time10, current time 29, horizon 19\n", + "adding: mem time11, current time 29, horizon 18\n", + "adding: mem time12, current time 29, horizon 17\n", + "adding: mem time13, current time 29, horizon 16\n", + "adding: mem time14, current time 29, horizon 15\n", + "adding: mem time15, current time 29, horizon 14\n", + "adding: mem time16, current time 29, horizon 13\n", + "adding: mem time17, current time 29, horizon 12\n", + "adding: mem time18, current time 29, horizon 11\n", + "adding: mem time19, current time 29, horizon 10\n", + "adding: mem time20, current time 29, horizon 9\n", + "adding: mem time21, current time 29, horizon 8\n", + "adding: mem time22, current time 29, horizon 7\n", + "adding: mem time23, current time 29, horizon 6\n", + "adding: mem time24, current time 29, horizon 5\n", + "adding: mem time25, current time 29, horizon 4\n", + "adding: mem time26, current time 29, horizon 3\n", + "adding: mem time27, current time 29, horizon 2\n", + "adding: mem time28, current time 29, horizon 1\n", + "adding: mem time0, current time 30, horizon 30\n", + "adding: mem time1, current time 30, horizon 29\n", + "adding: mem time2, current time 30, horizon 28\n", + "adding: mem time3, current time 30, horizon 27\n", + "adding: mem time4, current time 30, horizon 26\n", + "adding: mem time5, current time 30, horizon 25\n", + "adding: mem time6, current time 30, horizon 24\n", + "adding: mem time7, current time 30, horizon 23\n", + "adding: mem time8, current time 30, horizon 22\n", + "adding: mem time9, current time 30, horizon 21\n", + "adding: mem time10, current time 30, horizon 20\n", + "adding: mem time11, current time 30, horizon 19\n", + "adding: mem time12, current time 30, horizon 18\n", + "adding: mem time13, current time 30, horizon 17\n", + "adding: mem time14, current time 30, horizon 16\n", + "adding: mem time15, current time 30, horizon 15\n", + "adding: mem time16, current time 30, horizon 14\n", + "adding: mem time17, current time 30, horizon 13\n", + "adding: mem time18, current time 30, horizon 12\n", + "adding: mem time19, current time 30, horizon 11\n", + "adding: mem time20, current time 30, horizon 10\n", + "adding: mem time21, current time 30, horizon 9\n", + "adding: mem time22, current time 30, horizon 8\n", + "adding: mem time23, current time 30, horizon 7\n", + "adding: mem time24, current time 30, horizon 6\n", + "adding: mem time25, current time 30, horizon 5\n", + "adding: mem time26, current time 30, horizon 4\n", + "adding: mem time27, current time 30, horizon 3\n", + "adding: mem time28, current time 30, horizon 2\n", + "adding: mem time29, current time 30, horizon 1\n", + "adding: mem time0, current time 31, horizon 31\n", + "adding: mem time1, current time 31, horizon 30\n", + "adding: mem time2, current time 31, horizon 29\n", + "adding: mem time3, current time 31, horizon 28\n", + "adding: mem time4, current time 31, horizon 27\n", + "adding: mem time5, current time 31, horizon 26\n", + "adding: mem time6, current time 31, horizon 25\n", + "adding: mem time7, current time 31, horizon 24\n", + "adding: mem time8, current time 31, horizon 23\n", + "adding: mem time9, current time 31, horizon 22\n", + "adding: mem time10, current time 31, horizon 21\n", + "adding: mem time11, current time 31, horizon 20\n", + "adding: mem time12, current time 31, horizon 19\n", + "adding: mem time13, current time 31, horizon 18\n", + "adding: mem time14, current time 31, horizon 17\n", + "adding: mem time15, current time 31, horizon 16\n", + "adding: mem time16, current time 31, horizon 15\n", + "adding: mem time17, current time 31, horizon 14\n", + "adding: mem time18, current time 31, horizon 13\n", + "adding: mem time19, current time 31, horizon 12\n", + "adding: mem time20, current time 31, horizon 11\n", + "adding: mem time21, current time 31, horizon 10\n", + "adding: mem time22, current time 31, horizon 9\n", + "adding: mem time23, current time 31, horizon 8\n", + "adding: mem time24, current time 31, horizon 7\n", + "adding: mem time25, current time 31, horizon 6\n", + "adding: mem time26, current time 31, horizon 5\n", + "adding: mem time27, current time 31, horizon 4\n", + "adding: mem time28, current time 31, horizon 3\n", + "adding: mem time29, current time 31, horizon 2\n", + "adding: mem time30, current time 31, horizon 1\n", + "adding: mem time0, current time 32, horizon 32\n", + "adding: mem time1, current time 32, horizon 31\n", + "adding: mem time2, current time 32, horizon 30\n", + "adding: mem time3, current time 32, horizon 29\n", + "adding: mem time4, current time 32, horizon 28\n", + "adding: mem time5, current time 32, horizon 27\n", + "adding: mem time6, current time 32, horizon 26\n", + "adding: mem time7, current time 32, horizon 25\n", + "adding: mem time8, current time 32, horizon 24\n", + "adding: mem time9, current time 32, horizon 23\n", + "adding: mem time10, current time 32, horizon 22\n", + "adding: mem time11, current time 32, horizon 21\n", + "adding: mem time12, current time 32, horizon 20\n", + "adding: mem time13, current time 32, horizon 19\n", + "adding: mem time14, current time 32, horizon 18\n", + "adding: mem time15, current time 32, horizon 17\n", + "adding: mem time16, current time 32, horizon 16\n", + "adding: mem time17, current time 32, horizon 15\n", + "adding: mem time18, current time 32, horizon 14\n", + "adding: mem time19, current time 32, horizon 13\n", + "adding: mem time20, current time 32, horizon 12\n", + "adding: mem time21, current time 32, horizon 11\n", + "adding: mem time22, current time 32, horizon 10\n", + "adding: mem time23, current time 32, horizon 9\n", + "adding: mem time24, current time 32, horizon 8\n", + "adding: mem time25, current time 32, horizon 7\n", + "adding: mem time26, current time 32, horizon 6\n", + "adding: mem time27, current time 32, horizon 5\n", + "adding: mem time28, current time 32, horizon 4\n", + "adding: mem time29, current time 32, horizon 3\n", + "adding: mem time30, current time 32, horizon 2\n", + "adding: mem time31, current time 32, horizon 1\n", + "adding: mem time0, current time 33, horizon 33\n", + "adding: mem time1, current time 33, horizon 32\n", + "adding: mem time2, current time 33, horizon 31\n", + "adding: mem time3, current time 33, horizon 30\n", + "adding: mem time4, current time 33, horizon 29\n", + "adding: mem time5, current time 33, horizon 28\n", + "adding: mem time6, current time 33, horizon 27\n", + "adding: mem time7, current time 33, horizon 26\n", + "adding: mem time8, current time 33, horizon 25\n", + "adding: mem time9, current time 33, horizon 24\n", + "adding: mem time10, current time 33, horizon 23\n", + "adding: mem time11, current time 33, horizon 22\n", + "adding: mem time12, current time 33, horizon 21\n", + "adding: mem time13, current time 33, horizon 20\n", + "adding: mem time14, current time 33, horizon 19\n", + "adding: mem time15, current time 33, horizon 18\n", + "adding: mem time16, current time 33, horizon 17\n", + "adding: mem time17, current time 33, horizon 16\n", + "adding: mem time18, current time 33, horizon 15\n", + "adding: mem time19, current time 33, horizon 14\n", + "adding: mem time20, current time 33, horizon 13\n", + "adding: mem time21, current time 33, horizon 12\n", + "adding: mem time22, current time 33, horizon 11\n", + "adding: mem time23, current time 33, horizon 10\n", + "adding: mem time24, current time 33, horizon 9\n", + "adding: mem time25, current time 33, horizon 8\n", + "adding: mem time26, current time 33, horizon 7\n", + "adding: mem time27, current time 33, horizon 6\n", + "adding: mem time28, current time 33, horizon 5\n", + "adding: mem time29, current time 33, horizon 4\n", + "adding: mem time30, current time 33, horizon 3\n", + "adding: mem time31, current time 33, horizon 2\n", + "adding: mem time32, current time 33, horizon 1\n", + "adding: mem time0, current time 34, horizon 34\n", + "adding: mem time1, current time 34, horizon 33\n", + "adding: mem time2, current time 34, horizon 32\n", + "adding: mem time3, current time 34, horizon 31\n", + "adding: mem time4, current time 34, horizon 30\n", + "adding: mem time5, current time 34, horizon 29\n", + "adding: mem time6, current time 34, horizon 28\n", + "adding: mem time7, current time 34, horizon 27\n", + "adding: mem time8, current time 34, horizon 26\n", + "adding: mem time9, current time 34, horizon 25\n", + "adding: mem time10, current time 34, horizon 24\n", + "adding: mem time11, current time 34, horizon 23\n", + "adding: mem time12, current time 34, horizon 22\n", + "adding: mem time13, current time 34, horizon 21\n", + "adding: mem time14, current time 34, horizon 20\n", + "adding: mem time15, current time 34, horizon 19\n", + "adding: mem time16, current time 34, horizon 18\n", + "adding: mem time17, current time 34, horizon 17\n", + "adding: mem time18, current time 34, horizon 16\n", + "adding: mem time19, current time 34, horizon 15\n", + "adding: mem time20, current time 34, horizon 14\n", + "adding: mem time21, current time 34, horizon 13\n", + "adding: mem time22, current time 34, horizon 12\n", + "adding: mem time23, current time 34, horizon 11\n", + "adding: mem time24, current time 34, horizon 10\n", + "adding: mem time25, current time 34, horizon 9\n", + "adding: mem time26, current time 34, horizon 8\n", + "adding: mem time27, current time 34, horizon 7\n", + "adding: mem time28, current time 34, horizon 6\n", + "adding: mem time29, current time 34, horizon 5\n", + "adding: mem time30, current time 34, horizon 4\n", + "adding: mem time31, current time 34, horizon 3\n", + "adding: mem time32, current time 34, horizon 2\n", + "adding: mem time33, current time 34, horizon 1\n", + "adding: mem time0, current time 35, horizon 35\n", + "adding: mem time1, current time 35, horizon 34\n", + "adding: mem time2, current time 35, horizon 33\n", + "adding: mem time3, current time 35, horizon 32\n", + "adding: mem time4, current time 35, horizon 31\n", + "adding: mem time5, current time 35, horizon 30\n", + "adding: mem time6, current time 35, horizon 29\n", + "adding: mem time7, current time 35, horizon 28\n", + "adding: mem time8, current time 35, horizon 27\n", + "adding: mem time9, current time 35, horizon 26\n", + "adding: mem time10, current time 35, horizon 25\n", + "adding: mem time11, current time 35, horizon 24\n", + "adding: mem time12, current time 35, horizon 23\n", + "adding: mem time13, current time 35, horizon 22\n", + "adding: mem time14, current time 35, horizon 21\n", + "adding: mem time15, current time 35, horizon 20\n", + "adding: mem time16, current time 35, horizon 19\n", + "adding: mem time17, current time 35, horizon 18\n", + "adding: mem time18, current time 35, horizon 17\n", + "adding: mem time19, current time 35, horizon 16\n", + "adding: mem time20, current time 35, horizon 15\n", + "adding: mem time21, current time 35, horizon 14\n", + "adding: mem time22, current time 35, horizon 13\n", + "adding: mem time23, current time 35, horizon 12\n", + "adding: mem time24, current time 35, horizon 11\n", + "adding: mem time25, current time 35, horizon 10\n", + "adding: mem time26, current time 35, horizon 9\n", + "adding: mem time27, current time 35, horizon 8\n", + "adding: mem time28, current time 35, horizon 7\n", + "adding: mem time29, current time 35, horizon 6\n", + "adding: mem time30, current time 35, horizon 5\n", + "adding: mem time31, current time 35, horizon 4\n", + "adding: mem time32, current time 35, horizon 3\n", + "adding: mem time33, current time 35, horizon 2\n", + "adding: mem time34, current time 35, horizon 1\n", + "adding: mem time0, current time 36, horizon 36\n", + "adding: mem time1, current time 36, horizon 35\n", + "adding: mem time2, current time 36, horizon 34\n", + "adding: mem time3, current time 36, horizon 33\n", + "adding: mem time4, current time 36, horizon 32\n", + "adding: mem time5, current time 36, horizon 31\n", + "adding: mem time6, current time 36, horizon 30\n", + "adding: mem time7, current time 36, horizon 29\n", + "adding: mem time8, current time 36, horizon 28\n", + "adding: mem time9, current time 36, horizon 27\n", + "adding: mem time10, current time 36, horizon 26\n", + "adding: mem time11, current time 36, horizon 25\n", + "adding: mem time12, current time 36, horizon 24\n", + "adding: mem time13, current time 36, horizon 23\n", + "adding: mem time14, current time 36, horizon 22\n", + "adding: mem time15, current time 36, horizon 21\n", + "adding: mem time16, current time 36, horizon 20\n", + "adding: mem time17, current time 36, horizon 19\n", + "adding: mem time18, current time 36, horizon 18\n", + "adding: mem time19, current time 36, horizon 17\n", + "adding: mem time20, current time 36, horizon 16\n", + "adding: mem time21, current time 36, horizon 15\n", + "adding: mem time22, current time 36, horizon 14\n", + "adding: mem time23, current time 36, horizon 13\n", + "adding: mem time24, current time 36, horizon 12\n", + "adding: mem time25, current time 36, horizon 11\n", + "adding: mem time26, current time 36, horizon 10\n", + "adding: mem time27, current time 36, horizon 9\n", + "adding: mem time28, current time 36, horizon 8\n", + "adding: mem time29, current time 36, horizon 7\n", + "adding: mem time30, current time 36, horizon 6\n", + "adding: mem time31, current time 36, horizon 5\n", + "adding: mem time32, current time 36, horizon 4\n", + "adding: mem time33, current time 36, horizon 3\n", + "adding: mem time34, current time 36, horizon 2\n", + "adding: mem time35, current time 36, horizon 1\n", + "adding: mem time0, current time 37, horizon 37\n", + "adding: mem time1, current time 37, horizon 36\n", + "adding: mem time2, current time 37, horizon 35\n", + "adding: mem time3, current time 37, horizon 34\n", + "adding: mem time4, current time 37, horizon 33\n", + "adding: mem time5, current time 37, horizon 32\n", + "adding: mem time6, current time 37, horizon 31\n", + "adding: mem time7, current time 37, horizon 30\n", + "adding: mem time8, current time 37, horizon 29\n", + "adding: mem time9, current time 37, horizon 28\n", + "adding: mem time10, current time 37, horizon 27\n", + "adding: mem time11, current time 37, horizon 26\n", + "adding: mem time12, current time 37, horizon 25\n", + "adding: mem time13, current time 37, horizon 24\n", + "adding: mem time14, current time 37, horizon 23\n", + "adding: mem time15, current time 37, horizon 22\n", + "adding: mem time16, current time 37, horizon 21\n", + "adding: mem time17, current time 37, horizon 20\n", + "adding: mem time18, current time 37, horizon 19\n", + "adding: mem time19, current time 37, horizon 18\n", + "adding: mem time20, current time 37, horizon 17\n", + "adding: mem time21, current time 37, horizon 16\n", + "adding: mem time22, current time 37, horizon 15\n", + "adding: mem time23, current time 37, horizon 14\n", + "adding: mem time24, current time 37, horizon 13\n", + "adding: mem time25, current time 37, horizon 12\n", + "adding: mem time26, current time 37, horizon 11\n", + "adding: mem time27, current time 37, horizon 10\n", + "adding: mem time28, current time 37, horizon 9\n", + "adding: mem time29, current time 37, horizon 8\n", + "adding: mem time30, current time 37, horizon 7\n", + "adding: mem time31, current time 37, horizon 6\n", + "adding: mem time32, current time 37, horizon 5\n", + "adding: mem time33, current time 37, horizon 4\n", + "adding: mem time34, current time 37, horizon 3\n", + "adding: mem time35, current time 37, horizon 2\n", + "adding: mem time36, current time 37, horizon 1\n", + "adding: mem time0, current time 38, horizon 38\n", + "adding: mem time1, current time 38, horizon 37\n", + "adding: mem time2, current time 38, horizon 36\n", + "adding: mem time3, current time 38, horizon 35\n", + "adding: mem time4, current time 38, horizon 34\n", + "adding: mem time5, current time 38, horizon 33\n", + "adding: mem time6, current time 38, horizon 32\n", + "adding: mem time7, current time 38, horizon 31\n", + "adding: mem time8, current time 38, horizon 30\n", + "adding: mem time9, current time 38, horizon 29\n", + "adding: mem time10, current time 38, horizon 28\n", + "adding: mem time11, current time 38, horizon 27\n", + "adding: mem time12, current time 38, horizon 26\n", + "adding: mem time13, current time 38, horizon 25\n", + "adding: mem time14, current time 38, horizon 24\n", + "adding: mem time15, current time 38, horizon 23\n", + "adding: mem time16, current time 38, horizon 22\n", + "adding: mem time17, current time 38, horizon 21\n", + "adding: mem time18, current time 38, horizon 20\n", + "adding: mem time19, current time 38, horizon 19\n", + "adding: mem time20, current time 38, horizon 18\n", + "adding: mem time21, current time 38, horizon 17\n", + "adding: mem time22, current time 38, horizon 16\n", + "adding: mem time23, current time 38, horizon 15\n", + "adding: mem time24, current time 38, horizon 14\n", + "adding: mem time25, current time 38, horizon 13\n", + "adding: mem time26, current time 38, horizon 12\n", + "adding: mem time27, current time 38, horizon 11\n", + "adding: mem time28, current time 38, horizon 10\n", + "adding: mem time29, current time 38, horizon 9\n", + "adding: mem time30, current time 38, horizon 8\n", + "adding: mem time31, current time 38, horizon 7\n", + "adding: mem time32, current time 38, horizon 6\n", + "adding: mem time33, current time 38, horizon 5\n", + "adding: mem time34, current time 38, horizon 4\n", + "adding: mem time35, current time 38, horizon 3\n", + "adding: mem time36, current time 38, horizon 2\n", + "adding: mem time37, current time 38, horizon 1\n", + "adding: mem time0, current time 39, horizon 39\n", + "adding: mem time1, current time 39, horizon 38\n", + "adding: mem time2, current time 39, horizon 37\n", + "adding: mem time3, current time 39, horizon 36\n", + "adding: mem time4, current time 39, horizon 35\n", + "adding: mem time5, current time 39, horizon 34\n", + "adding: mem time6, current time 39, horizon 33\n", + "adding: mem time7, current time 39, horizon 32\n", + "adding: mem time8, current time 39, horizon 31\n", + "adding: mem time9, current time 39, horizon 30\n", + "adding: mem time10, current time 39, horizon 29\n", + "adding: mem time11, current time 39, horizon 28\n", + "adding: mem time12, current time 39, horizon 27\n", + "adding: mem time13, current time 39, horizon 26\n", + "adding: mem time14, current time 39, horizon 25\n", + "adding: mem time15, current time 39, horizon 24\n", + "adding: mem time16, current time 39, horizon 23\n", + "adding: mem time17, current time 39, horizon 22\n", + "adding: mem time18, current time 39, horizon 21\n", + "adding: mem time19, current time 39, horizon 20\n", + "adding: mem time20, current time 39, horizon 19\n", + "adding: mem time21, current time 39, horizon 18\n", + "adding: mem time22, current time 39, horizon 17\n", + "adding: mem time23, current time 39, horizon 16\n", + "adding: mem time24, current time 39, horizon 15\n", + "adding: mem time25, current time 39, horizon 14\n", + "adding: mem time26, current time 39, horizon 13\n", + "adding: mem time27, current time 39, horizon 12\n", + "adding: mem time28, current time 39, horizon 11\n", + "adding: mem time29, current time 39, horizon 10\n", + "adding: mem time30, current time 39, horizon 9\n", + "adding: mem time31, current time 39, horizon 8\n", + "adding: mem time32, current time 39, horizon 7\n", + "adding: mem time33, current time 39, horizon 6\n", + "adding: mem time34, current time 39, horizon 5\n", + "adding: mem time35, current time 39, horizon 4\n", + "adding: mem time36, current time 39, horizon 3\n", + "adding: mem time37, current time 39, horizon 2\n", + "adding: mem time38, current time 39, horizon 1\n", + "adding: mem time0, current time 40, horizon 40\n", + "adding: mem time1, current time 40, horizon 39\n", + "adding: mem time2, current time 40, horizon 38\n", + "adding: mem time3, current time 40, horizon 37\n", + "adding: mem time4, current time 40, horizon 36\n", + "adding: mem time5, current time 40, horizon 35\n", + "adding: mem time6, current time 40, horizon 34\n", + "adding: mem time7, current time 40, horizon 33\n", + "adding: mem time8, current time 40, horizon 32\n", + "adding: mem time9, current time 40, horizon 31\n", + "adding: mem time10, current time 40, horizon 30\n", + "adding: mem time11, current time 40, horizon 29\n", + "adding: mem time12, current time 40, horizon 28\n", + "adding: mem time13, current time 40, horizon 27\n", + "adding: mem time14, current time 40, horizon 26\n", + "adding: mem time15, current time 40, horizon 25\n", + "adding: mem time16, current time 40, horizon 24\n", + "adding: mem time17, current time 40, horizon 23\n", + "adding: mem time18, current time 40, horizon 22\n", + "adding: mem time19, current time 40, horizon 21\n", + "adding: mem time20, current time 40, horizon 20\n", + "adding: mem time21, current time 40, horizon 19\n", + "adding: mem time22, current time 40, horizon 18\n", + "adding: mem time23, current time 40, horizon 17\n", + "adding: mem time24, current time 40, horizon 16\n", + "adding: mem time25, current time 40, horizon 15\n", + "adding: mem time26, current time 40, horizon 14\n", + "adding: mem time27, current time 40, horizon 13\n", + "adding: mem time28, current time 40, horizon 12\n", + "adding: mem time29, current time 40, horizon 11\n", + "adding: mem time30, current time 40, horizon 10\n", + "adding: mem time31, current time 40, horizon 9\n", + "adding: mem time32, current time 40, horizon 8\n", + "adding: mem time33, current time 40, horizon 7\n", + "adding: mem time34, current time 40, horizon 6\n", + "adding: mem time35, current time 40, horizon 5\n", + "adding: mem time36, current time 40, horizon 4\n", + "adding: mem time37, current time 40, horizon 3\n", + "adding: mem time38, current time 40, horizon 2\n", + "adding: mem time39, current time 40, horizon 1\n", + "adding: mem time0, current time 41, horizon 41\n", + "adding: mem time1, current time 41, horizon 40\n", + "adding: mem time2, current time 41, horizon 39\n", + "adding: mem time3, current time 41, horizon 38\n", + "adding: mem time4, current time 41, horizon 37\n", + "adding: mem time5, current time 41, horizon 36\n", + "adding: mem time6, current time 41, horizon 35\n", + "adding: mem time7, current time 41, horizon 34\n", + "adding: mem time8, current time 41, horizon 33\n", + "adding: mem time9, current time 41, horizon 32\n", + "adding: mem time10, current time 41, horizon 31\n", + "adding: mem time11, current time 41, horizon 30\n", + "adding: mem time12, current time 41, horizon 29\n", + "adding: mem time13, current time 41, horizon 28\n", + "adding: mem time14, current time 41, horizon 27\n", + "adding: mem time15, current time 41, horizon 26\n", + "adding: mem time16, current time 41, horizon 25\n", + "adding: mem time17, current time 41, horizon 24\n", + "adding: mem time18, current time 41, horizon 23\n", + "adding: mem time19, current time 41, horizon 22\n", + "adding: mem time20, current time 41, horizon 21\n", + "adding: mem time21, current time 41, horizon 20\n", + "adding: mem time22, current time 41, horizon 19\n", + "adding: mem time23, current time 41, horizon 18\n", + "adding: mem time24, current time 41, horizon 17\n", + "adding: mem time25, current time 41, horizon 16\n", + "adding: mem time26, current time 41, horizon 15\n", + "adding: mem time27, current time 41, horizon 14\n", + "adding: mem time28, current time 41, horizon 13\n", + "adding: mem time29, current time 41, horizon 12\n", + "adding: mem time30, current time 41, horizon 11\n", + "adding: mem time31, current time 41, horizon 10\n", + "adding: mem time32, current time 41, horizon 9\n", + "adding: mem time33, current time 41, horizon 8\n", + "adding: mem time34, current time 41, horizon 7\n", + "adding: mem time35, current time 41, horizon 6\n", + "adding: mem time36, current time 41, horizon 5\n", + "adding: mem time37, current time 41, horizon 4\n", + "adding: mem time38, current time 41, horizon 3\n", + "adding: mem time39, current time 41, horizon 2\n", + "adding: mem time40, current time 41, horizon 1\n", + "adding: mem time0, current time 42, horizon 42\n", + "adding: mem time1, current time 42, horizon 41\n", + "adding: mem time2, current time 42, horizon 40\n", + "adding: mem time3, current time 42, horizon 39\n", + "adding: mem time4, current time 42, horizon 38\n", + "adding: mem time5, current time 42, horizon 37\n", + "adding: mem time6, current time 42, horizon 36\n", + "adding: mem time7, current time 42, horizon 35\n", + "adding: mem time8, current time 42, horizon 34\n", + "adding: mem time9, current time 42, horizon 33\n", + "adding: mem time10, current time 42, horizon 32\n", + "adding: mem time11, current time 42, horizon 31\n", + "adding: mem time12, current time 42, horizon 30\n", + "adding: mem time13, current time 42, horizon 29\n", + "adding: mem time14, current time 42, horizon 28\n", + "adding: mem time15, current time 42, horizon 27\n", + "adding: mem time16, current time 42, horizon 26\n", + "adding: mem time17, current time 42, horizon 25\n", + "adding: mem time18, current time 42, horizon 24\n", + "adding: mem time19, current time 42, horizon 23\n", + "adding: mem time20, current time 42, horizon 22\n", + "adding: mem time21, current time 42, horizon 21\n", + "adding: mem time22, current time 42, horizon 20\n", + "adding: mem time23, current time 42, horizon 19\n", + "adding: mem time24, current time 42, horizon 18\n", + "adding: mem time25, current time 42, horizon 17\n", + "adding: mem time26, current time 42, horizon 16\n", + "adding: mem time27, current time 42, horizon 15\n", + "adding: mem time28, current time 42, horizon 14\n", + "adding: mem time29, current time 42, horizon 13\n", + "adding: mem time30, current time 42, horizon 12\n", + "adding: mem time31, current time 42, horizon 11\n", + "adding: mem time32, current time 42, horizon 10\n", + "adding: mem time33, current time 42, horizon 9\n", + "adding: mem time34, current time 42, horizon 8\n", + "adding: mem time35, current time 42, horizon 7\n", + "adding: mem time36, current time 42, horizon 6\n", + "adding: mem time37, current time 42, horizon 5\n", + "adding: mem time38, current time 42, horizon 4\n", + "adding: mem time39, current time 42, horizon 3\n", + "adding: mem time40, current time 42, horizon 2\n", + "adding: mem time41, current time 42, horizon 1\n", + "adding: mem time0, current time 43, horizon 43\n", + "adding: mem time1, current time 43, horizon 42\n", + "adding: mem time2, current time 43, horizon 41\n", + "adding: mem time3, current time 43, horizon 40\n", + "adding: mem time4, current time 43, horizon 39\n", + "adding: mem time5, current time 43, horizon 38\n", + "adding: mem time6, current time 43, horizon 37\n", + "adding: mem time7, current time 43, horizon 36\n", + "adding: mem time8, current time 43, horizon 35\n", + "adding: mem time9, current time 43, horizon 34\n", + "adding: mem time10, current time 43, horizon 33\n", + "adding: mem time11, current time 43, horizon 32\n", + "adding: mem time12, current time 43, horizon 31\n", + "adding: mem time13, current time 43, horizon 30\n", + "adding: mem time14, current time 43, horizon 29\n", + "adding: mem time15, current time 43, horizon 28\n", + "adding: mem time16, current time 43, horizon 27\n", + "adding: mem time17, current time 43, horizon 26\n", + "adding: mem time18, current time 43, horizon 25\n", + "adding: mem time19, current time 43, horizon 24\n", + "adding: mem time20, current time 43, horizon 23\n", + "adding: mem time21, current time 43, horizon 22\n", + "adding: mem time22, current time 43, horizon 21\n", + "adding: mem time23, current time 43, horizon 20\n", + "adding: mem time24, current time 43, horizon 19\n", + "adding: mem time25, current time 43, horizon 18\n", + "adding: mem time26, current time 43, horizon 17\n", + "adding: mem time27, current time 43, horizon 16\n", + "adding: mem time28, current time 43, horizon 15\n", + "adding: mem time29, current time 43, horizon 14\n", + "adding: mem time30, current time 43, horizon 13\n", + "adding: mem time31, current time 43, horizon 12\n", + "adding: mem time32, current time 43, horizon 11\n", + "adding: mem time33, current time 43, horizon 10\n", + "adding: mem time34, current time 43, horizon 9\n", + "adding: mem time35, current time 43, horizon 8\n", + "adding: mem time36, current time 43, horizon 7\n", + "adding: mem time37, current time 43, horizon 6\n", + "adding: mem time38, current time 43, horizon 5\n", + "adding: mem time39, current time 43, horizon 4\n", + "adding: mem time40, current time 43, horizon 3\n", + "adding: mem time41, current time 43, horizon 2\n", + "adding: mem time42, current time 43, horizon 1\n", + "adding: mem time0, current time 44, horizon 44\n", + "adding: mem time1, current time 44, horizon 43\n", + "adding: mem time2, current time 44, horizon 42\n", + "adding: mem time3, current time 44, horizon 41\n", + "adding: mem time4, current time 44, horizon 40\n", + "adding: mem time5, current time 44, horizon 39\n", + "adding: mem time6, current time 44, horizon 38\n", + "adding: mem time7, current time 44, horizon 37\n", + "adding: mem time8, current time 44, horizon 36\n", + "adding: mem time9, current time 44, horizon 35\n", + "adding: mem time10, current time 44, horizon 34\n", + "adding: mem time11, current time 44, horizon 33\n", + "adding: mem time12, current time 44, horizon 32\n", + "adding: mem time13, current time 44, horizon 31\n", + "adding: mem time14, current time 44, horizon 30\n", + "adding: mem time15, current time 44, horizon 29\n", + "adding: mem time16, current time 44, horizon 28\n", + "adding: mem time17, current time 44, horizon 27\n", + "adding: mem time18, current time 44, horizon 26\n", + "adding: mem time19, current time 44, horizon 25\n", + "adding: mem time20, current time 44, horizon 24\n", + "adding: mem time21, current time 44, horizon 23\n", + "adding: mem time22, current time 44, horizon 22\n", + "adding: mem time23, current time 44, horizon 21\n", + "adding: mem time24, current time 44, horizon 20\n", + "adding: mem time25, current time 44, horizon 19\n", + "adding: mem time26, current time 44, horizon 18\n", + "adding: mem time27, current time 44, horizon 17\n", + "adding: mem time28, current time 44, horizon 16\n", + "adding: mem time29, current time 44, horizon 15\n", + "adding: mem time30, current time 44, horizon 14\n", + "adding: mem time31, current time 44, horizon 13\n", + "adding: mem time32, current time 44, horizon 12\n", + "adding: mem time33, current time 44, horizon 11\n", + "adding: mem time34, current time 44, horizon 10\n", + "adding: mem time35, current time 44, horizon 9\n", + "adding: mem time36, current time 44, horizon 8\n", + "adding: mem time37, current time 44, horizon 7\n", + "adding: mem time38, current time 44, horizon 6\n", + "adding: mem time39, current time 44, horizon 5\n", + "adding: mem time40, current time 44, horizon 4\n", + "adding: mem time41, current time 44, horizon 3\n", + "adding: mem time42, current time 44, horizon 2\n", + "adding: mem time43, current time 44, horizon 1\n", + "adding: mem time0, current time 45, horizon 45\n", + "adding: mem time1, current time 45, horizon 44\n", + "adding: mem time2, current time 45, horizon 43\n", + "adding: mem time3, current time 45, horizon 42\n", + "adding: mem time4, current time 45, horizon 41\n", + "adding: mem time5, current time 45, horizon 40\n", + "adding: mem time6, current time 45, horizon 39\n", + "adding: mem time7, current time 45, horizon 38\n", + "adding: mem time8, current time 45, horizon 37\n", + "adding: mem time9, current time 45, horizon 36\n", + "adding: mem time10, current time 45, horizon 35\n", + "adding: mem time11, current time 45, horizon 34\n", + "adding: mem time12, current time 45, horizon 33\n", + "adding: mem time13, current time 45, horizon 32\n", + "adding: mem time14, current time 45, horizon 31\n", + "adding: mem time15, current time 45, horizon 30\n", + "adding: mem time16, current time 45, horizon 29\n", + "adding: mem time17, current time 45, horizon 28\n", + "adding: mem time18, current time 45, horizon 27\n", + "adding: mem time19, current time 45, horizon 26\n", + "adding: mem time20, current time 45, horizon 25\n", + "adding: mem time21, current time 45, horizon 24\n", + "adding: mem time22, current time 45, horizon 23\n", + "adding: mem time23, current time 45, horizon 22\n", + "adding: mem time24, current time 45, horizon 21\n", + "adding: mem time25, current time 45, horizon 20\n", + "adding: mem time26, current time 45, horizon 19\n", + "adding: mem time27, current time 45, horizon 18\n", + "adding: mem time28, current time 45, horizon 17\n", + "adding: mem time29, current time 45, horizon 16\n", + "adding: mem time30, current time 45, horizon 15\n", + "adding: mem time31, current time 45, horizon 14\n", + "adding: mem time32, current time 45, horizon 13\n", + "adding: mem time33, current time 45, horizon 12\n", + "adding: mem time34, current time 45, horizon 11\n", + "adding: mem time35, current time 45, horizon 10\n", + "adding: mem time36, current time 45, horizon 9\n", + "adding: mem time37, current time 45, horizon 8\n", + "adding: mem time38, current time 45, horizon 7\n", + "adding: mem time39, current time 45, horizon 6\n", + "adding: mem time40, current time 45, horizon 5\n", + "adding: mem time41, current time 45, horizon 4\n", + "adding: mem time42, current time 45, horizon 3\n", + "adding: mem time43, current time 45, horizon 2\n", + "adding: mem time44, current time 45, horizon 1\n", + "adding: mem time0, current time 46, horizon 46\n", + "adding: mem time1, current time 46, horizon 45\n", + "adding: mem time2, current time 46, horizon 44\n", + "adding: mem time3, current time 46, horizon 43\n", + "adding: mem time4, current time 46, horizon 42\n", + "adding: mem time5, current time 46, horizon 41\n", + "adding: mem time6, current time 46, horizon 40\n", + "adding: mem time7, current time 46, horizon 39\n", + "adding: mem time8, current time 46, horizon 38\n", + "adding: mem time9, current time 46, horizon 37\n", + "adding: mem time10, current time 46, horizon 36\n", + "adding: mem time11, current time 46, horizon 35\n", + "adding: mem time12, current time 46, horizon 34\n", + "adding: mem time13, current time 46, horizon 33\n", + "adding: mem time14, current time 46, horizon 32\n", + "adding: mem time15, current time 46, horizon 31\n", + "adding: mem time16, current time 46, horizon 30\n", + "adding: mem time17, current time 46, horizon 29\n", + "adding: mem time18, current time 46, horizon 28\n", + "adding: mem time19, current time 46, horizon 27\n", + "adding: mem time20, current time 46, horizon 26\n", + "adding: mem time21, current time 46, horizon 25\n", + "adding: mem time22, current time 46, horizon 24\n", + "adding: mem time23, current time 46, horizon 23\n", + "adding: mem time24, current time 46, horizon 22\n", + "adding: mem time25, current time 46, horizon 21\n", + "adding: mem time26, current time 46, horizon 20\n", + "adding: mem time27, current time 46, horizon 19\n", + "adding: mem time28, current time 46, horizon 18\n", + "adding: mem time29, current time 46, horizon 17\n", + "adding: mem time30, current time 46, horizon 16\n", + "adding: mem time31, current time 46, horizon 15\n", + "adding: mem time32, current time 46, horizon 14\n", + "adding: mem time33, current time 46, horizon 13\n", + "adding: mem time34, current time 46, horizon 12\n", + "adding: mem time35, current time 46, horizon 11\n", + "adding: mem time36, current time 46, horizon 10\n", + "adding: mem time37, current time 46, horizon 9\n", + "adding: mem time38, current time 46, horizon 8\n", + "adding: mem time39, current time 46, horizon 7\n", + "adding: mem time40, current time 46, horizon 6\n", + "adding: mem time41, current time 46, horizon 5\n", + "adding: mem time42, current time 46, horizon 4\n", + "adding: mem time43, current time 46, horizon 3\n", + "adding: mem time44, current time 46, horizon 2\n", + "adding: mem time45, current time 46, horizon 1\n", + "adding: mem time0, current time 47, horizon 47\n", + "adding: mem time1, current time 47, horizon 46\n", + "adding: mem time2, current time 47, horizon 45\n", + "adding: mem time3, current time 47, horizon 44\n", + "adding: mem time4, current time 47, horizon 43\n", + "adding: mem time5, current time 47, horizon 42\n", + "adding: mem time6, current time 47, horizon 41\n", + "adding: mem time7, current time 47, horizon 40\n", + "adding: mem time8, current time 47, horizon 39\n", + "adding: mem time9, current time 47, horizon 38\n", + "adding: mem time10, current time 47, horizon 37\n", + "adding: mem time11, current time 47, horizon 36\n", + "adding: mem time12, current time 47, horizon 35\n", + "adding: mem time13, current time 47, horizon 34\n", + "adding: mem time14, current time 47, horizon 33\n", + "adding: mem time15, current time 47, horizon 32\n", + "adding: mem time16, current time 47, horizon 31\n", + "adding: mem time17, current time 47, horizon 30\n", + "adding: mem time18, current time 47, horizon 29\n", + "adding: mem time19, current time 47, horizon 28\n", + "adding: mem time20, current time 47, horizon 27\n", + "adding: mem time21, current time 47, horizon 26\n", + "adding: mem time22, current time 47, horizon 25\n", + "adding: mem time23, current time 47, horizon 24\n", + "adding: mem time24, current time 47, horizon 23\n", + "adding: mem time25, current time 47, horizon 22\n", + "adding: mem time26, current time 47, horizon 21\n", + "adding: mem time27, current time 47, horizon 20\n", + "adding: mem time28, current time 47, horizon 19\n", + "adding: mem time29, current time 47, horizon 18\n", + "adding: mem time30, current time 47, horizon 17\n", + "adding: mem time31, current time 47, horizon 16\n", + "adding: mem time32, current time 47, horizon 15\n", + "adding: mem time33, current time 47, horizon 14\n", + "adding: mem time34, current time 47, horizon 13\n", + "adding: mem time35, current time 47, horizon 12\n", + "adding: mem time36, current time 47, horizon 11\n", + "adding: mem time37, current time 47, horizon 10\n", + "adding: mem time38, current time 47, horizon 9\n", + "adding: mem time39, current time 47, horizon 8\n", + "adding: mem time40, current time 47, horizon 7\n", + "adding: mem time41, current time 47, horizon 6\n", + "adding: mem time42, current time 47, horizon 5\n", + "adding: mem time43, current time 47, horizon 4\n", + "adding: mem time44, current time 47, horizon 3\n", + "adding: mem time45, current time 47, horizon 2\n", + "adding: mem time46, current time 47, horizon 1\n", + "adding: mem time0, current time 48, horizon 48\n", + "adding: mem time1, current time 48, horizon 47\n", + "adding: mem time2, current time 48, horizon 46\n", + "adding: mem time3, current time 48, horizon 45\n", + "adding: mem time4, current time 48, horizon 44\n", + "adding: mem time5, current time 48, horizon 43\n", + "adding: mem time6, current time 48, horizon 42\n", + "adding: mem time7, current time 48, horizon 41\n", + "adding: mem time8, current time 48, horizon 40\n", + "adding: mem time9, current time 48, horizon 39\n", + "adding: mem time10, current time 48, horizon 38\n", + "adding: mem time11, current time 48, horizon 37\n", + "adding: mem time12, current time 48, horizon 36\n", + "adding: mem time13, current time 48, horizon 35\n", + "adding: mem time14, current time 48, horizon 34\n", + "adding: mem time15, current time 48, horizon 33\n", + "adding: mem time16, current time 48, horizon 32\n", + "adding: mem time17, current time 48, horizon 31\n", + "adding: mem time18, current time 48, horizon 30\n", + "adding: mem time19, current time 48, horizon 29\n", + "adding: mem time20, current time 48, horizon 28\n", + "adding: mem time21, current time 48, horizon 27\n", + "adding: mem time22, current time 48, horizon 26\n", + "adding: mem time23, current time 48, horizon 25\n", + "adding: mem time24, current time 48, horizon 24\n", + "adding: mem time25, current time 48, horizon 23\n", + "adding: mem time26, current time 48, horizon 22\n", + "adding: mem time27, current time 48, horizon 21\n", + "adding: mem time28, current time 48, horizon 20\n", + "adding: mem time29, current time 48, horizon 19\n", + "adding: mem time30, current time 48, horizon 18\n", + "adding: mem time31, current time 48, horizon 17\n", + "adding: mem time32, current time 48, horizon 16\n", + "adding: mem time33, current time 48, horizon 15\n", + "adding: mem time34, current time 48, horizon 14\n", + "adding: mem time35, current time 48, horizon 13\n", + "adding: mem time36, current time 48, horizon 12\n", + "adding: mem time37, current time 48, horizon 11\n", + "adding: mem time38, current time 48, horizon 10\n", + "adding: mem time39, current time 48, horizon 9\n", + "adding: mem time40, current time 48, horizon 8\n", + "adding: mem time41, current time 48, horizon 7\n", + "adding: mem time42, current time 48, horizon 6\n", + "adding: mem time43, current time 48, horizon 5\n", + "adding: mem time44, current time 48, horizon 4\n", + "adding: mem time45, current time 48, horizon 3\n", + "adding: mem time46, current time 48, horizon 2\n", + "adding: mem time47, current time 48, horizon 1\n", + "adding: mem time0, current time 49, horizon 49\n", + "adding: mem time1, current time 49, horizon 48\n", + "adding: mem time2, current time 49, horizon 47\n", + "adding: mem time3, current time 49, horizon 46\n", + "adding: mem time4, current time 49, horizon 45\n", + "adding: mem time5, current time 49, horizon 44\n", + "adding: mem time6, current time 49, horizon 43\n", + "adding: mem time7, current time 49, horizon 42\n", + "adding: mem time8, current time 49, horizon 41\n", + "adding: mem time9, current time 49, horizon 40\n", + "adding: mem time10, current time 49, horizon 39\n", + "adding: mem time11, current time 49, horizon 38\n", + "adding: mem time12, current time 49, horizon 37\n", + "adding: mem time13, current time 49, horizon 36\n", + "adding: mem time14, current time 49, horizon 35\n", + "adding: mem time15, current time 49, horizon 34\n", + "adding: mem time16, current time 49, horizon 33\n", + "adding: mem time17, current time 49, horizon 32\n", + "adding: mem time18, current time 49, horizon 31\n", + "adding: mem time19, current time 49, horizon 30\n", + "adding: mem time20, current time 49, horizon 29\n", + "adding: mem time21, current time 49, horizon 28\n", + "adding: mem time22, current time 49, horizon 27\n", + "adding: mem time23, current time 49, horizon 26\n", + "adding: mem time24, current time 49, horizon 25\n", + "adding: mem time25, current time 49, horizon 24\n", + "adding: mem time26, current time 49, horizon 23\n", + "adding: mem time27, current time 49, horizon 22\n", + "adding: mem time28, current time 49, horizon 21\n", + "adding: mem time29, current time 49, horizon 20\n", + "adding: mem time30, current time 49, horizon 19\n", + "adding: mem time31, current time 49, horizon 18\n", + "adding: mem time32, current time 49, horizon 17\n", + "adding: mem time33, current time 49, horizon 16\n", + "adding: mem time34, current time 49, horizon 15\n", + "adding: mem time35, current time 49, horizon 14\n", + "adding: mem time36, current time 49, horizon 13\n", + "adding: mem time37, current time 49, horizon 12\n", + "adding: mem time38, current time 49, horizon 11\n", + "adding: mem time39, current time 49, horizon 10\n", + "adding: mem time40, current time 49, horizon 9\n", + "adding: mem time41, current time 49, horizon 8\n", + "adding: mem time42, current time 49, horizon 7\n", + "adding: mem time43, current time 49, horizon 6\n", + "adding: mem time44, current time 49, horizon 5\n", + "adding: mem time45, current time 49, horizon 4\n", + "adding: mem time46, current time 49, horizon 3\n", + "adding: mem time47, current time 49, horizon 2\n", + "adding: mem time48, current time 49, horizon 1\n", + "adding: mem time0, current time 50, horizon 50\n", + "adding: mem time1, current time 50, horizon 49\n", + "adding: mem time2, current time 50, horizon 48\n", + "adding: mem time3, current time 50, horizon 47\n", + "adding: mem time4, current time 50, horizon 46\n", + "adding: mem time5, current time 50, horizon 45\n", + "adding: mem time6, current time 50, horizon 44\n", + "adding: mem time7, current time 50, horizon 43\n", + "adding: mem time8, current time 50, horizon 42\n", + "adding: mem time9, current time 50, horizon 41\n", + "adding: mem time10, current time 50, horizon 40\n", + "adding: mem time11, current time 50, horizon 39\n", + "adding: mem time12, current time 50, horizon 38\n", + "adding: mem time13, current time 50, horizon 37\n", + "adding: mem time14, current time 50, horizon 36\n", + "adding: mem time15, current time 50, horizon 35\n", + "adding: mem time16, current time 50, horizon 34\n", + "adding: mem time17, current time 50, horizon 33\n", + "adding: mem time18, current time 50, horizon 32\n", + "adding: mem time19, current time 50, horizon 31\n", + "adding: mem time20, current time 50, horizon 30\n", + "adding: mem time21, current time 50, horizon 29\n", + "adding: mem time22, current time 50, horizon 28\n", + "adding: mem time23, current time 50, horizon 27\n", + "adding: mem time24, current time 50, horizon 26\n", + "adding: mem time25, current time 50, horizon 25\n", + "adding: mem time26, current time 50, horizon 24\n", + "adding: mem time27, current time 50, horizon 23\n", + "adding: mem time28, current time 50, horizon 22\n", + "adding: mem time29, current time 50, horizon 21\n", + "adding: mem time30, current time 50, horizon 20\n", + "adding: mem time31, current time 50, horizon 19\n", + "adding: mem time32, current time 50, horizon 18\n", + "adding: mem time33, current time 50, horizon 17\n", + "adding: mem time34, current time 50, horizon 16\n", + "adding: mem time35, current time 50, horizon 15\n", + "adding: mem time36, current time 50, horizon 14\n", + "adding: mem time37, current time 50, horizon 13\n", + "adding: mem time38, current time 50, horizon 12\n", + "adding: mem time39, current time 50, horizon 11\n", + "adding: mem time40, current time 50, horizon 10\n", + "adding: mem time41, current time 50, horizon 9\n", + "adding: mem time42, current time 50, horizon 8\n", + "adding: mem time43, current time 50, horizon 7\n", + "adding: mem time44, current time 50, horizon 6\n", + "adding: mem time45, current time 50, horizon 5\n", + "adding: mem time46, current time 50, horizon 4\n", + "adding: mem time47, current time 50, horizon 3\n", + "adding: mem time48, current time 50, horizon 2\n", + "adding: mem time49, current time 50, horizon 1\n", + "adding: mem time0, current time 51, horizon 51\n", + "adding: mem time1, current time 51, horizon 50\n", + "adding: mem time2, current time 51, horizon 49\n", + "adding: mem time3, current time 51, horizon 48\n", + "adding: mem time4, current time 51, horizon 47\n", + "adding: mem time5, current time 51, horizon 46\n", + "adding: mem time6, current time 51, horizon 45\n", + "adding: mem time7, current time 51, horizon 44\n", + "adding: mem time8, current time 51, horizon 43\n", + "adding: mem time9, current time 51, horizon 42\n", + "adding: mem time10, current time 51, horizon 41\n", + "adding: mem time11, current time 51, horizon 40\n", + "adding: mem time12, current time 51, horizon 39\n", + "adding: mem time13, current time 51, horizon 38\n", + "adding: mem time14, current time 51, horizon 37\n", + "adding: mem time15, current time 51, horizon 36\n", + "adding: mem time16, current time 51, horizon 35\n", + "adding: mem time17, current time 51, horizon 34\n", + "adding: mem time18, current time 51, horizon 33\n", + "adding: mem time19, current time 51, horizon 32\n", + "adding: mem time20, current time 51, horizon 31\n", + "adding: mem time21, current time 51, horizon 30\n", + "adding: mem time22, current time 51, horizon 29\n", + "adding: mem time23, current time 51, horizon 28\n", + "adding: mem time24, current time 51, horizon 27\n", + "adding: mem time25, current time 51, horizon 26\n", + "adding: mem time26, current time 51, horizon 25\n", + "adding: mem time27, current time 51, horizon 24\n", + "adding: mem time28, current time 51, horizon 23\n", + "adding: mem time29, current time 51, horizon 22\n", + "adding: mem time30, current time 51, horizon 21\n", + "adding: mem time31, current time 51, horizon 20\n", + "adding: mem time32, current time 51, horizon 19\n", + "adding: mem time33, current time 51, horizon 18\n", + "adding: mem time34, current time 51, horizon 17\n", + "adding: mem time35, current time 51, horizon 16\n", + "adding: mem time36, current time 51, horizon 15\n", + "adding: mem time37, current time 51, horizon 14\n", + "adding: mem time38, current time 51, horizon 13\n", + "adding: mem time39, current time 51, horizon 12\n", + "adding: mem time40, current time 51, horizon 11\n", + "adding: mem time41, current time 51, horizon 10\n", + "adding: mem time42, current time 51, horizon 9\n", + "adding: mem time43, current time 51, horizon 8\n", + "adding: mem time44, current time 51, horizon 7\n", + "adding: mem time45, current time 51, horizon 6\n", + "adding: mem time46, current time 51, horizon 5\n", + "adding: mem time47, current time 51, horizon 4\n", + "adding: mem time48, current time 51, horizon 3\n", + "adding: mem time49, current time 51, horizon 2\n", + "adding: mem time50, current time 51, horizon 1\n", + "adding: mem time0, current time 52, horizon 52\n", + "adding: mem time1, current time 52, horizon 51\n", + "adding: mem time2, current time 52, horizon 50\n", + "adding: mem time3, current time 52, horizon 49\n", + "adding: mem time4, current time 52, horizon 48\n", + "adding: mem time5, current time 52, horizon 47\n", + "adding: mem time6, current time 52, horizon 46\n", + "adding: mem time7, current time 52, horizon 45\n", + "adding: mem time8, current time 52, horizon 44\n", + "adding: mem time9, current time 52, horizon 43\n", + "adding: mem time10, current time 52, horizon 42\n", + "adding: mem time11, current time 52, horizon 41\n", + "adding: mem time12, current time 52, horizon 40\n", + "adding: mem time13, current time 52, horizon 39\n", + "adding: mem time14, current time 52, horizon 38\n", + "adding: mem time15, current time 52, horizon 37\n", + "adding: mem time16, current time 52, horizon 36\n", + "adding: mem time17, current time 52, horizon 35\n", + "adding: mem time18, current time 52, horizon 34\n", + "adding: mem time19, current time 52, horizon 33\n", + "adding: mem time20, current time 52, horizon 32\n", + "adding: mem time21, current time 52, horizon 31\n", + "adding: mem time22, current time 52, horizon 30\n", + "adding: mem time23, current time 52, horizon 29\n", + "adding: mem time24, current time 52, horizon 28\n", + "adding: mem time25, current time 52, horizon 27\n", + "adding: mem time26, current time 52, horizon 26\n", + "adding: mem time27, current time 52, horizon 25\n", + "adding: mem time28, current time 52, horizon 24\n", + "adding: mem time29, current time 52, horizon 23\n", + "adding: mem time30, current time 52, horizon 22\n", + "adding: mem time31, current time 52, horizon 21\n", + "adding: mem time32, current time 52, horizon 20\n", + "adding: mem time33, current time 52, horizon 19\n", + "adding: mem time34, current time 52, horizon 18\n", + "adding: mem time35, current time 52, horizon 17\n", + "adding: mem time36, current time 52, horizon 16\n", + "adding: mem time37, current time 52, horizon 15\n", + "adding: mem time38, current time 52, horizon 14\n", + "adding: mem time39, current time 52, horizon 13\n", + "adding: mem time40, current time 52, horizon 12\n", + "adding: mem time41, current time 52, horizon 11\n", + "adding: mem time42, current time 52, horizon 10\n", + "adding: mem time43, current time 52, horizon 9\n", + "adding: mem time44, current time 52, horizon 8\n", + "adding: mem time45, current time 52, horizon 7\n", + "adding: mem time46, current time 52, horizon 6\n", + "adding: mem time47, current time 52, horizon 5\n", + "adding: mem time48, current time 52, horizon 4\n", + "adding: mem time49, current time 52, horizon 3\n", + "adding: mem time50, current time 52, horizon 2\n", + "adding: mem time51, current time 52, horizon 1\n", + "adding: mem time0, current time 53, horizon 53\n", + "adding: mem time1, current time 53, horizon 52\n", + "adding: mem time2, current time 53, horizon 51\n", + "adding: mem time3, current time 53, horizon 50\n", + "adding: mem time4, current time 53, horizon 49\n", + "adding: mem time5, current time 53, horizon 48\n", + "adding: mem time6, current time 53, horizon 47\n", + "adding: mem time7, current time 53, horizon 46\n", + "adding: mem time8, current time 53, horizon 45\n", + "adding: mem time9, current time 53, horizon 44\n", + "adding: mem time10, current time 53, horizon 43\n", + "adding: mem time11, current time 53, horizon 42\n", + "adding: mem time12, current time 53, horizon 41\n", + "adding: mem time13, current time 53, horizon 40\n", + "adding: mem time14, current time 53, horizon 39\n", + "adding: mem time15, current time 53, horizon 38\n", + "adding: mem time16, current time 53, horizon 37\n", + "adding: mem time17, current time 53, horizon 36\n", + "adding: mem time18, current time 53, horizon 35\n", + "adding: mem time19, current time 53, horizon 34\n", + "adding: mem time20, current time 53, horizon 33\n", + "adding: mem time21, current time 53, horizon 32\n", + "adding: mem time22, current time 53, horizon 31\n", + "adding: mem time23, current time 53, horizon 30\n", + "adding: mem time24, current time 53, horizon 29\n", + "adding: mem time25, current time 53, horizon 28\n", + "adding: mem time26, current time 53, horizon 27\n", + "adding: mem time27, current time 53, horizon 26\n", + "adding: mem time28, current time 53, horizon 25\n", + "adding: mem time29, current time 53, horizon 24\n", + "adding: mem time30, current time 53, horizon 23\n", + "adding: mem time31, current time 53, horizon 22\n", + "adding: mem time32, current time 53, horizon 21\n", + "adding: mem time33, current time 53, horizon 20\n", + "adding: mem time34, current time 53, horizon 19\n", + "adding: mem time35, current time 53, horizon 18\n", + "adding: mem time36, current time 53, horizon 17\n", + "adding: mem time37, current time 53, horizon 16\n", + "adding: mem time38, current time 53, horizon 15\n", + "adding: mem time39, current time 53, horizon 14\n", + "adding: mem time40, current time 53, horizon 13\n", + "adding: mem time41, current time 53, horizon 12\n", + "adding: mem time42, current time 53, horizon 11\n", + "adding: mem time43, current time 53, horizon 10\n", + "adding: mem time44, current time 53, horizon 9\n", + "adding: mem time45, current time 53, horizon 8\n", + "adding: mem time46, current time 53, horizon 7\n", + "adding: mem time47, current time 53, horizon 6\n", + "adding: mem time48, current time 53, horizon 5\n", + "adding: mem time49, current time 53, horizon 4\n", + "adding: mem time50, current time 53, horizon 3\n", + "adding: mem time51, current time 53, horizon 2\n", + "adding: mem time52, current time 53, horizon 1\n", + "adding: mem time0, current time 54, horizon 54\n", + "adding: mem time1, current time 54, horizon 53\n", + "adding: mem time2, current time 54, horizon 52\n", + "adding: mem time3, current time 54, horizon 51\n", + "adding: mem time4, current time 54, horizon 50\n", + "adding: mem time5, current time 54, horizon 49\n", + "adding: mem time6, current time 54, horizon 48\n", + "adding: mem time7, current time 54, horizon 47\n", + "adding: mem time8, current time 54, horizon 46\n", + "adding: mem time9, current time 54, horizon 45\n", + "adding: mem time10, current time 54, horizon 44\n", + "adding: mem time11, current time 54, horizon 43\n", + "adding: mem time12, current time 54, horizon 42\n", + "adding: mem time13, current time 54, horizon 41\n", + "adding: mem time14, current time 54, horizon 40\n", + "adding: mem time15, current time 54, horizon 39\n", + "adding: mem time16, current time 54, horizon 38\n", + "adding: mem time17, current time 54, horizon 37\n", + "adding: mem time18, current time 54, horizon 36\n", + "adding: mem time19, current time 54, horizon 35\n", + "adding: mem time20, current time 54, horizon 34\n", + "adding: mem time21, current time 54, horizon 33\n", + "adding: mem time22, current time 54, horizon 32\n", + "adding: mem time23, current time 54, horizon 31\n", + "adding: mem time24, current time 54, horizon 30\n", + "adding: mem time25, current time 54, horizon 29\n", + "adding: mem time26, current time 54, horizon 28\n", + "adding: mem time27, current time 54, horizon 27\n", + "adding: mem time28, current time 54, horizon 26\n", + "adding: mem time29, current time 54, horizon 25\n", + "adding: mem time30, current time 54, horizon 24\n", + "adding: mem time31, current time 54, horizon 23\n", + "adding: mem time32, current time 54, horizon 22\n", + "adding: mem time33, current time 54, horizon 21\n", + "adding: mem time34, current time 54, horizon 20\n", + "adding: mem time35, current time 54, horizon 19\n", + "adding: mem time36, current time 54, horizon 18\n", + "adding: mem time37, current time 54, horizon 17\n", + "adding: mem time38, current time 54, horizon 16\n", + "adding: mem time39, current time 54, horizon 15\n", + "adding: mem time40, current time 54, horizon 14\n", + "adding: mem time41, current time 54, horizon 13\n", + "adding: mem time42, current time 54, horizon 12\n", + "adding: mem time43, current time 54, horizon 11\n", + "adding: mem time44, current time 54, horizon 10\n", + "adding: mem time45, current time 54, horizon 9\n", + "adding: mem time46, current time 54, horizon 8\n", + "adding: mem time47, current time 54, horizon 7\n", + "adding: mem time48, current time 54, horizon 6\n", + "adding: mem time49, current time 54, horizon 5\n", + "adding: mem time50, current time 54, horizon 4\n", + "adding: mem time51, current time 54, horizon 3\n", + "adding: mem time52, current time 54, horizon 2\n", + "adding: mem time53, current time 54, horizon 1\n", + "adding: mem time0, current time 55, horizon 55\n", + "adding: mem time1, current time 55, horizon 54\n", + "adding: mem time2, current time 55, horizon 53\n", + "adding: mem time3, current time 55, horizon 52\n", + "adding: mem time4, current time 55, horizon 51\n", + "adding: mem time5, current time 55, horizon 50\n", + "adding: mem time6, current time 55, horizon 49\n", + "adding: mem time7, current time 55, horizon 48\n", + "adding: mem time8, current time 55, horizon 47\n", + "adding: mem time9, current time 55, horizon 46\n", + "adding: mem time10, current time 55, horizon 45\n", + "adding: mem time11, current time 55, horizon 44\n", + "adding: mem time12, current time 55, horizon 43\n", + "adding: mem time13, current time 55, horizon 42\n", + "adding: mem time14, current time 55, horizon 41\n", + "adding: mem time15, current time 55, horizon 40\n", + "adding: mem time16, current time 55, horizon 39\n", + "adding: mem time17, current time 55, horizon 38\n", + "adding: mem time18, current time 55, horizon 37\n", + "adding: mem time19, current time 55, horizon 36\n", + "adding: mem time20, current time 55, horizon 35\n", + "adding: mem time21, current time 55, horizon 34\n", + "adding: mem time22, current time 55, horizon 33\n", + "adding: mem time23, current time 55, horizon 32\n", + "adding: mem time24, current time 55, horizon 31\n", + "adding: mem time25, current time 55, horizon 30\n", + "adding: mem time26, current time 55, horizon 29\n", + "adding: mem time27, current time 55, horizon 28\n", + "adding: mem time28, current time 55, horizon 27\n", + "adding: mem time29, current time 55, horizon 26\n", + "adding: mem time30, current time 55, horizon 25\n", + "adding: mem time31, current time 55, horizon 24\n", + "adding: mem time32, current time 55, horizon 23\n", + "adding: mem time33, current time 55, horizon 22\n", + "adding: mem time34, current time 55, horizon 21\n", + "adding: mem time35, current time 55, horizon 20\n", + "adding: mem time36, current time 55, horizon 19\n", + "adding: mem time37, current time 55, horizon 18\n", + "adding: mem time38, current time 55, horizon 17\n", + "adding: mem time39, current time 55, horizon 16\n", + "adding: mem time40, current time 55, horizon 15\n", + "adding: mem time41, current time 55, horizon 14\n", + "adding: mem time42, current time 55, horizon 13\n", + "adding: mem time43, current time 55, horizon 12\n", + "adding: mem time44, current time 55, horizon 11\n", + "adding: mem time45, current time 55, horizon 10\n", + "adding: mem time46, current time 55, horizon 9\n", + "adding: mem time47, current time 55, horizon 8\n", + "adding: mem time48, current time 55, horizon 7\n", + "adding: mem time49, current time 55, horizon 6\n", + "adding: mem time50, current time 55, horizon 5\n", + "adding: mem time51, current time 55, horizon 4\n", + "adding: mem time52, current time 55, horizon 3\n", + "adding: mem time53, current time 55, horizon 2\n", + "adding: mem time54, current time 55, horizon 1\n", + "adding: mem time0, current time 56, horizon 56\n", + "adding: mem time1, current time 56, horizon 55\n", + "adding: mem time2, current time 56, horizon 54\n", + "adding: mem time3, current time 56, horizon 53\n", + "adding: mem time4, current time 56, horizon 52\n", + "adding: mem time5, current time 56, horizon 51\n", + "adding: mem time6, current time 56, horizon 50\n", + "adding: mem time7, current time 56, horizon 49\n", + "adding: mem time8, current time 56, horizon 48\n", + "adding: mem time9, current time 56, horizon 47\n", + "adding: mem time10, current time 56, horizon 46\n", + "adding: mem time11, current time 56, horizon 45\n", + "adding: mem time12, current time 56, horizon 44\n", + "adding: mem time13, current time 56, horizon 43\n", + "adding: mem time14, current time 56, horizon 42\n", + "adding: mem time15, current time 56, horizon 41\n", + "adding: mem time16, current time 56, horizon 40\n", + "adding: mem time17, current time 56, horizon 39\n", + "adding: mem time18, current time 56, horizon 38\n", + "adding: mem time19, current time 56, horizon 37\n", + "adding: mem time20, current time 56, horizon 36\n", + "adding: mem time21, current time 56, horizon 35\n", + "adding: mem time22, current time 56, horizon 34\n", + "adding: mem time23, current time 56, horizon 33\n", + "adding: mem time24, current time 56, horizon 32\n", + "adding: mem time25, current time 56, horizon 31\n", + "adding: mem time26, current time 56, horizon 30\n", + "adding: mem time27, current time 56, horizon 29\n", + "adding: mem time28, current time 56, horizon 28\n", + "adding: mem time29, current time 56, horizon 27\n", + "adding: mem time30, current time 56, horizon 26\n", + "adding: mem time31, current time 56, horizon 25\n", + "adding: mem time32, current time 56, horizon 24\n", + "adding: mem time33, current time 56, horizon 23\n", + "adding: mem time34, current time 56, horizon 22\n", + "adding: mem time35, current time 56, horizon 21\n", + "adding: mem time36, current time 56, horizon 20\n", + "adding: mem time37, current time 56, horizon 19\n", + "adding: mem time38, current time 56, horizon 18\n", + "adding: mem time39, current time 56, horizon 17\n", + "adding: mem time40, current time 56, horizon 16\n", + "adding: mem time41, current time 56, horizon 15\n", + "adding: mem time42, current time 56, horizon 14\n", + "adding: mem time43, current time 56, horizon 13\n", + "adding: mem time44, current time 56, horizon 12\n", + "adding: mem time45, current time 56, horizon 11\n", + "adding: mem time46, current time 56, horizon 10\n", + "adding: mem time47, current time 56, horizon 9\n", + "adding: mem time48, current time 56, horizon 8\n", + "adding: mem time49, current time 56, horizon 7\n", + "adding: mem time50, current time 56, horizon 6\n", + "adding: mem time51, current time 56, horizon 5\n", + "adding: mem time52, current time 56, horizon 4\n", + "adding: mem time53, current time 56, horizon 3\n", + "adding: mem time54, current time 56, horizon 2\n", + "adding: mem time55, current time 56, horizon 1\n", + "adding: mem time0, current time 57, horizon 57\n", + "adding: mem time1, current time 57, horizon 56\n", + "adding: mem time2, current time 57, horizon 55\n", + "adding: mem time3, current time 57, horizon 54\n", + "adding: mem time4, current time 57, horizon 53\n", + "adding: mem time5, current time 57, horizon 52\n", + "adding: mem time6, current time 57, horizon 51\n", + "adding: mem time7, current time 57, horizon 50\n", + "adding: mem time8, current time 57, horizon 49\n", + "adding: mem time9, current time 57, horizon 48\n", + "adding: mem time10, current time 57, horizon 47\n", + "adding: mem time11, current time 57, horizon 46\n", + "adding: mem time12, current time 57, horizon 45\n", + "adding: mem time13, current time 57, horizon 44\n", + "adding: mem time14, current time 57, horizon 43\n", + "adding: mem time15, current time 57, horizon 42\n", + "adding: mem time16, current time 57, horizon 41\n", + "adding: mem time17, current time 57, horizon 40\n", + "adding: mem time18, current time 57, horizon 39\n", + "adding: mem time19, current time 57, horizon 38\n", + "adding: mem time20, current time 57, horizon 37\n", + "adding: mem time21, current time 57, horizon 36\n", + "adding: mem time22, current time 57, horizon 35\n", + "adding: mem time23, current time 57, horizon 34\n", + "adding: mem time24, current time 57, horizon 33\n", + "adding: mem time25, current time 57, horizon 32\n", + "adding: mem time26, current time 57, horizon 31\n", + "adding: mem time27, current time 57, horizon 30\n", + "adding: mem time28, current time 57, horizon 29\n", + "adding: mem time29, current time 57, horizon 28\n", + "adding: mem time30, current time 57, horizon 27\n", + "adding: mem time31, current time 57, horizon 26\n", + "adding: mem time32, current time 57, horizon 25\n", + "adding: mem time33, current time 57, horizon 24\n", + "adding: mem time34, current time 57, horizon 23\n", + "adding: mem time35, current time 57, horizon 22\n", + "adding: mem time36, current time 57, horizon 21\n", + "adding: mem time37, current time 57, horizon 20\n", + "adding: mem time38, current time 57, horizon 19\n", + "adding: mem time39, current time 57, horizon 18\n", + "adding: mem time40, current time 57, horizon 17\n", + "adding: mem time41, current time 57, horizon 16\n", + "adding: mem time42, current time 57, horizon 15\n", + "adding: mem time43, current time 57, horizon 14\n", + "adding: mem time44, current time 57, horizon 13\n", + "adding: mem time45, current time 57, horizon 12\n", + "adding: mem time46, current time 57, horizon 11\n", + "adding: mem time47, current time 57, horizon 10\n", + "adding: mem time48, current time 57, horizon 9\n", + "adding: mem time49, current time 57, horizon 8\n", + "adding: mem time50, current time 57, horizon 7\n", + "adding: mem time51, current time 57, horizon 6\n", + "adding: mem time52, current time 57, horizon 5\n", + "adding: mem time53, current time 57, horizon 4\n", + "adding: mem time54, current time 57, horizon 3\n", + "adding: mem time55, current time 57, horizon 2\n", + "adding: mem time56, current time 57, horizon 1\n", + "adding: mem time0, current time 58, horizon 58\n", + "adding: mem time1, current time 58, horizon 57\n", + "adding: mem time2, current time 58, horizon 56\n", + "adding: mem time3, current time 58, horizon 55\n", + "adding: mem time4, current time 58, horizon 54\n", + "adding: mem time5, current time 58, horizon 53\n", + "adding: mem time6, current time 58, horizon 52\n", + "adding: mem time7, current time 58, horizon 51\n", + "adding: mem time8, current time 58, horizon 50\n", + "adding: mem time9, current time 58, horizon 49\n", + "adding: mem time10, current time 58, horizon 48\n", + "adding: mem time11, current time 58, horizon 47\n", + "adding: mem time12, current time 58, horizon 46\n", + "adding: mem time13, current time 58, horizon 45\n", + "adding: mem time14, current time 58, horizon 44\n", + "adding: mem time15, current time 58, horizon 43\n", + "adding: mem time16, current time 58, horizon 42\n", + "adding: mem time17, current time 58, horizon 41\n", + "adding: mem time18, current time 58, horizon 40\n", + "adding: mem time19, current time 58, horizon 39\n", + "adding: mem time20, current time 58, horizon 38\n", + "adding: mem time21, current time 58, horizon 37\n", + "adding: mem time22, current time 58, horizon 36\n", + "adding: mem time23, current time 58, horizon 35\n", + "adding: mem time24, current time 58, horizon 34\n", + "adding: mem time25, current time 58, horizon 33\n", + "adding: mem time26, current time 58, horizon 32\n", + "adding: mem time27, current time 58, horizon 31\n", + "adding: mem time28, current time 58, horizon 30\n", + "adding: mem time29, current time 58, horizon 29\n", + "adding: mem time30, current time 58, horizon 28\n", + "adding: mem time31, current time 58, horizon 27\n", + "adding: mem time32, current time 58, horizon 26\n", + "adding: mem time33, current time 58, horizon 25\n", + "adding: mem time34, current time 58, horizon 24\n", + "adding: mem time35, current time 58, horizon 23\n", + "adding: mem time36, current time 58, horizon 22\n", + "adding: mem time37, current time 58, horizon 21\n", + "adding: mem time38, current time 58, horizon 20\n", + "adding: mem time39, current time 58, horizon 19\n", + "adding: mem time40, current time 58, horizon 18\n", + "adding: mem time41, current time 58, horizon 17\n", + "adding: mem time42, current time 58, horizon 16\n", + "adding: mem time43, current time 58, horizon 15\n", + "adding: mem time44, current time 58, horizon 14\n", + "adding: mem time45, current time 58, horizon 13\n", + "adding: mem time46, current time 58, horizon 12\n", + "adding: mem time47, current time 58, horizon 11\n", + "adding: mem time48, current time 58, horizon 10\n", + "adding: mem time49, current time 58, horizon 9\n", + "adding: mem time50, current time 58, horizon 8\n", + "adding: mem time51, current time 58, horizon 7\n", + "adding: mem time52, current time 58, horizon 6\n", + "adding: mem time53, current time 58, horizon 5\n", + "adding: mem time54, current time 58, horizon 4\n", + "adding: mem time55, current time 58, horizon 3\n", + "adding: mem time56, current time 58, horizon 2\n", + "adding: mem time57, current time 58, horizon 1\n", + "adding: mem time0, current time 59, horizon 59\n", + "adding: mem time1, current time 59, horizon 58\n", + "adding: mem time2, current time 59, horizon 57\n", + "adding: mem time3, current time 59, horizon 56\n", + "adding: mem time4, current time 59, horizon 55\n", + "adding: mem time5, current time 59, horizon 54\n", + "adding: mem time6, current time 59, horizon 53\n", + "adding: mem time7, current time 59, horizon 52\n", + "adding: mem time8, current time 59, horizon 51\n", + "adding: mem time9, current time 59, horizon 50\n", + "adding: mem time10, current time 59, horizon 49\n", + "adding: mem time11, current time 59, horizon 48\n", + "adding: mem time12, current time 59, horizon 47\n", + "adding: mem time13, current time 59, horizon 46\n", + "adding: mem time14, current time 59, horizon 45\n", + "adding: mem time15, current time 59, horizon 44\n", + "adding: mem time16, current time 59, horizon 43\n", + "adding: mem time17, current time 59, horizon 42\n", + "adding: mem time18, current time 59, horizon 41\n", + "adding: mem time19, current time 59, horizon 40\n", + "adding: mem time20, current time 59, horizon 39\n", + "adding: mem time21, current time 59, horizon 38\n", + "adding: mem time22, current time 59, horizon 37\n", + "adding: mem time23, current time 59, horizon 36\n", + "adding: mem time24, current time 59, horizon 35\n", + "adding: mem time25, current time 59, horizon 34\n", + "adding: mem time26, current time 59, horizon 33\n", + "adding: mem time27, current time 59, horizon 32\n", + "adding: mem time28, current time 59, horizon 31\n", + "adding: mem time29, current time 59, horizon 30\n", + "adding: mem time30, current time 59, horizon 29\n", + "adding: mem time31, current time 59, horizon 28\n", + "adding: mem time32, current time 59, horizon 27\n", + "adding: mem time33, current time 59, horizon 26\n", + "adding: mem time34, current time 59, horizon 25\n", + "adding: mem time35, current time 59, horizon 24\n", + "adding: mem time36, current time 59, horizon 23\n", + "adding: mem time37, current time 59, horizon 22\n", + "adding: mem time38, current time 59, horizon 21\n", + "adding: mem time39, current time 59, horizon 20\n", + "adding: mem time40, current time 59, horizon 19\n", + "adding: mem time41, current time 59, horizon 18\n", + "adding: mem time42, current time 59, horizon 17\n", + "adding: mem time43, current time 59, horizon 16\n", + "adding: mem time44, current time 59, horizon 15\n", + "adding: mem time45, current time 59, horizon 14\n", + "adding: mem time46, current time 59, horizon 13\n", + "adding: mem time47, current time 59, horizon 12\n", + "adding: mem time48, current time 59, horizon 11\n", + "adding: mem time49, current time 59, horizon 10\n", + "adding: mem time50, current time 59, horizon 9\n", + "adding: mem time51, current time 59, horizon 8\n", + "adding: mem time52, current time 59, horizon 7\n", + "adding: mem time53, current time 59, horizon 6\n", + "adding: mem time54, current time 59, horizon 5\n", + "adding: mem time55, current time 59, horizon 4\n", + "adding: mem time56, current time 59, horizon 3\n", + "adding: mem time57, current time 59, horizon 2\n", + "adding: mem time58, current time 59, horizon 1\n", + "adding: mem time0, current time 60, horizon 60\n", + "adding: mem time1, current time 60, horizon 59\n", + "adding: mem time2, current time 60, horizon 58\n", + "adding: mem time3, current time 60, horizon 57\n", + "adding: mem time4, current time 60, horizon 56\n", + "adding: mem time5, current time 60, horizon 55\n", + "adding: mem time6, current time 60, horizon 54\n", + "adding: mem time7, current time 60, horizon 53\n", + "adding: mem time8, current time 60, horizon 52\n", + "adding: mem time9, current time 60, horizon 51\n", + "adding: mem time10, current time 60, horizon 50\n", + "adding: mem time11, current time 60, horizon 49\n", + "adding: mem time12, current time 60, horizon 48\n", + "adding: mem time13, current time 60, horizon 47\n", + "adding: mem time14, current time 60, horizon 46\n", + "adding: mem time15, current time 60, horizon 45\n", + "adding: mem time16, current time 60, horizon 44\n", + "adding: mem time17, current time 60, horizon 43\n", + "adding: mem time18, current time 60, horizon 42\n", + "adding: mem time19, current time 60, horizon 41\n", + "adding: mem time20, current time 60, horizon 40\n", + "adding: mem time21, current time 60, horizon 39\n", + "adding: mem time22, current time 60, horizon 38\n", + "adding: mem time23, current time 60, horizon 37\n", + "adding: mem time24, current time 60, horizon 36\n", + "adding: mem time25, current time 60, horizon 35\n", + "adding: mem time26, current time 60, horizon 34\n", + "adding: mem time27, current time 60, horizon 33\n", + "adding: mem time28, current time 60, horizon 32\n", + "adding: mem time29, current time 60, horizon 31\n", + "adding: mem time30, current time 60, horizon 30\n", + "adding: mem time31, current time 60, horizon 29\n", + "adding: mem time32, current time 60, horizon 28\n", + "adding: mem time33, current time 60, horizon 27\n", + "adding: mem time34, current time 60, horizon 26\n", + "adding: mem time35, current time 60, horizon 25\n", + "adding: mem time36, current time 60, horizon 24\n", + "adding: mem time37, current time 60, horizon 23\n", + "adding: mem time38, current time 60, horizon 22\n", + "adding: mem time39, current time 60, horizon 21\n", + "adding: mem time40, current time 60, horizon 20\n", + "adding: mem time41, current time 60, horizon 19\n", + "adding: mem time42, current time 60, horizon 18\n", + "adding: mem time43, current time 60, horizon 17\n", + "adding: mem time44, current time 60, horizon 16\n", + "adding: mem time45, current time 60, horizon 15\n", + "adding: mem time46, current time 60, horizon 14\n", + "adding: mem time47, current time 60, horizon 13\n", + "adding: mem time48, current time 60, horizon 12\n", + "adding: mem time49, current time 60, horizon 11\n", + "adding: mem time50, current time 60, horizon 10\n", + "adding: mem time51, current time 60, horizon 9\n", + "adding: mem time52, current time 60, horizon 8\n", + "adding: mem time53, current time 60, horizon 7\n", + "adding: mem time54, current time 60, horizon 6\n", + "adding: mem time55, current time 60, horizon 5\n", + "adding: mem time56, current time 60, horizon 4\n", + "adding: mem time57, current time 60, horizon 3\n", + "adding: mem time58, current time 60, horizon 2\n", + "adding: mem time59, current time 60, horizon 1\n", + "adding: mem time0, current time 61, horizon 61\n", + "adding: mem time1, current time 61, horizon 60\n", + "adding: mem time2, current time 61, horizon 59\n", + "adding: mem time3, current time 61, horizon 58\n", + "adding: mem time4, current time 61, horizon 57\n", + "adding: mem time5, current time 61, horizon 56\n", + "adding: mem time6, current time 61, horizon 55\n", + "adding: mem time7, current time 61, horizon 54\n", + "adding: mem time8, current time 61, horizon 53\n", + "adding: mem time9, current time 61, horizon 52\n", + "adding: mem time10, current time 61, horizon 51\n", + "adding: mem time11, current time 61, horizon 50\n", + "adding: mem time12, current time 61, horizon 49\n", + "adding: mem time13, current time 61, horizon 48\n", + "adding: mem time14, current time 61, horizon 47\n", + "adding: mem time15, current time 61, horizon 46\n", + "adding: mem time16, current time 61, horizon 45\n", + "adding: mem time17, current time 61, horizon 44\n", + "adding: mem time18, current time 61, horizon 43\n", + "adding: mem time19, current time 61, horizon 42\n", + "adding: mem time20, current time 61, horizon 41\n", + "adding: mem time21, current time 61, horizon 40\n", + "adding: mem time22, current time 61, horizon 39\n", + "adding: mem time23, current time 61, horizon 38\n", + "adding: mem time24, current time 61, horizon 37\n", + "adding: mem time25, current time 61, horizon 36\n", + "adding: mem time26, current time 61, horizon 35\n", + "adding: mem time27, current time 61, horizon 34\n", + "adding: mem time28, current time 61, horizon 33\n", + "adding: mem time29, current time 61, horizon 32\n", + "adding: mem time30, current time 61, horizon 31\n", + "adding: mem time31, current time 61, horizon 30\n", + "adding: mem time32, current time 61, horizon 29\n", + "adding: mem time33, current time 61, horizon 28\n", + "adding: mem time34, current time 61, horizon 27\n", + "adding: mem time35, current time 61, horizon 26\n", + "adding: mem time36, current time 61, horizon 25\n", + "adding: mem time37, current time 61, horizon 24\n", + "adding: mem time38, current time 61, horizon 23\n", + "adding: mem time39, current time 61, horizon 22\n", + "adding: mem time40, current time 61, horizon 21\n", + "adding: mem time41, current time 61, horizon 20\n", + "adding: mem time42, current time 61, horizon 19\n", + "adding: mem time43, current time 61, horizon 18\n", + "adding: mem time44, current time 61, horizon 17\n", + "adding: mem time45, current time 61, horizon 16\n", + "adding: mem time46, current time 61, horizon 15\n", + "adding: mem time47, current time 61, horizon 14\n", + "adding: mem time48, current time 61, horizon 13\n", + "adding: mem time49, current time 61, horizon 12\n", + "adding: mem time50, current time 61, horizon 11\n", + "adding: mem time51, current time 61, horizon 10\n", + "adding: mem time52, current time 61, horizon 9\n", + "adding: mem time53, current time 61, horizon 8\n", + "adding: mem time54, current time 61, horizon 7\n", + "adding: mem time55, current time 61, horizon 6\n", + "adding: mem time56, current time 61, horizon 5\n", + "adding: mem time57, current time 61, horizon 4\n", + "adding: mem time58, current time 61, horizon 3\n", + "adding: mem time59, current time 61, horizon 2\n", + "adding: mem time60, current time 61, horizon 1\n", + "adding: mem time0, current time 62, horizon 62\n", + "adding: mem time1, current time 62, horizon 61\n", + "adding: mem time2, current time 62, horizon 60\n", + "adding: mem time3, current time 62, horizon 59\n", + "adding: mem time4, current time 62, horizon 58\n", + "adding: mem time5, current time 62, horizon 57\n", + "adding: mem time6, current time 62, horizon 56\n", + "adding: mem time7, current time 62, horizon 55\n", + "adding: mem time8, current time 62, horizon 54\n", + "adding: mem time9, current time 62, horizon 53\n", + "adding: mem time10, current time 62, horizon 52\n", + "adding: mem time11, current time 62, horizon 51\n", + "adding: mem time12, current time 62, horizon 50\n", + "adding: mem time13, current time 62, horizon 49\n", + "adding: mem time14, current time 62, horizon 48\n", + "adding: mem time15, current time 62, horizon 47\n", + "adding: mem time16, current time 62, horizon 46\n", + "adding: mem time17, current time 62, horizon 45\n", + "adding: mem time18, current time 62, horizon 44\n", + "adding: mem time19, current time 62, horizon 43\n", + "adding: mem time20, current time 62, horizon 42\n", + "adding: mem time21, current time 62, horizon 41\n", + "adding: mem time22, current time 62, horizon 40\n", + "adding: mem time23, current time 62, horizon 39\n", + "adding: mem time24, current time 62, horizon 38\n", + "adding: mem time25, current time 62, horizon 37\n", + "adding: mem time26, current time 62, horizon 36\n", + "adding: mem time27, current time 62, horizon 35\n", + "adding: mem time28, current time 62, horizon 34\n", + "adding: mem time29, current time 62, horizon 33\n", + "adding: mem time30, current time 62, horizon 32\n", + "adding: mem time31, current time 62, horizon 31\n", + "adding: mem time32, current time 62, horizon 30\n", + "adding: mem time33, current time 62, horizon 29\n", + "adding: mem time34, current time 62, horizon 28\n", + "adding: mem time35, current time 62, horizon 27\n", + "adding: mem time36, current time 62, horizon 26\n", + "adding: mem time37, current time 62, horizon 25\n", + "adding: mem time38, current time 62, horizon 24\n", + "adding: mem time39, current time 62, horizon 23\n", + "adding: mem time40, current time 62, horizon 22\n", + "adding: mem time41, current time 62, horizon 21\n", + "adding: mem time42, current time 62, horizon 20\n", + "adding: mem time43, current time 62, horizon 19\n", + "adding: mem time44, current time 62, horizon 18\n", + "adding: mem time45, current time 62, horizon 17\n", + "adding: mem time46, current time 62, horizon 16\n", + "adding: mem time47, current time 62, horizon 15\n", + "adding: mem time48, current time 62, horizon 14\n", + "adding: mem time49, current time 62, horizon 13\n", + "adding: mem time50, current time 62, horizon 12\n", + "adding: mem time51, current time 62, horizon 11\n", + "adding: mem time52, current time 62, horizon 10\n", + "adding: mem time53, current time 62, horizon 9\n", + "adding: mem time54, current time 62, horizon 8\n", + "adding: mem time55, current time 62, horizon 7\n", + "adding: mem time56, current time 62, horizon 6\n", + "adding: mem time57, current time 62, horizon 5\n", + "adding: mem time58, current time 62, horizon 4\n", + "adding: mem time59, current time 62, horizon 3\n", + "adding: mem time60, current time 62, horizon 2\n", + "adding: mem time61, current time 62, horizon 1\n", + "adding: mem time0, current time 63, horizon 63\n", + "adding: mem time1, current time 63, horizon 62\n", + "adding: mem time2, current time 63, horizon 61\n", + "adding: mem time3, current time 63, horizon 60\n", + "adding: mem time4, current time 63, horizon 59\n", + "adding: mem time5, current time 63, horizon 58\n", + "adding: mem time6, current time 63, horizon 57\n", + "adding: mem time7, current time 63, horizon 56\n", + "adding: mem time8, current time 63, horizon 55\n", + "adding: mem time9, current time 63, horizon 54\n", + "adding: mem time10, current time 63, horizon 53\n", + "adding: mem time11, current time 63, horizon 52\n", + "adding: mem time12, current time 63, horizon 51\n", + "adding: mem time13, current time 63, horizon 50\n", + "adding: mem time14, current time 63, horizon 49\n", + "adding: mem time15, current time 63, horizon 48\n", + "adding: mem time16, current time 63, horizon 47\n", + "adding: mem time17, current time 63, horizon 46\n", + "adding: mem time18, current time 63, horizon 45\n", + "adding: mem time19, current time 63, horizon 44\n", + "adding: mem time20, current time 63, horizon 43\n", + "adding: mem time21, current time 63, horizon 42\n", + "adding: mem time22, current time 63, horizon 41\n", + "adding: mem time23, current time 63, horizon 40\n", + "adding: mem time24, current time 63, horizon 39\n", + "adding: mem time25, current time 63, horizon 38\n", + "adding: mem time26, current time 63, horizon 37\n", + "adding: mem time27, current time 63, horizon 36\n", + "adding: mem time28, current time 63, horizon 35\n", + "adding: mem time29, current time 63, horizon 34\n", + "adding: mem time30, current time 63, horizon 33\n", + "adding: mem time31, current time 63, horizon 32\n", + "adding: mem time32, current time 63, horizon 31\n", + "adding: mem time33, current time 63, horizon 30\n", + "adding: mem time34, current time 63, horizon 29\n", + "adding: mem time35, current time 63, horizon 28\n", + "adding: mem time36, current time 63, horizon 27\n", + "adding: mem time37, current time 63, horizon 26\n", + "adding: mem time38, current time 63, horizon 25\n", + "adding: mem time39, current time 63, horizon 24\n", + "adding: mem time40, current time 63, horizon 23\n", + "adding: mem time41, current time 63, horizon 22\n", + "adding: mem time42, current time 63, horizon 21\n", + "adding: mem time43, current time 63, horizon 20\n", + "adding: mem time44, current time 63, horizon 19\n", + "adding: mem time45, current time 63, horizon 18\n", + "adding: mem time46, current time 63, horizon 17\n", + "adding: mem time47, current time 63, horizon 16\n", + "adding: mem time48, current time 63, horizon 15\n", + "adding: mem time49, current time 63, horizon 14\n", + "adding: mem time50, current time 63, horizon 13\n", + "adding: mem time51, current time 63, horizon 12\n", + "adding: mem time52, current time 63, horizon 11\n", + "adding: mem time53, current time 63, horizon 10\n", + "adding: mem time54, current time 63, horizon 9\n", + "adding: mem time55, current time 63, horizon 8\n", + "adding: mem time56, current time 63, horizon 7\n", + "adding: mem time57, current time 63, horizon 6\n", + "adding: mem time58, current time 63, horizon 5\n", + "adding: mem time59, current time 63, horizon 4\n", + "adding: mem time60, current time 63, horizon 3\n", + "adding: mem time61, current time 63, horizon 2\n", + "adding: mem time62, current time 63, horizon 1\n", + "adding: mem time0, current time 64, horizon 64\n", + "adding: mem time1, current time 64, horizon 63\n", + "adding: mem time2, current time 64, horizon 62\n", + "adding: mem time3, current time 64, horizon 61\n", + "adding: mem time4, current time 64, horizon 60\n", + "adding: mem time5, current time 64, horizon 59\n", + "adding: mem time6, current time 64, horizon 58\n", + "adding: mem time7, current time 64, horizon 57\n", + "adding: mem time8, current time 64, horizon 56\n", + "adding: mem time9, current time 64, horizon 55\n", + "adding: mem time10, current time 64, horizon 54\n", + "adding: mem time11, current time 64, horizon 53\n", + "adding: mem time12, current time 64, horizon 52\n", + "adding: mem time13, current time 64, horizon 51\n", + "adding: mem time14, current time 64, horizon 50\n", + "adding: mem time15, current time 64, horizon 49\n", + "adding: mem time16, current time 64, horizon 48\n", + "adding: mem time17, current time 64, horizon 47\n", + "adding: mem time18, current time 64, horizon 46\n", + "adding: mem time19, current time 64, horizon 45\n", + "adding: mem time20, current time 64, horizon 44\n", + "adding: mem time21, current time 64, horizon 43\n", + "adding: mem time22, current time 64, horizon 42\n", + "adding: mem time23, current time 64, horizon 41\n", + "adding: mem time24, current time 64, horizon 40\n", + "adding: mem time25, current time 64, horizon 39\n", + "adding: mem time26, current time 64, horizon 38\n", + "adding: mem time27, current time 64, horizon 37\n", + "adding: mem time28, current time 64, horizon 36\n", + "adding: mem time29, current time 64, horizon 35\n", + "adding: mem time30, current time 64, horizon 34\n", + "adding: mem time31, current time 64, horizon 33\n", + "adding: mem time32, current time 64, horizon 32\n", + "adding: mem time33, current time 64, horizon 31\n", + "adding: mem time34, current time 64, horizon 30\n", + "adding: mem time35, current time 64, horizon 29\n", + "adding: mem time36, current time 64, horizon 28\n", + "adding: mem time37, current time 64, horizon 27\n", + "adding: mem time38, current time 64, horizon 26\n", + "adding: mem time39, current time 64, horizon 25\n", + "adding: mem time40, current time 64, horizon 24\n", + "adding: mem time41, current time 64, horizon 23\n", + "adding: mem time42, current time 64, horizon 22\n", + "adding: mem time43, current time 64, horizon 21\n", + "adding: mem time44, current time 64, horizon 20\n", + "adding: mem time45, current time 64, horizon 19\n", + "adding: mem time46, current time 64, horizon 18\n", + "adding: mem time47, current time 64, horizon 17\n", + "adding: mem time48, current time 64, horizon 16\n", + "adding: mem time49, current time 64, horizon 15\n", + "adding: mem time50, current time 64, horizon 14\n", + "adding: mem time51, current time 64, horizon 13\n", + "adding: mem time52, current time 64, horizon 12\n", + "adding: mem time53, current time 64, horizon 11\n", + "adding: mem time54, current time 64, horizon 10\n", + "adding: mem time55, current time 64, horizon 9\n", + "adding: mem time56, current time 64, horizon 8\n", + "adding: mem time57, current time 64, horizon 7\n", + "adding: mem time58, current time 64, horizon 6\n", + "adding: mem time59, current time 64, horizon 5\n", + "adding: mem time60, current time 64, horizon 4\n", + "adding: mem time61, current time 64, horizon 3\n", + "adding: mem time62, current time 64, horizon 2\n", + "adding: mem time63, current time 64, horizon 1\n", + "adding: mem time0, current time 65, horizon 65\n", + "adding: mem time1, current time 65, horizon 64\n", + "adding: mem time2, current time 65, horizon 63\n", + "adding: mem time3, current time 65, horizon 62\n", + "adding: mem time4, current time 65, horizon 61\n", + "adding: mem time5, current time 65, horizon 60\n", + "adding: mem time6, current time 65, horizon 59\n", + "adding: mem time7, current time 65, horizon 58\n", + "adding: mem time8, current time 65, horizon 57\n", + "adding: mem time9, current time 65, horizon 56\n", + "adding: mem time10, current time 65, horizon 55\n", + "adding: mem time11, current time 65, horizon 54\n", + "adding: mem time12, current time 65, horizon 53\n", + "adding: mem time13, current time 65, horizon 52\n", + "adding: mem time14, current time 65, horizon 51\n", + "adding: mem time15, current time 65, horizon 50\n", + "adding: mem time16, current time 65, horizon 49\n", + "adding: mem time17, current time 65, horizon 48\n", + "adding: mem time18, current time 65, horizon 47\n", + "adding: mem time19, current time 65, horizon 46\n", + "adding: mem time20, current time 65, horizon 45\n", + "adding: mem time21, current time 65, horizon 44\n", + "adding: mem time22, current time 65, horizon 43\n", + "adding: mem time23, current time 65, horizon 42\n", + "adding: mem time24, current time 65, horizon 41\n", + "adding: mem time25, current time 65, horizon 40\n", + "adding: mem time26, current time 65, horizon 39\n", + "adding: mem time27, current time 65, horizon 38\n", + "adding: mem time28, current time 65, horizon 37\n", + "adding: mem time29, current time 65, horizon 36\n", + "adding: mem time30, current time 65, horizon 35\n", + "adding: mem time31, current time 65, horizon 34\n", + "adding: mem time32, current time 65, horizon 33\n", + "adding: mem time33, current time 65, horizon 32\n", + "adding: mem time34, current time 65, horizon 31\n", + "adding: mem time35, current time 65, horizon 30\n", + "adding: mem time36, current time 65, horizon 29\n", + "adding: mem time37, current time 65, horizon 28\n", + "adding: mem time38, current time 65, horizon 27\n", + "adding: mem time39, current time 65, horizon 26\n", + "adding: mem time40, current time 65, horizon 25\n", + "adding: mem time41, current time 65, horizon 24\n", + "adding: mem time42, current time 65, horizon 23\n", + "adding: mem time43, current time 65, horizon 22\n", + "adding: mem time44, current time 65, horizon 21\n", + "adding: mem time45, current time 65, horizon 20\n", + "adding: mem time46, current time 65, horizon 19\n", + "adding: mem time47, current time 65, horizon 18\n", + "adding: mem time48, current time 65, horizon 17\n", + "adding: mem time49, current time 65, horizon 16\n", + "adding: mem time50, current time 65, horizon 15\n", + "adding: mem time51, current time 65, horizon 14\n", + "adding: mem time52, current time 65, horizon 13\n", + "adding: mem time53, current time 65, horizon 12\n", + "adding: mem time54, current time 65, horizon 11\n", + "adding: mem time55, current time 65, horizon 10\n", + "adding: mem time56, current time 65, horizon 9\n", + "adding: mem time57, current time 65, horizon 8\n", + "adding: mem time58, current time 65, horizon 7\n", + "adding: mem time59, current time 65, horizon 6\n", + "adding: mem time60, current time 65, horizon 5\n", + "adding: mem time61, current time 65, horizon 4\n", + "adding: mem time62, current time 65, horizon 3\n", + "adding: mem time63, current time 65, horizon 2\n", + "adding: mem time64, current time 65, horizon 1\n", + "adding: mem time0, current time 66, horizon 66\n", + "adding: mem time1, current time 66, horizon 65\n", + "adding: mem time2, current time 66, horizon 64\n", + "adding: mem time3, current time 66, horizon 63\n", + "adding: mem time4, current time 66, horizon 62\n", + "adding: mem time5, current time 66, horizon 61\n", + "adding: mem time6, current time 66, horizon 60\n", + "adding: mem time7, current time 66, horizon 59\n", + "adding: mem time8, current time 66, horizon 58\n", + "adding: mem time9, current time 66, horizon 57\n", + "adding: mem time10, current time 66, horizon 56\n", + "adding: mem time11, current time 66, horizon 55\n", + "adding: mem time12, current time 66, horizon 54\n", + "adding: mem time13, current time 66, horizon 53\n", + "adding: mem time14, current time 66, horizon 52\n", + "adding: mem time15, current time 66, horizon 51\n", + "adding: mem time16, current time 66, horizon 50\n", + "adding: mem time17, current time 66, horizon 49\n", + "adding: mem time18, current time 66, horizon 48\n", + "adding: mem time19, current time 66, horizon 47\n", + "adding: mem time20, current time 66, horizon 46\n", + "adding: mem time21, current time 66, horizon 45\n", + "adding: mem time22, current time 66, horizon 44\n", + "adding: mem time23, current time 66, horizon 43\n", + "adding: mem time24, current time 66, horizon 42\n", + "adding: mem time25, current time 66, horizon 41\n", + "adding: mem time26, current time 66, horizon 40\n", + "adding: mem time27, current time 66, horizon 39\n", + "adding: mem time28, current time 66, horizon 38\n", + "adding: mem time29, current time 66, horizon 37\n", + "adding: mem time30, current time 66, horizon 36\n", + "adding: mem time31, current time 66, horizon 35\n", + "adding: mem time32, current time 66, horizon 34\n", + "adding: mem time33, current time 66, horizon 33\n", + "adding: mem time34, current time 66, horizon 32\n", + "adding: mem time35, current time 66, horizon 31\n", + "adding: mem time36, current time 66, horizon 30\n", + "adding: mem time37, current time 66, horizon 29\n", + "adding: mem time38, current time 66, horizon 28\n", + "adding: mem time39, current time 66, horizon 27\n", + "adding: mem time40, current time 66, horizon 26\n", + "adding: mem time41, current time 66, horizon 25\n", + "adding: mem time42, current time 66, horizon 24\n", + "adding: mem time43, current time 66, horizon 23\n", + "adding: mem time44, current time 66, horizon 22\n", + "adding: mem time45, current time 66, horizon 21\n", + "adding: mem time46, current time 66, horizon 20\n", + "adding: mem time47, current time 66, horizon 19\n", + "adding: mem time48, current time 66, horizon 18\n", + "adding: mem time49, current time 66, horizon 17\n", + "adding: mem time50, current time 66, horizon 16\n", + "adding: mem time51, current time 66, horizon 15\n", + "adding: mem time52, current time 66, horizon 14\n", + "adding: mem time53, current time 66, horizon 13\n", + "adding: mem time54, current time 66, horizon 12\n", + "adding: mem time55, current time 66, horizon 11\n", + "adding: mem time56, current time 66, horizon 10\n", + "adding: mem time57, current time 66, horizon 9\n", + "adding: mem time58, current time 66, horizon 8\n", + "adding: mem time59, current time 66, horizon 7\n", + "adding: mem time60, current time 66, horizon 6\n", + "adding: mem time61, current time 66, horizon 5\n", + "adding: mem time62, current time 66, horizon 4\n", + "adding: mem time63, current time 66, horizon 3\n", + "adding: mem time64, current time 66, horizon 2\n", + "adding: mem time65, current time 66, horizon 1\n", + "adding: mem time0, current time 67, horizon 67\n", + "adding: mem time1, current time 67, horizon 66\n", + "adding: mem time2, current time 67, horizon 65\n", + "adding: mem time3, current time 67, horizon 64\n", + "adding: mem time4, current time 67, horizon 63\n", + "adding: mem time5, current time 67, horizon 62\n", + "adding: mem time6, current time 67, horizon 61\n", + "adding: mem time7, current time 67, horizon 60\n", + "adding: mem time8, current time 67, horizon 59\n", + "adding: mem time9, current time 67, horizon 58\n", + "adding: mem time10, current time 67, horizon 57\n", + "adding: mem time11, current time 67, horizon 56\n", + "adding: mem time12, current time 67, horizon 55\n", + "adding: mem time13, current time 67, horizon 54\n", + "adding: mem time14, current time 67, horizon 53\n", + "adding: mem time15, current time 67, horizon 52\n", + "adding: mem time16, current time 67, horizon 51\n", + "adding: mem time17, current time 67, horizon 50\n", + "adding: mem time18, current time 67, horizon 49\n", + "adding: mem time19, current time 67, horizon 48\n", + "adding: mem time20, current time 67, horizon 47\n", + "adding: mem time21, current time 67, horizon 46\n", + "adding: mem time22, current time 67, horizon 45\n", + "adding: mem time23, current time 67, horizon 44\n", + "adding: mem time24, current time 67, horizon 43\n", + "adding: mem time25, current time 67, horizon 42\n", + "adding: mem time26, current time 67, horizon 41\n", + "adding: mem time27, current time 67, horizon 40\n", + "adding: mem time28, current time 67, horizon 39\n", + "adding: mem time29, current time 67, horizon 38\n", + "adding: mem time30, current time 67, horizon 37\n", + "adding: mem time31, current time 67, horizon 36\n", + "adding: mem time32, current time 67, horizon 35\n", + "adding: mem time33, current time 67, horizon 34\n", + "adding: mem time34, current time 67, horizon 33\n", + "adding: mem time35, current time 67, horizon 32\n", + "adding: mem time36, current time 67, horizon 31\n", + "adding: mem time37, current time 67, horizon 30\n", + "adding: mem time38, current time 67, horizon 29\n", + "adding: mem time39, current time 67, horizon 28\n", + "adding: mem time40, current time 67, horizon 27\n", + "adding: mem time41, current time 67, horizon 26\n", + "adding: mem time42, current time 67, horizon 25\n", + "adding: mem time43, current time 67, horizon 24\n", + "adding: mem time44, current time 67, horizon 23\n", + "adding: mem time45, current time 67, horizon 22\n", + "adding: mem time46, current time 67, horizon 21\n", + "adding: mem time47, current time 67, horizon 20\n", + "adding: mem time48, current time 67, horizon 19\n", + "adding: mem time49, current time 67, horizon 18\n", + "adding: mem time50, current time 67, horizon 17\n", + "adding: mem time51, current time 67, horizon 16\n", + "adding: mem time52, current time 67, horizon 15\n", + "adding: mem time53, current time 67, horizon 14\n", + "adding: mem time54, current time 67, horizon 13\n", + "adding: mem time55, current time 67, horizon 12\n", + "adding: mem time56, current time 67, horizon 11\n", + "adding: mem time57, current time 67, horizon 10\n", + "adding: mem time58, current time 67, horizon 9\n", + "adding: mem time59, current time 67, horizon 8\n", + "adding: mem time60, current time 67, horizon 7\n", + "adding: mem time61, current time 67, horizon 6\n", + "adding: mem time62, current time 67, horizon 5\n", + "adding: mem time63, current time 67, horizon 4\n", + "adding: mem time64, current time 67, horizon 3\n", + "adding: mem time65, current time 67, horizon 2\n", + "adding: mem time66, current time 67, horizon 1\n", + "adding: mem time0, current time 68, horizon 68\n", + "adding: mem time1, current time 68, horizon 67\n", + "adding: mem time2, current time 68, horizon 66\n", + "adding: mem time3, current time 68, horizon 65\n", + "adding: mem time4, current time 68, horizon 64\n", + "adding: mem time5, current time 68, horizon 63\n", + "adding: mem time6, current time 68, horizon 62\n", + "adding: mem time7, current time 68, horizon 61\n", + "adding: mem time8, current time 68, horizon 60\n", + "adding: mem time9, current time 68, horizon 59\n", + "adding: mem time10, current time 68, horizon 58\n", + "adding: mem time11, current time 68, horizon 57\n", + "adding: mem time12, current time 68, horizon 56\n", + "adding: mem time13, current time 68, horizon 55\n", + "adding: mem time14, current time 68, horizon 54\n", + "adding: mem time15, current time 68, horizon 53\n", + "adding: mem time16, current time 68, horizon 52\n", + "adding: mem time17, current time 68, horizon 51\n", + "adding: mem time18, current time 68, horizon 50\n", + "adding: mem time19, current time 68, horizon 49\n", + "adding: mem time20, current time 68, horizon 48\n", + "adding: mem time21, current time 68, horizon 47\n", + "adding: mem time22, current time 68, horizon 46\n", + "adding: mem time23, current time 68, horizon 45\n", + "adding: mem time24, current time 68, horizon 44\n", + "adding: mem time25, current time 68, horizon 43\n", + "adding: mem time26, current time 68, horizon 42\n", + "adding: mem time27, current time 68, horizon 41\n", + "adding: mem time28, current time 68, horizon 40\n", + "adding: mem time29, current time 68, horizon 39\n", + "adding: mem time30, current time 68, horizon 38\n", + "adding: mem time31, current time 68, horizon 37\n", + "adding: mem time32, current time 68, horizon 36\n", + "adding: mem time33, current time 68, horizon 35\n", + "adding: mem time34, current time 68, horizon 34\n", + "adding: mem time35, current time 68, horizon 33\n", + "adding: mem time36, current time 68, horizon 32\n", + "adding: mem time37, current time 68, horizon 31\n", + "adding: mem time38, current time 68, horizon 30\n", + "adding: mem time39, current time 68, horizon 29\n", + "adding: mem time40, current time 68, horizon 28\n", + "adding: mem time41, current time 68, horizon 27\n", + "adding: mem time42, current time 68, horizon 26\n", + "adding: mem time43, current time 68, horizon 25\n", + "adding: mem time44, current time 68, horizon 24\n", + "adding: mem time45, current time 68, horizon 23\n", + "adding: mem time46, current time 68, horizon 22\n", + "adding: mem time47, current time 68, horizon 21\n", + "adding: mem time48, current time 68, horizon 20\n", + "adding: mem time49, current time 68, horizon 19\n", + "adding: mem time50, current time 68, horizon 18\n", + "adding: mem time51, current time 68, horizon 17\n", + "adding: mem time52, current time 68, horizon 16\n", + "adding: mem time53, current time 68, horizon 15\n", + "adding: mem time54, current time 68, horizon 14\n", + "adding: mem time55, current time 68, horizon 13\n", + "adding: mem time56, current time 68, horizon 12\n", + "adding: mem time57, current time 68, horizon 11\n", + "adding: mem time58, current time 68, horizon 10\n", + "adding: mem time59, current time 68, horizon 9\n", + "adding: mem time60, current time 68, horizon 8\n", + "adding: mem time61, current time 68, horizon 7\n", + "adding: mem time62, current time 68, horizon 6\n", + "adding: mem time63, current time 68, horizon 5\n", + "adding: mem time64, current time 68, horizon 4\n", + "adding: mem time65, current time 68, horizon 3\n", + "adding: mem time66, current time 68, horizon 2\n", + "adding: mem time67, current time 68, horizon 1\n", + "adding: mem time0, current time 69, horizon 69\n", + "adding: mem time1, current time 69, horizon 68\n", + "adding: mem time2, current time 69, horizon 67\n", + "adding: mem time3, current time 69, horizon 66\n", + "adding: mem time4, current time 69, horizon 65\n", + "adding: mem time5, current time 69, horizon 64\n", + "adding: mem time6, current time 69, horizon 63\n", + "adding: mem time7, current time 69, horizon 62\n", + "adding: mem time8, current time 69, horizon 61\n", + "adding: mem time9, current time 69, horizon 60\n", + "adding: mem time10, current time 69, horizon 59\n", + "adding: mem time11, current time 69, horizon 58\n", + "adding: mem time12, current time 69, horizon 57\n", + "adding: mem time13, current time 69, horizon 56\n", + "adding: mem time14, current time 69, horizon 55\n", + "adding: mem time15, current time 69, horizon 54\n", + "adding: mem time16, current time 69, horizon 53\n", + "adding: mem time17, current time 69, horizon 52\n", + "adding: mem time18, current time 69, horizon 51\n", + "adding: mem time19, current time 69, horizon 50\n", + "adding: mem time20, current time 69, horizon 49\n", + "adding: mem time21, current time 69, horizon 48\n", + "adding: mem time22, current time 69, horizon 47\n", + "adding: mem time23, current time 69, horizon 46\n", + "adding: mem time24, current time 69, horizon 45\n", + "adding: mem time25, current time 69, horizon 44\n", + "adding: mem time26, current time 69, horizon 43\n", + "adding: mem time27, current time 69, horizon 42\n", + "adding: mem time28, current time 69, horizon 41\n", + "adding: mem time29, current time 69, horizon 40\n", + "adding: mem time30, current time 69, horizon 39\n", + "adding: mem time31, current time 69, horizon 38\n", + "adding: mem time32, current time 69, horizon 37\n", + "adding: mem time33, current time 69, horizon 36\n", + "adding: mem time34, current time 69, horizon 35\n", + "adding: mem time35, current time 69, horizon 34\n", + "adding: mem time36, current time 69, horizon 33\n", + "adding: mem time37, current time 69, horizon 32\n", + "adding: mem time38, current time 69, horizon 31\n", + "adding: mem time39, current time 69, horizon 30\n", + "adding: mem time40, current time 69, horizon 29\n", + "adding: mem time41, current time 69, horizon 28\n", + "adding: mem time42, current time 69, horizon 27\n", + "adding: mem time43, current time 69, horizon 26\n", + "adding: mem time44, current time 69, horizon 25\n", + "adding: mem time45, current time 69, horizon 24\n", + "adding: mem time46, current time 69, horizon 23\n", + "adding: mem time47, current time 69, horizon 22\n", + "adding: mem time48, current time 69, horizon 21\n", + "adding: mem time49, current time 69, horizon 20\n", + "adding: mem time50, current time 69, horizon 19\n", + "adding: mem time51, current time 69, horizon 18\n", + "adding: mem time52, current time 69, horizon 17\n", + "adding: mem time53, current time 69, horizon 16\n", + "adding: mem time54, current time 69, horizon 15\n", + "adding: mem time55, current time 69, horizon 14\n", + "adding: mem time56, current time 69, horizon 13\n", + "adding: mem time57, current time 69, horizon 12\n", + "adding: mem time58, current time 69, horizon 11\n", + "adding: mem time59, current time 69, horizon 10\n", + "adding: mem time60, current time 69, horizon 9\n", + "adding: mem time61, current time 69, horizon 8\n", + "adding: mem time62, current time 69, horizon 7\n", + "adding: mem time63, current time 69, horizon 6\n", + "adding: mem time64, current time 69, horizon 5\n", + "adding: mem time65, current time 69, horizon 4\n", + "adding: mem time66, current time 69, horizon 3\n", + "adding: mem time67, current time 69, horizon 2\n", + "adding: mem time68, current time 69, horizon 1\n", + "adding: mem time0, current time 70, horizon 70\n", + "adding: mem time1, current time 70, horizon 69\n", + "adding: mem time2, current time 70, horizon 68\n", + "adding: mem time3, current time 70, horizon 67\n", + "adding: mem time4, current time 70, horizon 66\n", + "adding: mem time5, current time 70, horizon 65\n", + "adding: mem time6, current time 70, horizon 64\n", + "adding: mem time7, current time 70, horizon 63\n", + "adding: mem time8, current time 70, horizon 62\n", + "adding: mem time9, current time 70, horizon 61\n", + "adding: mem time10, current time 70, horizon 60\n", + "adding: mem time11, current time 70, horizon 59\n", + "adding: mem time12, current time 70, horizon 58\n", + "adding: mem time13, current time 70, horizon 57\n", + "adding: mem time14, current time 70, horizon 56\n", + "adding: mem time15, current time 70, horizon 55\n", + "adding: mem time16, current time 70, horizon 54\n", + "adding: mem time17, current time 70, horizon 53\n", + "adding: mem time18, current time 70, horizon 52\n", + "adding: mem time19, current time 70, horizon 51\n", + "adding: mem time20, current time 70, horizon 50\n", + "adding: mem time21, current time 70, horizon 49\n", + "adding: mem time22, current time 70, horizon 48\n", + "adding: mem time23, current time 70, horizon 47\n", + "adding: mem time24, current time 70, horizon 46\n", + "adding: mem time25, current time 70, horizon 45\n", + "adding: mem time26, current time 70, horizon 44\n", + "adding: mem time27, current time 70, horizon 43\n", + "adding: mem time28, current time 70, horizon 42\n", + "adding: mem time29, current time 70, horizon 41\n", + "adding: mem time30, current time 70, horizon 40\n", + "adding: mem time31, current time 70, horizon 39\n", + "adding: mem time32, current time 70, horizon 38\n", + "adding: mem time33, current time 70, horizon 37\n", + "adding: mem time34, current time 70, horizon 36\n", + "adding: mem time35, current time 70, horizon 35\n", + "adding: mem time36, current time 70, horizon 34\n", + "adding: mem time37, current time 70, horizon 33\n", + "adding: mem time38, current time 70, horizon 32\n", + "adding: mem time39, current time 70, horizon 31\n", + "adding: mem time40, current time 70, horizon 30\n", + "adding: mem time41, current time 70, horizon 29\n", + "adding: mem time42, current time 70, horizon 28\n", + "adding: mem time43, current time 70, horizon 27\n", + "adding: mem time44, current time 70, horizon 26\n", + "adding: mem time45, current time 70, horizon 25\n", + "adding: mem time46, current time 70, horizon 24\n", + "adding: mem time47, current time 70, horizon 23\n", + "adding: mem time48, current time 70, horizon 22\n", + "adding: mem time49, current time 70, horizon 21\n", + "adding: mem time50, current time 70, horizon 20\n", + "adding: mem time51, current time 70, horizon 19\n", + "adding: mem time52, current time 70, horizon 18\n", + "adding: mem time53, current time 70, horizon 17\n", + "adding: mem time54, current time 70, horizon 16\n", + "adding: mem time55, current time 70, horizon 15\n", + "adding: mem time56, current time 70, horizon 14\n", + "adding: mem time57, current time 70, horizon 13\n", + "adding: mem time58, current time 70, horizon 12\n", + "adding: mem time59, current time 70, horizon 11\n", + "adding: mem time60, current time 70, horizon 10\n", + "adding: mem time61, current time 70, horizon 9\n", + "adding: mem time62, current time 70, horizon 8\n", + "adding: mem time63, current time 70, horizon 7\n", + "adding: mem time64, current time 70, horizon 6\n", + "adding: mem time65, current time 70, horizon 5\n", + "adding: mem time66, current time 70, horizon 4\n", + "adding: mem time67, current time 70, horizon 3\n", + "adding: mem time68, current time 70, horizon 2\n", + "adding: mem time69, current time 70, horizon 1\n", + "adding: mem time0, current time 71, horizon 71\n", + "adding: mem time1, current time 71, horizon 70\n", + "adding: mem time2, current time 71, horizon 69\n", + "adding: mem time3, current time 71, horizon 68\n", + "adding: mem time4, current time 71, horizon 67\n", + "adding: mem time5, current time 71, horizon 66\n", + "adding: mem time6, current time 71, horizon 65\n", + "adding: mem time7, current time 71, horizon 64\n", + "adding: mem time8, current time 71, horizon 63\n", + "adding: mem time9, current time 71, horizon 62\n", + "adding: mem time10, current time 71, horizon 61\n", + "adding: mem time11, current time 71, horizon 60\n", + "adding: mem time12, current time 71, horizon 59\n", + "adding: mem time13, current time 71, horizon 58\n", + "adding: mem time14, current time 71, horizon 57\n", + "adding: mem time15, current time 71, horizon 56\n", + "adding: mem time16, current time 71, horizon 55\n", + "adding: mem time17, current time 71, horizon 54\n", + "adding: mem time18, current time 71, horizon 53\n", + "adding: mem time19, current time 71, horizon 52\n", + "adding: mem time20, current time 71, horizon 51\n", + "adding: mem time21, current time 71, horizon 50\n", + "adding: mem time22, current time 71, horizon 49\n", + "adding: mem time23, current time 71, horizon 48\n", + "adding: mem time24, current time 71, horizon 47\n", + "adding: mem time25, current time 71, horizon 46\n", + "adding: mem time26, current time 71, horizon 45\n", + "adding: mem time27, current time 71, horizon 44\n", + "adding: mem time28, current time 71, horizon 43\n", + "adding: mem time29, current time 71, horizon 42\n", + "adding: mem time30, current time 71, horizon 41\n", + "adding: mem time31, current time 71, horizon 40\n", + "adding: mem time32, current time 71, horizon 39\n", + "adding: mem time33, current time 71, horizon 38\n", + "adding: mem time34, current time 71, horizon 37\n", + "adding: mem time35, current time 71, horizon 36\n", + "adding: mem time36, current time 71, horizon 35\n", + "adding: mem time37, current time 71, horizon 34\n", + "adding: mem time38, current time 71, horizon 33\n", + "adding: mem time39, current time 71, horizon 32\n", + "adding: mem time40, current time 71, horizon 31\n", + "adding: mem time41, current time 71, horizon 30\n", + "adding: mem time42, current time 71, horizon 29\n", + "adding: mem time43, current time 71, horizon 28\n", + "adding: mem time44, current time 71, horizon 27\n", + "adding: mem time45, current time 71, horizon 26\n", + "adding: mem time46, current time 71, horizon 25\n", + "adding: mem time47, current time 71, horizon 24\n", + "adding: mem time48, current time 71, horizon 23\n", + "adding: mem time49, current time 71, horizon 22\n", + "adding: mem time50, current time 71, horizon 21\n", + "adding: mem time51, current time 71, horizon 20\n", + "adding: mem time52, current time 71, horizon 19\n", + "adding: mem time53, current time 71, horizon 18\n", + "adding: mem time54, current time 71, horizon 17\n", + "adding: mem time55, current time 71, horizon 16\n", + "adding: mem time56, current time 71, horizon 15\n", + "adding: mem time57, current time 71, horizon 14\n", + "adding: mem time58, current time 71, horizon 13\n", + "adding: mem time59, current time 71, horizon 12\n", + "adding: mem time60, current time 71, horizon 11\n", + "adding: mem time61, current time 71, horizon 10\n", + "adding: mem time62, current time 71, horizon 9\n", + "adding: mem time63, current time 71, horizon 8\n", + "adding: mem time64, current time 71, horizon 7\n", + "adding: mem time65, current time 71, horizon 6\n", + "adding: mem time66, current time 71, horizon 5\n", + "adding: mem time67, current time 71, horizon 4\n", + "adding: mem time68, current time 71, horizon 3\n", + "adding: mem time69, current time 71, horizon 2\n", + "adding: mem time70, current time 71, horizon 1\n", + "adding: mem time0, current time 72, horizon 72\n", + "adding: mem time1, current time 72, horizon 71\n", + "adding: mem time2, current time 72, horizon 70\n", + "adding: mem time3, current time 72, horizon 69\n", + "adding: mem time4, current time 72, horizon 68\n", + "adding: mem time5, current time 72, horizon 67\n", + "adding: mem time6, current time 72, horizon 66\n", + "adding: mem time7, current time 72, horizon 65\n", + "adding: mem time8, current time 72, horizon 64\n", + "adding: mem time9, current time 72, horizon 63\n", + "adding: mem time10, current time 72, horizon 62\n", + "adding: mem time11, current time 72, horizon 61\n", + "adding: mem time12, current time 72, horizon 60\n", + "adding: mem time13, current time 72, horizon 59\n", + "adding: mem time14, current time 72, horizon 58\n", + "adding: mem time15, current time 72, horizon 57\n", + "adding: mem time16, current time 72, horizon 56\n", + "adding: mem time17, current time 72, horizon 55\n", + "adding: mem time18, current time 72, horizon 54\n", + "adding: mem time19, current time 72, horizon 53\n", + "adding: mem time20, current time 72, horizon 52\n", + "adding: mem time21, current time 72, horizon 51\n", + "adding: mem time22, current time 72, horizon 50\n", + "adding: mem time23, current time 72, horizon 49\n", + "adding: mem time24, current time 72, horizon 48\n", + "adding: mem time25, current time 72, horizon 47\n", + "adding: mem time26, current time 72, horizon 46\n", + "adding: mem time27, current time 72, horizon 45\n", + "adding: mem time28, current time 72, horizon 44\n", + "adding: mem time29, current time 72, horizon 43\n", + "adding: mem time30, current time 72, horizon 42\n", + "adding: mem time31, current time 72, horizon 41\n", + "adding: mem time32, current time 72, horizon 40\n", + "adding: mem time33, current time 72, horizon 39\n", + "adding: mem time34, current time 72, horizon 38\n", + "adding: mem time35, current time 72, horizon 37\n", + "adding: mem time36, current time 72, horizon 36\n", + "adding: mem time37, current time 72, horizon 35\n", + "adding: mem time38, current time 72, horizon 34\n", + "adding: mem time39, current time 72, horizon 33\n", + "adding: mem time40, current time 72, horizon 32\n", + "adding: mem time41, current time 72, horizon 31\n", + "adding: mem time42, current time 72, horizon 30\n", + "adding: mem time43, current time 72, horizon 29\n", + "adding: mem time44, current time 72, horizon 28\n", + "adding: mem time45, current time 72, horizon 27\n", + "adding: mem time46, current time 72, horizon 26\n", + "adding: mem time47, current time 72, horizon 25\n", + "adding: mem time48, current time 72, horizon 24\n", + "adding: mem time49, current time 72, horizon 23\n", + "adding: mem time50, current time 72, horizon 22\n", + "adding: mem time51, current time 72, horizon 21\n", + "adding: mem time52, current time 72, horizon 20\n", + "adding: mem time53, current time 72, horizon 19\n", + "adding: mem time54, current time 72, horizon 18\n", + "adding: mem time55, current time 72, horizon 17\n", + "adding: mem time56, current time 72, horizon 16\n", + "adding: mem time57, current time 72, horizon 15\n", + "adding: mem time58, current time 72, horizon 14\n", + "adding: mem time59, current time 72, horizon 13\n", + "adding: mem time60, current time 72, horizon 12\n", + "adding: mem time61, current time 72, horizon 11\n", + "adding: mem time62, current time 72, horizon 10\n", + "adding: mem time63, current time 72, horizon 9\n", + "adding: mem time64, current time 72, horizon 8\n", + "adding: mem time65, current time 72, horizon 7\n", + "adding: mem time66, current time 72, horizon 6\n", + "adding: mem time67, current time 72, horizon 5\n", + "adding: mem time68, current time 72, horizon 4\n", + "adding: mem time69, current time 72, horizon 3\n", + "adding: mem time70, current time 72, horizon 2\n", + "adding: mem time71, current time 72, horizon 1\n", + "adding: mem time0, current time 73, horizon 73\n", + "adding: mem time1, current time 73, horizon 72\n", + "adding: mem time2, current time 73, horizon 71\n", + "adding: mem time3, current time 73, horizon 70\n", + "adding: mem time4, current time 73, horizon 69\n", + "adding: mem time5, current time 73, horizon 68\n", + "adding: mem time6, current time 73, horizon 67\n", + "adding: mem time7, current time 73, horizon 66\n", + "adding: mem time8, current time 73, horizon 65\n", + "adding: mem time9, current time 73, horizon 64\n", + "adding: mem time10, current time 73, horizon 63\n", + "adding: mem time11, current time 73, horizon 62\n", + "adding: mem time12, current time 73, horizon 61\n", + "adding: mem time13, current time 73, horizon 60\n", + "adding: mem time14, current time 73, horizon 59\n", + "adding: mem time15, current time 73, horizon 58\n", + "adding: mem time16, current time 73, horizon 57\n", + "adding: mem time17, current time 73, horizon 56\n", + "adding: mem time18, current time 73, horizon 55\n", + "adding: mem time19, current time 73, horizon 54\n", + "adding: mem time20, current time 73, horizon 53\n", + "adding: mem time21, current time 73, horizon 52\n", + "adding: mem time22, current time 73, horizon 51\n", + "adding: mem time23, current time 73, horizon 50\n", + "adding: mem time24, current time 73, horizon 49\n", + "adding: mem time25, current time 73, horizon 48\n", + "adding: mem time26, current time 73, horizon 47\n", + "adding: mem time27, current time 73, horizon 46\n", + "adding: mem time28, current time 73, horizon 45\n", + "adding: mem time29, current time 73, horizon 44\n", + "adding: mem time30, current time 73, horizon 43\n", + "adding: mem time31, current time 73, horizon 42\n", + "adding: mem time32, current time 73, horizon 41\n", + "adding: mem time33, current time 73, horizon 40\n", + "adding: mem time34, current time 73, horizon 39\n", + "adding: mem time35, current time 73, horizon 38\n", + "adding: mem time36, current time 73, horizon 37\n", + "adding: mem time37, current time 73, horizon 36\n", + "adding: mem time38, current time 73, horizon 35\n", + "adding: mem time39, current time 73, horizon 34\n", + "adding: mem time40, current time 73, horizon 33\n", + "adding: mem time41, current time 73, horizon 32\n", + "adding: mem time42, current time 73, horizon 31\n", + "adding: mem time43, current time 73, horizon 30\n", + "adding: mem time44, current time 73, horizon 29\n", + "adding: mem time45, current time 73, horizon 28\n", + "adding: mem time46, current time 73, horizon 27\n", + "adding: mem time47, current time 73, horizon 26\n", + "adding: mem time48, current time 73, horizon 25\n", + "adding: mem time49, current time 73, horizon 24\n", + "adding: mem time50, current time 73, horizon 23\n", + "adding: mem time51, current time 73, horizon 22\n", + "adding: mem time52, current time 73, horizon 21\n", + "adding: mem time53, current time 73, horizon 20\n", + "adding: mem time54, current time 73, horizon 19\n", + "adding: mem time55, current time 73, horizon 18\n", + "adding: mem time56, current time 73, horizon 17\n", + "adding: mem time57, current time 73, horizon 16\n", + "adding: mem time58, current time 73, horizon 15\n", + "adding: mem time59, current time 73, horizon 14\n", + "adding: mem time60, current time 73, horizon 13\n", + "adding: mem time61, current time 73, horizon 12\n", + "adding: mem time62, current time 73, horizon 11\n", + "adding: mem time63, current time 73, horizon 10\n", + "adding: mem time64, current time 73, horizon 9\n", + "adding: mem time65, current time 73, horizon 8\n", + "adding: mem time66, current time 73, horizon 7\n", + "adding: mem time67, current time 73, horizon 6\n", + "adding: mem time68, current time 73, horizon 5\n", + "adding: mem time69, current time 73, horizon 4\n", + "adding: mem time70, current time 73, horizon 3\n", + "adding: mem time71, current time 73, horizon 2\n", + "adding: mem time72, current time 73, horizon 1\n", + "adding: mem time0, current time 74, horizon 74\n", + "adding: mem time1, current time 74, horizon 73\n", + "adding: mem time2, current time 74, horizon 72\n", + "adding: mem time3, current time 74, horizon 71\n", + "adding: mem time4, current time 74, horizon 70\n", + "adding: mem time5, current time 74, horizon 69\n", + "adding: mem time6, current time 74, horizon 68\n", + "adding: mem time7, current time 74, horizon 67\n", + "adding: mem time8, current time 74, horizon 66\n", + "adding: mem time9, current time 74, horizon 65\n", + "adding: mem time10, current time 74, horizon 64\n", + "adding: mem time11, current time 74, horizon 63\n", + "adding: mem time12, current time 74, horizon 62\n", + "adding: mem time13, current time 74, horizon 61\n", + "adding: mem time14, current time 74, horizon 60\n", + "adding: mem time15, current time 74, horizon 59\n", + "adding: mem time16, current time 74, horizon 58\n", + "adding: mem time17, current time 74, horizon 57\n", + "adding: mem time18, current time 74, horizon 56\n", + "adding: mem time19, current time 74, horizon 55\n", + "adding: mem time20, current time 74, horizon 54\n", + "adding: mem time21, current time 74, horizon 53\n", + "adding: mem time22, current time 74, horizon 52\n", + "adding: mem time23, current time 74, horizon 51\n", + "adding: mem time24, current time 74, horizon 50\n", + "adding: mem time25, current time 74, horizon 49\n", + "adding: mem time26, current time 74, horizon 48\n", + "adding: mem time27, current time 74, horizon 47\n", + "adding: mem time28, current time 74, horizon 46\n", + "adding: mem time29, current time 74, horizon 45\n", + "adding: mem time30, current time 74, horizon 44\n", + "adding: mem time31, current time 74, horizon 43\n", + "adding: mem time32, current time 74, horizon 42\n", + "adding: mem time33, current time 74, horizon 41\n", + "adding: mem time34, current time 74, horizon 40\n", + "adding: mem time35, current time 74, horizon 39\n", + "adding: mem time36, current time 74, horizon 38\n", + "adding: mem time37, current time 74, horizon 37\n", + "adding: mem time38, current time 74, horizon 36\n", + "adding: mem time39, current time 74, horizon 35\n", + "adding: mem time40, current time 74, horizon 34\n", + "adding: mem time41, current time 74, horizon 33\n", + "adding: mem time42, current time 74, horizon 32\n", + "adding: mem time43, current time 74, horizon 31\n", + "adding: mem time44, current time 74, horizon 30\n", + "adding: mem time45, current time 74, horizon 29\n", + "adding: mem time46, current time 74, horizon 28\n", + "adding: mem time47, current time 74, horizon 27\n", + "adding: mem time48, current time 74, horizon 26\n", + "adding: mem time49, current time 74, horizon 25\n", + "adding: mem time50, current time 74, horizon 24\n", + "adding: mem time51, current time 74, horizon 23\n", + "adding: mem time52, current time 74, horizon 22\n", + "adding: mem time53, current time 74, horizon 21\n", + "adding: mem time54, current time 74, horizon 20\n", + "adding: mem time55, current time 74, horizon 19\n", + "adding: mem time56, current time 74, horizon 18\n", + "adding: mem time57, current time 74, horizon 17\n", + "adding: mem time58, current time 74, horizon 16\n", + "adding: mem time59, current time 74, horizon 15\n", + "adding: mem time60, current time 74, horizon 14\n", + "adding: mem time61, current time 74, horizon 13\n", + "adding: mem time62, current time 74, horizon 12\n", + "adding: mem time63, current time 74, horizon 11\n", + "adding: mem time64, current time 74, horizon 10\n", + "adding: mem time65, current time 74, horizon 9\n", + "adding: mem time66, current time 74, horizon 8\n", + "adding: mem time67, current time 74, horizon 7\n", + "adding: mem time68, current time 74, horizon 6\n", + "adding: mem time69, current time 74, horizon 5\n", + "adding: mem time70, current time 74, horizon 4\n", + "adding: mem time71, current time 74, horizon 3\n", + "adding: mem time72, current time 74, horizon 2\n", + "adding: mem time73, current time 74, horizon 1\n", + "adding: mem time0, current time 75, horizon 75\n", + "adding: mem time1, current time 75, horizon 74\n", + "adding: mem time2, current time 75, horizon 73\n", + "adding: mem time3, current time 75, horizon 72\n", + "adding: mem time4, current time 75, horizon 71\n", + "adding: mem time5, current time 75, horizon 70\n", + "adding: mem time6, current time 75, horizon 69\n", + "adding: mem time7, current time 75, horizon 68\n", + "adding: mem time8, current time 75, horizon 67\n", + "adding: mem time9, current time 75, horizon 66\n", + "adding: mem time10, current time 75, horizon 65\n", + "adding: mem time11, current time 75, horizon 64\n", + "adding: mem time12, current time 75, horizon 63\n", + "adding: mem time13, current time 75, horizon 62\n", + "adding: mem time14, current time 75, horizon 61\n", + "adding: mem time15, current time 75, horizon 60\n", + "adding: mem time16, current time 75, horizon 59\n", + "adding: mem time17, current time 75, horizon 58\n", + "adding: mem time18, current time 75, horizon 57\n", + "adding: mem time19, current time 75, horizon 56\n", + "adding: mem time20, current time 75, horizon 55\n", + "adding: mem time21, current time 75, horizon 54\n", + "adding: mem time22, current time 75, horizon 53\n", + "adding: mem time23, current time 75, horizon 52\n", + "adding: mem time24, current time 75, horizon 51\n", + "adding: mem time25, current time 75, horizon 50\n", + "adding: mem time26, current time 75, horizon 49\n", + "adding: mem time27, current time 75, horizon 48\n", + "adding: mem time28, current time 75, horizon 47\n", + "adding: mem time29, current time 75, horizon 46\n", + "adding: mem time30, current time 75, horizon 45\n", + "adding: mem time31, current time 75, horizon 44\n", + "adding: mem time32, current time 75, horizon 43\n", + "adding: mem time33, current time 75, horizon 42\n", + "adding: mem time34, current time 75, horizon 41\n", + "adding: mem time35, current time 75, horizon 40\n", + "adding: mem time36, current time 75, horizon 39\n", + "adding: mem time37, current time 75, horizon 38\n", + "adding: mem time38, current time 75, horizon 37\n", + "adding: mem time39, current time 75, horizon 36\n", + "adding: mem time40, current time 75, horizon 35\n", + "adding: mem time41, current time 75, horizon 34\n", + "adding: mem time42, current time 75, horizon 33\n", + "adding: mem time43, current time 75, horizon 32\n", + "adding: mem time44, current time 75, horizon 31\n", + "adding: mem time45, current time 75, horizon 30\n", + "adding: mem time46, current time 75, horizon 29\n", + "adding: mem time47, current time 75, horizon 28\n", + "adding: mem time48, current time 75, horizon 27\n", + "adding: mem time49, current time 75, horizon 26\n", + "adding: mem time50, current time 75, horizon 25\n", + "adding: mem time51, current time 75, horizon 24\n", + "adding: mem time52, current time 75, horizon 23\n", + "adding: mem time53, current time 75, horizon 22\n", + "adding: mem time54, current time 75, horizon 21\n", + "adding: mem time55, current time 75, horizon 20\n", + "adding: mem time56, current time 75, horizon 19\n", + "adding: mem time57, current time 75, horizon 18\n", + "adding: mem time58, current time 75, horizon 17\n", + "adding: mem time59, current time 75, horizon 16\n", + "adding: mem time60, current time 75, horizon 15\n", + "adding: mem time61, current time 75, horizon 14\n", + "adding: mem time62, current time 75, horizon 13\n", + "adding: mem time63, current time 75, horizon 12\n", + "adding: mem time64, current time 75, horizon 11\n", + "adding: mem time65, current time 75, horizon 10\n", + "adding: mem time66, current time 75, horizon 9\n", + "adding: mem time67, current time 75, horizon 8\n", + "adding: mem time68, current time 75, horizon 7\n", + "adding: mem time69, current time 75, horizon 6\n", + "adding: mem time70, current time 75, horizon 5\n", + "adding: mem time71, current time 75, horizon 4\n", + "adding: mem time72, current time 75, horizon 3\n", + "adding: mem time73, current time 75, horizon 2\n", + "adding: mem time74, current time 75, horizon 1\n", + "adding: mem time0, current time 76, horizon 76\n", + "adding: mem time1, current time 76, horizon 75\n", + "adding: mem time2, current time 76, horizon 74\n", + "adding: mem time3, current time 76, horizon 73\n", + "adding: mem time4, current time 76, horizon 72\n", + "adding: mem time5, current time 76, horizon 71\n", + "adding: mem time6, current time 76, horizon 70\n", + "adding: mem time7, current time 76, horizon 69\n", + "adding: mem time8, current time 76, horizon 68\n", + "adding: mem time9, current time 76, horizon 67\n", + "adding: mem time10, current time 76, horizon 66\n", + "adding: mem time11, current time 76, horizon 65\n", + "adding: mem time12, current time 76, horizon 64\n", + "adding: mem time13, current time 76, horizon 63\n", + "adding: mem time14, current time 76, horizon 62\n", + "adding: mem time15, current time 76, horizon 61\n", + "adding: mem time16, current time 76, horizon 60\n", + "adding: mem time17, current time 76, horizon 59\n", + "adding: mem time18, current time 76, horizon 58\n", + "adding: mem time19, current time 76, horizon 57\n", + "adding: mem time20, current time 76, horizon 56\n", + "adding: mem time21, current time 76, horizon 55\n", + "adding: mem time22, current time 76, horizon 54\n", + "adding: mem time23, current time 76, horizon 53\n", + "adding: mem time24, current time 76, horizon 52\n", + "adding: mem time25, current time 76, horizon 51\n", + "adding: mem time26, current time 76, horizon 50\n", + "adding: mem time27, current time 76, horizon 49\n", + "adding: mem time28, current time 76, horizon 48\n", + "adding: mem time29, current time 76, horizon 47\n", + "adding: mem time30, current time 76, horizon 46\n", + "adding: mem time31, current time 76, horizon 45\n", + "adding: mem time32, current time 76, horizon 44\n", + "adding: mem time33, current time 76, horizon 43\n", + "adding: mem time34, current time 76, horizon 42\n", + "adding: mem time35, current time 76, horizon 41\n", + "adding: mem time36, current time 76, horizon 40\n", + "adding: mem time37, current time 76, horizon 39\n", + "adding: mem time38, current time 76, horizon 38\n", + "adding: mem time39, current time 76, horizon 37\n", + "adding: mem time40, current time 76, horizon 36\n", + "adding: mem time41, current time 76, horizon 35\n", + "adding: mem time42, current time 76, horizon 34\n", + "adding: mem time43, current time 76, horizon 33\n", + "adding: mem time44, current time 76, horizon 32\n", + "adding: mem time45, current time 76, horizon 31\n", + "adding: mem time46, current time 76, horizon 30\n", + "adding: mem time47, current time 76, horizon 29\n", + "adding: mem time48, current time 76, horizon 28\n", + "adding: mem time49, current time 76, horizon 27\n", + "adding: mem time50, current time 76, horizon 26\n", + "adding: mem time51, current time 76, horizon 25\n", + "adding: mem time52, current time 76, horizon 24\n", + "adding: mem time53, current time 76, horizon 23\n", + "adding: mem time54, current time 76, horizon 22\n", + "adding: mem time55, current time 76, horizon 21\n", + "adding: mem time56, current time 76, horizon 20\n", + "adding: mem time57, current time 76, horizon 19\n", + "adding: mem time58, current time 76, horizon 18\n", + "adding: mem time59, current time 76, horizon 17\n", + "adding: mem time60, current time 76, horizon 16\n", + "adding: mem time61, current time 76, horizon 15\n", + "adding: mem time62, current time 76, horizon 14\n", + "adding: mem time63, current time 76, horizon 13\n", + "adding: mem time64, current time 76, horizon 12\n", + "adding: mem time65, current time 76, horizon 11\n", + "adding: mem time66, current time 76, horizon 10\n", + "adding: mem time67, current time 76, horizon 9\n", + "adding: mem time68, current time 76, horizon 8\n", + "adding: mem time69, current time 76, horizon 7\n", + "adding: mem time70, current time 76, horizon 6\n", + "adding: mem time71, current time 76, horizon 5\n", + "adding: mem time72, current time 76, horizon 4\n", + "adding: mem time73, current time 76, horizon 3\n", + "adding: mem time74, current time 76, horizon 2\n", + "adding: mem time75, current time 76, horizon 1\n", + "adding: mem time0, current time 77, horizon 77\n", + "adding: mem time1, current time 77, horizon 76\n", + "adding: mem time2, current time 77, horizon 75\n", + "adding: mem time3, current time 77, horizon 74\n", + "adding: mem time4, current time 77, horizon 73\n", + "adding: mem time5, current time 77, horizon 72\n", + "adding: mem time6, current time 77, horizon 71\n", + "adding: mem time7, current time 77, horizon 70\n", + "adding: mem time8, current time 77, horizon 69\n", + "adding: mem time9, current time 77, horizon 68\n", + "adding: mem time10, current time 77, horizon 67\n", + "adding: mem time11, current time 77, horizon 66\n", + "adding: mem time12, current time 77, horizon 65\n", + "adding: mem time13, current time 77, horizon 64\n", + "adding: mem time14, current time 77, horizon 63\n", + "adding: mem time15, current time 77, horizon 62\n", + "adding: mem time16, current time 77, horizon 61\n", + "adding: mem time17, current time 77, horizon 60\n", + "adding: mem time18, current time 77, horizon 59\n", + "adding: mem time19, current time 77, horizon 58\n", + "adding: mem time20, current time 77, horizon 57\n", + "adding: mem time21, current time 77, horizon 56\n", + "adding: mem time22, current time 77, horizon 55\n", + "adding: mem time23, current time 77, horizon 54\n", + "adding: mem time24, current time 77, horizon 53\n", + "adding: mem time25, current time 77, horizon 52\n", + "adding: mem time26, current time 77, horizon 51\n", + "adding: mem time27, current time 77, horizon 50\n", + "adding: mem time28, current time 77, horizon 49\n", + "adding: mem time29, current time 77, horizon 48\n", + "adding: mem time30, current time 77, horizon 47\n", + "adding: mem time31, current time 77, horizon 46\n", + "adding: mem time32, current time 77, horizon 45\n", + "adding: mem time33, current time 77, horizon 44\n", + "adding: mem time34, current time 77, horizon 43\n", + "adding: mem time35, current time 77, horizon 42\n", + "adding: mem time36, current time 77, horizon 41\n", + "adding: mem time37, current time 77, horizon 40\n", + "adding: mem time38, current time 77, horizon 39\n", + "adding: mem time39, current time 77, horizon 38\n", + "adding: mem time40, current time 77, horizon 37\n", + "adding: mem time41, current time 77, horizon 36\n", + "adding: mem time42, current time 77, horizon 35\n", + "adding: mem time43, current time 77, horizon 34\n", + "adding: mem time44, current time 77, horizon 33\n", + "adding: mem time45, current time 77, horizon 32\n", + "adding: mem time46, current time 77, horizon 31\n", + "adding: mem time47, current time 77, horizon 30\n", + "adding: mem time48, current time 77, horizon 29\n", + "adding: mem time49, current time 77, horizon 28\n", + "adding: mem time50, current time 77, horizon 27\n", + "adding: mem time51, current time 77, horizon 26\n", + "adding: mem time52, current time 77, horizon 25\n", + "adding: mem time53, current time 77, horizon 24\n", + "adding: mem time54, current time 77, horizon 23\n", + "adding: mem time55, current time 77, horizon 22\n", + "adding: mem time56, current time 77, horizon 21\n", + "adding: mem time57, current time 77, horizon 20\n", + "adding: mem time58, current time 77, horizon 19\n", + "adding: mem time59, current time 77, horizon 18\n", + "adding: mem time60, current time 77, horizon 17\n", + "adding: mem time61, current time 77, horizon 16\n", + "adding: mem time62, current time 77, horizon 15\n", + "adding: mem time63, current time 77, horizon 14\n", + "adding: mem time64, current time 77, horizon 13\n", + "adding: mem time65, current time 77, horizon 12\n", + "adding: mem time66, current time 77, horizon 11\n", + "adding: mem time67, current time 77, horizon 10\n", + "adding: mem time68, current time 77, horizon 9\n", + "adding: mem time69, current time 77, horizon 8\n", + "adding: mem time70, current time 77, horizon 7\n", + "adding: mem time71, current time 77, horizon 6\n", + "adding: mem time72, current time 77, horizon 5\n", + "adding: mem time73, current time 77, horizon 4\n", + "adding: mem time74, current time 77, horizon 3\n", + "adding: mem time75, current time 77, horizon 2\n", + "adding: mem time76, current time 77, horizon 1\n", + "adding: mem time0, current time 78, horizon 78\n", + "adding: mem time1, current time 78, horizon 77\n", + "adding: mem time2, current time 78, horizon 76\n", + "adding: mem time3, current time 78, horizon 75\n", + "adding: mem time4, current time 78, horizon 74\n", + "adding: mem time5, current time 78, horizon 73\n", + "adding: mem time6, current time 78, horizon 72\n", + "adding: mem time7, current time 78, horizon 71\n", + "adding: mem time8, current time 78, horizon 70\n", + "adding: mem time9, current time 78, horizon 69\n", + "adding: mem time10, current time 78, horizon 68\n", + "adding: mem time11, current time 78, horizon 67\n", + "adding: mem time12, current time 78, horizon 66\n", + "adding: mem time13, current time 78, horizon 65\n", + "adding: mem time14, current time 78, horizon 64\n", + "adding: mem time15, current time 78, horizon 63\n", + "adding: mem time16, current time 78, horizon 62\n", + "adding: mem time17, current time 78, horizon 61\n", + "adding: mem time18, current time 78, horizon 60\n", + "adding: mem time19, current time 78, horizon 59\n", + "adding: mem time20, current time 78, horizon 58\n", + "adding: mem time21, current time 78, horizon 57\n", + "adding: mem time22, current time 78, horizon 56\n", + "adding: mem time23, current time 78, horizon 55\n", + "adding: mem time24, current time 78, horizon 54\n", + "adding: mem time25, current time 78, horizon 53\n", + "adding: mem time26, current time 78, horizon 52\n", + "adding: mem time27, current time 78, horizon 51\n", + "adding: mem time28, current time 78, horizon 50\n", + "adding: mem time29, current time 78, horizon 49\n", + "adding: mem time30, current time 78, horizon 48\n", + "adding: mem time31, current time 78, horizon 47\n", + "adding: mem time32, current time 78, horizon 46\n", + "adding: mem time33, current time 78, horizon 45\n", + "adding: mem time34, current time 78, horizon 44\n", + "adding: mem time35, current time 78, horizon 43\n", + "adding: mem time36, current time 78, horizon 42\n", + "adding: mem time37, current time 78, horizon 41\n", + "adding: mem time38, current time 78, horizon 40\n", + "adding: mem time39, current time 78, horizon 39\n", + "adding: mem time40, current time 78, horizon 38\n", + "adding: mem time41, current time 78, horizon 37\n", + "adding: mem time42, current time 78, horizon 36\n", + "adding: mem time43, current time 78, horizon 35\n", + "adding: mem time44, current time 78, horizon 34\n", + "adding: mem time45, current time 78, horizon 33\n", + "adding: mem time46, current time 78, horizon 32\n", + "adding: mem time47, current time 78, horizon 31\n", + "adding: mem time48, current time 78, horizon 30\n", + "adding: mem time49, current time 78, horizon 29\n", + "adding: mem time50, current time 78, horizon 28\n", + "adding: mem time51, current time 78, horizon 27\n", + "adding: mem time52, current time 78, horizon 26\n", + "adding: mem time53, current time 78, horizon 25\n", + "adding: mem time54, current time 78, horizon 24\n", + "adding: mem time55, current time 78, horizon 23\n", + "adding: mem time56, current time 78, horizon 22\n", + "adding: mem time57, current time 78, horizon 21\n", + "adding: mem time58, current time 78, horizon 20\n", + "adding: mem time59, current time 78, horizon 19\n", + "adding: mem time60, current time 78, horizon 18\n", + "adding: mem time61, current time 78, horizon 17\n", + "adding: mem time62, current time 78, horizon 16\n", + "adding: mem time63, current time 78, horizon 15\n", + "adding: mem time64, current time 78, horizon 14\n", + "adding: mem time65, current time 78, horizon 13\n", + "adding: mem time66, current time 78, horizon 12\n", + "adding: mem time67, current time 78, horizon 11\n", + "adding: mem time68, current time 78, horizon 10\n", + "adding: mem time69, current time 78, horizon 9\n", + "adding: mem time70, current time 78, horizon 8\n", + "adding: mem time71, current time 78, horizon 7\n", + "adding: mem time72, current time 78, horizon 6\n", + "adding: mem time73, current time 78, horizon 5\n", + "adding: mem time74, current time 78, horizon 4\n", + "adding: mem time75, current time 78, horizon 3\n", + "adding: mem time76, current time 78, horizon 2\n", + "adding: mem time77, current time 78, horizon 1\n", + "adding: mem time0, current time 79, horizon 79\n", + "adding: mem time1, current time 79, horizon 78\n", + "adding: mem time2, current time 79, horizon 77\n", + "adding: mem time3, current time 79, horizon 76\n", + "adding: mem time4, current time 79, horizon 75\n", + "adding: mem time5, current time 79, horizon 74\n", + "adding: mem time6, current time 79, horizon 73\n", + "adding: mem time7, current time 79, horizon 72\n", + "adding: mem time8, current time 79, horizon 71\n", + "adding: mem time9, current time 79, horizon 70\n", + "adding: mem time10, current time 79, horizon 69\n", + "adding: mem time11, current time 79, horizon 68\n", + "adding: mem time12, current time 79, horizon 67\n", + "adding: mem time13, current time 79, horizon 66\n", + "adding: mem time14, current time 79, horizon 65\n", + "adding: mem time15, current time 79, horizon 64\n", + "adding: mem time16, current time 79, horizon 63\n", + "adding: mem time17, current time 79, horizon 62\n", + "adding: mem time18, current time 79, horizon 61\n", + "adding: mem time19, current time 79, horizon 60\n", + "adding: mem time20, current time 79, horizon 59\n", + "adding: mem time21, current time 79, horizon 58\n", + "adding: mem time22, current time 79, horizon 57\n", + "adding: mem time23, current time 79, horizon 56\n", + "adding: mem time24, current time 79, horizon 55\n", + "adding: mem time25, current time 79, horizon 54\n", + "adding: mem time26, current time 79, horizon 53\n", + "adding: mem time27, current time 79, horizon 52\n", + "adding: mem time28, current time 79, horizon 51\n", + "adding: mem time29, current time 79, horizon 50\n", + "adding: mem time30, current time 79, horizon 49\n", + "adding: mem time31, current time 79, horizon 48\n", + "adding: mem time32, current time 79, horizon 47\n", + "adding: mem time33, current time 79, horizon 46\n", + "adding: mem time34, current time 79, horizon 45\n", + "adding: mem time35, current time 79, horizon 44\n", + "adding: mem time36, current time 79, horizon 43\n", + "adding: mem time37, current time 79, horizon 42\n", + "adding: mem time38, current time 79, horizon 41\n", + "adding: mem time39, current time 79, horizon 40\n", + "adding: mem time40, current time 79, horizon 39\n", + "adding: mem time41, current time 79, horizon 38\n", + "adding: mem time42, current time 79, horizon 37\n", + "adding: mem time43, current time 79, horizon 36\n", + "adding: mem time44, current time 79, horizon 35\n", + "adding: mem time45, current time 79, horizon 34\n", + "adding: mem time46, current time 79, horizon 33\n", + "adding: mem time47, current time 79, horizon 32\n", + "adding: mem time48, current time 79, horizon 31\n", + "adding: mem time49, current time 79, horizon 30\n", + "adding: mem time50, current time 79, horizon 29\n", + "adding: mem time51, current time 79, horizon 28\n", + "adding: mem time52, current time 79, horizon 27\n", + "adding: mem time53, current time 79, horizon 26\n", + "adding: mem time54, current time 79, horizon 25\n", + "adding: mem time55, current time 79, horizon 24\n", + "adding: mem time56, current time 79, horizon 23\n", + "adding: mem time57, current time 79, horizon 22\n", + "adding: mem time58, current time 79, horizon 21\n", + "adding: mem time59, current time 79, horizon 20\n", + "adding: mem time60, current time 79, horizon 19\n", + "adding: mem time61, current time 79, horizon 18\n", + "adding: mem time62, current time 79, horizon 17\n", + "adding: mem time63, current time 79, horizon 16\n", + "adding: mem time64, current time 79, horizon 15\n", + "adding: mem time65, current time 79, horizon 14\n", + "adding: mem time66, current time 79, horizon 13\n", + "adding: mem time67, current time 79, horizon 12\n", + "adding: mem time68, current time 79, horizon 11\n", + "adding: mem time69, current time 79, horizon 10\n", + "adding: mem time70, current time 79, horizon 9\n", + "adding: mem time71, current time 79, horizon 8\n", + "adding: mem time72, current time 79, horizon 7\n", + "adding: mem time73, current time 79, horizon 6\n", + "adding: mem time74, current time 79, horizon 5\n", + "adding: mem time75, current time 79, horizon 4\n", + "adding: mem time76, current time 79, horizon 3\n", + "adding: mem time77, current time 79, horizon 2\n", + "adding: mem time78, current time 79, horizon 1\n", + "adding: mem time0, current time 80, horizon 80\n", + "adding: mem time1, current time 80, horizon 79\n", + "adding: mem time2, current time 80, horizon 78\n", + "adding: mem time3, current time 80, horizon 77\n", + "adding: mem time4, current time 80, horizon 76\n", + "adding: mem time5, current time 80, horizon 75\n", + "adding: mem time6, current time 80, horizon 74\n", + "adding: mem time7, current time 80, horizon 73\n", + "adding: mem time8, current time 80, horizon 72\n", + "adding: mem time9, current time 80, horizon 71\n", + "adding: mem time10, current time 80, horizon 70\n", + "adding: mem time11, current time 80, horizon 69\n", + "adding: mem time12, current time 80, horizon 68\n", + "adding: mem time13, current time 80, horizon 67\n", + "adding: mem time14, current time 80, horizon 66\n", + "adding: mem time15, current time 80, horizon 65\n", + "adding: mem time16, current time 80, horizon 64\n", + "adding: mem time17, current time 80, horizon 63\n", + "adding: mem time18, current time 80, horizon 62\n", + "adding: mem time19, current time 80, horizon 61\n", + "adding: mem time20, current time 80, horizon 60\n", + "adding: mem time21, current time 80, horizon 59\n", + "adding: mem time22, current time 80, horizon 58\n", + "adding: mem time23, current time 80, horizon 57\n", + "adding: mem time24, current time 80, horizon 56\n", + "adding: mem time25, current time 80, horizon 55\n", + "adding: mem time26, current time 80, horizon 54\n", + "adding: mem time27, current time 80, horizon 53\n", + "adding: mem time28, current time 80, horizon 52\n", + "adding: mem time29, current time 80, horizon 51\n", + "adding: mem time30, current time 80, horizon 50\n", + "adding: mem time31, current time 80, horizon 49\n", + "adding: mem time32, current time 80, horizon 48\n", + "adding: mem time33, current time 80, horizon 47\n", + "adding: mem time34, current time 80, horizon 46\n", + "adding: mem time35, current time 80, horizon 45\n", + "adding: mem time36, current time 80, horizon 44\n", + "adding: mem time37, current time 80, horizon 43\n", + "adding: mem time38, current time 80, horizon 42\n", + "adding: mem time39, current time 80, horizon 41\n", + "adding: mem time40, current time 80, horizon 40\n", + "adding: mem time41, current time 80, horizon 39\n", + "adding: mem time42, current time 80, horizon 38\n", + "adding: mem time43, current time 80, horizon 37\n", + "adding: mem time44, current time 80, horizon 36\n", + "adding: mem time45, current time 80, horizon 35\n", + "adding: mem time46, current time 80, horizon 34\n", + "adding: mem time47, current time 80, horizon 33\n", + "adding: mem time48, current time 80, horizon 32\n", + "adding: mem time49, current time 80, horizon 31\n", + "adding: mem time50, current time 80, horizon 30\n", + "adding: mem time51, current time 80, horizon 29\n", + "adding: mem time52, current time 80, horizon 28\n", + "adding: mem time53, current time 80, horizon 27\n", + "adding: mem time54, current time 80, horizon 26\n", + "adding: mem time55, current time 80, horizon 25\n", + "adding: mem time56, current time 80, horizon 24\n", + "adding: mem time57, current time 80, horizon 23\n", + "adding: mem time58, current time 80, horizon 22\n", + "adding: mem time59, current time 80, horizon 21\n", + "adding: mem time60, current time 80, horizon 20\n", + "adding: mem time61, current time 80, horizon 19\n", + "adding: mem time62, current time 80, horizon 18\n", + "adding: mem time63, current time 80, horizon 17\n", + "adding: mem time64, current time 80, horizon 16\n", + "adding: mem time65, current time 80, horizon 15\n", + "adding: mem time66, current time 80, horizon 14\n", + "adding: mem time67, current time 80, horizon 13\n", + "adding: mem time68, current time 80, horizon 12\n", + "adding: mem time69, current time 80, horizon 11\n", + "adding: mem time70, current time 80, horizon 10\n", + "adding: mem time71, current time 80, horizon 9\n", + "adding: mem time72, current time 80, horizon 8\n", + "adding: mem time73, current time 80, horizon 7\n", + "adding: mem time74, current time 80, horizon 6\n", + "adding: mem time75, current time 80, horizon 5\n", + "adding: mem time76, current time 80, horizon 4\n", + "adding: mem time77, current time 80, horizon 3\n", + "adding: mem time78, current time 80, horizon 2\n", + "adding: mem time79, current time 80, horizon 1\n", + "adding: mem time0, current time 81, horizon 81\n", + "adding: mem time1, current time 81, horizon 80\n", + "adding: mem time2, current time 81, horizon 79\n", + "adding: mem time3, current time 81, horizon 78\n", + "adding: mem time4, current time 81, horizon 77\n", + "adding: mem time5, current time 81, horizon 76\n", + "adding: mem time6, current time 81, horizon 75\n", + "adding: mem time7, current time 81, horizon 74\n", + "adding: mem time8, current time 81, horizon 73\n", + "adding: mem time9, current time 81, horizon 72\n", + "adding: mem time10, current time 81, horizon 71\n", + "adding: mem time11, current time 81, horizon 70\n", + "adding: mem time12, current time 81, horizon 69\n", + "adding: mem time13, current time 81, horizon 68\n", + "adding: mem time14, current time 81, horizon 67\n", + "adding: mem time15, current time 81, horizon 66\n", + "adding: mem time16, current time 81, horizon 65\n", + "adding: mem time17, current time 81, horizon 64\n", + "adding: mem time18, current time 81, horizon 63\n", + "adding: mem time19, current time 81, horizon 62\n", + "adding: mem time20, current time 81, horizon 61\n", + "adding: mem time21, current time 81, horizon 60\n", + "adding: mem time22, current time 81, horizon 59\n", + "adding: mem time23, current time 81, horizon 58\n", + "adding: mem time24, current time 81, horizon 57\n", + "adding: mem time25, current time 81, horizon 56\n", + "adding: mem time26, current time 81, horizon 55\n", + "adding: mem time27, current time 81, horizon 54\n", + "adding: mem time28, current time 81, horizon 53\n", + "adding: mem time29, current time 81, horizon 52\n", + "adding: mem time30, current time 81, horizon 51\n", + "adding: mem time31, current time 81, horizon 50\n", + "adding: mem time32, current time 81, horizon 49\n", + "adding: mem time33, current time 81, horizon 48\n", + "adding: mem time34, current time 81, horizon 47\n", + "adding: mem time35, current time 81, horizon 46\n", + "adding: mem time36, current time 81, horizon 45\n", + "adding: mem time37, current time 81, horizon 44\n", + "adding: mem time38, current time 81, horizon 43\n", + "adding: mem time39, current time 81, horizon 42\n", + "adding: mem time40, current time 81, horizon 41\n", + "adding: mem time41, current time 81, horizon 40\n", + "adding: mem time42, current time 81, horizon 39\n", + "adding: mem time43, current time 81, horizon 38\n", + "adding: mem time44, current time 81, horizon 37\n", + "adding: mem time45, current time 81, horizon 36\n", + "adding: mem time46, current time 81, horizon 35\n", + "adding: mem time47, current time 81, horizon 34\n", + "adding: mem time48, current time 81, horizon 33\n", + "adding: mem time49, current time 81, horizon 32\n", + "adding: mem time50, current time 81, horizon 31\n", + "adding: mem time51, current time 81, horizon 30\n", + "adding: mem time52, current time 81, horizon 29\n", + "adding: mem time53, current time 81, horizon 28\n", + "adding: mem time54, current time 81, horizon 27\n", + "adding: mem time55, current time 81, horizon 26\n", + "adding: mem time56, current time 81, horizon 25\n", + "adding: mem time57, current time 81, horizon 24\n", + "adding: mem time58, current time 81, horizon 23\n", + "adding: mem time59, current time 81, horizon 22\n", + "adding: mem time60, current time 81, horizon 21\n", + "adding: mem time61, current time 81, horizon 20\n", + "adding: mem time62, current time 81, horizon 19\n", + "adding: mem time63, current time 81, horizon 18\n", + "adding: mem time64, current time 81, horizon 17\n", + "adding: mem time65, current time 81, horizon 16\n", + "adding: mem time66, current time 81, horizon 15\n", + "adding: mem time67, current time 81, horizon 14\n", + "adding: mem time68, current time 81, horizon 13\n", + "adding: mem time69, current time 81, horizon 12\n", + "adding: mem time70, current time 81, horizon 11\n", + "adding: mem time71, current time 81, horizon 10\n", + "adding: mem time72, current time 81, horizon 9\n", + "adding: mem time73, current time 81, horizon 8\n", + "adding: mem time74, current time 81, horizon 7\n", + "adding: mem time75, current time 81, horizon 6\n", + "adding: mem time76, current time 81, horizon 5\n", + "adding: mem time77, current time 81, horizon 4\n", + "adding: mem time78, current time 81, horizon 3\n", + "adding: mem time79, current time 81, horizon 2\n", + "adding: mem time80, current time 81, horizon 1\n", + "adding: mem time0, current time 82, horizon 82\n", + "adding: mem time1, current time 82, horizon 81\n", + "adding: mem time2, current time 82, horizon 80\n", + "adding: mem time3, current time 82, horizon 79\n", + "adding: mem time4, current time 82, horizon 78\n", + "adding: mem time5, current time 82, horizon 77\n", + "adding: mem time6, current time 82, horizon 76\n", + "adding: mem time7, current time 82, horizon 75\n", + "adding: mem time8, current time 82, horizon 74\n", + "adding: mem time9, current time 82, horizon 73\n", + "adding: mem time10, current time 82, horizon 72\n", + "adding: mem time11, current time 82, horizon 71\n", + "adding: mem time12, current time 82, horizon 70\n", + "adding: mem time13, current time 82, horizon 69\n", + "adding: mem time14, current time 82, horizon 68\n", + "adding: mem time15, current time 82, horizon 67\n", + "adding: mem time16, current time 82, horizon 66\n", + "adding: mem time17, current time 82, horizon 65\n", + "adding: mem time18, current time 82, horizon 64\n", + "adding: mem time19, current time 82, horizon 63\n", + "adding: mem time20, current time 82, horizon 62\n", + "adding: mem time21, current time 82, horizon 61\n", + "adding: mem time22, current time 82, horizon 60\n", + "adding: mem time23, current time 82, horizon 59\n", + "adding: mem time24, current time 82, horizon 58\n", + "adding: mem time25, current time 82, horizon 57\n", + "adding: mem time26, current time 82, horizon 56\n", + "adding: mem time27, current time 82, horizon 55\n", + "adding: mem time28, current time 82, horizon 54\n", + "adding: mem time29, current time 82, horizon 53\n", + "adding: mem time30, current time 82, horizon 52\n", + "adding: mem time31, current time 82, horizon 51\n", + "adding: mem time32, current time 82, horizon 50\n", + "adding: mem time33, current time 82, horizon 49\n", + "adding: mem time34, current time 82, horizon 48\n", + "adding: mem time35, current time 82, horizon 47\n", + "adding: mem time36, current time 82, horizon 46\n", + "adding: mem time37, current time 82, horizon 45\n", + "adding: mem time38, current time 82, horizon 44\n", + "adding: mem time39, current time 82, horizon 43\n", + "adding: mem time40, current time 82, horizon 42\n", + "adding: mem time41, current time 82, horizon 41\n", + "adding: mem time42, current time 82, horizon 40\n", + "adding: mem time43, current time 82, horizon 39\n", + "adding: mem time44, current time 82, horizon 38\n", + "adding: mem time45, current time 82, horizon 37\n", + "adding: mem time46, current time 82, horizon 36\n", + "adding: mem time47, current time 82, horizon 35\n", + "adding: mem time48, current time 82, horizon 34\n", + "adding: mem time49, current time 82, horizon 33\n", + "adding: mem time50, current time 82, horizon 32\n", + "adding: mem time51, current time 82, horizon 31\n", + "adding: mem time52, current time 82, horizon 30\n", + "adding: mem time53, current time 82, horizon 29\n", + "adding: mem time54, current time 82, horizon 28\n", + "adding: mem time55, current time 82, horizon 27\n", + "adding: mem time56, current time 82, horizon 26\n", + "adding: mem time57, current time 82, horizon 25\n", + "adding: mem time58, current time 82, horizon 24\n", + "adding: mem time59, current time 82, horizon 23\n", + "adding: mem time60, current time 82, horizon 22\n", + "adding: mem time61, current time 82, horizon 21\n", + "adding: mem time62, current time 82, horizon 20\n", + "adding: mem time63, current time 82, horizon 19\n", + "adding: mem time64, current time 82, horizon 18\n", + "adding: mem time65, current time 82, horizon 17\n", + "adding: mem time66, current time 82, horizon 16\n", + "adding: mem time67, current time 82, horizon 15\n", + "adding: mem time68, current time 82, horizon 14\n", + "adding: mem time69, current time 82, horizon 13\n", + "adding: mem time70, current time 82, horizon 12\n", + "adding: mem time71, current time 82, horizon 11\n", + "adding: mem time72, current time 82, horizon 10\n", + "adding: mem time73, current time 82, horizon 9\n", + "adding: mem time74, current time 82, horizon 8\n", + "adding: mem time75, current time 82, horizon 7\n", + "adding: mem time76, current time 82, horizon 6\n", + "adding: mem time77, current time 82, horizon 5\n", + "adding: mem time78, current time 82, horizon 4\n", + "adding: mem time79, current time 82, horizon 3\n", + "adding: mem time80, current time 82, horizon 2\n", + "adding: mem time81, current time 82, horizon 1\n", + "adding: mem time0, current time 83, horizon 83\n", + "adding: mem time1, current time 83, horizon 82\n", + "adding: mem time2, current time 83, horizon 81\n", + "adding: mem time3, current time 83, horizon 80\n", + "adding: mem time4, current time 83, horizon 79\n", + "adding: mem time5, current time 83, horizon 78\n", + "adding: mem time6, current time 83, horizon 77\n", + "adding: mem time7, current time 83, horizon 76\n", + "adding: mem time8, current time 83, horizon 75\n", + "adding: mem time9, current time 83, horizon 74\n", + "adding: mem time10, current time 83, horizon 73\n", + "adding: mem time11, current time 83, horizon 72\n", + "adding: mem time12, current time 83, horizon 71\n", + "adding: mem time13, current time 83, horizon 70\n", + "adding: mem time14, current time 83, horizon 69\n", + "adding: mem time15, current time 83, horizon 68\n", + "adding: mem time16, current time 83, horizon 67\n", + "adding: mem time17, current time 83, horizon 66\n", + "adding: mem time18, current time 83, horizon 65\n", + "adding: mem time19, current time 83, horizon 64\n", + "adding: mem time20, current time 83, horizon 63\n", + "adding: mem time21, current time 83, horizon 62\n", + "adding: mem time22, current time 83, horizon 61\n", + "adding: mem time23, current time 83, horizon 60\n", + "adding: mem time24, current time 83, horizon 59\n", + "adding: mem time25, current time 83, horizon 58\n", + "adding: mem time26, current time 83, horizon 57\n", + "adding: mem time27, current time 83, horizon 56\n", + "adding: mem time28, current time 83, horizon 55\n", + "adding: mem time29, current time 83, horizon 54\n", + "adding: mem time30, current time 83, horizon 53\n", + "adding: mem time31, current time 83, horizon 52\n", + "adding: mem time32, current time 83, horizon 51\n", + "adding: mem time33, current time 83, horizon 50\n", + "adding: mem time34, current time 83, horizon 49\n", + "adding: mem time35, current time 83, horizon 48\n", + "adding: mem time36, current time 83, horizon 47\n", + "adding: mem time37, current time 83, horizon 46\n", + "adding: mem time38, current time 83, horizon 45\n", + "adding: mem time39, current time 83, horizon 44\n", + "adding: mem time40, current time 83, horizon 43\n", + "adding: mem time41, current time 83, horizon 42\n", + "adding: mem time42, current time 83, horizon 41\n", + "adding: mem time43, current time 83, horizon 40\n", + "adding: mem time44, current time 83, horizon 39\n", + "adding: mem time45, current time 83, horizon 38\n", + "adding: mem time46, current time 83, horizon 37\n", + "adding: mem time47, current time 83, horizon 36\n", + "adding: mem time48, current time 83, horizon 35\n", + "adding: mem time49, current time 83, horizon 34\n", + "adding: mem time50, current time 83, horizon 33\n", + "adding: mem time51, current time 83, horizon 32\n", + "adding: mem time52, current time 83, horizon 31\n", + "adding: mem time53, current time 83, horizon 30\n", + "adding: mem time54, current time 83, horizon 29\n", + "adding: mem time55, current time 83, horizon 28\n", + "adding: mem time56, current time 83, horizon 27\n", + "adding: mem time57, current time 83, horizon 26\n", + "adding: mem time58, current time 83, horizon 25\n", + "adding: mem time59, current time 83, horizon 24\n", + "adding: mem time60, current time 83, horizon 23\n", + "adding: mem time61, current time 83, horizon 22\n", + "adding: mem time62, current time 83, horizon 21\n", + "adding: mem time63, current time 83, horizon 20\n", + "adding: mem time64, current time 83, horizon 19\n", + "adding: mem time65, current time 83, horizon 18\n", + "adding: mem time66, current time 83, horizon 17\n", + "adding: mem time67, current time 83, horizon 16\n", + "adding: mem time68, current time 83, horizon 15\n", + "adding: mem time69, current time 83, horizon 14\n", + "adding: mem time70, current time 83, horizon 13\n", + "adding: mem time71, current time 83, horizon 12\n", + "adding: mem time72, current time 83, horizon 11\n", + "adding: mem time73, current time 83, horizon 10\n", + "adding: mem time74, current time 83, horizon 9\n", + "adding: mem time75, current time 83, horizon 8\n", + "adding: mem time76, current time 83, horizon 7\n", + "adding: mem time77, current time 83, horizon 6\n", + "adding: mem time78, current time 83, horizon 5\n", + "adding: mem time79, current time 83, horizon 4\n", + "adding: mem time80, current time 83, horizon 3\n", + "adding: mem time81, current time 83, horizon 2\n", + "adding: mem time82, current time 83, horizon 1\n", + "adding: mem time0, current time 84, horizon 84\n", + "adding: mem time1, current time 84, horizon 83\n", + "adding: mem time2, current time 84, horizon 82\n", + "adding: mem time3, current time 84, horizon 81\n", + "adding: mem time4, current time 84, horizon 80\n", + "adding: mem time5, current time 84, horizon 79\n", + "adding: mem time6, current time 84, horizon 78\n", + "adding: mem time7, current time 84, horizon 77\n", + "adding: mem time8, current time 84, horizon 76\n", + "adding: mem time9, current time 84, horizon 75\n", + "adding: mem time10, current time 84, horizon 74\n", + "adding: mem time11, current time 84, horizon 73\n", + "adding: mem time12, current time 84, horizon 72\n", + "adding: mem time13, current time 84, horizon 71\n", + "adding: mem time14, current time 84, horizon 70\n", + "adding: mem time15, current time 84, horizon 69\n", + "adding: mem time16, current time 84, horizon 68\n", + "adding: mem time17, current time 84, horizon 67\n", + "adding: mem time18, current time 84, horizon 66\n", + "adding: mem time19, current time 84, horizon 65\n", + "adding: mem time20, current time 84, horizon 64\n", + "adding: mem time21, current time 84, horizon 63\n", + "adding: mem time22, current time 84, horizon 62\n", + "adding: mem time23, current time 84, horizon 61\n", + "adding: mem time24, current time 84, horizon 60\n", + "adding: mem time25, current time 84, horizon 59\n", + "adding: mem time26, current time 84, horizon 58\n", + "adding: mem time27, current time 84, horizon 57\n", + "adding: mem time28, current time 84, horizon 56\n", + "adding: mem time29, current time 84, horizon 55\n", + "adding: mem time30, current time 84, horizon 54\n", + "adding: mem time31, current time 84, horizon 53\n", + "adding: mem time32, current time 84, horizon 52\n", + "adding: mem time33, current time 84, horizon 51\n", + "adding: mem time34, current time 84, horizon 50\n", + "adding: mem time35, current time 84, horizon 49\n", + "adding: mem time36, current time 84, horizon 48\n", + "adding: mem time37, current time 84, horizon 47\n", + "adding: mem time38, current time 84, horizon 46\n", + "adding: mem time39, current time 84, horizon 45\n", + "adding: mem time40, current time 84, horizon 44\n", + "adding: mem time41, current time 84, horizon 43\n", + "adding: mem time42, current time 84, horizon 42\n", + "adding: mem time43, current time 84, horizon 41\n", + "adding: mem time44, current time 84, horizon 40\n", + "adding: mem time45, current time 84, horizon 39\n", + "adding: mem time46, current time 84, horizon 38\n", + "adding: mem time47, current time 84, horizon 37\n", + "adding: mem time48, current time 84, horizon 36\n", + "adding: mem time49, current time 84, horizon 35\n", + "adding: mem time50, current time 84, horizon 34\n", + "adding: mem time51, current time 84, horizon 33\n", + "adding: mem time52, current time 84, horizon 32\n", + "adding: mem time53, current time 84, horizon 31\n", + "adding: mem time54, current time 84, horizon 30\n", + "adding: mem time55, current time 84, horizon 29\n", + "adding: mem time56, current time 84, horizon 28\n", + "adding: mem time57, current time 84, horizon 27\n", + "adding: mem time58, current time 84, horizon 26\n", + "adding: mem time59, current time 84, horizon 25\n", + "adding: mem time60, current time 84, horizon 24\n", + "adding: mem time61, current time 84, horizon 23\n", + "adding: mem time62, current time 84, horizon 22\n", + "adding: mem time63, current time 84, horizon 21\n", + "adding: mem time64, current time 84, horizon 20\n", + "adding: mem time65, current time 84, horizon 19\n", + "adding: mem time66, current time 84, horizon 18\n", + "adding: mem time67, current time 84, horizon 17\n", + "adding: mem time68, current time 84, horizon 16\n", + "adding: mem time69, current time 84, horizon 15\n", + "adding: mem time70, current time 84, horizon 14\n", + "adding: mem time71, current time 84, horizon 13\n", + "adding: mem time72, current time 84, horizon 12\n", + "adding: mem time73, current time 84, horizon 11\n", + "adding: mem time74, current time 84, horizon 10\n", + "adding: mem time75, current time 84, horizon 9\n", + "adding: mem time76, current time 84, horizon 8\n", + "adding: mem time77, current time 84, horizon 7\n", + "adding: mem time78, current time 84, horizon 6\n", + "adding: mem time79, current time 84, horizon 5\n", + "adding: mem time80, current time 84, horizon 4\n", + "adding: mem time81, current time 84, horizon 3\n", + "adding: mem time82, current time 84, horizon 2\n", + "adding: mem time83, current time 84, horizon 1\n", + "adding: mem time0, current time 85, horizon 85\n", + "adding: mem time1, current time 85, horizon 84\n", + "adding: mem time2, current time 85, horizon 83\n", + "adding: mem time3, current time 85, horizon 82\n", + "adding: mem time4, current time 85, horizon 81\n", + "adding: mem time5, current time 85, horizon 80\n", + "adding: mem time6, current time 85, horizon 79\n", + "adding: mem time7, current time 85, horizon 78\n", + "adding: mem time8, current time 85, horizon 77\n", + "adding: mem time9, current time 85, horizon 76\n", + "adding: mem time10, current time 85, horizon 75\n", + "adding: mem time11, current time 85, horizon 74\n", + "adding: mem time12, current time 85, horizon 73\n", + "adding: mem time13, current time 85, horizon 72\n", + "adding: mem time14, current time 85, horizon 71\n", + "adding: mem time15, current time 85, horizon 70\n", + "adding: mem time16, current time 85, horizon 69\n", + "adding: mem time17, current time 85, horizon 68\n", + "adding: mem time18, current time 85, horizon 67\n", + "adding: mem time19, current time 85, horizon 66\n", + "adding: mem time20, current time 85, horizon 65\n", + "adding: mem time21, current time 85, horizon 64\n", + "adding: mem time22, current time 85, horizon 63\n", + "adding: mem time23, current time 85, horizon 62\n", + "adding: mem time24, current time 85, horizon 61\n", + "adding: mem time25, current time 85, horizon 60\n", + "adding: mem time26, current time 85, horizon 59\n", + "adding: mem time27, current time 85, horizon 58\n", + "adding: mem time28, current time 85, horizon 57\n", + "adding: mem time29, current time 85, horizon 56\n", + "adding: mem time30, current time 85, horizon 55\n", + "adding: mem time31, current time 85, horizon 54\n", + "adding: mem time32, current time 85, horizon 53\n", + "adding: mem time33, current time 85, horizon 52\n", + "adding: mem time34, current time 85, horizon 51\n", + "adding: mem time35, current time 85, horizon 50\n", + "adding: mem time36, current time 85, horizon 49\n", + "adding: mem time37, current time 85, horizon 48\n", + "adding: mem time38, current time 85, horizon 47\n", + "adding: mem time39, current time 85, horizon 46\n", + "adding: mem time40, current time 85, horizon 45\n", + "adding: mem time41, current time 85, horizon 44\n", + "adding: mem time42, current time 85, horizon 43\n", + "adding: mem time43, current time 85, horizon 42\n", + "adding: mem time44, current time 85, horizon 41\n", + "adding: mem time45, current time 85, horizon 40\n", + "adding: mem time46, current time 85, horizon 39\n", + "adding: mem time47, current time 85, horizon 38\n", + "adding: mem time48, current time 85, horizon 37\n", + "adding: mem time49, current time 85, horizon 36\n", + "adding: mem time50, current time 85, horizon 35\n", + "adding: mem time51, current time 85, horizon 34\n", + "adding: mem time52, current time 85, horizon 33\n", + "adding: mem time53, current time 85, horizon 32\n", + "adding: mem time54, current time 85, horizon 31\n", + "adding: mem time55, current time 85, horizon 30\n", + "adding: mem time56, current time 85, horizon 29\n", + "adding: mem time57, current time 85, horizon 28\n", + "adding: mem time58, current time 85, horizon 27\n", + "adding: mem time59, current time 85, horizon 26\n", + "adding: mem time60, current time 85, horizon 25\n", + "adding: mem time61, current time 85, horizon 24\n", + "adding: mem time62, current time 85, horizon 23\n", + "adding: mem time63, current time 85, horizon 22\n", + "adding: mem time64, current time 85, horizon 21\n", + "adding: mem time65, current time 85, horizon 20\n", + "adding: mem time66, current time 85, horizon 19\n", + "adding: mem time67, current time 85, horizon 18\n", + "adding: mem time68, current time 85, horizon 17\n", + "adding: mem time69, current time 85, horizon 16\n", + "adding: mem time70, current time 85, horizon 15\n", + "adding: mem time71, current time 85, horizon 14\n", + "adding: mem time72, current time 85, horizon 13\n", + "adding: mem time73, current time 85, horizon 12\n", + "adding: mem time74, current time 85, horizon 11\n", + "adding: mem time75, current time 85, horizon 10\n", + "adding: mem time76, current time 85, horizon 9\n", + "adding: mem time77, current time 85, horizon 8\n", + "adding: mem time78, current time 85, horizon 7\n", + "adding: mem time79, current time 85, horizon 6\n", + "adding: mem time80, current time 85, horizon 5\n", + "adding: mem time81, current time 85, horizon 4\n", + "adding: mem time82, current time 85, horizon 3\n", + "adding: mem time83, current time 85, horizon 2\n", + "adding: mem time84, current time 85, horizon 1\n", + "adding: mem time0, current time 86, horizon 86\n", + "adding: mem time1, current time 86, horizon 85\n", + "adding: mem time2, current time 86, horizon 84\n", + "adding: mem time3, current time 86, horizon 83\n", + "adding: mem time4, current time 86, horizon 82\n", + "adding: mem time5, current time 86, horizon 81\n", + "adding: mem time6, current time 86, horizon 80\n", + "adding: mem time7, current time 86, horizon 79\n", + "adding: mem time8, current time 86, horizon 78\n", + "adding: mem time9, current time 86, horizon 77\n", + "adding: mem time10, current time 86, horizon 76\n", + "adding: mem time11, current time 86, horizon 75\n", + "adding: mem time12, current time 86, horizon 74\n", + "adding: mem time13, current time 86, horizon 73\n", + "adding: mem time14, current time 86, horizon 72\n", + "adding: mem time15, current time 86, horizon 71\n", + "adding: mem time16, current time 86, horizon 70\n", + "adding: mem time17, current time 86, horizon 69\n", + "adding: mem time18, current time 86, horizon 68\n", + "adding: mem time19, current time 86, horizon 67\n", + "adding: mem time20, current time 86, horizon 66\n", + "adding: mem time21, current time 86, horizon 65\n", + "adding: mem time22, current time 86, horizon 64\n", + "adding: mem time23, current time 86, horizon 63\n", + "adding: mem time24, current time 86, horizon 62\n", + "adding: mem time25, current time 86, horizon 61\n", + "adding: mem time26, current time 86, horizon 60\n", + "adding: mem time27, current time 86, horizon 59\n", + "adding: mem time28, current time 86, horizon 58\n", + "adding: mem time29, current time 86, horizon 57\n", + "adding: mem time30, current time 86, horizon 56\n", + "adding: mem time31, current time 86, horizon 55\n", + "adding: mem time32, current time 86, horizon 54\n", + "adding: mem time33, current time 86, horizon 53\n", + "adding: mem time34, current time 86, horizon 52\n", + "adding: mem time35, current time 86, horizon 51\n", + "adding: mem time36, current time 86, horizon 50\n", + "adding: mem time37, current time 86, horizon 49\n", + "adding: mem time38, current time 86, horizon 48\n", + "adding: mem time39, current time 86, horizon 47\n", + "adding: mem time40, current time 86, horizon 46\n", + "adding: mem time41, current time 86, horizon 45\n", + "adding: mem time42, current time 86, horizon 44\n", + "adding: mem time43, current time 86, horizon 43\n", + "adding: mem time44, current time 86, horizon 42\n", + "adding: mem time45, current time 86, horizon 41\n", + "adding: mem time46, current time 86, horizon 40\n", + "adding: mem time47, current time 86, horizon 39\n", + "adding: mem time48, current time 86, horizon 38\n", + "adding: mem time49, current time 86, horizon 37\n", + "adding: mem time50, current time 86, horizon 36\n", + "adding: mem time51, current time 86, horizon 35\n", + "adding: mem time52, current time 86, horizon 34\n", + "adding: mem time53, current time 86, horizon 33\n", + "adding: mem time54, current time 86, horizon 32\n", + "adding: mem time55, current time 86, horizon 31\n", + "adding: mem time56, current time 86, horizon 30\n", + "adding: mem time57, current time 86, horizon 29\n", + "adding: mem time58, current time 86, horizon 28\n", + "adding: mem time59, current time 86, horizon 27\n", + "adding: mem time60, current time 86, horizon 26\n", + "adding: mem time61, current time 86, horizon 25\n", + "adding: mem time62, current time 86, horizon 24\n", + "adding: mem time63, current time 86, horizon 23\n", + "adding: mem time64, current time 86, horizon 22\n", + "adding: mem time65, current time 86, horizon 21\n", + "adding: mem time66, current time 86, horizon 20\n", + "adding: mem time67, current time 86, horizon 19\n", + "adding: mem time68, current time 86, horizon 18\n", + "adding: mem time69, current time 86, horizon 17\n", + "adding: mem time70, current time 86, horizon 16\n", + "adding: mem time71, current time 86, horizon 15\n", + "adding: mem time72, current time 86, horizon 14\n", + "adding: mem time73, current time 86, horizon 13\n", + "adding: mem time74, current time 86, horizon 12\n", + "adding: mem time75, current time 86, horizon 11\n", + "adding: mem time76, current time 86, horizon 10\n", + "adding: mem time77, current time 86, horizon 9\n", + "adding: mem time78, current time 86, horizon 8\n", + "adding: mem time79, current time 86, horizon 7\n", + "adding: mem time80, current time 86, horizon 6\n", + "adding: mem time81, current time 86, horizon 5\n", + "adding: mem time82, current time 86, horizon 4\n", + "adding: mem time83, current time 86, horizon 3\n", + "adding: mem time84, current time 86, horizon 2\n", + "adding: mem time85, current time 86, horizon 1\n", + "adding: mem time0, current time 87, horizon 87\n", + "adding: mem time1, current time 87, horizon 86\n", + "adding: mem time2, current time 87, horizon 85\n", + "adding: mem time3, current time 87, horizon 84\n", + "adding: mem time4, current time 87, horizon 83\n", + "adding: mem time5, current time 87, horizon 82\n", + "adding: mem time6, current time 87, horizon 81\n", + "adding: mem time7, current time 87, horizon 80\n", + "adding: mem time8, current time 87, horizon 79\n", + "adding: mem time9, current time 87, horizon 78\n", + "adding: mem time10, current time 87, horizon 77\n", + "adding: mem time11, current time 87, horizon 76\n", + "adding: mem time12, current time 87, horizon 75\n", + "adding: mem time13, current time 87, horizon 74\n", + "adding: mem time14, current time 87, horizon 73\n", + "adding: mem time15, current time 87, horizon 72\n", + "adding: mem time16, current time 87, horizon 71\n", + "adding: mem time17, current time 87, horizon 70\n", + "adding: mem time18, current time 87, horizon 69\n", + "adding: mem time19, current time 87, horizon 68\n", + "adding: mem time20, current time 87, horizon 67\n", + "adding: mem time21, current time 87, horizon 66\n", + "adding: mem time22, current time 87, horizon 65\n", + "adding: mem time23, current time 87, horizon 64\n", + "adding: mem time24, current time 87, horizon 63\n", + "adding: mem time25, current time 87, horizon 62\n", + "adding: mem time26, current time 87, horizon 61\n", + "adding: mem time27, current time 87, horizon 60\n", + "adding: mem time28, current time 87, horizon 59\n", + "adding: mem time29, current time 87, horizon 58\n", + "adding: mem time30, current time 87, horizon 57\n", + "adding: mem time31, current time 87, horizon 56\n", + "adding: mem time32, current time 87, horizon 55\n", + "adding: mem time33, current time 87, horizon 54\n", + "adding: mem time34, current time 87, horizon 53\n", + "adding: mem time35, current time 87, horizon 52\n", + "adding: mem time36, current time 87, horizon 51\n", + "adding: mem time37, current time 87, horizon 50\n", + "adding: mem time38, current time 87, horizon 49\n", + "adding: mem time39, current time 87, horizon 48\n", + "adding: mem time40, current time 87, horizon 47\n", + "adding: mem time41, current time 87, horizon 46\n", + "adding: mem time42, current time 87, horizon 45\n", + "adding: mem time43, current time 87, horizon 44\n", + "adding: mem time44, current time 87, horizon 43\n", + "adding: mem time45, current time 87, horizon 42\n", + "adding: mem time46, current time 87, horizon 41\n", + "adding: mem time47, current time 87, horizon 40\n", + "adding: mem time48, current time 87, horizon 39\n", + "adding: mem time49, current time 87, horizon 38\n", + "adding: mem time50, current time 87, horizon 37\n", + "adding: mem time51, current time 87, horizon 36\n", + "adding: mem time52, current time 87, horizon 35\n", + "adding: mem time53, current time 87, horizon 34\n", + "adding: mem time54, current time 87, horizon 33\n", + "adding: mem time55, current time 87, horizon 32\n", + "adding: mem time56, current time 87, horizon 31\n", + "adding: mem time57, current time 87, horizon 30\n", + "adding: mem time58, current time 87, horizon 29\n", + "adding: mem time59, current time 87, horizon 28\n", + "adding: mem time60, current time 87, horizon 27\n", + "adding: mem time61, current time 87, horizon 26\n", + "adding: mem time62, current time 87, horizon 25\n", + "adding: mem time63, current time 87, horizon 24\n", + "adding: mem time64, current time 87, horizon 23\n", + "adding: mem time65, current time 87, horizon 22\n", + "adding: mem time66, current time 87, horizon 21\n", + "adding: mem time67, current time 87, horizon 20\n", + "adding: mem time68, current time 87, horizon 19\n", + "adding: mem time69, current time 87, horizon 18\n", + "adding: mem time70, current time 87, horizon 17\n", + "adding: mem time71, current time 87, horizon 16\n", + "adding: mem time72, current time 87, horizon 15\n", + "adding: mem time73, current time 87, horizon 14\n", + "adding: mem time74, current time 87, horizon 13\n", + "adding: mem time75, current time 87, horizon 12\n", + "adding: mem time76, current time 87, horizon 11\n", + "adding: mem time77, current time 87, horizon 10\n", + "adding: mem time78, current time 87, horizon 9\n", + "adding: mem time79, current time 87, horizon 8\n", + "adding: mem time80, current time 87, horizon 7\n", + "adding: mem time81, current time 87, horizon 6\n", + "adding: mem time82, current time 87, horizon 5\n", + "adding: mem time83, current time 87, horizon 4\n", + "adding: mem time84, current time 87, horizon 3\n", + "adding: mem time85, current time 87, horizon 2\n", + "adding: mem time86, current time 87, horizon 1\n", + "adding: mem time0, current time 88, horizon 88\n", + "adding: mem time1, current time 88, horizon 87\n", + "adding: mem time2, current time 88, horizon 86\n", + "adding: mem time3, current time 88, horizon 85\n", + "adding: mem time4, current time 88, horizon 84\n", + "adding: mem time5, current time 88, horizon 83\n", + "adding: mem time6, current time 88, horizon 82\n", + "adding: mem time7, current time 88, horizon 81\n", + "adding: mem time8, current time 88, horizon 80\n", + "adding: mem time9, current time 88, horizon 79\n", + "adding: mem time10, current time 88, horizon 78\n", + "adding: mem time11, current time 88, horizon 77\n", + "adding: mem time12, current time 88, horizon 76\n", + "adding: mem time13, current time 88, horizon 75\n", + "adding: mem time14, current time 88, horizon 74\n", + "adding: mem time15, current time 88, horizon 73\n", + "adding: mem time16, current time 88, horizon 72\n", + "adding: mem time17, current time 88, horizon 71\n", + "adding: mem time18, current time 88, horizon 70\n", + "adding: mem time19, current time 88, horizon 69\n", + "adding: mem time20, current time 88, horizon 68\n", + "adding: mem time21, current time 88, horizon 67\n", + "adding: mem time22, current time 88, horizon 66\n", + "adding: mem time23, current time 88, horizon 65\n", + "adding: mem time24, current time 88, horizon 64\n", + "adding: mem time25, current time 88, horizon 63\n", + "adding: mem time26, current time 88, horizon 62\n", + "adding: mem time27, current time 88, horizon 61\n", + "adding: mem time28, current time 88, horizon 60\n", + "adding: mem time29, current time 88, horizon 59\n", + "adding: mem time30, current time 88, horizon 58\n", + "adding: mem time31, current time 88, horizon 57\n", + "adding: mem time32, current time 88, horizon 56\n", + "adding: mem time33, current time 88, horizon 55\n", + "adding: mem time34, current time 88, horizon 54\n", + "adding: mem time35, current time 88, horizon 53\n", + "adding: mem time36, current time 88, horizon 52\n", + "adding: mem time37, current time 88, horizon 51\n", + "adding: mem time38, current time 88, horizon 50\n", + "adding: mem time39, current time 88, horizon 49\n", + "adding: mem time40, current time 88, horizon 48\n", + "adding: mem time41, current time 88, horizon 47\n", + "adding: mem time42, current time 88, horizon 46\n", + "adding: mem time43, current time 88, horizon 45\n", + "adding: mem time44, current time 88, horizon 44\n", + "adding: mem time45, current time 88, horizon 43\n", + "adding: mem time46, current time 88, horizon 42\n", + "adding: mem time47, current time 88, horizon 41\n", + "adding: mem time48, current time 88, horizon 40\n", + "adding: mem time49, current time 88, horizon 39\n", + "adding: mem time50, current time 88, horizon 38\n", + "adding: mem time51, current time 88, horizon 37\n", + "adding: mem time52, current time 88, horizon 36\n", + "adding: mem time53, current time 88, horizon 35\n", + "adding: mem time54, current time 88, horizon 34\n", + "adding: mem time55, current time 88, horizon 33\n", + "adding: mem time56, current time 88, horizon 32\n", + "adding: mem time57, current time 88, horizon 31\n", + "adding: mem time58, current time 88, horizon 30\n", + "adding: mem time59, current time 88, horizon 29\n", + "adding: mem time60, current time 88, horizon 28\n", + "adding: mem time61, current time 88, horizon 27\n", + "adding: mem time62, current time 88, horizon 26\n", + "adding: mem time63, current time 88, horizon 25\n", + "adding: mem time64, current time 88, horizon 24\n", + "adding: mem time65, current time 88, horizon 23\n", + "adding: mem time66, current time 88, horizon 22\n", + "adding: mem time67, current time 88, horizon 21\n", + "adding: mem time68, current time 88, horizon 20\n", + "adding: mem time69, current time 88, horizon 19\n", + "adding: mem time70, current time 88, horizon 18\n", + "adding: mem time71, current time 88, horizon 17\n", + "adding: mem time72, current time 88, horizon 16\n", + "adding: mem time73, current time 88, horizon 15\n", + "adding: mem time74, current time 88, horizon 14\n", + "adding: mem time75, current time 88, horizon 13\n", + "adding: mem time76, current time 88, horizon 12\n", + "adding: mem time77, current time 88, horizon 11\n", + "adding: mem time78, current time 88, horizon 10\n", + "adding: mem time79, current time 88, horizon 9\n", + "adding: mem time80, current time 88, horizon 8\n", + "adding: mem time81, current time 88, horizon 7\n", + "adding: mem time82, current time 88, horizon 6\n", + "adding: mem time83, current time 88, horizon 5\n", + "adding: mem time84, current time 88, horizon 4\n", + "adding: mem time85, current time 88, horizon 3\n", + "adding: mem time86, current time 88, horizon 2\n", + "adding: mem time87, current time 88, horizon 1\n", + "adding: mem time0, current time 89, horizon 89\n", + "adding: mem time1, current time 89, horizon 88\n", + "adding: mem time2, current time 89, horizon 87\n", + "adding: mem time3, current time 89, horizon 86\n", + "adding: mem time4, current time 89, horizon 85\n", + "adding: mem time5, current time 89, horizon 84\n", + "adding: mem time6, current time 89, horizon 83\n", + "adding: mem time7, current time 89, horizon 82\n", + "adding: mem time8, current time 89, horizon 81\n", + "adding: mem time9, current time 89, horizon 80\n", + "adding: mem time10, current time 89, horizon 79\n", + "adding: mem time11, current time 89, horizon 78\n", + "adding: mem time12, current time 89, horizon 77\n", + "adding: mem time13, current time 89, horizon 76\n", + "adding: mem time14, current time 89, horizon 75\n", + "adding: mem time15, current time 89, horizon 74\n", + "adding: mem time16, current time 89, horizon 73\n", + "adding: mem time17, current time 89, horizon 72\n", + "adding: mem time18, current time 89, horizon 71\n", + "adding: mem time19, current time 89, horizon 70\n", + "adding: mem time20, current time 89, horizon 69\n", + "adding: mem time21, current time 89, horizon 68\n", + "adding: mem time22, current time 89, horizon 67\n", + "adding: mem time23, current time 89, horizon 66\n", + "adding: mem time24, current time 89, horizon 65\n", + "adding: mem time25, current time 89, horizon 64\n", + "adding: mem time26, current time 89, horizon 63\n", + "adding: mem time27, current time 89, horizon 62\n", + "adding: mem time28, current time 89, horizon 61\n", + "adding: mem time29, current time 89, horizon 60\n", + "adding: mem time30, current time 89, horizon 59\n", + "adding: mem time31, current time 89, horizon 58\n", + "adding: mem time32, current time 89, horizon 57\n", + "adding: mem time33, current time 89, horizon 56\n", + "adding: mem time34, current time 89, horizon 55\n", + "adding: mem time35, current time 89, horizon 54\n", + "adding: mem time36, current time 89, horizon 53\n", + "adding: mem time37, current time 89, horizon 52\n", + "adding: mem time38, current time 89, horizon 51\n", + "adding: mem time39, current time 89, horizon 50\n", + "adding: mem time40, current time 89, horizon 49\n", + "adding: mem time41, current time 89, horizon 48\n", + "adding: mem time42, current time 89, horizon 47\n", + "adding: mem time43, current time 89, horizon 46\n", + "adding: mem time44, current time 89, horizon 45\n", + "adding: mem time45, current time 89, horizon 44\n", + "adding: mem time46, current time 89, horizon 43\n", + "adding: mem time47, current time 89, horizon 42\n", + "adding: mem time48, current time 89, horizon 41\n", + "adding: mem time49, current time 89, horizon 40\n", + "adding: mem time50, current time 89, horizon 39\n", + "adding: mem time51, current time 89, horizon 38\n", + "adding: mem time52, current time 89, horizon 37\n", + "adding: mem time53, current time 89, horizon 36\n", + "adding: mem time54, current time 89, horizon 35\n", + "adding: mem time55, current time 89, horizon 34\n", + "adding: mem time56, current time 89, horizon 33\n", + "adding: mem time57, current time 89, horizon 32\n", + "adding: mem time58, current time 89, horizon 31\n", + "adding: mem time59, current time 89, horizon 30\n", + "adding: mem time60, current time 89, horizon 29\n", + "adding: mem time61, current time 89, horizon 28\n", + "adding: mem time62, current time 89, horizon 27\n", + "adding: mem time63, current time 89, horizon 26\n", + "adding: mem time64, current time 89, horizon 25\n", + "adding: mem time65, current time 89, horizon 24\n", + "adding: mem time66, current time 89, horizon 23\n", + "adding: mem time67, current time 89, horizon 22\n", + "adding: mem time68, current time 89, horizon 21\n", + "adding: mem time69, current time 89, horizon 20\n", + "adding: mem time70, current time 89, horizon 19\n", + "adding: mem time71, current time 89, horizon 18\n", + "adding: mem time72, current time 89, horizon 17\n", + "adding: mem time73, current time 89, horizon 16\n", + "adding: mem time74, current time 89, horizon 15\n", + "adding: mem time75, current time 89, horizon 14\n", + "adding: mem time76, current time 89, horizon 13\n", + "adding: mem time77, current time 89, horizon 12\n", + "adding: mem time78, current time 89, horizon 11\n", + "adding: mem time79, current time 89, horizon 10\n", + "adding: mem time80, current time 89, horizon 9\n", + "adding: mem time81, current time 89, horizon 8\n", + "adding: mem time82, current time 89, horizon 7\n", + "adding: mem time83, current time 89, horizon 6\n", + "adding: mem time84, current time 89, horizon 5\n", + "adding: mem time85, current time 89, horizon 4\n", + "adding: mem time86, current time 89, horizon 3\n", + "adding: mem time87, current time 89, horizon 2\n", + "adding: mem time88, current time 89, horizon 1\n", + "adding: mem time0, current time 90, horizon 90\n", + "adding: mem time1, current time 90, horizon 89\n", + "adding: mem time2, current time 90, horizon 88\n", + "adding: mem time3, current time 90, horizon 87\n", + "adding: mem time4, current time 90, horizon 86\n", + "adding: mem time5, current time 90, horizon 85\n", + "adding: mem time6, current time 90, horizon 84\n", + "adding: mem time7, current time 90, horizon 83\n", + "adding: mem time8, current time 90, horizon 82\n", + "adding: mem time9, current time 90, horizon 81\n", + "adding: mem time10, current time 90, horizon 80\n", + "adding: mem time11, current time 90, horizon 79\n", + "adding: mem time12, current time 90, horizon 78\n", + "adding: mem time13, current time 90, horizon 77\n", + "adding: mem time14, current time 90, horizon 76\n", + "adding: mem time15, current time 90, horizon 75\n", + "adding: mem time16, current time 90, horizon 74\n", + "adding: mem time17, current time 90, horizon 73\n", + "adding: mem time18, current time 90, horizon 72\n", + "adding: mem time19, current time 90, horizon 71\n", + "adding: mem time20, current time 90, horizon 70\n", + "adding: mem time21, current time 90, horizon 69\n", + "adding: mem time22, current time 90, horizon 68\n", + "adding: mem time23, current time 90, horizon 67\n", + "adding: mem time24, current time 90, horizon 66\n", + "adding: mem time25, current time 90, horizon 65\n", + "adding: mem time26, current time 90, horizon 64\n", + "adding: mem time27, current time 90, horizon 63\n", + "adding: mem time28, current time 90, horizon 62\n", + "adding: mem time29, current time 90, horizon 61\n", + "adding: mem time30, current time 90, horizon 60\n", + "adding: mem time31, current time 90, horizon 59\n", + "adding: mem time32, current time 90, horizon 58\n", + "adding: mem time33, current time 90, horizon 57\n", + "adding: mem time34, current time 90, horizon 56\n", + "adding: mem time35, current time 90, horizon 55\n", + "adding: mem time36, current time 90, horizon 54\n", + "adding: mem time37, current time 90, horizon 53\n", + "adding: mem time38, current time 90, horizon 52\n", + "adding: mem time39, current time 90, horizon 51\n", + "adding: mem time40, current time 90, horizon 50\n", + "adding: mem time41, current time 90, horizon 49\n", + "adding: mem time42, current time 90, horizon 48\n", + "adding: mem time43, current time 90, horizon 47\n", + "adding: mem time44, current time 90, horizon 46\n", + "adding: mem time45, current time 90, horizon 45\n", + "adding: mem time46, current time 90, horizon 44\n", + "adding: mem time47, current time 90, horizon 43\n", + "adding: mem time48, current time 90, horizon 42\n", + "adding: mem time49, current time 90, horizon 41\n", + "adding: mem time50, current time 90, horizon 40\n", + "adding: mem time51, current time 90, horizon 39\n", + "adding: mem time52, current time 90, horizon 38\n", + "adding: mem time53, current time 90, horizon 37\n", + "adding: mem time54, current time 90, horizon 36\n", + "adding: mem time55, current time 90, horizon 35\n", + "adding: mem time56, current time 90, horizon 34\n", + "adding: mem time57, current time 90, horizon 33\n", + "adding: mem time58, current time 90, horizon 32\n", + "adding: mem time59, current time 90, horizon 31\n", + "adding: mem time60, current time 90, horizon 30\n", + "adding: mem time61, current time 90, horizon 29\n", + "adding: mem time62, current time 90, horizon 28\n", + "adding: mem time63, current time 90, horizon 27\n", + "adding: mem time64, current time 90, horizon 26\n", + "adding: mem time65, current time 90, horizon 25\n", + "adding: mem time66, current time 90, horizon 24\n", + "adding: mem time67, current time 90, horizon 23\n", + "adding: mem time68, current time 90, horizon 22\n", + "adding: mem time69, current time 90, horizon 21\n", + "adding: mem time70, current time 90, horizon 20\n", + "adding: mem time71, current time 90, horizon 19\n", + "adding: mem time72, current time 90, horizon 18\n", + "adding: mem time73, current time 90, horizon 17\n", + "adding: mem time74, current time 90, horizon 16\n", + "adding: mem time75, current time 90, horizon 15\n", + "adding: mem time76, current time 90, horizon 14\n", + "adding: mem time77, current time 90, horizon 13\n", + "adding: mem time78, current time 90, horizon 12\n", + "adding: mem time79, current time 90, horizon 11\n", + "adding: mem time80, current time 90, horizon 10\n", + "adding: mem time81, current time 90, horizon 9\n", + "adding: mem time82, current time 90, horizon 8\n", + "adding: mem time83, current time 90, horizon 7\n", + "adding: mem time84, current time 90, horizon 6\n", + "adding: mem time85, current time 90, horizon 5\n", + "adding: mem time86, current time 90, horizon 4\n", + "adding: mem time87, current time 90, horizon 3\n", + "adding: mem time88, current time 90, horizon 2\n", + "adding: mem time89, current time 90, horizon 1\n", + "adding: mem time0, current time 91, horizon 91\n", + "adding: mem time1, current time 91, horizon 90\n", + "adding: mem time2, current time 91, horizon 89\n", + "adding: mem time3, current time 91, horizon 88\n", + "adding: mem time4, current time 91, horizon 87\n", + "adding: mem time5, current time 91, horizon 86\n", + "adding: mem time6, current time 91, horizon 85\n", + "adding: mem time7, current time 91, horizon 84\n", + "adding: mem time8, current time 91, horizon 83\n", + "adding: mem time9, current time 91, horizon 82\n", + "adding: mem time10, current time 91, horizon 81\n", + "adding: mem time11, current time 91, horizon 80\n", + "adding: mem time12, current time 91, horizon 79\n", + "adding: mem time13, current time 91, horizon 78\n", + "adding: mem time14, current time 91, horizon 77\n", + "adding: mem time15, current time 91, horizon 76\n", + "adding: mem time16, current time 91, horizon 75\n", + "adding: mem time17, current time 91, horizon 74\n", + "adding: mem time18, current time 91, horizon 73\n", + "adding: mem time19, current time 91, horizon 72\n", + "adding: mem time20, current time 91, horizon 71\n", + "adding: mem time21, current time 91, horizon 70\n", + "adding: mem time22, current time 91, horizon 69\n", + "adding: mem time23, current time 91, horizon 68\n", + "adding: mem time24, current time 91, horizon 67\n", + "adding: mem time25, current time 91, horizon 66\n", + "adding: mem time26, current time 91, horizon 65\n", + "adding: mem time27, current time 91, horizon 64\n", + "adding: mem time28, current time 91, horizon 63\n", + "adding: mem time29, current time 91, horizon 62\n", + "adding: mem time30, current time 91, horizon 61\n", + "adding: mem time31, current time 91, horizon 60\n", + "adding: mem time32, current time 91, horizon 59\n", + "adding: mem time33, current time 91, horizon 58\n", + "adding: mem time34, current time 91, horizon 57\n", + "adding: mem time35, current time 91, horizon 56\n", + "adding: mem time36, current time 91, horizon 55\n", + "adding: mem time37, current time 91, horizon 54\n", + "adding: mem time38, current time 91, horizon 53\n", + "adding: mem time39, current time 91, horizon 52\n", + "adding: mem time40, current time 91, horizon 51\n", + "adding: mem time41, current time 91, horizon 50\n", + "adding: mem time42, current time 91, horizon 49\n", + "adding: mem time43, current time 91, horizon 48\n", + "adding: mem time44, current time 91, horizon 47\n", + "adding: mem time45, current time 91, horizon 46\n", + "adding: mem time46, current time 91, horizon 45\n", + "adding: mem time47, current time 91, horizon 44\n", + "adding: mem time48, current time 91, horizon 43\n", + "adding: mem time49, current time 91, horizon 42\n", + "adding: mem time50, current time 91, horizon 41\n", + "adding: mem time51, current time 91, horizon 40\n", + "adding: mem time52, current time 91, horizon 39\n", + "adding: mem time53, current time 91, horizon 38\n", + "adding: mem time54, current time 91, horizon 37\n", + "adding: mem time55, current time 91, horizon 36\n", + "adding: mem time56, current time 91, horizon 35\n", + "adding: mem time57, current time 91, horizon 34\n", + "adding: mem time58, current time 91, horizon 33\n", + "adding: mem time59, current time 91, horizon 32\n", + "adding: mem time60, current time 91, horizon 31\n", + "adding: mem time61, current time 91, horizon 30\n", + "adding: mem time62, current time 91, horizon 29\n", + "adding: mem time63, current time 91, horizon 28\n", + "adding: mem time64, current time 91, horizon 27\n", + "adding: mem time65, current time 91, horizon 26\n", + "adding: mem time66, current time 91, horizon 25\n", + "adding: mem time67, current time 91, horizon 24\n", + "adding: mem time68, current time 91, horizon 23\n", + "adding: mem time69, current time 91, horizon 22\n", + "adding: mem time70, current time 91, horizon 21\n", + "adding: mem time71, current time 91, horizon 20\n", + "adding: mem time72, current time 91, horizon 19\n", + "adding: mem time73, current time 91, horizon 18\n", + "adding: mem time74, current time 91, horizon 17\n", + "adding: mem time75, current time 91, horizon 16\n", + "adding: mem time76, current time 91, horizon 15\n", + "adding: mem time77, current time 91, horizon 14\n", + "adding: mem time78, current time 91, horizon 13\n", + "adding: mem time79, current time 91, horizon 12\n", + "adding: mem time80, current time 91, horizon 11\n", + "adding: mem time81, current time 91, horizon 10\n", + "adding: mem time82, current time 91, horizon 9\n", + "adding: mem time83, current time 91, horizon 8\n", + "adding: mem time84, current time 91, horizon 7\n", + "adding: mem time85, current time 91, horizon 6\n", + "adding: mem time86, current time 91, horizon 5\n", + "adding: mem time87, current time 91, horizon 4\n", + "adding: mem time88, current time 91, horizon 3\n", + "adding: mem time89, current time 91, horizon 2\n", + "adding: mem time90, current time 91, horizon 1\n", + "adding: mem time0, current time 92, horizon 92\n", + "adding: mem time1, current time 92, horizon 91\n", + "adding: mem time2, current time 92, horizon 90\n", + "adding: mem time3, current time 92, horizon 89\n", + "adding: mem time4, current time 92, horizon 88\n", + "adding: mem time5, current time 92, horizon 87\n", + "adding: mem time6, current time 92, horizon 86\n", + "adding: mem time7, current time 92, horizon 85\n", + "adding: mem time8, current time 92, horizon 84\n", + "adding: mem time9, current time 92, horizon 83\n", + "adding: mem time10, current time 92, horizon 82\n", + "adding: mem time11, current time 92, horizon 81\n", + "adding: mem time12, current time 92, horizon 80\n", + "adding: mem time13, current time 92, horizon 79\n", + "adding: mem time14, current time 92, horizon 78\n", + "adding: mem time15, current time 92, horizon 77\n", + "adding: mem time16, current time 92, horizon 76\n", + "adding: mem time17, current time 92, horizon 75\n", + "adding: mem time18, current time 92, horizon 74\n", + "adding: mem time19, current time 92, horizon 73\n", + "adding: mem time20, current time 92, horizon 72\n", + "adding: mem time21, current time 92, horizon 71\n", + "adding: mem time22, current time 92, horizon 70\n", + "adding: mem time23, current time 92, horizon 69\n", + "adding: mem time24, current time 92, horizon 68\n", + "adding: mem time25, current time 92, horizon 67\n", + "adding: mem time26, current time 92, horizon 66\n", + "adding: mem time27, current time 92, horizon 65\n", + "adding: mem time28, current time 92, horizon 64\n", + "adding: mem time29, current time 92, horizon 63\n", + "adding: mem time30, current time 92, horizon 62\n", + "adding: mem time31, current time 92, horizon 61\n", + "adding: mem time32, current time 92, horizon 60\n", + "adding: mem time33, current time 92, horizon 59\n", + "adding: mem time34, current time 92, horizon 58\n", + "adding: mem time35, current time 92, horizon 57\n", + "adding: mem time36, current time 92, horizon 56\n", + "adding: mem time37, current time 92, horizon 55\n", + "adding: mem time38, current time 92, horizon 54\n", + "adding: mem time39, current time 92, horizon 53\n", + "adding: mem time40, current time 92, horizon 52\n", + "adding: mem time41, current time 92, horizon 51\n", + "adding: mem time42, current time 92, horizon 50\n", + "adding: mem time43, current time 92, horizon 49\n", + "adding: mem time44, current time 92, horizon 48\n", + "adding: mem time45, current time 92, horizon 47\n", + "adding: mem time46, current time 92, horizon 46\n", + "adding: mem time47, current time 92, horizon 45\n", + "adding: mem time48, current time 92, horizon 44\n", + "adding: mem time49, current time 92, horizon 43\n", + "adding: mem time50, current time 92, horizon 42\n", + "adding: mem time51, current time 92, horizon 41\n", + "adding: mem time52, current time 92, horizon 40\n", + "adding: mem time53, current time 92, horizon 39\n", + "adding: mem time54, current time 92, horizon 38\n", + "adding: mem time55, current time 92, horizon 37\n", + "adding: mem time56, current time 92, horizon 36\n", + "adding: mem time57, current time 92, horizon 35\n", + "adding: mem time58, current time 92, horizon 34\n", + "adding: mem time59, current time 92, horizon 33\n", + "adding: mem time60, current time 92, horizon 32\n", + "adding: mem time61, current time 92, horizon 31\n", + "adding: mem time62, current time 92, horizon 30\n", + "adding: mem time63, current time 92, horizon 29\n", + "adding: mem time64, current time 92, horizon 28\n", + "adding: mem time65, current time 92, horizon 27\n", + "adding: mem time66, current time 92, horizon 26\n", + "adding: mem time67, current time 92, horizon 25\n", + "adding: mem time68, current time 92, horizon 24\n", + "adding: mem time69, current time 92, horizon 23\n", + "adding: mem time70, current time 92, horizon 22\n", + "adding: mem time71, current time 92, horizon 21\n", + "adding: mem time72, current time 92, horizon 20\n", + "adding: mem time73, current time 92, horizon 19\n", + "adding: mem time74, current time 92, horizon 18\n", + "adding: mem time75, current time 92, horizon 17\n", + "adding: mem time76, current time 92, horizon 16\n", + "adding: mem time77, current time 92, horizon 15\n", + "adding: mem time78, current time 92, horizon 14\n", + "adding: mem time79, current time 92, horizon 13\n", + "adding: mem time80, current time 92, horizon 12\n", + "adding: mem time81, current time 92, horizon 11\n", + "adding: mem time82, current time 92, horizon 10\n", + "adding: mem time83, current time 92, horizon 9\n", + "adding: mem time84, current time 92, horizon 8\n", + "adding: mem time85, current time 92, horizon 7\n", + "adding: mem time86, current time 92, horizon 6\n", + "adding: mem time87, current time 92, horizon 5\n", + "adding: mem time88, current time 92, horizon 4\n", + "adding: mem time89, current time 92, horizon 3\n", + "adding: mem time90, current time 92, horizon 2\n", + "adding: mem time91, current time 92, horizon 1\n", + "adding: mem time0, current time 93, horizon 93\n", + "adding: mem time1, current time 93, horizon 92\n", + "adding: mem time2, current time 93, horizon 91\n", + "adding: mem time3, current time 93, horizon 90\n", + "adding: mem time4, current time 93, horizon 89\n", + "adding: mem time5, current time 93, horizon 88\n", + "adding: mem time6, current time 93, horizon 87\n", + "adding: mem time7, current time 93, horizon 86\n", + "adding: mem time8, current time 93, horizon 85\n", + "adding: mem time9, current time 93, horizon 84\n", + "adding: mem time10, current time 93, horizon 83\n", + "adding: mem time11, current time 93, horizon 82\n", + "adding: mem time12, current time 93, horizon 81\n", + "adding: mem time13, current time 93, horizon 80\n", + "adding: mem time14, current time 93, horizon 79\n", + "adding: mem time15, current time 93, horizon 78\n", + "adding: mem time16, current time 93, horizon 77\n", + "adding: mem time17, current time 93, horizon 76\n", + "adding: mem time18, current time 93, horizon 75\n", + "adding: mem time19, current time 93, horizon 74\n", + "adding: mem time20, current time 93, horizon 73\n", + "adding: mem time21, current time 93, horizon 72\n", + "adding: mem time22, current time 93, horizon 71\n", + "adding: mem time23, current time 93, horizon 70\n", + "adding: mem time24, current time 93, horizon 69\n", + "adding: mem time25, current time 93, horizon 68\n", + "adding: mem time26, current time 93, horizon 67\n", + "adding: mem time27, current time 93, horizon 66\n", + "adding: mem time28, current time 93, horizon 65\n", + "adding: mem time29, current time 93, horizon 64\n", + "adding: mem time30, current time 93, horizon 63\n", + "adding: mem time31, current time 93, horizon 62\n", + "adding: mem time32, current time 93, horizon 61\n", + "adding: mem time33, current time 93, horizon 60\n", + "adding: mem time34, current time 93, horizon 59\n", + "adding: mem time35, current time 93, horizon 58\n", + "adding: mem time36, current time 93, horizon 57\n", + "adding: mem time37, current time 93, horizon 56\n", + "adding: mem time38, current time 93, horizon 55\n", + "adding: mem time39, current time 93, horizon 54\n", + "adding: mem time40, current time 93, horizon 53\n", + "adding: mem time41, current time 93, horizon 52\n", + "adding: mem time42, current time 93, horizon 51\n", + "adding: mem time43, current time 93, horizon 50\n", + "adding: mem time44, current time 93, horizon 49\n", + "adding: mem time45, current time 93, horizon 48\n", + "adding: mem time46, current time 93, horizon 47\n", + "adding: mem time47, current time 93, horizon 46\n", + "adding: mem time48, current time 93, horizon 45\n", + "adding: mem time49, current time 93, horizon 44\n", + "adding: mem time50, current time 93, horizon 43\n", + "adding: mem time51, current time 93, horizon 42\n", + "adding: mem time52, current time 93, horizon 41\n", + "adding: mem time53, current time 93, horizon 40\n", + "adding: mem time54, current time 93, horizon 39\n", + "adding: mem time55, current time 93, horizon 38\n", + "adding: mem time56, current time 93, horizon 37\n", + "adding: mem time57, current time 93, horizon 36\n", + "adding: mem time58, current time 93, horizon 35\n", + "adding: mem time59, current time 93, horizon 34\n", + "adding: mem time60, current time 93, horizon 33\n", + "adding: mem time61, current time 93, horizon 32\n", + "adding: mem time62, current time 93, horizon 31\n", + "adding: mem time63, current time 93, horizon 30\n", + "adding: mem time64, current time 93, horizon 29\n", + "adding: mem time65, current time 93, horizon 28\n", + "adding: mem time66, current time 93, horizon 27\n", + "adding: mem time67, current time 93, horizon 26\n", + "adding: mem time68, current time 93, horizon 25\n", + "adding: mem time69, current time 93, horizon 24\n", + "adding: mem time70, current time 93, horizon 23\n", + "adding: mem time71, current time 93, horizon 22\n", + "adding: mem time72, current time 93, horizon 21\n", + "adding: mem time73, current time 93, horizon 20\n", + "adding: mem time74, current time 93, horizon 19\n", + "adding: mem time75, current time 93, horizon 18\n", + "adding: mem time76, current time 93, horizon 17\n", + "adding: mem time77, current time 93, horizon 16\n", + "adding: mem time78, current time 93, horizon 15\n", + "adding: mem time79, current time 93, horizon 14\n", + "adding: mem time80, current time 93, horizon 13\n", + "adding: mem time81, current time 93, horizon 12\n", + "adding: mem time82, current time 93, horizon 11\n", + "adding: mem time83, current time 93, horizon 10\n", + "adding: mem time84, current time 93, horizon 9\n", + "adding: mem time85, current time 93, horizon 8\n", + "adding: mem time86, current time 93, horizon 7\n", + "adding: mem time87, current time 93, horizon 6\n", + "adding: mem time88, current time 93, horizon 5\n", + "adding: mem time89, current time 93, horizon 4\n", + "adding: mem time90, current time 93, horizon 3\n", + "adding: mem time91, current time 93, horizon 2\n", + "adding: mem time92, current time 93, horizon 1\n", + "adding: mem time0, current time 94, horizon 94\n", + "adding: mem time1, current time 94, horizon 93\n", + "adding: mem time2, current time 94, horizon 92\n", + "adding: mem time3, current time 94, horizon 91\n", + "adding: mem time4, current time 94, horizon 90\n", + "adding: mem time5, current time 94, horizon 89\n", + "adding: mem time6, current time 94, horizon 88\n", + "adding: mem time7, current time 94, horizon 87\n", + "adding: mem time8, current time 94, horizon 86\n", + "adding: mem time9, current time 94, horizon 85\n", + "adding: mem time10, current time 94, horizon 84\n", + "adding: mem time11, current time 94, horizon 83\n", + "adding: mem time12, current time 94, horizon 82\n", + "adding: mem time13, current time 94, horizon 81\n", + "adding: mem time14, current time 94, horizon 80\n", + "adding: mem time15, current time 94, horizon 79\n", + "adding: mem time16, current time 94, horizon 78\n", + "adding: mem time17, current time 94, horizon 77\n", + "adding: mem time18, current time 94, horizon 76\n", + "adding: mem time19, current time 94, horizon 75\n", + "adding: mem time20, current time 94, horizon 74\n", + "adding: mem time21, current time 94, horizon 73\n", + "adding: mem time22, current time 94, horizon 72\n", + "adding: mem time23, current time 94, horizon 71\n", + "adding: mem time24, current time 94, horizon 70\n", + "adding: mem time25, current time 94, horizon 69\n", + "adding: mem time26, current time 94, horizon 68\n", + "adding: mem time27, current time 94, horizon 67\n", + "adding: mem time28, current time 94, horizon 66\n", + "adding: mem time29, current time 94, horizon 65\n", + "adding: mem time30, current time 94, horizon 64\n", + "adding: mem time31, current time 94, horizon 63\n", + "adding: mem time32, current time 94, horizon 62\n", + "adding: mem time33, current time 94, horizon 61\n", + "adding: mem time34, current time 94, horizon 60\n", + "adding: mem time35, current time 94, horizon 59\n", + "adding: mem time36, current time 94, horizon 58\n", + "adding: mem time37, current time 94, horizon 57\n", + "adding: mem time38, current time 94, horizon 56\n", + "adding: mem time39, current time 94, horizon 55\n", + "adding: mem time40, current time 94, horizon 54\n", + "adding: mem time41, current time 94, horizon 53\n", + "adding: mem time42, current time 94, horizon 52\n", + "adding: mem time43, current time 94, horizon 51\n", + "adding: mem time44, current time 94, horizon 50\n", + "adding: mem time45, current time 94, horizon 49\n", + "adding: mem time46, current time 94, horizon 48\n", + "adding: mem time47, current time 94, horizon 47\n", + "adding: mem time48, current time 94, horizon 46\n", + "adding: mem time49, current time 94, horizon 45\n", + "adding: mem time50, current time 94, horizon 44\n", + "adding: mem time51, current time 94, horizon 43\n", + "adding: mem time52, current time 94, horizon 42\n", + "adding: mem time53, current time 94, horizon 41\n", + "adding: mem time54, current time 94, horizon 40\n", + "adding: mem time55, current time 94, horizon 39\n", + "adding: mem time56, current time 94, horizon 38\n", + "adding: mem time57, current time 94, horizon 37\n", + "adding: mem time58, current time 94, horizon 36\n", + "adding: mem time59, current time 94, horizon 35\n", + "adding: mem time60, current time 94, horizon 34\n", + "adding: mem time61, current time 94, horizon 33\n", + "adding: mem time62, current time 94, horizon 32\n", + "adding: mem time63, current time 94, horizon 31\n", + "adding: mem time64, current time 94, horizon 30\n", + "adding: mem time65, current time 94, horizon 29\n", + "adding: mem time66, current time 94, horizon 28\n", + "adding: mem time67, current time 94, horizon 27\n", + "adding: mem time68, current time 94, horizon 26\n", + "adding: mem time69, current time 94, horizon 25\n", + "adding: mem time70, current time 94, horizon 24\n", + "adding: mem time71, current time 94, horizon 23\n", + "adding: mem time72, current time 94, horizon 22\n", + "adding: mem time73, current time 94, horizon 21\n", + "adding: mem time74, current time 94, horizon 20\n", + "adding: mem time75, current time 94, horizon 19\n", + "adding: mem time76, current time 94, horizon 18\n", + "adding: mem time77, current time 94, horizon 17\n", + "adding: mem time78, current time 94, horizon 16\n", + "adding: mem time79, current time 94, horizon 15\n", + "adding: mem time80, current time 94, horizon 14\n", + "adding: mem time81, current time 94, horizon 13\n", + "adding: mem time82, current time 94, horizon 12\n", + "adding: mem time83, current time 94, horizon 11\n", + "adding: mem time84, current time 94, horizon 10\n", + "adding: mem time85, current time 94, horizon 9\n", + "adding: mem time86, current time 94, horizon 8\n", + "adding: mem time87, current time 94, horizon 7\n", + "adding: mem time88, current time 94, horizon 6\n", + "adding: mem time89, current time 94, horizon 5\n", + "adding: mem time90, current time 94, horizon 4\n", + "adding: mem time91, current time 94, horizon 3\n", + "adding: mem time92, current time 94, horizon 2\n", + "adding: mem time93, current time 94, horizon 1\n", + "adding: mem time0, current time 95, horizon 95\n", + "adding: mem time1, current time 95, horizon 94\n", + "adding: mem time2, current time 95, horizon 93\n", + "adding: mem time3, current time 95, horizon 92\n", + "adding: mem time4, current time 95, horizon 91\n", + "adding: mem time5, current time 95, horizon 90\n", + "adding: mem time6, current time 95, horizon 89\n", + "adding: mem time7, current time 95, horizon 88\n", + "adding: mem time8, current time 95, horizon 87\n", + "adding: mem time9, current time 95, horizon 86\n", + "adding: mem time10, current time 95, horizon 85\n", + "adding: mem time11, current time 95, horizon 84\n", + "adding: mem time12, current time 95, horizon 83\n", + "adding: mem time13, current time 95, horizon 82\n", + "adding: mem time14, current time 95, horizon 81\n", + "adding: mem time15, current time 95, horizon 80\n", + "adding: mem time16, current time 95, horizon 79\n", + "adding: mem time17, current time 95, horizon 78\n", + "adding: mem time18, current time 95, horizon 77\n", + "adding: mem time19, current time 95, horizon 76\n", + "adding: mem time20, current time 95, horizon 75\n", + "adding: mem time21, current time 95, horizon 74\n", + "adding: mem time22, current time 95, horizon 73\n", + "adding: mem time23, current time 95, horizon 72\n", + "adding: mem time24, current time 95, horizon 71\n", + "adding: mem time25, current time 95, horizon 70\n", + "adding: mem time26, current time 95, horizon 69\n", + "adding: mem time27, current time 95, horizon 68\n", + "adding: mem time28, current time 95, horizon 67\n", + "adding: mem time29, current time 95, horizon 66\n", + "adding: mem time30, current time 95, horizon 65\n", + "adding: mem time31, current time 95, horizon 64\n", + "adding: mem time32, current time 95, horizon 63\n", + "adding: mem time33, current time 95, horizon 62\n", + "adding: mem time34, current time 95, horizon 61\n", + "adding: mem time35, current time 95, horizon 60\n", + "adding: mem time36, current time 95, horizon 59\n", + "adding: mem time37, current time 95, horizon 58\n", + "adding: mem time38, current time 95, horizon 57\n", + "adding: mem time39, current time 95, horizon 56\n", + "adding: mem time40, current time 95, horizon 55\n", + "adding: mem time41, current time 95, horizon 54\n", + "adding: mem time42, current time 95, horizon 53\n", + "adding: mem time43, current time 95, horizon 52\n", + "adding: mem time44, current time 95, horizon 51\n", + "adding: mem time45, current time 95, horizon 50\n", + "adding: mem time46, current time 95, horizon 49\n", + "adding: mem time47, current time 95, horizon 48\n", + "adding: mem time48, current time 95, horizon 47\n", + "adding: mem time49, current time 95, horizon 46\n", + "adding: mem time50, current time 95, horizon 45\n", + "adding: mem time51, current time 95, horizon 44\n", + "adding: mem time52, current time 95, horizon 43\n", + "adding: mem time53, current time 95, horizon 42\n", + "adding: mem time54, current time 95, horizon 41\n", + "adding: mem time55, current time 95, horizon 40\n", + "adding: mem time56, current time 95, horizon 39\n", + "adding: mem time57, current time 95, horizon 38\n", + "adding: mem time58, current time 95, horizon 37\n", + "adding: mem time59, current time 95, horizon 36\n", + "adding: mem time60, current time 95, horizon 35\n", + "adding: mem time61, current time 95, horizon 34\n", + "adding: mem time62, current time 95, horizon 33\n", + "adding: mem time63, current time 95, horizon 32\n", + "adding: mem time64, current time 95, horizon 31\n", + "adding: mem time65, current time 95, horizon 30\n", + "adding: mem time66, current time 95, horizon 29\n", + "adding: mem time67, current time 95, horizon 28\n", + "adding: mem time68, current time 95, horizon 27\n", + "adding: mem time69, current time 95, horizon 26\n", + "adding: mem time70, current time 95, horizon 25\n", + "adding: mem time71, current time 95, horizon 24\n", + "adding: mem time72, current time 95, horizon 23\n", + "adding: mem time73, current time 95, horizon 22\n", + "adding: mem time74, current time 95, horizon 21\n", + "adding: mem time75, current time 95, horizon 20\n", + "adding: mem time76, current time 95, horizon 19\n", + "adding: mem time77, current time 95, horizon 18\n", + "adding: mem time78, current time 95, horizon 17\n", + "adding: mem time79, current time 95, horizon 16\n", + "adding: mem time80, current time 95, horizon 15\n", + "adding: mem time81, current time 95, horizon 14\n", + "adding: mem time82, current time 95, horizon 13\n", + "adding: mem time83, current time 95, horizon 12\n", + "adding: mem time84, current time 95, horizon 11\n", + "adding: mem time85, current time 95, horizon 10\n", + "adding: mem time86, current time 95, horizon 9\n", + "adding: mem time87, current time 95, horizon 8\n", + "adding: mem time88, current time 95, horizon 7\n", + "adding: mem time89, current time 95, horizon 6\n", + "adding: mem time90, current time 95, horizon 5\n", + "adding: mem time91, current time 95, horizon 4\n", + "adding: mem time92, current time 95, horizon 3\n", + "adding: mem time93, current time 95, horizon 2\n", + "adding: mem time94, current time 95, horizon 1\n", + "adding: mem time0, current time 96, horizon 96\n", + "adding: mem time1, current time 96, horizon 95\n", + "adding: mem time2, current time 96, horizon 94\n", + "adding: mem time3, current time 96, horizon 93\n", + "adding: mem time4, current time 96, horizon 92\n", + "adding: mem time5, current time 96, horizon 91\n", + "adding: mem time6, current time 96, horizon 90\n", + "adding: mem time7, current time 96, horizon 89\n", + "adding: mem time8, current time 96, horizon 88\n", + "adding: mem time9, current time 96, horizon 87\n", + "adding: mem time10, current time 96, horizon 86\n", + "adding: mem time11, current time 96, horizon 85\n", + "adding: mem time12, current time 96, horizon 84\n", + "adding: mem time13, current time 96, horizon 83\n", + "adding: mem time14, current time 96, horizon 82\n", + "adding: mem time15, current time 96, horizon 81\n", + "adding: mem time16, current time 96, horizon 80\n", + "adding: mem time17, current time 96, horizon 79\n", + "adding: mem time18, current time 96, horizon 78\n", + "adding: mem time19, current time 96, horizon 77\n", + "adding: mem time20, current time 96, horizon 76\n", + "adding: mem time21, current time 96, horizon 75\n", + "adding: mem time22, current time 96, horizon 74\n", + "adding: mem time23, current time 96, horizon 73\n", + "adding: mem time24, current time 96, horizon 72\n", + "adding: mem time25, current time 96, horizon 71\n", + "adding: mem time26, current time 96, horizon 70\n", + "adding: mem time27, current time 96, horizon 69\n", + "adding: mem time28, current time 96, horizon 68\n", + "adding: mem time29, current time 96, horizon 67\n", + "adding: mem time30, current time 96, horizon 66\n", + "adding: mem time31, current time 96, horizon 65\n", + "adding: mem time32, current time 96, horizon 64\n", + "adding: mem time33, current time 96, horizon 63\n", + "adding: mem time34, current time 96, horizon 62\n", + "adding: mem time35, current time 96, horizon 61\n", + "adding: mem time36, current time 96, horizon 60\n", + "adding: mem time37, current time 96, horizon 59\n", + "adding: mem time38, current time 96, horizon 58\n", + "adding: mem time39, current time 96, horizon 57\n", + "adding: mem time40, current time 96, horizon 56\n", + "adding: mem time41, current time 96, horizon 55\n", + "adding: mem time42, current time 96, horizon 54\n", + "adding: mem time43, current time 96, horizon 53\n", + "adding: mem time44, current time 96, horizon 52\n", + "adding: mem time45, current time 96, horizon 51\n", + "adding: mem time46, current time 96, horizon 50\n", + "adding: mem time47, current time 96, horizon 49\n", + "adding: mem time48, current time 96, horizon 48\n", + "adding: mem time49, current time 96, horizon 47\n", + "adding: mem time50, current time 96, horizon 46\n", + "adding: mem time51, current time 96, horizon 45\n", + "adding: mem time52, current time 96, horizon 44\n", + "adding: mem time53, current time 96, horizon 43\n", + "adding: mem time54, current time 96, horizon 42\n", + "adding: mem time55, current time 96, horizon 41\n", + "adding: mem time56, current time 96, horizon 40\n", + "adding: mem time57, current time 96, horizon 39\n", + "adding: mem time58, current time 96, horizon 38\n", + "adding: mem time59, current time 96, horizon 37\n", + "adding: mem time60, current time 96, horizon 36\n", + "adding: mem time61, current time 96, horizon 35\n", + "adding: mem time62, current time 96, horizon 34\n", + "adding: mem time63, current time 96, horizon 33\n", + "adding: mem time64, current time 96, horizon 32\n", + "adding: mem time65, current time 96, horizon 31\n", + "adding: mem time66, current time 96, horizon 30\n", + "adding: mem time67, current time 96, horizon 29\n", + "adding: mem time68, current time 96, horizon 28\n", + "adding: mem time69, current time 96, horizon 27\n", + "adding: mem time70, current time 96, horizon 26\n", + "adding: mem time71, current time 96, horizon 25\n", + "adding: mem time72, current time 96, horizon 24\n", + "adding: mem time73, current time 96, horizon 23\n", + "adding: mem time74, current time 96, horizon 22\n", + "adding: mem time75, current time 96, horizon 21\n", + "adding: mem time76, current time 96, horizon 20\n", + "adding: mem time77, current time 96, horizon 19\n", + "adding: mem time78, current time 96, horizon 18\n", + "adding: mem time79, current time 96, horizon 17\n", + "adding: mem time80, current time 96, horizon 16\n", + "adding: mem time81, current time 96, horizon 15\n", + "adding: mem time82, current time 96, horizon 14\n", + "adding: mem time83, current time 96, horizon 13\n", + "adding: mem time84, current time 96, horizon 12\n", + "adding: mem time85, current time 96, horizon 11\n", + "adding: mem time86, current time 96, horizon 10\n", + "adding: mem time87, current time 96, horizon 9\n", + "adding: mem time88, current time 96, horizon 8\n", + "adding: mem time89, current time 96, horizon 7\n", + "adding: mem time90, current time 96, horizon 6\n", + "adding: mem time91, current time 96, horizon 5\n", + "adding: mem time92, current time 96, horizon 4\n", + "adding: mem time93, current time 96, horizon 3\n", + "adding: mem time94, current time 96, horizon 2\n", + "adding: mem time95, current time 96, horizon 1\n", + "adding: mem time0, current time 97, horizon 97\n", + "adding: mem time1, current time 97, horizon 96\n", + "adding: mem time2, current time 97, horizon 95\n", + "adding: mem time3, current time 97, horizon 94\n", + "adding: mem time4, current time 97, horizon 93\n", + "adding: mem time5, current time 97, horizon 92\n", + "adding: mem time6, current time 97, horizon 91\n", + "adding: mem time7, current time 97, horizon 90\n", + "adding: mem time8, current time 97, horizon 89\n", + "adding: mem time9, current time 97, horizon 88\n", + "adding: mem time10, current time 97, horizon 87\n", + "adding: mem time11, current time 97, horizon 86\n", + "adding: mem time12, current time 97, horizon 85\n", + "adding: mem time13, current time 97, horizon 84\n", + "adding: mem time14, current time 97, horizon 83\n", + "adding: mem time15, current time 97, horizon 82\n", + "adding: mem time16, current time 97, horizon 81\n", + "adding: mem time17, current time 97, horizon 80\n", + "adding: mem time18, current time 97, horizon 79\n", + "adding: mem time19, current time 97, horizon 78\n", + "adding: mem time20, current time 97, horizon 77\n", + "adding: mem time21, current time 97, horizon 76\n", + "adding: mem time22, current time 97, horizon 75\n", + "adding: mem time23, current time 97, horizon 74\n", + "adding: mem time24, current time 97, horizon 73\n", + "adding: mem time25, current time 97, horizon 72\n", + "adding: mem time26, current time 97, horizon 71\n", + "adding: mem time27, current time 97, horizon 70\n", + "adding: mem time28, current time 97, horizon 69\n", + "adding: mem time29, current time 97, horizon 68\n", + "adding: mem time30, current time 97, horizon 67\n", + "adding: mem time31, current time 97, horizon 66\n", + "adding: mem time32, current time 97, horizon 65\n", + "adding: mem time33, current time 97, horizon 64\n", + "adding: mem time34, current time 97, horizon 63\n", + "adding: mem time35, current time 97, horizon 62\n", + "adding: mem time36, current time 97, horizon 61\n", + "adding: mem time37, current time 97, horizon 60\n", + "adding: mem time38, current time 97, horizon 59\n", + "adding: mem time39, current time 97, horizon 58\n", + "adding: mem time40, current time 97, horizon 57\n", + "adding: mem time41, current time 97, horizon 56\n", + "adding: mem time42, current time 97, horizon 55\n", + "adding: mem time43, current time 97, horizon 54\n", + "adding: mem time44, current time 97, horizon 53\n", + "adding: mem time45, current time 97, horizon 52\n", + "adding: mem time46, current time 97, horizon 51\n", + "adding: mem time47, current time 97, horizon 50\n", + "adding: mem time48, current time 97, horizon 49\n", + "adding: mem time49, current time 97, horizon 48\n", + "adding: mem time50, current time 97, horizon 47\n", + "adding: mem time51, current time 97, horizon 46\n", + "adding: mem time52, current time 97, horizon 45\n", + "adding: mem time53, current time 97, horizon 44\n", + "adding: mem time54, current time 97, horizon 43\n", + "adding: mem time55, current time 97, horizon 42\n", + "adding: mem time56, current time 97, horizon 41\n", + "adding: mem time57, current time 97, horizon 40\n", + "adding: mem time58, current time 97, horizon 39\n", + "adding: mem time59, current time 97, horizon 38\n", + "adding: mem time60, current time 97, horizon 37\n", + "adding: mem time61, current time 97, horizon 36\n", + "adding: mem time62, current time 97, horizon 35\n", + "adding: mem time63, current time 97, horizon 34\n", + "adding: mem time64, current time 97, horizon 33\n", + "adding: mem time65, current time 97, horizon 32\n", + "adding: mem time66, current time 97, horizon 31\n", + "adding: mem time67, current time 97, horizon 30\n", + "adding: mem time68, current time 97, horizon 29\n", + "adding: mem time69, current time 97, horizon 28\n", + "adding: mem time70, current time 97, horizon 27\n", + "adding: mem time71, current time 97, horizon 26\n", + "adding: mem time72, current time 97, horizon 25\n", + "adding: mem time73, current time 97, horizon 24\n", + "adding: mem time74, current time 97, horizon 23\n", + "adding: mem time75, current time 97, horizon 22\n", + "adding: mem time76, current time 97, horizon 21\n", + "adding: mem time77, current time 97, horizon 20\n", + "adding: mem time78, current time 97, horizon 19\n", + "adding: mem time79, current time 97, horizon 18\n", + "adding: mem time80, current time 97, horizon 17\n", + "adding: mem time81, current time 97, horizon 16\n", + "adding: mem time82, current time 97, horizon 15\n", + "adding: mem time83, current time 97, horizon 14\n", + "adding: mem time84, current time 97, horizon 13\n", + "adding: mem time85, current time 97, horizon 12\n", + "adding: mem time86, current time 97, horizon 11\n", + "adding: mem time87, current time 97, horizon 10\n", + "adding: mem time88, current time 97, horizon 9\n", + "adding: mem time89, current time 97, horizon 8\n", + "adding: mem time90, current time 97, horizon 7\n", + "adding: mem time91, current time 97, horizon 6\n", + "adding: mem time92, current time 97, horizon 5\n", + "adding: mem time93, current time 97, horizon 4\n", + "adding: mem time94, current time 97, horizon 3\n", + "adding: mem time95, current time 97, horizon 2\n", + "adding: mem time96, current time 97, horizon 1\n", + "adding: mem time0, current time 98, horizon 98\n", + "adding: mem time1, current time 98, horizon 97\n", + "adding: mem time2, current time 98, horizon 96\n", + "adding: mem time3, current time 98, horizon 95\n", + "adding: mem time4, current time 98, horizon 94\n", + "adding: mem time5, current time 98, horizon 93\n", + "adding: mem time6, current time 98, horizon 92\n", + "adding: mem time7, current time 98, horizon 91\n", + "adding: mem time8, current time 98, horizon 90\n", + "adding: mem time9, current time 98, horizon 89\n", + "adding: mem time10, current time 98, horizon 88\n", + "adding: mem time11, current time 98, horizon 87\n", + "adding: mem time12, current time 98, horizon 86\n", + "adding: mem time13, current time 98, horizon 85\n", + "adding: mem time14, current time 98, horizon 84\n", + "adding: mem time15, current time 98, horizon 83\n", + "adding: mem time16, current time 98, horizon 82\n", + "adding: mem time17, current time 98, horizon 81\n", + "adding: mem time18, current time 98, horizon 80\n", + "adding: mem time19, current time 98, horizon 79\n", + "adding: mem time20, current time 98, horizon 78\n", + "adding: mem time21, current time 98, horizon 77\n", + "adding: mem time22, current time 98, horizon 76\n", + "adding: mem time23, current time 98, horizon 75\n", + "adding: mem time24, current time 98, horizon 74\n", + "adding: mem time25, current time 98, horizon 73\n", + "adding: mem time26, current time 98, horizon 72\n", + "adding: mem time27, current time 98, horizon 71\n", + "adding: mem time28, current time 98, horizon 70\n", + "adding: mem time29, current time 98, horizon 69\n", + "adding: mem time30, current time 98, horizon 68\n", + "adding: mem time31, current time 98, horizon 67\n", + "adding: mem time32, current time 98, horizon 66\n", + "adding: mem time33, current time 98, horizon 65\n", + "adding: mem time34, current time 98, horizon 64\n", + "adding: mem time35, current time 98, horizon 63\n", + "adding: mem time36, current time 98, horizon 62\n", + "adding: mem time37, current time 98, horizon 61\n", + "adding: mem time38, current time 98, horizon 60\n", + "adding: mem time39, current time 98, horizon 59\n", + "adding: mem time40, current time 98, horizon 58\n", + "adding: mem time41, current time 98, horizon 57\n", + "adding: mem time42, current time 98, horizon 56\n", + "adding: mem time43, current time 98, horizon 55\n", + "adding: mem time44, current time 98, horizon 54\n", + "adding: mem time45, current time 98, horizon 53\n", + "adding: mem time46, current time 98, horizon 52\n", + "adding: mem time47, current time 98, horizon 51\n", + "adding: mem time48, current time 98, horizon 50\n", + "adding: mem time49, current time 98, horizon 49\n", + "adding: mem time50, current time 98, horizon 48\n", + "adding: mem time51, current time 98, horizon 47\n", + "adding: mem time52, current time 98, horizon 46\n", + "adding: mem time53, current time 98, horizon 45\n", + "adding: mem time54, current time 98, horizon 44\n", + "adding: mem time55, current time 98, horizon 43\n", + "adding: mem time56, current time 98, horizon 42\n", + "adding: mem time57, current time 98, horizon 41\n", + "adding: mem time58, current time 98, horizon 40\n", + "adding: mem time59, current time 98, horizon 39\n", + "adding: mem time60, current time 98, horizon 38\n", + "adding: mem time61, current time 98, horizon 37\n", + "adding: mem time62, current time 98, horizon 36\n", + "adding: mem time63, current time 98, horizon 35\n", + "adding: mem time64, current time 98, horizon 34\n", + "adding: mem time65, current time 98, horizon 33\n", + "adding: mem time66, current time 98, horizon 32\n", + "adding: mem time67, current time 98, horizon 31\n", + "adding: mem time68, current time 98, horizon 30\n", + "adding: mem time69, current time 98, horizon 29\n", + "adding: mem time70, current time 98, horizon 28\n", + "adding: mem time71, current time 98, horizon 27\n", + "adding: mem time72, current time 98, horizon 26\n", + "adding: mem time73, current time 98, horizon 25\n", + "adding: mem time74, current time 98, horizon 24\n", + "adding: mem time75, current time 98, horizon 23\n", + "adding: mem time76, current time 98, horizon 22\n", + "adding: mem time77, current time 98, horizon 21\n", + "adding: mem time78, current time 98, horizon 20\n", + "adding: mem time79, current time 98, horizon 19\n", + "adding: mem time80, current time 98, horizon 18\n", + "adding: mem time81, current time 98, horizon 17\n", + "adding: mem time82, current time 98, horizon 16\n", + "adding: mem time83, current time 98, horizon 15\n", + "adding: mem time84, current time 98, horizon 14\n", + "adding: mem time85, current time 98, horizon 13\n", + "adding: mem time86, current time 98, horizon 12\n", + "adding: mem time87, current time 98, horizon 11\n", + "adding: mem time88, current time 98, horizon 10\n", + "adding: mem time89, current time 98, horizon 9\n", + "adding: mem time90, current time 98, horizon 8\n", + "adding: mem time91, current time 98, horizon 7\n", + "adding: mem time92, current time 98, horizon 6\n", + "adding: mem time93, current time 98, horizon 5\n", + "adding: mem time94, current time 98, horizon 4\n", + "adding: mem time95, current time 98, horizon 3\n", + "adding: mem time96, current time 98, horizon 2\n", + "adding: mem time97, current time 98, horizon 1\n", + "adding: mem time0, current time 99, horizon 99\n", + "adding: mem time1, current time 99, horizon 98\n", + "adding: mem time2, current time 99, horizon 97\n", + "adding: mem time3, current time 99, horizon 96\n", + "adding: mem time4, current time 99, horizon 95\n", + "adding: mem time5, current time 99, horizon 94\n", + "adding: mem time6, current time 99, horizon 93\n", + "adding: mem time7, current time 99, horizon 92\n", + "adding: mem time8, current time 99, horizon 91\n", + "adding: mem time9, current time 99, horizon 90\n", + "adding: mem time10, current time 99, horizon 89\n", + "adding: mem time11, current time 99, horizon 88\n", + "adding: mem time12, current time 99, horizon 87\n", + "adding: mem time13, current time 99, horizon 86\n", + "adding: mem time14, current time 99, horizon 85\n", + "adding: mem time15, current time 99, horizon 84\n", + "adding: mem time16, current time 99, horizon 83\n", + "adding: mem time17, current time 99, horizon 82\n", + "adding: mem time18, current time 99, horizon 81\n", + "adding: mem time19, current time 99, horizon 80\n", + "adding: mem time20, current time 99, horizon 79\n", + "adding: mem time21, current time 99, horizon 78\n", + "adding: mem time22, current time 99, horizon 77\n", + "adding: mem time23, current time 99, horizon 76\n", + "adding: mem time24, current time 99, horizon 75\n", + "adding: mem time25, current time 99, horizon 74\n", + "adding: mem time26, current time 99, horizon 73\n", + "adding: mem time27, current time 99, horizon 72\n", + "adding: mem time28, current time 99, horizon 71\n", + "adding: mem time29, current time 99, horizon 70\n", + "adding: mem time30, current time 99, horizon 69\n", + "adding: mem time31, current time 99, horizon 68\n", + "adding: mem time32, current time 99, horizon 67\n", + "adding: mem time33, current time 99, horizon 66\n", + "adding: mem time34, current time 99, horizon 65\n", + "adding: mem time35, current time 99, horizon 64\n", + "adding: mem time36, current time 99, horizon 63\n", + "adding: mem time37, current time 99, horizon 62\n", + "adding: mem time38, current time 99, horizon 61\n", + "adding: mem time39, current time 99, horizon 60\n", + "adding: mem time40, current time 99, horizon 59\n", + "adding: mem time41, current time 99, horizon 58\n", + "adding: mem time42, current time 99, horizon 57\n", + "adding: mem time43, current time 99, horizon 56\n", + "adding: mem time44, current time 99, horizon 55\n", + "adding: mem time45, current time 99, horizon 54\n", + "adding: mem time46, current time 99, horizon 53\n", + "adding: mem time47, current time 99, horizon 52\n", + "adding: mem time48, current time 99, horizon 51\n", + "adding: mem time49, current time 99, horizon 50\n", + "adding: mem time50, current time 99, horizon 49\n", + "adding: mem time51, current time 99, horizon 48\n", + "adding: mem time52, current time 99, horizon 47\n", + "adding: mem time53, current time 99, horizon 46\n", + "adding: mem time54, current time 99, horizon 45\n", + "adding: mem time55, current time 99, horizon 44\n", + "adding: mem time56, current time 99, horizon 43\n", + "adding: mem time57, current time 99, horizon 42\n", + "adding: mem time58, current time 99, horizon 41\n", + "adding: mem time59, current time 99, horizon 40\n", + "adding: mem time60, current time 99, horizon 39\n", + "adding: mem time61, current time 99, horizon 38\n", + "adding: mem time62, current time 99, horizon 37\n", + "adding: mem time63, current time 99, horizon 36\n", + "adding: mem time64, current time 99, horizon 35\n", + "adding: mem time65, current time 99, horizon 34\n", + "adding: mem time66, current time 99, horizon 33\n", + "adding: mem time67, current time 99, horizon 32\n", + "adding: mem time68, current time 99, horizon 31\n", + "adding: mem time69, current time 99, horizon 30\n", + "adding: mem time70, current time 99, horizon 29\n", + "adding: mem time71, current time 99, horizon 28\n", + "adding: mem time72, current time 99, horizon 27\n", + "adding: mem time73, current time 99, horizon 26\n", + "adding: mem time74, current time 99, horizon 25\n", + "adding: mem time75, current time 99, horizon 24\n", + "adding: mem time76, current time 99, horizon 23\n", + "adding: mem time77, current time 99, horizon 22\n", + "adding: mem time78, current time 99, horizon 21\n", + "adding: mem time79, current time 99, horizon 20\n", + "adding: mem time80, current time 99, horizon 19\n", + "adding: mem time81, current time 99, horizon 18\n", + "adding: mem time82, current time 99, horizon 17\n", + "adding: mem time83, current time 99, horizon 16\n", + "adding: mem time84, current time 99, horizon 15\n", + "adding: mem time85, current time 99, horizon 14\n", + "adding: mem time86, current time 99, horizon 13\n", + "adding: mem time87, current time 99, horizon 12\n", + "adding: mem time88, current time 99, horizon 11\n", + "adding: mem time89, current time 99, horizon 10\n", + "adding: mem time90, current time 99, horizon 9\n", + "adding: mem time91, current time 99, horizon 8\n", + "adding: mem time92, current time 99, horizon 7\n", + "adding: mem time93, current time 99, horizon 6\n", + "adding: mem time94, current time 99, horizon 5\n", + "adding: mem time95, current time 99, horizon 4\n", + "adding: mem time96, current time 99, horizon 3\n", + "adding: mem time97, current time 99, horizon 2\n", + "adding: mem time98, current time 99, horizon 1\n", + "adding: mem time0, current time 100, horizon 100\n", + "adding: mem time1, current time 100, horizon 99\n", + "adding: mem time2, current time 100, horizon 98\n", + "adding: mem time3, current time 100, horizon 97\n", + "adding: mem time4, current time 100, horizon 96\n", + "adding: mem time5, current time 100, horizon 95\n", + "adding: mem time6, current time 100, horizon 94\n", + "adding: mem time7, current time 100, horizon 93\n", + "adding: mem time8, current time 100, horizon 92\n", + "adding: mem time9, current time 100, horizon 91\n", + "adding: mem time10, current time 100, horizon 90\n", + "adding: mem time11, current time 100, horizon 89\n", + "adding: mem time12, current time 100, horizon 88\n", + "adding: mem time13, current time 100, horizon 87\n", + "adding: mem time14, current time 100, horizon 86\n", + "adding: mem time15, current time 100, horizon 85\n", + "adding: mem time16, current time 100, horizon 84\n", + "adding: mem time17, current time 100, horizon 83\n", + "adding: mem time18, current time 100, horizon 82\n", + "adding: mem time19, current time 100, horizon 81\n", + "adding: mem time20, current time 100, horizon 80\n", + "adding: mem time21, current time 100, horizon 79\n", + "adding: mem time22, current time 100, horizon 78\n", + "adding: mem time23, current time 100, horizon 77\n", + "adding: mem time24, current time 100, horizon 76\n", + "adding: mem time25, current time 100, horizon 75\n", + "adding: mem time26, current time 100, horizon 74\n", + "adding: mem time27, current time 100, horizon 73\n", + "adding: mem time28, current time 100, horizon 72\n", + "adding: mem time29, current time 100, horizon 71\n", + "adding: mem time30, current time 100, horizon 70\n", + "adding: mem time31, current time 100, horizon 69\n", + "adding: mem time32, current time 100, horizon 68\n", + "adding: mem time33, current time 100, horizon 67\n", + "adding: mem time34, current time 100, horizon 66\n", + "adding: mem time35, current time 100, horizon 65\n", + "adding: mem time36, current time 100, horizon 64\n", + "adding: mem time37, current time 100, horizon 63\n", + "adding: mem time38, current time 100, horizon 62\n", + "adding: mem time39, current time 100, horizon 61\n", + "adding: mem time40, current time 100, horizon 60\n", + "adding: mem time41, current time 100, horizon 59\n", + "adding: mem time42, current time 100, horizon 58\n", + "adding: mem time43, current time 100, horizon 57\n", + "adding: mem time44, current time 100, horizon 56\n", + "adding: mem time45, current time 100, horizon 55\n", + "adding: mem time46, current time 100, horizon 54\n", + "adding: mem time47, current time 100, horizon 53\n", + "adding: mem time48, current time 100, horizon 52\n", + "adding: mem time49, current time 100, horizon 51\n", + "adding: mem time50, current time 100, horizon 50\n", + "adding: mem time51, current time 100, horizon 49\n", + "adding: mem time52, current time 100, horizon 48\n", + "adding: mem time53, current time 100, horizon 47\n", + "adding: mem time54, current time 100, horizon 46\n", + "adding: mem time55, current time 100, horizon 45\n", + "adding: mem time56, current time 100, horizon 44\n", + "adding: mem time57, current time 100, horizon 43\n", + "adding: mem time58, current time 100, horizon 42\n", + "adding: mem time59, current time 100, horizon 41\n", + "adding: mem time60, current time 100, horizon 40\n", + "adding: mem time61, current time 100, horizon 39\n", + "adding: mem time62, current time 100, horizon 38\n", + "adding: mem time63, current time 100, horizon 37\n", + "adding: mem time64, current time 100, horizon 36\n", + "adding: mem time65, current time 100, horizon 35\n", + "adding: mem time66, current time 100, horizon 34\n", + "adding: mem time67, current time 100, horizon 33\n", + "adding: mem time68, current time 100, horizon 32\n", + "adding: mem time69, current time 100, horizon 31\n", + "adding: mem time70, current time 100, horizon 30\n", + "adding: mem time71, current time 100, horizon 29\n", + "adding: mem time72, current time 100, horizon 28\n", + "adding: mem time73, current time 100, horizon 27\n", + "adding: mem time74, current time 100, horizon 26\n", + "adding: mem time75, current time 100, horizon 25\n", + "adding: mem time76, current time 100, horizon 24\n", + "adding: mem time77, current time 100, horizon 23\n", + "adding: mem time78, current time 100, horizon 22\n", + "adding: mem time79, current time 100, horizon 21\n", + "adding: mem time80, current time 100, horizon 20\n", + "adding: mem time81, current time 100, horizon 19\n", + "adding: mem time82, current time 100, horizon 18\n", + "adding: mem time83, current time 100, horizon 17\n", + "adding: mem time84, current time 100, horizon 16\n", + "adding: mem time85, current time 100, horizon 15\n", + "adding: mem time86, current time 100, horizon 14\n", + "adding: mem time87, current time 100, horizon 13\n", + "adding: mem time88, current time 100, horizon 12\n", + "adding: mem time89, current time 100, horizon 11\n", + "adding: mem time90, current time 100, horizon 10\n", + "adding: mem time91, current time 100, horizon 9\n", + "adding: mem time92, current time 100, horizon 8\n", + "adding: mem time93, current time 100, horizon 7\n", + "adding: mem time94, current time 100, horizon 6\n", + "adding: mem time95, current time 100, horizon 5\n", + "adding: mem time96, current time 100, horizon 4\n", + "adding: mem time97, current time 100, horizon 3\n", + "adding: mem time98, current time 100, horizon 2\n", + "adding: mem time99, current time 100, horizon 1\n", + "adding: mem time0, current time 101, horizon 101\n", + "adding: mem time1, current time 101, horizon 100\n", + "adding: mem time2, current time 101, horizon 99\n", + "adding: mem time3, current time 101, horizon 98\n", + "adding: mem time4, current time 101, horizon 97\n", + "adding: mem time5, current time 101, horizon 96\n", + "adding: mem time6, current time 101, horizon 95\n", + "adding: mem time7, current time 101, horizon 94\n", + "adding: mem time8, current time 101, horizon 93\n", + "adding: mem time9, current time 101, horizon 92\n", + "adding: mem time10, current time 101, horizon 91\n", + "adding: mem time11, current time 101, horizon 90\n", + "adding: mem time12, current time 101, horizon 89\n", + "adding: mem time13, current time 101, horizon 88\n", + "adding: mem time14, current time 101, horizon 87\n", + "adding: mem time15, current time 101, horizon 86\n", + "adding: mem time16, current time 101, horizon 85\n", + "adding: mem time17, current time 101, horizon 84\n", + "adding: mem time18, current time 101, horizon 83\n", + "adding: mem time19, current time 101, horizon 82\n", + "adding: mem time20, current time 101, horizon 81\n", + "adding: mem time21, current time 101, horizon 80\n", + "adding: mem time22, current time 101, horizon 79\n", + "adding: mem time23, current time 101, horizon 78\n", + "adding: mem time24, current time 101, horizon 77\n", + "adding: mem time25, current time 101, horizon 76\n", + "adding: mem time26, current time 101, horizon 75\n", + "adding: mem time27, current time 101, horizon 74\n", + "adding: mem time28, current time 101, horizon 73\n", + "adding: mem time29, current time 101, horizon 72\n", + "adding: mem time30, current time 101, horizon 71\n", + "adding: mem time31, current time 101, horizon 70\n", + "adding: mem time32, current time 101, horizon 69\n", + "adding: mem time33, current time 101, horizon 68\n", + "adding: mem time34, current time 101, horizon 67\n", + "adding: mem time35, current time 101, horizon 66\n", + "adding: mem time36, current time 101, horizon 65\n", + "adding: mem time37, current time 101, horizon 64\n", + "adding: mem time38, current time 101, horizon 63\n", + "adding: mem time39, current time 101, horizon 62\n", + "adding: mem time40, current time 101, horizon 61\n", + "adding: mem time41, current time 101, horizon 60\n", + "adding: mem time42, current time 101, horizon 59\n", + "adding: mem time43, current time 101, horizon 58\n", + "adding: mem time44, current time 101, horizon 57\n", + "adding: mem time45, current time 101, horizon 56\n", + "adding: mem time46, current time 101, horizon 55\n", + "adding: mem time47, current time 101, horizon 54\n", + "adding: mem time48, current time 101, horizon 53\n", + "adding: mem time49, current time 101, horizon 52\n", + "adding: mem time50, current time 101, horizon 51\n", + "adding: mem time51, current time 101, horizon 50\n", + "adding: mem time52, current time 101, horizon 49\n", + "adding: mem time53, current time 101, horizon 48\n", + "adding: mem time54, current time 101, horizon 47\n", + "adding: mem time55, current time 101, horizon 46\n", + "adding: mem time56, current time 101, horizon 45\n", + "adding: mem time57, current time 101, horizon 44\n", + "adding: mem time58, current time 101, horizon 43\n", + "adding: mem time59, current time 101, horizon 42\n", + "adding: mem time60, current time 101, horizon 41\n", + "adding: mem time61, current time 101, horizon 40\n", + "adding: mem time62, current time 101, horizon 39\n", + "adding: mem time63, current time 101, horizon 38\n", + "adding: mem time64, current time 101, horizon 37\n", + "adding: mem time65, current time 101, horizon 36\n", + "adding: mem time66, current time 101, horizon 35\n", + "adding: mem time67, current time 101, horizon 34\n", + "adding: mem time68, current time 101, horizon 33\n", + "adding: mem time69, current time 101, horizon 32\n", + "adding: mem time70, current time 101, horizon 31\n", + "adding: mem time71, current time 101, horizon 30\n", + "adding: mem time72, current time 101, horizon 29\n", + "adding: mem time73, current time 101, horizon 28\n", + "adding: mem time74, current time 101, horizon 27\n", + "adding: mem time75, current time 101, horizon 26\n", + "adding: mem time76, current time 101, horizon 25\n", + "adding: mem time77, current time 101, horizon 24\n", + "adding: mem time78, current time 101, horizon 23\n", + "adding: mem time79, current time 101, horizon 22\n", + "adding: mem time80, current time 101, horizon 21\n", + "adding: mem time81, current time 101, horizon 20\n", + "adding: mem time82, current time 101, horizon 19\n", + "adding: mem time83, current time 101, horizon 18\n", + "adding: mem time84, current time 101, horizon 17\n", + "adding: mem time85, current time 101, horizon 16\n", + "adding: mem time86, current time 101, horizon 15\n", + "adding: mem time87, current time 101, horizon 14\n", + "adding: mem time88, current time 101, horizon 13\n", + "adding: mem time89, current time 101, horizon 12\n", + "adding: mem time90, current time 101, horizon 11\n", + "adding: mem time91, current time 101, horizon 10\n", + "adding: mem time92, current time 101, horizon 9\n", + "adding: mem time93, current time 101, horizon 8\n", + "adding: mem time94, current time 101, horizon 7\n", + "adding: mem time95, current time 101, horizon 6\n", + "adding: mem time96, current time 101, horizon 5\n", + "adding: mem time97, current time 101, horizon 4\n", + "adding: mem time98, current time 101, horizon 3\n", + "adding: mem time99, current time 101, horizon 2\n", + "adding: mem time100, current time 101, horizon 1\n", + "adding: mem time0, current time 102, horizon 102\n", + "adding: mem time1, current time 102, horizon 101\n", + "adding: mem time2, current time 102, horizon 100\n", + "adding: mem time3, current time 102, horizon 99\n", + "adding: mem time4, current time 102, horizon 98\n", + "adding: mem time5, current time 102, horizon 97\n", + "adding: mem time6, current time 102, horizon 96\n", + "adding: mem time7, current time 102, horizon 95\n", + "adding: mem time8, current time 102, horizon 94\n", + "adding: mem time9, current time 102, horizon 93\n", + "adding: mem time10, current time 102, horizon 92\n", + "adding: mem time11, current time 102, horizon 91\n", + "adding: mem time12, current time 102, horizon 90\n", + "adding: mem time13, current time 102, horizon 89\n", + "adding: mem time14, current time 102, horizon 88\n", + "adding: mem time15, current time 102, horizon 87\n", + "adding: mem time16, current time 102, horizon 86\n", + "adding: mem time17, current time 102, horizon 85\n", + "adding: mem time18, current time 102, horizon 84\n", + "adding: mem time19, current time 102, horizon 83\n", + "adding: mem time20, current time 102, horizon 82\n", + "adding: mem time21, current time 102, horizon 81\n", + "adding: mem time22, current time 102, horizon 80\n", + "adding: mem time23, current time 102, horizon 79\n", + "adding: mem time24, current time 102, horizon 78\n", + "adding: mem time25, current time 102, horizon 77\n", + "adding: mem time26, current time 102, horizon 76\n", + "adding: mem time27, current time 102, horizon 75\n", + "adding: mem time28, current time 102, horizon 74\n", + "adding: mem time29, current time 102, horizon 73\n", + "adding: mem time30, current time 102, horizon 72\n", + "adding: mem time31, current time 102, horizon 71\n", + "adding: mem time32, current time 102, horizon 70\n", + "adding: mem time33, current time 102, horizon 69\n", + "adding: mem time34, current time 102, horizon 68\n", + "adding: mem time35, current time 102, horizon 67\n", + "adding: mem time36, current time 102, horizon 66\n", + "adding: mem time37, current time 102, horizon 65\n", + "adding: mem time38, current time 102, horizon 64\n", + "adding: mem time39, current time 102, horizon 63\n", + "adding: mem time40, current time 102, horizon 62\n", + "adding: mem time41, current time 102, horizon 61\n", + "adding: mem time42, current time 102, horizon 60\n", + "adding: mem time43, current time 102, horizon 59\n", + "adding: mem time44, current time 102, horizon 58\n", + "adding: mem time45, current time 102, horizon 57\n", + "adding: mem time46, current time 102, horizon 56\n", + "adding: mem time47, current time 102, horizon 55\n", + "adding: mem time48, current time 102, horizon 54\n", + "adding: mem time49, current time 102, horizon 53\n", + "adding: mem time50, current time 102, horizon 52\n", + "adding: mem time51, current time 102, horizon 51\n", + "adding: mem time52, current time 102, horizon 50\n", + "adding: mem time53, current time 102, horizon 49\n", + "adding: mem time54, current time 102, horizon 48\n", + "adding: mem time55, current time 102, horizon 47\n", + "adding: mem time56, current time 102, horizon 46\n", + "adding: mem time57, current time 102, horizon 45\n", + "adding: mem time58, current time 102, horizon 44\n", + "adding: mem time59, current time 102, horizon 43\n", + "adding: mem time60, current time 102, horizon 42\n", + "adding: mem time61, current time 102, horizon 41\n", + "adding: mem time62, current time 102, horizon 40\n", + "adding: mem time63, current time 102, horizon 39\n", + "adding: mem time64, current time 102, horizon 38\n", + "adding: mem time65, current time 102, horizon 37\n", + "adding: mem time66, current time 102, horizon 36\n", + "adding: mem time67, current time 102, horizon 35\n", + "adding: mem time68, current time 102, horizon 34\n", + "adding: mem time69, current time 102, horizon 33\n", + "adding: mem time70, current time 102, horizon 32\n", + "adding: mem time71, current time 102, horizon 31\n", + "adding: mem time72, current time 102, horizon 30\n", + "adding: mem time73, current time 102, horizon 29\n", + "adding: mem time74, current time 102, horizon 28\n", + "adding: mem time75, current time 102, horizon 27\n", + "adding: mem time76, current time 102, horizon 26\n", + "adding: mem time77, current time 102, horizon 25\n", + "adding: mem time78, current time 102, horizon 24\n", + "adding: mem time79, current time 102, horizon 23\n", + "adding: mem time80, current time 102, horizon 22\n", + "adding: mem time81, current time 102, horizon 21\n", + "adding: mem time82, current time 102, horizon 20\n", + "adding: mem time83, current time 102, horizon 19\n", + "adding: mem time84, current time 102, horizon 18\n", + "adding: mem time85, current time 102, horizon 17\n", + "adding: mem time86, current time 102, horizon 16\n", + "adding: mem time87, current time 102, horizon 15\n", + "adding: mem time88, current time 102, horizon 14\n", + "adding: mem time89, current time 102, horizon 13\n", + "adding: mem time90, current time 102, horizon 12\n", + "adding: mem time91, current time 102, horizon 11\n", + "adding: mem time92, current time 102, horizon 10\n", + "adding: mem time93, current time 102, horizon 9\n", + "adding: mem time94, current time 102, horizon 8\n", + "adding: mem time95, current time 102, horizon 7\n", + "adding: mem time96, current time 102, horizon 6\n", + "adding: mem time97, current time 102, horizon 5\n", + "adding: mem time98, current time 102, horizon 4\n", + "adding: mem time99, current time 102, horizon 3\n", + "adding: mem time100, current time 102, horizon 2\n", + "adding: mem time101, current time 102, horizon 1\n", + "adding: mem time0, current time 103, horizon 103\n", + "adding: mem time1, current time 103, horizon 102\n", + "adding: mem time2, current time 103, horizon 101\n", + "adding: mem time3, current time 103, horizon 100\n", + "adding: mem time4, current time 103, horizon 99\n", + "adding: mem time5, current time 103, horizon 98\n", + "adding: mem time6, current time 103, horizon 97\n", + "adding: mem time7, current time 103, horizon 96\n", + "adding: mem time8, current time 103, horizon 95\n", + "adding: mem time9, current time 103, horizon 94\n", + "adding: mem time10, current time 103, horizon 93\n", + "adding: mem time11, current time 103, horizon 92\n", + "adding: mem time12, current time 103, horizon 91\n", + "adding: mem time13, current time 103, horizon 90\n", + "adding: mem time14, current time 103, horizon 89\n", + "adding: mem time15, current time 103, horizon 88\n", + "adding: mem time16, current time 103, horizon 87\n", + "adding: mem time17, current time 103, horizon 86\n", + "adding: mem time18, current time 103, horizon 85\n", + "adding: mem time19, current time 103, horizon 84\n", + "adding: mem time20, current time 103, horizon 83\n", + "adding: mem time21, current time 103, horizon 82\n", + "adding: mem time22, current time 103, horizon 81\n", + "adding: mem time23, current time 103, horizon 80\n", + "adding: mem time24, current time 103, horizon 79\n", + "adding: mem time25, current time 103, horizon 78\n", + "adding: mem time26, current time 103, horizon 77\n", + "adding: mem time27, current time 103, horizon 76\n", + "adding: mem time28, current time 103, horizon 75\n", + "adding: mem time29, current time 103, horizon 74\n", + "adding: mem time30, current time 103, horizon 73\n", + "adding: mem time31, current time 103, horizon 72\n", + "adding: mem time32, current time 103, horizon 71\n", + "adding: mem time33, current time 103, horizon 70\n", + "adding: mem time34, current time 103, horizon 69\n", + "adding: mem time35, current time 103, horizon 68\n", + "adding: mem time36, current time 103, horizon 67\n", + "adding: mem time37, current time 103, horizon 66\n", + "adding: mem time38, current time 103, horizon 65\n", + "adding: mem time39, current time 103, horizon 64\n", + "adding: mem time40, current time 103, horizon 63\n", + "adding: mem time41, current time 103, horizon 62\n", + "adding: mem time42, current time 103, horizon 61\n", + "adding: mem time43, current time 103, horizon 60\n", + "adding: mem time44, current time 103, horizon 59\n", + "adding: mem time45, current time 103, horizon 58\n", + "adding: mem time46, current time 103, horizon 57\n", + "adding: mem time47, current time 103, horizon 56\n", + "adding: mem time48, current time 103, horizon 55\n", + "adding: mem time49, current time 103, horizon 54\n", + "adding: mem time50, current time 103, horizon 53\n", + "adding: mem time51, current time 103, horizon 52\n", + "adding: mem time52, current time 103, horizon 51\n", + "adding: mem time53, current time 103, horizon 50\n", + "adding: mem time54, current time 103, horizon 49\n", + "adding: mem time55, current time 103, horizon 48\n", + "adding: mem time56, current time 103, horizon 47\n", + "adding: mem time57, current time 103, horizon 46\n", + "adding: mem time58, current time 103, horizon 45\n", + "adding: mem time59, current time 103, horizon 44\n", + "adding: mem time60, current time 103, horizon 43\n", + "adding: mem time61, current time 103, horizon 42\n", + "adding: mem time62, current time 103, horizon 41\n", + "adding: mem time63, current time 103, horizon 40\n", + "adding: mem time64, current time 103, horizon 39\n", + "adding: mem time65, current time 103, horizon 38\n", + "adding: mem time66, current time 103, horizon 37\n", + "adding: mem time67, current time 103, horizon 36\n", + "adding: mem time68, current time 103, horizon 35\n", + "adding: mem time69, current time 103, horizon 34\n", + "adding: mem time70, current time 103, horizon 33\n", + "adding: mem time71, current time 103, horizon 32\n", + "adding: mem time72, current time 103, horizon 31\n", + "adding: mem time73, current time 103, horizon 30\n", + "adding: mem time74, current time 103, horizon 29\n", + "adding: mem time75, current time 103, horizon 28\n", + "adding: mem time76, current time 103, horizon 27\n", + "adding: mem time77, current time 103, horizon 26\n", + "adding: mem time78, current time 103, horizon 25\n", + "adding: mem time79, current time 103, horizon 24\n", + "adding: mem time80, current time 103, horizon 23\n", + "adding: mem time81, current time 103, horizon 22\n", + "adding: mem time82, current time 103, horizon 21\n", + "adding: mem time83, current time 103, horizon 20\n", + "adding: mem time84, current time 103, horizon 19\n", + "adding: mem time85, current time 103, horizon 18\n", + "adding: mem time86, current time 103, horizon 17\n", + "adding: mem time87, current time 103, horizon 16\n", + "adding: mem time88, current time 103, horizon 15\n", + "adding: mem time89, current time 103, horizon 14\n", + "adding: mem time90, current time 103, horizon 13\n", + "adding: mem time91, current time 103, horizon 12\n", + "adding: mem time92, current time 103, horizon 11\n", + "adding: mem time93, current time 103, horizon 10\n", + "adding: mem time94, current time 103, horizon 9\n", + "adding: mem time95, current time 103, horizon 8\n", + "adding: mem time96, current time 103, horizon 7\n", + "adding: mem time97, current time 103, horizon 6\n", + "adding: mem time98, current time 103, horizon 5\n", + "adding: mem time99, current time 103, horizon 4\n", + "adding: mem time100, current time 103, horizon 3\n", + "adding: mem time101, current time 103, horizon 2\n", + "adding: mem time102, current time 103, horizon 1\n", + "adding: mem time0, current time 104, horizon 104\n", + "adding: mem time1, current time 104, horizon 103\n", + "adding: mem time2, current time 104, horizon 102\n", + "adding: mem time3, current time 104, horizon 101\n", + "adding: mem time4, current time 104, horizon 100\n", + "adding: mem time5, current time 104, horizon 99\n", + "adding: mem time6, current time 104, horizon 98\n", + "adding: mem time7, current time 104, horizon 97\n", + "adding: mem time8, current time 104, horizon 96\n", + "adding: mem time9, current time 104, horizon 95\n", + "adding: mem time10, current time 104, horizon 94\n", + "adding: mem time11, current time 104, horizon 93\n", + "adding: mem time12, current time 104, horizon 92\n", + "adding: mem time13, current time 104, horizon 91\n", + "adding: mem time14, current time 104, horizon 90\n", + "adding: mem time15, current time 104, horizon 89\n", + "adding: mem time16, current time 104, horizon 88\n", + "adding: mem time17, current time 104, horizon 87\n", + "adding: mem time18, current time 104, horizon 86\n", + "adding: mem time19, current time 104, horizon 85\n", + "adding: mem time20, current time 104, horizon 84\n", + "adding: mem time21, current time 104, horizon 83\n", + "adding: mem time22, current time 104, horizon 82\n", + "adding: mem time23, current time 104, horizon 81\n", + "adding: mem time24, current time 104, horizon 80\n", + "adding: mem time25, current time 104, horizon 79\n", + "adding: mem time26, current time 104, horizon 78\n", + "adding: mem time27, current time 104, horizon 77\n", + "adding: mem time28, current time 104, horizon 76\n", + "adding: mem time29, current time 104, horizon 75\n", + "adding: mem time30, current time 104, horizon 74\n", + "adding: mem time31, current time 104, horizon 73\n", + "adding: mem time32, current time 104, horizon 72\n", + "adding: mem time33, current time 104, horizon 71\n", + "adding: mem time34, current time 104, horizon 70\n", + "adding: mem time35, current time 104, horizon 69\n", + "adding: mem time36, current time 104, horizon 68\n", + "adding: mem time37, current time 104, horizon 67\n", + "adding: mem time38, current time 104, horizon 66\n", + "adding: mem time39, current time 104, horizon 65\n", + "adding: mem time40, current time 104, horizon 64\n", + "adding: mem time41, current time 104, horizon 63\n", + "adding: mem time42, current time 104, horizon 62\n", + "adding: mem time43, current time 104, horizon 61\n", + "adding: mem time44, current time 104, horizon 60\n", + "adding: mem time45, current time 104, horizon 59\n", + "adding: mem time46, current time 104, horizon 58\n", + "adding: mem time47, current time 104, horizon 57\n", + "adding: mem time48, current time 104, horizon 56\n", + "adding: mem time49, current time 104, horizon 55\n", + "adding: mem time50, current time 104, horizon 54\n", + "adding: mem time51, current time 104, horizon 53\n", + "adding: mem time52, current time 104, horizon 52\n", + "adding: mem time53, current time 104, horizon 51\n", + "adding: mem time54, current time 104, horizon 50\n", + "adding: mem time55, current time 104, horizon 49\n", + "adding: mem time56, current time 104, horizon 48\n", + "adding: mem time57, current time 104, horizon 47\n", + "adding: mem time58, current time 104, horizon 46\n", + "adding: mem time59, current time 104, horizon 45\n", + "adding: mem time60, current time 104, horizon 44\n", + "adding: mem time61, current time 104, horizon 43\n", + "adding: mem time62, current time 104, horizon 42\n", + "adding: mem time63, current time 104, horizon 41\n", + "adding: mem time64, current time 104, horizon 40\n", + "adding: mem time65, current time 104, horizon 39\n", + "adding: mem time66, current time 104, horizon 38\n", + "adding: mem time67, current time 104, horizon 37\n", + "adding: mem time68, current time 104, horizon 36\n", + "adding: mem time69, current time 104, horizon 35\n", + "adding: mem time70, current time 104, horizon 34\n", + "adding: mem time71, current time 104, horizon 33\n", + "adding: mem time72, current time 104, horizon 32\n", + "adding: mem time73, current time 104, horizon 31\n", + "adding: mem time74, current time 104, horizon 30\n", + "adding: mem time75, current time 104, horizon 29\n", + "adding: mem time76, current time 104, horizon 28\n", + "adding: mem time77, current time 104, horizon 27\n", + "adding: mem time78, current time 104, horizon 26\n", + "adding: mem time79, current time 104, horizon 25\n", + "adding: mem time80, current time 104, horizon 24\n", + "adding: mem time81, current time 104, horizon 23\n", + "adding: mem time82, current time 104, horizon 22\n", + "adding: mem time83, current time 104, horizon 21\n", + "adding: mem time84, current time 104, horizon 20\n", + "adding: mem time85, current time 104, horizon 19\n", + "adding: mem time86, current time 104, horizon 18\n", + "adding: mem time87, current time 104, horizon 17\n", + "adding: mem time88, current time 104, horizon 16\n", + "adding: mem time89, current time 104, horizon 15\n", + "adding: mem time90, current time 104, horizon 14\n", + "adding: mem time91, current time 104, horizon 13\n", + "adding: mem time92, current time 104, horizon 12\n", + "adding: mem time93, current time 104, horizon 11\n", + "adding: mem time94, current time 104, horizon 10\n", + "adding: mem time95, current time 104, horizon 9\n", + "adding: mem time96, current time 104, horizon 8\n", + "adding: mem time97, current time 104, horizon 7\n", + "adding: mem time98, current time 104, horizon 6\n", + "adding: mem time99, current time 104, horizon 5\n", + "adding: mem time100, current time 104, horizon 4\n", + "adding: mem time101, current time 104, horizon 3\n", + "adding: mem time102, current time 104, horizon 2\n", + "adding: mem time103, current time 104, horizon 1\n", + "adding: mem time0, current time 105, horizon 105\n", + "adding: mem time1, current time 105, horizon 104\n", + "adding: mem time2, current time 105, horizon 103\n", + "adding: mem time3, current time 105, horizon 102\n", + "adding: mem time4, current time 105, horizon 101\n", + "adding: mem time5, current time 105, horizon 100\n", + "adding: mem time6, current time 105, horizon 99\n", + "adding: mem time7, current time 105, horizon 98\n", + "adding: mem time8, current time 105, horizon 97\n", + "adding: mem time9, current time 105, horizon 96\n", + "adding: mem time10, current time 105, horizon 95\n", + "adding: mem time11, current time 105, horizon 94\n", + "adding: mem time12, current time 105, horizon 93\n", + "adding: mem time13, current time 105, horizon 92\n", + "adding: mem time14, current time 105, horizon 91\n", + "adding: mem time15, current time 105, horizon 90\n", + "adding: mem time16, current time 105, horizon 89\n", + "adding: mem time17, current time 105, horizon 88\n", + "adding: mem time18, current time 105, horizon 87\n", + "adding: mem time19, current time 105, horizon 86\n", + "adding: mem time20, current time 105, horizon 85\n", + "adding: mem time21, current time 105, horizon 84\n", + "adding: mem time22, current time 105, horizon 83\n", + "adding: mem time23, current time 105, horizon 82\n", + "adding: mem time24, current time 105, horizon 81\n", + "adding: mem time25, current time 105, horizon 80\n", + "adding: mem time26, current time 105, horizon 79\n", + "adding: mem time27, current time 105, horizon 78\n", + "adding: mem time28, current time 105, horizon 77\n", + "adding: mem time29, current time 105, horizon 76\n", + "adding: mem time30, current time 105, horizon 75\n", + "adding: mem time31, current time 105, horizon 74\n", + "adding: mem time32, current time 105, horizon 73\n", + "adding: mem time33, current time 105, horizon 72\n", + "adding: mem time34, current time 105, horizon 71\n", + "adding: mem time35, current time 105, horizon 70\n", + "adding: mem time36, current time 105, horizon 69\n", + "adding: mem time37, current time 105, horizon 68\n", + "adding: mem time38, current time 105, horizon 67\n", + "adding: mem time39, current time 105, horizon 66\n", + "adding: mem time40, current time 105, horizon 65\n", + "adding: mem time41, current time 105, horizon 64\n", + "adding: mem time42, current time 105, horizon 63\n", + "adding: mem time43, current time 105, horizon 62\n", + "adding: mem time44, current time 105, horizon 61\n", + "adding: mem time45, current time 105, horizon 60\n", + "adding: mem time46, current time 105, horizon 59\n", + "adding: mem time47, current time 105, horizon 58\n", + "adding: mem time48, current time 105, horizon 57\n", + "adding: mem time49, current time 105, horizon 56\n", + "adding: mem time50, current time 105, horizon 55\n", + "adding: mem time51, current time 105, horizon 54\n", + "adding: mem time52, current time 105, horizon 53\n", + "adding: mem time53, current time 105, horizon 52\n", + "adding: mem time54, current time 105, horizon 51\n", + "adding: mem time55, current time 105, horizon 50\n", + "adding: mem time56, current time 105, horizon 49\n", + "adding: mem time57, current time 105, horizon 48\n", + "adding: mem time58, current time 105, horizon 47\n", + "adding: mem time59, current time 105, horizon 46\n", + "adding: mem time60, current time 105, horizon 45\n", + "adding: mem time61, current time 105, horizon 44\n", + "adding: mem time62, current time 105, horizon 43\n", + "adding: mem time63, current time 105, horizon 42\n", + "adding: mem time64, current time 105, horizon 41\n", + "adding: mem time65, current time 105, horizon 40\n", + "adding: mem time66, current time 105, horizon 39\n", + "adding: mem time67, current time 105, horizon 38\n", + "adding: mem time68, current time 105, horizon 37\n", + "adding: mem time69, current time 105, horizon 36\n", + "adding: mem time70, current time 105, horizon 35\n", + "adding: mem time71, current time 105, horizon 34\n", + "adding: mem time72, current time 105, horizon 33\n", + "adding: mem time73, current time 105, horizon 32\n", + "adding: mem time74, current time 105, horizon 31\n", + "adding: mem time75, current time 105, horizon 30\n", + "adding: mem time76, current time 105, horizon 29\n", + "adding: mem time77, current time 105, horizon 28\n", + "adding: mem time78, current time 105, horizon 27\n", + "adding: mem time79, current time 105, horizon 26\n", + "adding: mem time80, current time 105, horizon 25\n", + "adding: mem time81, current time 105, horizon 24\n", + "adding: mem time82, current time 105, horizon 23\n", + "adding: mem time83, current time 105, horizon 22\n", + "adding: mem time84, current time 105, horizon 21\n", + "adding: mem time85, current time 105, horizon 20\n", + "adding: mem time86, current time 105, horizon 19\n", + "adding: mem time87, current time 105, horizon 18\n", + "adding: mem time88, current time 105, horizon 17\n", + "adding: mem time89, current time 105, horizon 16\n", + "adding: mem time90, current time 105, horizon 15\n", + "adding: mem time91, current time 105, horizon 14\n", + "adding: mem time92, current time 105, horizon 13\n", + "adding: mem time93, current time 105, horizon 12\n", + "adding: mem time94, current time 105, horizon 11\n", + "adding: mem time95, current time 105, horizon 10\n", + "adding: mem time96, current time 105, horizon 9\n", + "adding: mem time97, current time 105, horizon 8\n", + "adding: mem time98, current time 105, horizon 7\n", + "adding: mem time99, current time 105, horizon 6\n", + "adding: mem time100, current time 105, horizon 5\n", + "adding: mem time101, current time 105, horizon 4\n", + "adding: mem time102, current time 105, horizon 3\n", + "adding: mem time103, current time 105, horizon 2\n", + "adding: mem time104, current time 105, horizon 1\n", + "adding: mem time0, current time 106, horizon 106\n", + "adding: mem time1, current time 106, horizon 105\n", + "adding: mem time2, current time 106, horizon 104\n", + "adding: mem time3, current time 106, horizon 103\n", + "adding: mem time4, current time 106, horizon 102\n", + "adding: mem time5, current time 106, horizon 101\n", + "adding: mem time6, current time 106, horizon 100\n", + "adding: mem time7, current time 106, horizon 99\n", + "adding: mem time8, current time 106, horizon 98\n", + "adding: mem time9, current time 106, horizon 97\n", + "adding: mem time10, current time 106, horizon 96\n", + "adding: mem time11, current time 106, horizon 95\n", + "adding: mem time12, current time 106, horizon 94\n", + "adding: mem time13, current time 106, horizon 93\n", + "adding: mem time14, current time 106, horizon 92\n", + "adding: mem time15, current time 106, horizon 91\n", + "adding: mem time16, current time 106, horizon 90\n", + "adding: mem time17, current time 106, horizon 89\n", + "adding: mem time18, current time 106, horizon 88\n", + "adding: mem time19, current time 106, horizon 87\n", + "adding: mem time20, current time 106, horizon 86\n", + "adding: mem time21, current time 106, horizon 85\n", + "adding: mem time22, current time 106, horizon 84\n", + "adding: mem time23, current time 106, horizon 83\n", + "adding: mem time24, current time 106, horizon 82\n", + "adding: mem time25, current time 106, horizon 81\n", + "adding: mem time26, current time 106, horizon 80\n", + "adding: mem time27, current time 106, horizon 79\n", + "adding: mem time28, current time 106, horizon 78\n", + "adding: mem time29, current time 106, horizon 77\n", + "adding: mem time30, current time 106, horizon 76\n", + "adding: mem time31, current time 106, horizon 75\n", + "adding: mem time32, current time 106, horizon 74\n", + "adding: mem time33, current time 106, horizon 73\n", + "adding: mem time34, current time 106, horizon 72\n", + "adding: mem time35, current time 106, horizon 71\n", + "adding: mem time36, current time 106, horizon 70\n", + "adding: mem time37, current time 106, horizon 69\n", + "adding: mem time38, current time 106, horizon 68\n", + "adding: mem time39, current time 106, horizon 67\n", + "adding: mem time40, current time 106, horizon 66\n", + "adding: mem time41, current time 106, horizon 65\n", + "adding: mem time42, current time 106, horizon 64\n", + "adding: mem time43, current time 106, horizon 63\n", + "adding: mem time44, current time 106, horizon 62\n", + "adding: mem time45, current time 106, horizon 61\n", + "adding: mem time46, current time 106, horizon 60\n", + "adding: mem time47, current time 106, horizon 59\n", + "adding: mem time48, current time 106, horizon 58\n", + "adding: mem time49, current time 106, horizon 57\n", + "adding: mem time50, current time 106, horizon 56\n", + "adding: mem time51, current time 106, horizon 55\n", + "adding: mem time52, current time 106, horizon 54\n", + "adding: mem time53, current time 106, horizon 53\n", + "adding: mem time54, current time 106, horizon 52\n", + "adding: mem time55, current time 106, horizon 51\n", + "adding: mem time56, current time 106, horizon 50\n", + "adding: mem time57, current time 106, horizon 49\n", + "adding: mem time58, current time 106, horizon 48\n", + "adding: mem time59, current time 106, horizon 47\n", + "adding: mem time60, current time 106, horizon 46\n", + "adding: mem time61, current time 106, horizon 45\n", + "adding: mem time62, current time 106, horizon 44\n", + "adding: mem time63, current time 106, horizon 43\n", + "adding: mem time64, current time 106, horizon 42\n", + "adding: mem time65, current time 106, horizon 41\n", + "adding: mem time66, current time 106, horizon 40\n", + "adding: mem time67, current time 106, horizon 39\n", + "adding: mem time68, current time 106, horizon 38\n", + "adding: mem time69, current time 106, horizon 37\n", + "adding: mem time70, current time 106, horizon 36\n", + "adding: mem time71, current time 106, horizon 35\n", + "adding: mem time72, current time 106, horizon 34\n", + "adding: mem time73, current time 106, horizon 33\n", + "adding: mem time74, current time 106, horizon 32\n", + "adding: mem time75, current time 106, horizon 31\n", + "adding: mem time76, current time 106, horizon 30\n", + "adding: mem time77, current time 106, horizon 29\n", + "adding: mem time78, current time 106, horizon 28\n", + "adding: mem time79, current time 106, horizon 27\n", + "adding: mem time80, current time 106, horizon 26\n", + "adding: mem time81, current time 106, horizon 25\n", + "adding: mem time82, current time 106, horizon 24\n", + "adding: mem time83, current time 106, horizon 23\n", + "adding: mem time84, current time 106, horizon 22\n", + "adding: mem time85, current time 106, horizon 21\n", + "adding: mem time86, current time 106, horizon 20\n", + "adding: mem time87, current time 106, horizon 19\n", + "adding: mem time88, current time 106, horizon 18\n", + "adding: mem time89, current time 106, horizon 17\n", + "adding: mem time90, current time 106, horizon 16\n", + "adding: mem time91, current time 106, horizon 15\n", + "adding: mem time92, current time 106, horizon 14\n", + "adding: mem time93, current time 106, horizon 13\n", + "adding: mem time94, current time 106, horizon 12\n", + "adding: mem time95, current time 106, horizon 11\n", + "adding: mem time96, current time 106, horizon 10\n", + "adding: mem time97, current time 106, horizon 9\n", + "adding: mem time98, current time 106, horizon 8\n", + "adding: mem time99, current time 106, horizon 7\n", + "adding: mem time100, current time 106, horizon 6\n", + "adding: mem time101, current time 106, horizon 5\n", + "adding: mem time102, current time 106, horizon 4\n", + "adding: mem time103, current time 106, horizon 3\n", + "adding: mem time104, current time 106, horizon 2\n", + "adding: mem time105, current time 106, horizon 1\n", + "adding: mem time0, current time 107, horizon 107\n", + "adding: mem time1, current time 107, horizon 106\n", + "adding: mem time2, current time 107, horizon 105\n", + "adding: mem time3, current time 107, horizon 104\n", + "adding: mem time4, current time 107, horizon 103\n", + "adding: mem time5, current time 107, horizon 102\n", + "adding: mem time6, current time 107, horizon 101\n", + "adding: mem time7, current time 107, horizon 100\n", + "adding: mem time8, current time 107, horizon 99\n", + "adding: mem time9, current time 107, horizon 98\n", + "adding: mem time10, current time 107, horizon 97\n", + "adding: mem time11, current time 107, horizon 96\n", + "adding: mem time12, current time 107, horizon 95\n", + "adding: mem time13, current time 107, horizon 94\n", + "adding: mem time14, current time 107, horizon 93\n", + "adding: mem time15, current time 107, horizon 92\n", + "adding: mem time16, current time 107, horizon 91\n", + "adding: mem time17, current time 107, horizon 90\n", + "adding: mem time18, current time 107, horizon 89\n", + "adding: mem time19, current time 107, horizon 88\n", + "adding: mem time20, current time 107, horizon 87\n", + "adding: mem time21, current time 107, horizon 86\n", + "adding: mem time22, current time 107, horizon 85\n", + "adding: mem time23, current time 107, horizon 84\n", + "adding: mem time24, current time 107, horizon 83\n", + "adding: mem time25, current time 107, horizon 82\n", + "adding: mem time26, current time 107, horizon 81\n", + "adding: mem time27, current time 107, horizon 80\n", + "adding: mem time28, current time 107, horizon 79\n", + "adding: mem time29, current time 107, horizon 78\n", + "adding: mem time30, current time 107, horizon 77\n", + "adding: mem time31, current time 107, horizon 76\n", + "adding: mem time32, current time 107, horizon 75\n", + "adding: mem time33, current time 107, horizon 74\n", + "adding: mem time34, current time 107, horizon 73\n", + "adding: mem time35, current time 107, horizon 72\n", + "adding: mem time36, current time 107, horizon 71\n", + "adding: mem time37, current time 107, horizon 70\n", + "adding: mem time38, current time 107, horizon 69\n", + "adding: mem time39, current time 107, horizon 68\n", + "adding: mem time40, current time 107, horizon 67\n", + "adding: mem time41, current time 107, horizon 66\n", + "adding: mem time42, current time 107, horizon 65\n", + "adding: mem time43, current time 107, horizon 64\n", + "adding: mem time44, current time 107, horizon 63\n", + "adding: mem time45, current time 107, horizon 62\n", + "adding: mem time46, current time 107, horizon 61\n", + "adding: mem time47, current time 107, horizon 60\n", + "adding: mem time48, current time 107, horizon 59\n", + "adding: mem time49, current time 107, horizon 58\n", + "adding: mem time50, current time 107, horizon 57\n", + "adding: mem time51, current time 107, horizon 56\n", + "adding: mem time52, current time 107, horizon 55\n", + "adding: mem time53, current time 107, horizon 54\n", + "adding: mem time54, current time 107, horizon 53\n", + "adding: mem time55, current time 107, horizon 52\n", + "adding: mem time56, current time 107, horizon 51\n", + "adding: mem time57, current time 107, horizon 50\n", + "adding: mem time58, current time 107, horizon 49\n", + "adding: mem time59, current time 107, horizon 48\n", + "adding: mem time60, current time 107, horizon 47\n", + "adding: mem time61, current time 107, horizon 46\n", + "adding: mem time62, current time 107, horizon 45\n", + "adding: mem time63, current time 107, horizon 44\n", + "adding: mem time64, current time 107, horizon 43\n", + "adding: mem time65, current time 107, horizon 42\n", + "adding: mem time66, current time 107, horizon 41\n", + "adding: mem time67, current time 107, horizon 40\n", + "adding: mem time68, current time 107, horizon 39\n", + "adding: mem time69, current time 107, horizon 38\n", + "adding: mem time70, current time 107, horizon 37\n", + "adding: mem time71, current time 107, horizon 36\n", + "adding: mem time72, current time 107, horizon 35\n", + "adding: mem time73, current time 107, horizon 34\n", + "adding: mem time74, current time 107, horizon 33\n", + "adding: mem time75, current time 107, horizon 32\n", + "adding: mem time76, current time 107, horizon 31\n", + "adding: mem time77, current time 107, horizon 30\n", + "adding: mem time78, current time 107, horizon 29\n", + "adding: mem time79, current time 107, horizon 28\n", + "adding: mem time80, current time 107, horizon 27\n", + "adding: mem time81, current time 107, horizon 26\n", + "adding: mem time82, current time 107, horizon 25\n", + "adding: mem time83, current time 107, horizon 24\n", + "adding: mem time84, current time 107, horizon 23\n", + "adding: mem time85, current time 107, horizon 22\n", + "adding: mem time86, current time 107, horizon 21\n", + "adding: mem time87, current time 107, horizon 20\n", + "adding: mem time88, current time 107, horizon 19\n", + "adding: mem time89, current time 107, horizon 18\n", + "adding: mem time90, current time 107, horizon 17\n", + "adding: mem time91, current time 107, horizon 16\n", + "adding: mem time92, current time 107, horizon 15\n", + "adding: mem time93, current time 107, horizon 14\n", + "adding: mem time94, current time 107, horizon 13\n", + "adding: mem time95, current time 107, horizon 12\n", + "adding: mem time96, current time 107, horizon 11\n", + "adding: mem time97, current time 107, horizon 10\n", + "adding: mem time98, current time 107, horizon 9\n", + "adding: mem time99, current time 107, horizon 8\n", + "adding: mem time100, current time 107, horizon 7\n", + "adding: mem time101, current time 107, horizon 6\n", + "adding: mem time102, current time 107, horizon 5\n", + "adding: mem time103, current time 107, horizon 4\n", + "adding: mem time104, current time 107, horizon 3\n", + "adding: mem time105, current time 107, horizon 2\n", + "adding: mem time106, current time 107, horizon 1\n", + "adding: mem time0, current time 108, horizon 108\n", + "adding: mem time1, current time 108, horizon 107\n", + "adding: mem time2, current time 108, horizon 106\n", + "adding: mem time3, current time 108, horizon 105\n", + "adding: mem time4, current time 108, horizon 104\n", + "adding: mem time5, current time 108, horizon 103\n", + "adding: mem time6, current time 108, horizon 102\n", + "adding: mem time7, current time 108, horizon 101\n", + "adding: mem time8, current time 108, horizon 100\n", + "adding: mem time9, current time 108, horizon 99\n", + "adding: mem time10, current time 108, horizon 98\n", + "adding: mem time11, current time 108, horizon 97\n", + "adding: mem time12, current time 108, horizon 96\n", + "adding: mem time13, current time 108, horizon 95\n", + "adding: mem time14, current time 108, horizon 94\n", + "adding: mem time15, current time 108, horizon 93\n", + "adding: mem time16, current time 108, horizon 92\n", + "adding: mem time17, current time 108, horizon 91\n", + "adding: mem time18, current time 108, horizon 90\n", + "adding: mem time19, current time 108, horizon 89\n", + "adding: mem time20, current time 108, horizon 88\n", + "adding: mem time21, current time 108, horizon 87\n", + "adding: mem time22, current time 108, horizon 86\n", + "adding: mem time23, current time 108, horizon 85\n", + "adding: mem time24, current time 108, horizon 84\n", + "adding: mem time25, current time 108, horizon 83\n", + "adding: mem time26, current time 108, horizon 82\n", + "adding: mem time27, current time 108, horizon 81\n", + "adding: mem time28, current time 108, horizon 80\n", + "adding: mem time29, current time 108, horizon 79\n", + "adding: mem time30, current time 108, horizon 78\n", + "adding: mem time31, current time 108, horizon 77\n", + "adding: mem time32, current time 108, horizon 76\n", + "adding: mem time33, current time 108, horizon 75\n", + "adding: mem time34, current time 108, horizon 74\n", + "adding: mem time35, current time 108, horizon 73\n", + "adding: mem time36, current time 108, horizon 72\n", + "adding: mem time37, current time 108, horizon 71\n", + "adding: mem time38, current time 108, horizon 70\n", + "adding: mem time39, current time 108, horizon 69\n", + "adding: mem time40, current time 108, horizon 68\n", + "adding: mem time41, current time 108, horizon 67\n", + "adding: mem time42, current time 108, horizon 66\n", + "adding: mem time43, current time 108, horizon 65\n", + "adding: mem time44, current time 108, horizon 64\n", + "adding: mem time45, current time 108, horizon 63\n", + "adding: mem time46, current time 108, horizon 62\n", + "adding: mem time47, current time 108, horizon 61\n", + "adding: mem time48, current time 108, horizon 60\n", + "adding: mem time49, current time 108, horizon 59\n", + "adding: mem time50, current time 108, horizon 58\n", + "adding: mem time51, current time 108, horizon 57\n", + "adding: mem time52, current time 108, horizon 56\n", + "adding: mem time53, current time 108, horizon 55\n", + "adding: mem time54, current time 108, horizon 54\n", + "adding: mem time55, current time 108, horizon 53\n", + "adding: mem time56, current time 108, horizon 52\n", + "adding: mem time57, current time 108, horizon 51\n", + "adding: mem time58, current time 108, horizon 50\n", + "adding: mem time59, current time 108, horizon 49\n", + "adding: mem time60, current time 108, horizon 48\n", + "adding: mem time61, current time 108, horizon 47\n", + "adding: mem time62, current time 108, horizon 46\n", + "adding: mem time63, current time 108, horizon 45\n", + "adding: mem time64, current time 108, horizon 44\n", + "adding: mem time65, current time 108, horizon 43\n", + "adding: mem time66, current time 108, horizon 42\n", + "adding: mem time67, current time 108, horizon 41\n", + "adding: mem time68, current time 108, horizon 40\n", + "adding: mem time69, current time 108, horizon 39\n", + "adding: mem time70, current time 108, horizon 38\n", + "adding: mem time71, current time 108, horizon 37\n", + "adding: mem time72, current time 108, horizon 36\n", + "adding: mem time73, current time 108, horizon 35\n", + "adding: mem time74, current time 108, horizon 34\n", + "adding: mem time75, current time 108, horizon 33\n", + "adding: mem time76, current time 108, horizon 32\n", + "adding: mem time77, current time 108, horizon 31\n", + "adding: mem time78, current time 108, horizon 30\n", + "adding: mem time79, current time 108, horizon 29\n", + "adding: mem time80, current time 108, horizon 28\n", + "adding: mem time81, current time 108, horizon 27\n", + "adding: mem time82, current time 108, horizon 26\n", + "adding: mem time83, current time 108, horizon 25\n", + "adding: mem time84, current time 108, horizon 24\n", + "adding: mem time85, current time 108, horizon 23\n", + "adding: mem time86, current time 108, horizon 22\n", + "adding: mem time87, current time 108, horizon 21\n", + "adding: mem time88, current time 108, horizon 20\n", + "adding: mem time89, current time 108, horizon 19\n", + "adding: mem time90, current time 108, horizon 18\n", + "adding: mem time91, current time 108, horizon 17\n", + "adding: mem time92, current time 108, horizon 16\n", + "adding: mem time93, current time 108, horizon 15\n", + "adding: mem time94, current time 108, horizon 14\n", + "adding: mem time95, current time 108, horizon 13\n", + "adding: mem time96, current time 108, horizon 12\n", + "adding: mem time97, current time 108, horizon 11\n", + "adding: mem time98, current time 108, horizon 10\n", + "adding: mem time99, current time 108, horizon 9\n", + "adding: mem time100, current time 108, horizon 8\n", + "adding: mem time101, current time 108, horizon 7\n", + "adding: mem time102, current time 108, horizon 6\n", + "adding: mem time103, current time 108, horizon 5\n", + "adding: mem time104, current time 108, horizon 4\n", + "adding: mem time105, current time 108, horizon 3\n", + "adding: mem time106, current time 108, horizon 2\n", + "adding: mem time107, current time 108, horizon 1\n", + "adding: mem time0, current time 109, horizon 109\n", + "adding: mem time1, current time 109, horizon 108\n", + "adding: mem time2, current time 109, horizon 107\n", + "adding: mem time3, current time 109, horizon 106\n", + "adding: mem time4, current time 109, horizon 105\n", + "adding: mem time5, current time 109, horizon 104\n", + "adding: mem time6, current time 109, horizon 103\n", + "adding: mem time7, current time 109, horizon 102\n", + "adding: mem time8, current time 109, horizon 101\n", + "adding: mem time9, current time 109, horizon 100\n", + "adding: mem time10, current time 109, horizon 99\n", + "adding: mem time11, current time 109, horizon 98\n", + "adding: mem time12, current time 109, horizon 97\n", + "adding: mem time13, current time 109, horizon 96\n", + "adding: mem time14, current time 109, horizon 95\n", + "adding: mem time15, current time 109, horizon 94\n", + "adding: mem time16, current time 109, horizon 93\n", + "adding: mem time17, current time 109, horizon 92\n", + "adding: mem time18, current time 109, horizon 91\n", + "adding: mem time19, current time 109, horizon 90\n", + "adding: mem time20, current time 109, horizon 89\n", + "adding: mem time21, current time 109, horizon 88\n", + "adding: mem time22, current time 109, horizon 87\n", + "adding: mem time23, current time 109, horizon 86\n", + "adding: mem time24, current time 109, horizon 85\n", + "adding: mem time25, current time 109, horizon 84\n", + "adding: mem time26, current time 109, horizon 83\n", + "adding: mem time27, current time 109, horizon 82\n", + "adding: mem time28, current time 109, horizon 81\n", + "adding: mem time29, current time 109, horizon 80\n", + "adding: mem time30, current time 109, horizon 79\n", + "adding: mem time31, current time 109, horizon 78\n", + "adding: mem time32, current time 109, horizon 77\n", + "adding: mem time33, current time 109, horizon 76\n", + "adding: mem time34, current time 109, horizon 75\n", + "adding: mem time35, current time 109, horizon 74\n", + "adding: mem time36, current time 109, horizon 73\n", + "adding: mem time37, current time 109, horizon 72\n", + "adding: mem time38, current time 109, horizon 71\n", + "adding: mem time39, current time 109, horizon 70\n", + "adding: mem time40, current time 109, horizon 69\n", + "adding: mem time41, current time 109, horizon 68\n", + "adding: mem time42, current time 109, horizon 67\n", + "adding: mem time43, current time 109, horizon 66\n", + "adding: mem time44, current time 109, horizon 65\n", + "adding: mem time45, current time 109, horizon 64\n", + "adding: mem time46, current time 109, horizon 63\n", + "adding: mem time47, current time 109, horizon 62\n", + "adding: mem time48, current time 109, horizon 61\n", + "adding: mem time49, current time 109, horizon 60\n", + "adding: mem time50, current time 109, horizon 59\n", + "adding: mem time51, current time 109, horizon 58\n", + "adding: mem time52, current time 109, horizon 57\n", + "adding: mem time53, current time 109, horizon 56\n", + "adding: mem time54, current time 109, horizon 55\n", + "adding: mem time55, current time 109, horizon 54\n", + "adding: mem time56, current time 109, horizon 53\n", + "adding: mem time57, current time 109, horizon 52\n", + "adding: mem time58, current time 109, horizon 51\n", + "adding: mem time59, current time 109, horizon 50\n", + "adding: mem time60, current time 109, horizon 49\n", + "adding: mem time61, current time 109, horizon 48\n", + "adding: mem time62, current time 109, horizon 47\n", + "adding: mem time63, current time 109, horizon 46\n", + "adding: mem time64, current time 109, horizon 45\n", + "adding: mem time65, current time 109, horizon 44\n", + "adding: mem time66, current time 109, horizon 43\n", + "adding: mem time67, current time 109, horizon 42\n", + "adding: mem time68, current time 109, horizon 41\n", + "adding: mem time69, current time 109, horizon 40\n", + "adding: mem time70, current time 109, horizon 39\n", + "adding: mem time71, current time 109, horizon 38\n", + "adding: mem time72, current time 109, horizon 37\n", + "adding: mem time73, current time 109, horizon 36\n", + "adding: mem time74, current time 109, horizon 35\n", + "adding: mem time75, current time 109, horizon 34\n", + "adding: mem time76, current time 109, horizon 33\n", + "adding: mem time77, current time 109, horizon 32\n", + "adding: mem time78, current time 109, horizon 31\n", + "adding: mem time79, current time 109, horizon 30\n", + "adding: mem time80, current time 109, horizon 29\n", + "adding: mem time81, current time 109, horizon 28\n", + "adding: mem time82, current time 109, horizon 27\n", + "adding: mem time83, current time 109, horizon 26\n", + "adding: mem time84, current time 109, horizon 25\n", + "adding: mem time85, current time 109, horizon 24\n", + "adding: mem time86, current time 109, horizon 23\n", + "adding: mem time87, current time 109, horizon 22\n", + "adding: mem time88, current time 109, horizon 21\n", + "adding: mem time89, current time 109, horizon 20\n", + "adding: mem time90, current time 109, horizon 19\n", + "adding: mem time91, current time 109, horizon 18\n", + "adding: mem time92, current time 109, horizon 17\n", + "adding: mem time93, current time 109, horizon 16\n", + "adding: mem time94, current time 109, horizon 15\n", + "adding: mem time95, current time 109, horizon 14\n", + "adding: mem time96, current time 109, horizon 13\n", + "adding: mem time97, current time 109, horizon 12\n", + "adding: mem time98, current time 109, horizon 11\n", + "adding: mem time99, current time 109, horizon 10\n", + "adding: mem time100, current time 109, horizon 9\n", + "adding: mem time101, current time 109, horizon 8\n", + "adding: mem time102, current time 109, horizon 7\n", + "adding: mem time103, current time 109, horizon 6\n", + "adding: mem time104, current time 109, horizon 5\n", + "adding: mem time105, current time 109, horizon 4\n", + "adding: mem time106, current time 109, horizon 3\n", + "adding: mem time107, current time 109, horizon 2\n", + "adding: mem time108, current time 109, horizon 1\n", + "adding: mem time0, current time 110, horizon 110\n", + "adding: mem time1, current time 110, horizon 109\n", + "adding: mem time2, current time 110, horizon 108\n", + "adding: mem time3, current time 110, horizon 107\n", + "adding: mem time4, current time 110, horizon 106\n", + "adding: mem time5, current time 110, horizon 105\n", + "adding: mem time6, current time 110, horizon 104\n", + "adding: mem time7, current time 110, horizon 103\n", + "adding: mem time8, current time 110, horizon 102\n", + "adding: mem time9, current time 110, horizon 101\n", + "adding: mem time10, current time 110, horizon 100\n", + "adding: mem time11, current time 110, horizon 99\n", + "adding: mem time12, current time 110, horizon 98\n", + "adding: mem time13, current time 110, horizon 97\n", + "adding: mem time14, current time 110, horizon 96\n", + "adding: mem time15, current time 110, horizon 95\n", + "adding: mem time16, current time 110, horizon 94\n", + "adding: mem time17, current time 110, horizon 93\n", + "adding: mem time18, current time 110, horizon 92\n", + "adding: mem time19, current time 110, horizon 91\n", + "adding: mem time20, current time 110, horizon 90\n", + "adding: mem time21, current time 110, horizon 89\n", + "adding: mem time22, current time 110, horizon 88\n", + "adding: mem time23, current time 110, horizon 87\n", + "adding: mem time24, current time 110, horizon 86\n", + "adding: mem time25, current time 110, horizon 85\n", + "adding: mem time26, current time 110, horizon 84\n", + "adding: mem time27, current time 110, horizon 83\n", + "adding: mem time28, current time 110, horizon 82\n", + "adding: mem time29, current time 110, horizon 81\n", + "adding: mem time30, current time 110, horizon 80\n", + "adding: mem time31, current time 110, horizon 79\n", + "adding: mem time32, current time 110, horizon 78\n", + "adding: mem time33, current time 110, horizon 77\n", + "adding: mem time34, current time 110, horizon 76\n", + "adding: mem time35, current time 110, horizon 75\n", + "adding: mem time36, current time 110, horizon 74\n", + "adding: mem time37, current time 110, horizon 73\n", + "adding: mem time38, current time 110, horizon 72\n", + "adding: mem time39, current time 110, horizon 71\n", + "adding: mem time40, current time 110, horizon 70\n", + "adding: mem time41, current time 110, horizon 69\n", + "adding: mem time42, current time 110, horizon 68\n", + "adding: mem time43, current time 110, horizon 67\n", + "adding: mem time44, current time 110, horizon 66\n", + "adding: mem time45, current time 110, horizon 65\n", + "adding: mem time46, current time 110, horizon 64\n", + "adding: mem time47, current time 110, horizon 63\n", + "adding: mem time48, current time 110, horizon 62\n", + "adding: mem time49, current time 110, horizon 61\n", + "adding: mem time50, current time 110, horizon 60\n", + "adding: mem time51, current time 110, horizon 59\n", + "adding: mem time52, current time 110, horizon 58\n", + "adding: mem time53, current time 110, horizon 57\n", + "adding: mem time54, current time 110, horizon 56\n", + "adding: mem time55, current time 110, horizon 55\n", + "adding: mem time56, current time 110, horizon 54\n", + "adding: mem time57, current time 110, horizon 53\n", + "adding: mem time58, current time 110, horizon 52\n", + "adding: mem time59, current time 110, horizon 51\n", + "adding: mem time60, current time 110, horizon 50\n", + "adding: mem time61, current time 110, horizon 49\n", + "adding: mem time62, current time 110, horizon 48\n", + "adding: mem time63, current time 110, horizon 47\n", + "adding: mem time64, current time 110, horizon 46\n", + "adding: mem time65, current time 110, horizon 45\n", + "adding: mem time66, current time 110, horizon 44\n", + "adding: mem time67, current time 110, horizon 43\n", + "adding: mem time68, current time 110, horizon 42\n", + "adding: mem time69, current time 110, horizon 41\n", + "adding: mem time70, current time 110, horizon 40\n", + "adding: mem time71, current time 110, horizon 39\n", + "adding: mem time72, current time 110, horizon 38\n", + "adding: mem time73, current time 110, horizon 37\n", + "adding: mem time74, current time 110, horizon 36\n", + "adding: mem time75, current time 110, horizon 35\n", + "adding: mem time76, current time 110, horizon 34\n", + "adding: mem time77, current time 110, horizon 33\n", + "adding: mem time78, current time 110, horizon 32\n", + "adding: mem time79, current time 110, horizon 31\n", + "adding: mem time80, current time 110, horizon 30\n", + "adding: mem time81, current time 110, horizon 29\n", + "adding: mem time82, current time 110, horizon 28\n", + "adding: mem time83, current time 110, horizon 27\n", + "adding: mem time84, current time 110, horizon 26\n", + "adding: mem time85, current time 110, horizon 25\n", + "adding: mem time86, current time 110, horizon 24\n", + "adding: mem time87, current time 110, horizon 23\n", + "adding: mem time88, current time 110, horizon 22\n", + "adding: mem time89, current time 110, horizon 21\n", + "adding: mem time90, current time 110, horizon 20\n", + "adding: mem time91, current time 110, horizon 19\n", + "adding: mem time92, current time 110, horizon 18\n", + "adding: mem time93, current time 110, horizon 17\n", + "adding: mem time94, current time 110, horizon 16\n", + "adding: mem time95, current time 110, horizon 15\n", + "adding: mem time96, current time 110, horizon 14\n", + "adding: mem time97, current time 110, horizon 13\n", + "adding: mem time98, current time 110, horizon 12\n", + "adding: mem time99, current time 110, horizon 11\n", + "adding: mem time100, current time 110, horizon 10\n", + "adding: mem time101, current time 110, horizon 9\n", + "adding: mem time102, current time 110, horizon 8\n", + "adding: mem time103, current time 110, horizon 7\n", + "adding: mem time104, current time 110, horizon 6\n", + "adding: mem time105, current time 110, horizon 5\n", + "adding: mem time106, current time 110, horizon 4\n", + "adding: mem time107, current time 110, horizon 3\n", + "adding: mem time108, current time 110, horizon 2\n", + "adding: mem time109, current time 110, horizon 1\n", + "adding: mem time0, current time 111, horizon 111\n", + "adding: mem time1, current time 111, horizon 110\n", + "adding: mem time2, current time 111, horizon 109\n", + "adding: mem time3, current time 111, horizon 108\n", + "adding: mem time4, current time 111, horizon 107\n", + "adding: mem time5, current time 111, horizon 106\n", + "adding: mem time6, current time 111, horizon 105\n", + "adding: mem time7, current time 111, horizon 104\n", + "adding: mem time8, current time 111, horizon 103\n", + "adding: mem time9, current time 111, horizon 102\n", + "adding: mem time10, current time 111, horizon 101\n", + "adding: mem time11, current time 111, horizon 100\n", + "adding: mem time12, current time 111, horizon 99\n", + "adding: mem time13, current time 111, horizon 98\n", + "adding: mem time14, current time 111, horizon 97\n", + "adding: mem time15, current time 111, horizon 96\n", + "adding: mem time16, current time 111, horizon 95\n", + "adding: mem time17, current time 111, horizon 94\n", + "adding: mem time18, current time 111, horizon 93\n", + "adding: mem time19, current time 111, horizon 92\n", + "adding: mem time20, current time 111, horizon 91\n", + "adding: mem time21, current time 111, horizon 90\n", + "adding: mem time22, current time 111, horizon 89\n", + "adding: mem time23, current time 111, horizon 88\n", + "adding: mem time24, current time 111, horizon 87\n", + "adding: mem time25, current time 111, horizon 86\n", + "adding: mem time26, current time 111, horizon 85\n", + "adding: mem time27, current time 111, horizon 84\n", + "adding: mem time28, current time 111, horizon 83\n", + "adding: mem time29, current time 111, horizon 82\n", + "adding: mem time30, current time 111, horizon 81\n", + "adding: mem time31, current time 111, horizon 80\n", + "adding: mem time32, current time 111, horizon 79\n", + "adding: mem time33, current time 111, horizon 78\n", + "adding: mem time34, current time 111, horizon 77\n", + "adding: mem time35, current time 111, horizon 76\n", + "adding: mem time36, current time 111, horizon 75\n", + "adding: mem time37, current time 111, horizon 74\n", + "adding: mem time38, current time 111, horizon 73\n", + "adding: mem time39, current time 111, horizon 72\n", + "adding: mem time40, current time 111, horizon 71\n", + "adding: mem time41, current time 111, horizon 70\n", + "adding: mem time42, current time 111, horizon 69\n", + "adding: mem time43, current time 111, horizon 68\n", + "adding: mem time44, current time 111, horizon 67\n", + "adding: mem time45, current time 111, horizon 66\n", + "adding: mem time46, current time 111, horizon 65\n", + "adding: mem time47, current time 111, horizon 64\n", + "adding: mem time48, current time 111, horizon 63\n", + "adding: mem time49, current time 111, horizon 62\n", + "adding: mem time50, current time 111, horizon 61\n", + "adding: mem time51, current time 111, horizon 60\n", + "adding: mem time52, current time 111, horizon 59\n", + "adding: mem time53, current time 111, horizon 58\n", + "adding: mem time54, current time 111, horizon 57\n", + "adding: mem time55, current time 111, horizon 56\n", + "adding: mem time56, current time 111, horizon 55\n", + "adding: mem time57, current time 111, horizon 54\n", + "adding: mem time58, current time 111, horizon 53\n", + "adding: mem time59, current time 111, horizon 52\n", + "adding: mem time60, current time 111, horizon 51\n", + "adding: mem time61, current time 111, horizon 50\n", + "adding: mem time62, current time 111, horizon 49\n", + "adding: mem time63, current time 111, horizon 48\n", + "adding: mem time64, current time 111, horizon 47\n", + "adding: mem time65, current time 111, horizon 46\n", + "adding: mem time66, current time 111, horizon 45\n", + "adding: mem time67, current time 111, horizon 44\n", + "adding: mem time68, current time 111, horizon 43\n", + "adding: mem time69, current time 111, horizon 42\n", + "adding: mem time70, current time 111, horizon 41\n", + "adding: mem time71, current time 111, horizon 40\n", + "adding: mem time72, current time 111, horizon 39\n", + "adding: mem time73, current time 111, horizon 38\n", + "adding: mem time74, current time 111, horizon 37\n", + "adding: mem time75, current time 111, horizon 36\n", + "adding: mem time76, current time 111, horizon 35\n", + "adding: mem time77, current time 111, horizon 34\n", + "adding: mem time78, current time 111, horizon 33\n", + "adding: mem time79, current time 111, horizon 32\n", + "adding: mem time80, current time 111, horizon 31\n", + "adding: mem time81, current time 111, horizon 30\n", + "adding: mem time82, current time 111, horizon 29\n", + "adding: mem time83, current time 111, horizon 28\n", + "adding: mem time84, current time 111, horizon 27\n", + "adding: mem time85, current time 111, horizon 26\n", + "adding: mem time86, current time 111, horizon 25\n", + "adding: mem time87, current time 111, horizon 24\n", + "adding: mem time88, current time 111, horizon 23\n", + "adding: mem time89, current time 111, horizon 22\n", + "adding: mem time90, current time 111, horizon 21\n", + "adding: mem time91, current time 111, horizon 20\n", + "adding: mem time92, current time 111, horizon 19\n", + "adding: mem time93, current time 111, horizon 18\n", + "adding: mem time94, current time 111, horizon 17\n", + "adding: mem time95, current time 111, horizon 16\n", + "adding: mem time96, current time 111, horizon 15\n", + "adding: mem time97, current time 111, horizon 14\n", + "adding: mem time98, current time 111, horizon 13\n", + "adding: mem time99, current time 111, horizon 12\n", + "adding: mem time100, current time 111, horizon 11\n", + "adding: mem time101, current time 111, horizon 10\n", + "adding: mem time102, current time 111, horizon 9\n", + "adding: mem time103, current time 111, horizon 8\n", + "adding: mem time104, current time 111, horizon 7\n", + "adding: mem time105, current time 111, horizon 6\n", + "adding: mem time106, current time 111, horizon 5\n", + "adding: mem time107, current time 111, horizon 4\n", + "adding: mem time108, current time 111, horizon 3\n", + "adding: mem time109, current time 111, horizon 2\n", + "adding: mem time110, current time 111, horizon 1\n", + "adding: mem time0, current time 112, horizon 112\n", + "adding: mem time1, current time 112, horizon 111\n", + "adding: mem time2, current time 112, horizon 110\n", + "adding: mem time3, current time 112, horizon 109\n", + "adding: mem time4, current time 112, horizon 108\n", + "adding: mem time5, current time 112, horizon 107\n", + "adding: mem time6, current time 112, horizon 106\n", + "adding: mem time7, current time 112, horizon 105\n", + "adding: mem time8, current time 112, horizon 104\n", + "adding: mem time9, current time 112, horizon 103\n", + "adding: mem time10, current time 112, horizon 102\n", + "adding: mem time11, current time 112, horizon 101\n", + "adding: mem time12, current time 112, horizon 100\n", + "adding: mem time13, current time 112, horizon 99\n", + "adding: mem time14, current time 112, horizon 98\n", + "adding: mem time15, current time 112, horizon 97\n", + "adding: mem time16, current time 112, horizon 96\n", + "adding: mem time17, current time 112, horizon 95\n", + "adding: mem time18, current time 112, horizon 94\n", + "adding: mem time19, current time 112, horizon 93\n", + "adding: mem time20, current time 112, horizon 92\n", + "adding: mem time21, current time 112, horizon 91\n", + "adding: mem time22, current time 112, horizon 90\n", + "adding: mem time23, current time 112, horizon 89\n", + "adding: mem time24, current time 112, horizon 88\n", + "adding: mem time25, current time 112, horizon 87\n", + "adding: mem time26, current time 112, horizon 86\n", + "adding: mem time27, current time 112, horizon 85\n", + "adding: mem time28, current time 112, horizon 84\n", + "adding: mem time29, current time 112, horizon 83\n", + "adding: mem time30, current time 112, horizon 82\n", + "adding: mem time31, current time 112, horizon 81\n", + "adding: mem time32, current time 112, horizon 80\n", + "adding: mem time33, current time 112, horizon 79\n", + "adding: mem time34, current time 112, horizon 78\n", + "adding: mem time35, current time 112, horizon 77\n", + "adding: mem time36, current time 112, horizon 76\n", + "adding: mem time37, current time 112, horizon 75\n", + "adding: mem time38, current time 112, horizon 74\n", + "adding: mem time39, current time 112, horizon 73\n", + "adding: mem time40, current time 112, horizon 72\n", + "adding: mem time41, current time 112, horizon 71\n", + "adding: mem time42, current time 112, horizon 70\n", + "adding: mem time43, current time 112, horizon 69\n", + "adding: mem time44, current time 112, horizon 68\n", + "adding: mem time45, current time 112, horizon 67\n", + "adding: mem time46, current time 112, horizon 66\n", + "adding: mem time47, current time 112, horizon 65\n", + "adding: mem time48, current time 112, horizon 64\n", + "adding: mem time49, current time 112, horizon 63\n", + "adding: mem time50, current time 112, horizon 62\n", + "adding: mem time51, current time 112, horizon 61\n", + "adding: mem time52, current time 112, horizon 60\n", + "adding: mem time53, current time 112, horizon 59\n", + "adding: mem time54, current time 112, horizon 58\n", + "adding: mem time55, current time 112, horizon 57\n", + "adding: mem time56, current time 112, horizon 56\n", + "adding: mem time57, current time 112, horizon 55\n", + "adding: mem time58, current time 112, horizon 54\n", + "adding: mem time59, current time 112, horizon 53\n", + "adding: mem time60, current time 112, horizon 52\n", + "adding: mem time61, current time 112, horizon 51\n", + "adding: mem time62, current time 112, horizon 50\n", + "adding: mem time63, current time 112, horizon 49\n", + "adding: mem time64, current time 112, horizon 48\n", + "adding: mem time65, current time 112, horizon 47\n", + "adding: mem time66, current time 112, horizon 46\n", + "adding: mem time67, current time 112, horizon 45\n", + "adding: mem time68, current time 112, horizon 44\n", + "adding: mem time69, current time 112, horizon 43\n", + "adding: mem time70, current time 112, horizon 42\n", + "adding: mem time71, current time 112, horizon 41\n", + "adding: mem time72, current time 112, horizon 40\n", + "adding: mem time73, current time 112, horizon 39\n", + "adding: mem time74, current time 112, horizon 38\n", + "adding: mem time75, current time 112, horizon 37\n", + "adding: mem time76, current time 112, horizon 36\n", + "adding: mem time77, current time 112, horizon 35\n", + "adding: mem time78, current time 112, horizon 34\n", + "adding: mem time79, current time 112, horizon 33\n", + "adding: mem time80, current time 112, horizon 32\n", + "adding: mem time81, current time 112, horizon 31\n", + "adding: mem time82, current time 112, horizon 30\n", + "adding: mem time83, current time 112, horizon 29\n", + "adding: mem time84, current time 112, horizon 28\n", + "adding: mem time85, current time 112, horizon 27\n", + "adding: mem time86, current time 112, horizon 26\n", + "adding: mem time87, current time 112, horizon 25\n", + "adding: mem time88, current time 112, horizon 24\n", + "adding: mem time89, current time 112, horizon 23\n", + "adding: mem time90, current time 112, horizon 22\n", + "adding: mem time91, current time 112, horizon 21\n", + "adding: mem time92, current time 112, horizon 20\n", + "adding: mem time93, current time 112, horizon 19\n", + "adding: mem time94, current time 112, horizon 18\n", + "adding: mem time95, current time 112, horizon 17\n", + "adding: mem time96, current time 112, horizon 16\n", + "adding: mem time97, current time 112, horizon 15\n", + "adding: mem time98, current time 112, horizon 14\n", + "adding: mem time99, current time 112, horizon 13\n", + "adding: mem time100, current time 112, horizon 12\n", + "adding: mem time101, current time 112, horizon 11\n", + "adding: mem time102, current time 112, horizon 10\n", + "adding: mem time103, current time 112, horizon 9\n", + "adding: mem time104, current time 112, horizon 8\n", + "adding: mem time105, current time 112, horizon 7\n", + "adding: mem time106, current time 112, horizon 6\n", + "adding: mem time107, current time 112, horizon 5\n", + "adding: mem time108, current time 112, horizon 4\n", + "adding: mem time109, current time 112, horizon 3\n", + "adding: mem time110, current time 112, horizon 2\n", + "adding: mem time111, current time 112, horizon 1\n", + "adding: mem time0, current time 113, horizon 113\n", + "adding: mem time1, current time 113, horizon 112\n", + "adding: mem time2, current time 113, horizon 111\n", + "adding: mem time3, current time 113, horizon 110\n", + "adding: mem time4, current time 113, horizon 109\n", + "adding: mem time5, current time 113, horizon 108\n", + "adding: mem time6, current time 113, horizon 107\n", + "adding: mem time7, current time 113, horizon 106\n", + "adding: mem time8, current time 113, horizon 105\n", + "adding: mem time9, current time 113, horizon 104\n", + "adding: mem time10, current time 113, horizon 103\n", + "adding: mem time11, current time 113, horizon 102\n", + "adding: mem time12, current time 113, horizon 101\n", + "adding: mem time13, current time 113, horizon 100\n", + "adding: mem time14, current time 113, horizon 99\n", + "adding: mem time15, current time 113, horizon 98\n", + "adding: mem time16, current time 113, horizon 97\n", + "adding: mem time17, current time 113, horizon 96\n", + "adding: mem time18, current time 113, horizon 95\n", + "adding: mem time19, current time 113, horizon 94\n", + "adding: mem time20, current time 113, horizon 93\n", + "adding: mem time21, current time 113, horizon 92\n", + "adding: mem time22, current time 113, horizon 91\n", + "adding: mem time23, current time 113, horizon 90\n", + "adding: mem time24, current time 113, horizon 89\n", + "adding: mem time25, current time 113, horizon 88\n", + "adding: mem time26, current time 113, horizon 87\n", + "adding: mem time27, current time 113, horizon 86\n", + "adding: mem time28, current time 113, horizon 85\n", + "adding: mem time29, current time 113, horizon 84\n", + "adding: mem time30, current time 113, horizon 83\n", + "adding: mem time31, current time 113, horizon 82\n", + "adding: mem time32, current time 113, horizon 81\n", + "adding: mem time33, current time 113, horizon 80\n", + "adding: mem time34, current time 113, horizon 79\n", + "adding: mem time35, current time 113, horizon 78\n", + "adding: mem time36, current time 113, horizon 77\n", + "adding: mem time37, current time 113, horizon 76\n", + "adding: mem time38, current time 113, horizon 75\n", + "adding: mem time39, current time 113, horizon 74\n", + "adding: mem time40, current time 113, horizon 73\n", + "adding: mem time41, current time 113, horizon 72\n", + "adding: mem time42, current time 113, horizon 71\n", + "adding: mem time43, current time 113, horizon 70\n", + "adding: mem time44, current time 113, horizon 69\n", + "adding: mem time45, current time 113, horizon 68\n", + "adding: mem time46, current time 113, horizon 67\n", + "adding: mem time47, current time 113, horizon 66\n", + "adding: mem time48, current time 113, horizon 65\n", + "adding: mem time49, current time 113, horizon 64\n", + "adding: mem time50, current time 113, horizon 63\n", + "adding: mem time51, current time 113, horizon 62\n", + "adding: mem time52, current time 113, horizon 61\n", + "adding: mem time53, current time 113, horizon 60\n", + "adding: mem time54, current time 113, horizon 59\n", + "adding: mem time55, current time 113, horizon 58\n", + "adding: mem time56, current time 113, horizon 57\n", + "adding: mem time57, current time 113, horizon 56\n", + "adding: mem time58, current time 113, horizon 55\n", + "adding: mem time59, current time 113, horizon 54\n", + "adding: mem time60, current time 113, horizon 53\n", + "adding: mem time61, current time 113, horizon 52\n", + "adding: mem time62, current time 113, horizon 51\n", + "adding: mem time63, current time 113, horizon 50\n", + "adding: mem time64, current time 113, horizon 49\n", + "adding: mem time65, current time 113, horizon 48\n", + "adding: mem time66, current time 113, horizon 47\n", + "adding: mem time67, current time 113, horizon 46\n", + "adding: mem time68, current time 113, horizon 45\n", + "adding: mem time69, current time 113, horizon 44\n", + "adding: mem time70, current time 113, horizon 43\n", + "adding: mem time71, current time 113, horizon 42\n", + "adding: mem time72, current time 113, horizon 41\n", + "adding: mem time73, current time 113, horizon 40\n", + "adding: mem time74, current time 113, horizon 39\n", + "adding: mem time75, current time 113, horizon 38\n", + "adding: mem time76, current time 113, horizon 37\n", + "adding: mem time77, current time 113, horizon 36\n", + "adding: mem time78, current time 113, horizon 35\n", + "adding: mem time79, current time 113, horizon 34\n", + "adding: mem time80, current time 113, horizon 33\n", + "adding: mem time81, current time 113, horizon 32\n", + "adding: mem time82, current time 113, horizon 31\n", + "adding: mem time83, current time 113, horizon 30\n", + "adding: mem time84, current time 113, horizon 29\n", + "adding: mem time85, current time 113, horizon 28\n", + "adding: mem time86, current time 113, horizon 27\n", + "adding: mem time87, current time 113, horizon 26\n", + "adding: mem time88, current time 113, horizon 25\n", + "adding: mem time89, current time 113, horizon 24\n", + "adding: mem time90, current time 113, horizon 23\n", + "adding: mem time91, current time 113, horizon 22\n", + "adding: mem time92, current time 113, horizon 21\n", + "adding: mem time93, current time 113, horizon 20\n", + "adding: mem time94, current time 113, horizon 19\n", + "adding: mem time95, current time 113, horizon 18\n", + "adding: mem time96, current time 113, horizon 17\n", + "adding: mem time97, current time 113, horizon 16\n", + "adding: mem time98, current time 113, horizon 15\n", + "adding: mem time99, current time 113, horizon 14\n", + "adding: mem time100, current time 113, horizon 13\n", + "adding: mem time101, current time 113, horizon 12\n", + "adding: mem time102, current time 113, horizon 11\n", + "adding: mem time103, current time 113, horizon 10\n", + "adding: mem time104, current time 113, horizon 9\n", + "adding: mem time105, current time 113, horizon 8\n", + "adding: mem time106, current time 113, horizon 7\n", + "adding: mem time107, current time 113, horizon 6\n", + "adding: mem time108, current time 113, horizon 5\n", + "adding: mem time109, current time 113, horizon 4\n", + "adding: mem time110, current time 113, horizon 3\n", + "adding: mem time111, current time 113, horizon 2\n", + "adding: mem time112, current time 113, horizon 1\n", + "adding: mem time0, current time 114, horizon 114\n", + "adding: mem time1, current time 114, horizon 113\n", + "adding: mem time2, current time 114, horizon 112\n", + "adding: mem time3, current time 114, horizon 111\n", + "adding: mem time4, current time 114, horizon 110\n", + "adding: mem time5, current time 114, horizon 109\n", + "adding: mem time6, current time 114, horizon 108\n", + "adding: mem time7, current time 114, horizon 107\n", + "adding: mem time8, current time 114, horizon 106\n", + "adding: mem time9, current time 114, horizon 105\n", + "adding: mem time10, current time 114, horizon 104\n", + "adding: mem time11, current time 114, horizon 103\n", + "adding: mem time12, current time 114, horizon 102\n", + "adding: mem time13, current time 114, horizon 101\n", + "adding: mem time14, current time 114, horizon 100\n", + "adding: mem time15, current time 114, horizon 99\n", + "adding: mem time16, current time 114, horizon 98\n", + "adding: mem time17, current time 114, horizon 97\n", + "adding: mem time18, current time 114, horizon 96\n", + "adding: mem time19, current time 114, horizon 95\n", + "adding: mem time20, current time 114, horizon 94\n", + "adding: mem time21, current time 114, horizon 93\n", + "adding: mem time22, current time 114, horizon 92\n", + "adding: mem time23, current time 114, horizon 91\n", + "adding: mem time24, current time 114, horizon 90\n", + "adding: mem time25, current time 114, horizon 89\n", + "adding: mem time26, current time 114, horizon 88\n", + "adding: mem time27, current time 114, horizon 87\n", + "adding: mem time28, current time 114, horizon 86\n", + "adding: mem time29, current time 114, horizon 85\n", + "adding: mem time30, current time 114, horizon 84\n", + "adding: mem time31, current time 114, horizon 83\n", + "adding: mem time32, current time 114, horizon 82\n", + "adding: mem time33, current time 114, horizon 81\n", + "adding: mem time34, current time 114, horizon 80\n", + "adding: mem time35, current time 114, horizon 79\n", + "adding: mem time36, current time 114, horizon 78\n", + "adding: mem time37, current time 114, horizon 77\n", + "adding: mem time38, current time 114, horizon 76\n", + "adding: mem time39, current time 114, horizon 75\n", + "adding: mem time40, current time 114, horizon 74\n", + "adding: mem time41, current time 114, horizon 73\n", + "adding: mem time42, current time 114, horizon 72\n", + "adding: mem time43, current time 114, horizon 71\n", + "adding: mem time44, current time 114, horizon 70\n", + "adding: mem time45, current time 114, horizon 69\n", + "adding: mem time46, current time 114, horizon 68\n", + "adding: mem time47, current time 114, horizon 67\n", + "adding: mem time48, current time 114, horizon 66\n", + "adding: mem time49, current time 114, horizon 65\n", + "adding: mem time50, current time 114, horizon 64\n", + "adding: mem time51, current time 114, horizon 63\n", + "adding: mem time52, current time 114, horizon 62\n", + "adding: mem time53, current time 114, horizon 61\n", + "adding: mem time54, current time 114, horizon 60\n", + "adding: mem time55, current time 114, horizon 59\n", + "adding: mem time56, current time 114, horizon 58\n", + "adding: mem time57, current time 114, horizon 57\n", + "adding: mem time58, current time 114, horizon 56\n", + "adding: mem time59, current time 114, horizon 55\n", + "adding: mem time60, current time 114, horizon 54\n", + "adding: mem time61, current time 114, horizon 53\n", + "adding: mem time62, current time 114, horizon 52\n", + "adding: mem time63, current time 114, horizon 51\n", + "adding: mem time64, current time 114, horizon 50\n", + "adding: mem time65, current time 114, horizon 49\n", + "adding: mem time66, current time 114, horizon 48\n", + "adding: mem time67, current time 114, horizon 47\n", + "adding: mem time68, current time 114, horizon 46\n", + "adding: mem time69, current time 114, horizon 45\n", + "adding: mem time70, current time 114, horizon 44\n", + "adding: mem time71, current time 114, horizon 43\n", + "adding: mem time72, current time 114, horizon 42\n", + "adding: mem time73, current time 114, horizon 41\n", + "adding: mem time74, current time 114, horizon 40\n", + "adding: mem time75, current time 114, horizon 39\n", + "adding: mem time76, current time 114, horizon 38\n", + "adding: mem time77, current time 114, horizon 37\n", + "adding: mem time78, current time 114, horizon 36\n", + "adding: mem time79, current time 114, horizon 35\n", + "adding: mem time80, current time 114, horizon 34\n", + "adding: mem time81, current time 114, horizon 33\n", + "adding: mem time82, current time 114, horizon 32\n", + "adding: mem time83, current time 114, horizon 31\n", + "adding: mem time84, current time 114, horizon 30\n", + "adding: mem time85, current time 114, horizon 29\n", + "adding: mem time86, current time 114, horizon 28\n", + "adding: mem time87, current time 114, horizon 27\n", + "adding: mem time88, current time 114, horizon 26\n", + "adding: mem time89, current time 114, horizon 25\n", + "adding: mem time90, current time 114, horizon 24\n", + "adding: mem time91, current time 114, horizon 23\n", + "adding: mem time92, current time 114, horizon 22\n", + "adding: mem time93, current time 114, horizon 21\n", + "adding: mem time94, current time 114, horizon 20\n", + "adding: mem time95, current time 114, horizon 19\n", + "adding: mem time96, current time 114, horizon 18\n", + "adding: mem time97, current time 114, horizon 17\n", + "adding: mem time98, current time 114, horizon 16\n", + "adding: mem time99, current time 114, horizon 15\n", + "adding: mem time100, current time 114, horizon 14\n", + "adding: mem time101, current time 114, horizon 13\n", + "adding: mem time102, current time 114, horizon 12\n", + "adding: mem time103, current time 114, horizon 11\n", + "adding: mem time104, current time 114, horizon 10\n", + "adding: mem time105, current time 114, horizon 9\n", + "adding: mem time106, current time 114, horizon 8\n", + "adding: mem time107, current time 114, horizon 7\n", + "adding: mem time108, current time 114, horizon 6\n", + "adding: mem time109, current time 114, horizon 5\n", + "adding: mem time110, current time 114, horizon 4\n", + "adding: mem time111, current time 114, horizon 3\n", + "adding: mem time112, current time 114, horizon 2\n", + "adding: mem time113, current time 114, horizon 1\n", + "adding: mem time0, current time 115, horizon 115\n", + "adding: mem time1, current time 115, horizon 114\n", + "adding: mem time2, current time 115, horizon 113\n", + "adding: mem time3, current time 115, horizon 112\n", + "adding: mem time4, current time 115, horizon 111\n", + "adding: mem time5, current time 115, horizon 110\n", + "adding: mem time6, current time 115, horizon 109\n", + "adding: mem time7, current time 115, horizon 108\n", + "adding: mem time8, current time 115, horizon 107\n", + "adding: mem time9, current time 115, horizon 106\n", + "adding: mem time10, current time 115, horizon 105\n", + "adding: mem time11, current time 115, horizon 104\n", + "adding: mem time12, current time 115, horizon 103\n", + "adding: mem time13, current time 115, horizon 102\n", + "adding: mem time14, current time 115, horizon 101\n", + "adding: mem time15, current time 115, horizon 100\n", + "adding: mem time16, current time 115, horizon 99\n", + "adding: mem time17, current time 115, horizon 98\n", + "adding: mem time18, current time 115, horizon 97\n", + "adding: mem time19, current time 115, horizon 96\n", + "adding: mem time20, current time 115, horizon 95\n", + "adding: mem time21, current time 115, horizon 94\n", + "adding: mem time22, current time 115, horizon 93\n", + "adding: mem time23, current time 115, horizon 92\n", + "adding: mem time24, current time 115, horizon 91\n", + "adding: mem time25, current time 115, horizon 90\n", + "adding: mem time26, current time 115, horizon 89\n", + "adding: mem time27, current time 115, horizon 88\n", + "adding: mem time28, current time 115, horizon 87\n", + "adding: mem time29, current time 115, horizon 86\n", + "adding: mem time30, current time 115, horizon 85\n", + "adding: mem time31, current time 115, horizon 84\n", + "adding: mem time32, current time 115, horizon 83\n", + "adding: mem time33, current time 115, horizon 82\n", + "adding: mem time34, current time 115, horizon 81\n", + "adding: mem time35, current time 115, horizon 80\n", + "adding: mem time36, current time 115, horizon 79\n", + "adding: mem time37, current time 115, horizon 78\n", + "adding: mem time38, current time 115, horizon 77\n", + "adding: mem time39, current time 115, horizon 76\n", + "adding: mem time40, current time 115, horizon 75\n", + "adding: mem time41, current time 115, horizon 74\n", + "adding: mem time42, current time 115, horizon 73\n", + "adding: mem time43, current time 115, horizon 72\n", + "adding: mem time44, current time 115, horizon 71\n", + "adding: mem time45, current time 115, horizon 70\n", + "adding: mem time46, current time 115, horizon 69\n", + "adding: mem time47, current time 115, horizon 68\n", + "adding: mem time48, current time 115, horizon 67\n", + "adding: mem time49, current time 115, horizon 66\n", + "adding: mem time50, current time 115, horizon 65\n", + "adding: mem time51, current time 115, horizon 64\n", + "adding: mem time52, current time 115, horizon 63\n", + "adding: mem time53, current time 115, horizon 62\n", + "adding: mem time54, current time 115, horizon 61\n", + "adding: mem time55, current time 115, horizon 60\n", + "adding: mem time56, current time 115, horizon 59\n", + "adding: mem time57, current time 115, horizon 58\n", + "adding: mem time58, current time 115, horizon 57\n", + "adding: mem time59, current time 115, horizon 56\n", + "adding: mem time60, current time 115, horizon 55\n", + "adding: mem time61, current time 115, horizon 54\n", + "adding: mem time62, current time 115, horizon 53\n", + "adding: mem time63, current time 115, horizon 52\n", + "adding: mem time64, current time 115, horizon 51\n", + "adding: mem time65, current time 115, horizon 50\n", + "adding: mem time66, current time 115, horizon 49\n", + "adding: mem time67, current time 115, horizon 48\n", + "adding: mem time68, current time 115, horizon 47\n", + "adding: mem time69, current time 115, horizon 46\n", + "adding: mem time70, current time 115, horizon 45\n", + "adding: mem time71, current time 115, horizon 44\n", + "adding: mem time72, current time 115, horizon 43\n", + "adding: mem time73, current time 115, horizon 42\n", + "adding: mem time74, current time 115, horizon 41\n", + "adding: mem time75, current time 115, horizon 40\n", + "adding: mem time76, current time 115, horizon 39\n", + "adding: mem time77, current time 115, horizon 38\n", + "adding: mem time78, current time 115, horizon 37\n", + "adding: mem time79, current time 115, horizon 36\n", + "adding: mem time80, current time 115, horizon 35\n", + "adding: mem time81, current time 115, horizon 34\n", + "adding: mem time82, current time 115, horizon 33\n", + "adding: mem time83, current time 115, horizon 32\n", + "adding: mem time84, current time 115, horizon 31\n", + "adding: mem time85, current time 115, horizon 30\n", + "adding: mem time86, current time 115, horizon 29\n", + "adding: mem time87, current time 115, horizon 28\n", + "adding: mem time88, current time 115, horizon 27\n", + "adding: mem time89, current time 115, horizon 26\n", + "adding: mem time90, current time 115, horizon 25\n", + "adding: mem time91, current time 115, horizon 24\n", + "adding: mem time92, current time 115, horizon 23\n", + "adding: mem time93, current time 115, horizon 22\n", + "adding: mem time94, current time 115, horizon 21\n", + "adding: mem time95, current time 115, horizon 20\n", + "adding: mem time96, current time 115, horizon 19\n", + "adding: mem time97, current time 115, horizon 18\n", + "adding: mem time98, current time 115, horizon 17\n", + "adding: mem time99, current time 115, horizon 16\n", + "adding: mem time100, current time 115, horizon 15\n", + "adding: mem time101, current time 115, horizon 14\n", + "adding: mem time102, current time 115, horizon 13\n", + "adding: mem time103, current time 115, horizon 12\n", + "adding: mem time104, current time 115, horizon 11\n", + "adding: mem time105, current time 115, horizon 10\n", + "adding: mem time106, current time 115, horizon 9\n", + "adding: mem time107, current time 115, horizon 8\n", + "adding: mem time108, current time 115, horizon 7\n", + "adding: mem time109, current time 115, horizon 6\n", + "adding: mem time110, current time 115, horizon 5\n", + "adding: mem time111, current time 115, horizon 4\n", + "adding: mem time112, current time 115, horizon 3\n", + "adding: mem time113, current time 115, horizon 2\n", + "adding: mem time114, current time 115, horizon 1\n", + "adding: mem time0, current time 116, horizon 116\n", + "adding: mem time1, current time 116, horizon 115\n", + "adding: mem time2, current time 116, horizon 114\n", + "adding: mem time3, current time 116, horizon 113\n", + "adding: mem time4, current time 116, horizon 112\n", + "adding: mem time5, current time 116, horizon 111\n", + "adding: mem time6, current time 116, horizon 110\n", + "adding: mem time7, current time 116, horizon 109\n", + "adding: mem time8, current time 116, horizon 108\n", + "adding: mem time9, current time 116, horizon 107\n", + "adding: mem time10, current time 116, horizon 106\n", + "adding: mem time11, current time 116, horizon 105\n", + "adding: mem time12, current time 116, horizon 104\n", + "adding: mem time13, current time 116, horizon 103\n", + "adding: mem time14, current time 116, horizon 102\n", + "adding: mem time15, current time 116, horizon 101\n", + "adding: mem time16, current time 116, horizon 100\n", + "adding: mem time17, current time 116, horizon 99\n", + "adding: mem time18, current time 116, horizon 98\n", + "adding: mem time19, current time 116, horizon 97\n", + "adding: mem time20, current time 116, horizon 96\n", + "adding: mem time21, current time 116, horizon 95\n", + "adding: mem time22, current time 116, horizon 94\n", + "adding: mem time23, current time 116, horizon 93\n", + "adding: mem time24, current time 116, horizon 92\n", + "adding: mem time25, current time 116, horizon 91\n", + "adding: mem time26, current time 116, horizon 90\n", + "adding: mem time27, current time 116, horizon 89\n", + "adding: mem time28, current time 116, horizon 88\n", + "adding: mem time29, current time 116, horizon 87\n", + "adding: mem time30, current time 116, horizon 86\n", + "adding: mem time31, current time 116, horizon 85\n", + "adding: mem time32, current time 116, horizon 84\n", + "adding: mem time33, current time 116, horizon 83\n", + "adding: mem time34, current time 116, horizon 82\n", + "adding: mem time35, current time 116, horizon 81\n", + "adding: mem time36, current time 116, horizon 80\n", + "adding: mem time37, current time 116, horizon 79\n", + "adding: mem time38, current time 116, horizon 78\n", + "adding: mem time39, current time 116, horizon 77\n", + "adding: mem time40, current time 116, horizon 76\n", + "adding: mem time41, current time 116, horizon 75\n", + "adding: mem time42, current time 116, horizon 74\n", + "adding: mem time43, current time 116, horizon 73\n", + "adding: mem time44, current time 116, horizon 72\n", + "adding: mem time45, current time 116, horizon 71\n", + "adding: mem time46, current time 116, horizon 70\n", + "adding: mem time47, current time 116, horizon 69\n", + "adding: mem time48, current time 116, horizon 68\n", + "adding: mem time49, current time 116, horizon 67\n", + "adding: mem time50, current time 116, horizon 66\n", + "adding: mem time51, current time 116, horizon 65\n", + "adding: mem time52, current time 116, horizon 64\n", + "adding: mem time53, current time 116, horizon 63\n", + "adding: mem time54, current time 116, horizon 62\n", + "adding: mem time55, current time 116, horizon 61\n", + "adding: mem time56, current time 116, horizon 60\n", + "adding: mem time57, current time 116, horizon 59\n", + "adding: mem time58, current time 116, horizon 58\n", + "adding: mem time59, current time 116, horizon 57\n", + "adding: mem time60, current time 116, horizon 56\n", + "adding: mem time61, current time 116, horizon 55\n", + "adding: mem time62, current time 116, horizon 54\n", + "adding: mem time63, current time 116, horizon 53\n", + "adding: mem time64, current time 116, horizon 52\n", + "adding: mem time65, current time 116, horizon 51\n", + "adding: mem time66, current time 116, horizon 50\n", + "adding: mem time67, current time 116, horizon 49\n", + "adding: mem time68, current time 116, horizon 48\n", + "adding: mem time69, current time 116, horizon 47\n", + "adding: mem time70, current time 116, horizon 46\n", + "adding: mem time71, current time 116, horizon 45\n", + "adding: mem time72, current time 116, horizon 44\n", + "adding: mem time73, current time 116, horizon 43\n", + "adding: mem time74, current time 116, horizon 42\n", + "adding: mem time75, current time 116, horizon 41\n", + "adding: mem time76, current time 116, horizon 40\n", + "adding: mem time77, current time 116, horizon 39\n", + "adding: mem time78, current time 116, horizon 38\n", + "adding: mem time79, current time 116, horizon 37\n", + "adding: mem time80, current time 116, horizon 36\n", + "adding: mem time81, current time 116, horizon 35\n", + "adding: mem time82, current time 116, horizon 34\n", + "adding: mem time83, current time 116, horizon 33\n", + "adding: mem time84, current time 116, horizon 32\n", + "adding: mem time85, current time 116, horizon 31\n", + "adding: mem time86, current time 116, horizon 30\n", + "adding: mem time87, current time 116, horizon 29\n", + "adding: mem time88, current time 116, horizon 28\n", + "adding: mem time89, current time 116, horizon 27\n", + "adding: mem time90, current time 116, horizon 26\n", + "adding: mem time91, current time 116, horizon 25\n", + "adding: mem time92, current time 116, horizon 24\n", + "adding: mem time93, current time 116, horizon 23\n", + "adding: mem time94, current time 116, horizon 22\n", + "adding: mem time95, current time 116, horizon 21\n", + "adding: mem time96, current time 116, horizon 20\n", + "adding: mem time97, current time 116, horizon 19\n", + "adding: mem time98, current time 116, horizon 18\n", + "adding: mem time99, current time 116, horizon 17\n", + "adding: mem time100, current time 116, horizon 16\n", + "adding: mem time101, current time 116, horizon 15\n", + "adding: mem time102, current time 116, horizon 14\n", + "adding: mem time103, current time 116, horizon 13\n", + "adding: mem time104, current time 116, horizon 12\n", + "adding: mem time105, current time 116, horizon 11\n", + "adding: mem time106, current time 116, horizon 10\n", + "adding: mem time107, current time 116, horizon 9\n", + "adding: mem time108, current time 116, horizon 8\n", + "adding: mem time109, current time 116, horizon 7\n", + "adding: mem time110, current time 116, horizon 6\n", + "adding: mem time111, current time 116, horizon 5\n", + "adding: mem time112, current time 116, horizon 4\n", + "adding: mem time113, current time 116, horizon 3\n", + "adding: mem time114, current time 116, horizon 2\n", + "adding: mem time115, current time 116, horizon 1\n", + "adding: mem time0, current time 117, horizon 117\n", + "adding: mem time1, current time 117, horizon 116\n", + "adding: mem time2, current time 117, horizon 115\n", + "adding: mem time3, current time 117, horizon 114\n", + "adding: mem time4, current time 117, horizon 113\n", + "adding: mem time5, current time 117, horizon 112\n", + "adding: mem time6, current time 117, horizon 111\n", + "adding: mem time7, current time 117, horizon 110\n", + "adding: mem time8, current time 117, horizon 109\n", + "adding: mem time9, current time 117, horizon 108\n", + "adding: mem time10, current time 117, horizon 107\n", + "adding: mem time11, current time 117, horizon 106\n", + "adding: mem time12, current time 117, horizon 105\n", + "adding: mem time13, current time 117, horizon 104\n", + "adding: mem time14, current time 117, horizon 103\n", + "adding: mem time15, current time 117, horizon 102\n", + "adding: mem time16, current time 117, horizon 101\n", + "adding: mem time17, current time 117, horizon 100\n", + "adding: mem time18, current time 117, horizon 99\n", + "adding: mem time19, current time 117, horizon 98\n", + "adding: mem time20, current time 117, horizon 97\n", + "adding: mem time21, current time 117, horizon 96\n", + "adding: mem time22, current time 117, horizon 95\n", + "adding: mem time23, current time 117, horizon 94\n", + "adding: mem time24, current time 117, horizon 93\n", + "adding: mem time25, current time 117, horizon 92\n", + "adding: mem time26, current time 117, horizon 91\n", + "adding: mem time27, current time 117, horizon 90\n", + "adding: mem time28, current time 117, horizon 89\n", + "adding: mem time29, current time 117, horizon 88\n", + "adding: mem time30, current time 117, horizon 87\n", + "adding: mem time31, current time 117, horizon 86\n", + "adding: mem time32, current time 117, horizon 85\n", + "adding: mem time33, current time 117, horizon 84\n", + "adding: mem time34, current time 117, horizon 83\n", + "adding: mem time35, current time 117, horizon 82\n", + "adding: mem time36, current time 117, horizon 81\n", + "adding: mem time37, current time 117, horizon 80\n", + "adding: mem time38, current time 117, horizon 79\n", + "adding: mem time39, current time 117, horizon 78\n", + "adding: mem time40, current time 117, horizon 77\n", + "adding: mem time41, current time 117, horizon 76\n", + "adding: mem time42, current time 117, horizon 75\n", + "adding: mem time43, current time 117, horizon 74\n", + "adding: mem time44, current time 117, horizon 73\n", + "adding: mem time45, current time 117, horizon 72\n", + "adding: mem time46, current time 117, horizon 71\n", + "adding: mem time47, current time 117, horizon 70\n", + "adding: mem time48, current time 117, horizon 69\n", + "adding: mem time49, current time 117, horizon 68\n", + "adding: mem time50, current time 117, horizon 67\n", + "adding: mem time51, current time 117, horizon 66\n", + "adding: mem time52, current time 117, horizon 65\n", + "adding: mem time53, current time 117, horizon 64\n", + "adding: mem time54, current time 117, horizon 63\n", + "adding: mem time55, current time 117, horizon 62\n", + "adding: mem time56, current time 117, horizon 61\n", + "adding: mem time57, current time 117, horizon 60\n", + "adding: mem time58, current time 117, horizon 59\n", + "adding: mem time59, current time 117, horizon 58\n", + "adding: mem time60, current time 117, horizon 57\n", + "adding: mem time61, current time 117, horizon 56\n", + "adding: mem time62, current time 117, horizon 55\n", + "adding: mem time63, current time 117, horizon 54\n", + "adding: mem time64, current time 117, horizon 53\n", + "adding: mem time65, current time 117, horizon 52\n", + "adding: mem time66, current time 117, horizon 51\n", + "adding: mem time67, current time 117, horizon 50\n", + "adding: mem time68, current time 117, horizon 49\n", + "adding: mem time69, current time 117, horizon 48\n", + "adding: mem time70, current time 117, horizon 47\n", + "adding: mem time71, current time 117, horizon 46\n", + "adding: mem time72, current time 117, horizon 45\n", + "adding: mem time73, current time 117, horizon 44\n", + "adding: mem time74, current time 117, horizon 43\n", + "adding: mem time75, current time 117, horizon 42\n", + "adding: mem time76, current time 117, horizon 41\n", + "adding: mem time77, current time 117, horizon 40\n", + "adding: mem time78, current time 117, horizon 39\n", + "adding: mem time79, current time 117, horizon 38\n", + "adding: mem time80, current time 117, horizon 37\n", + "adding: mem time81, current time 117, horizon 36\n", + "adding: mem time82, current time 117, horizon 35\n", + "adding: mem time83, current time 117, horizon 34\n", + "adding: mem time84, current time 117, horizon 33\n", + "adding: mem time85, current time 117, horizon 32\n", + "adding: mem time86, current time 117, horizon 31\n", + "adding: mem time87, current time 117, horizon 30\n", + "adding: mem time88, current time 117, horizon 29\n", + "adding: mem time89, current time 117, horizon 28\n", + "adding: mem time90, current time 117, horizon 27\n", + "adding: mem time91, current time 117, horizon 26\n", + "adding: mem time92, current time 117, horizon 25\n", + "adding: mem time93, current time 117, horizon 24\n", + "adding: mem time94, current time 117, horizon 23\n", + "adding: mem time95, current time 117, horizon 22\n", + "adding: mem time96, current time 117, horizon 21\n", + "adding: mem time97, current time 117, horizon 20\n", + "adding: mem time98, current time 117, horizon 19\n", + "adding: mem time99, current time 117, horizon 18\n", + "adding: mem time100, current time 117, horizon 17\n", + "adding: mem time101, current time 117, horizon 16\n", + "adding: mem time102, current time 117, horizon 15\n", + "adding: mem time103, current time 117, horizon 14\n", + "adding: mem time104, current time 117, horizon 13\n", + "adding: mem time105, current time 117, horizon 12\n", + "adding: mem time106, current time 117, horizon 11\n", + "adding: mem time107, current time 117, horizon 10\n", + "adding: mem time108, current time 117, horizon 9\n", + "adding: mem time109, current time 117, horizon 8\n", + "adding: mem time110, current time 117, horizon 7\n", + "adding: mem time111, current time 117, horizon 6\n", + "adding: mem time112, current time 117, horizon 5\n", + "adding: mem time113, current time 117, horizon 4\n", + "adding: mem time114, current time 117, horizon 3\n", + "adding: mem time115, current time 117, horizon 2\n", + "adding: mem time116, current time 117, horizon 1\n", + "adding: mem time0, current time 118, horizon 118\n", + "adding: mem time1, current time 118, horizon 117\n", + "adding: mem time2, current time 118, horizon 116\n", + "adding: mem time3, current time 118, horizon 115\n", + "adding: mem time4, current time 118, horizon 114\n", + "adding: mem time5, current time 118, horizon 113\n", + "adding: mem time6, current time 118, horizon 112\n", + "adding: mem time7, current time 118, horizon 111\n", + "adding: mem time8, current time 118, horizon 110\n", + "adding: mem time9, current time 118, horizon 109\n", + "adding: mem time10, current time 118, horizon 108\n", + "adding: mem time11, current time 118, horizon 107\n", + "adding: mem time12, current time 118, horizon 106\n", + "adding: mem time13, current time 118, horizon 105\n", + "adding: mem time14, current time 118, horizon 104\n", + "adding: mem time15, current time 118, horizon 103\n", + "adding: mem time16, current time 118, horizon 102\n", + "adding: mem time17, current time 118, horizon 101\n", + "adding: mem time18, current time 118, horizon 100\n", + "adding: mem time19, current time 118, horizon 99\n", + "adding: mem time20, current time 118, horizon 98\n", + "adding: mem time21, current time 118, horizon 97\n", + "adding: mem time22, current time 118, horizon 96\n", + "adding: mem time23, current time 118, horizon 95\n", + "adding: mem time24, current time 118, horizon 94\n", + "adding: mem time25, current time 118, horizon 93\n", + "adding: mem time26, current time 118, horizon 92\n", + "adding: mem time27, current time 118, horizon 91\n", + "adding: mem time28, current time 118, horizon 90\n", + "adding: mem time29, current time 118, horizon 89\n", + "adding: mem time30, current time 118, horizon 88\n", + "adding: mem time31, current time 118, horizon 87\n", + "adding: mem time32, current time 118, horizon 86\n", + "adding: mem time33, current time 118, horizon 85\n", + "adding: mem time34, current time 118, horizon 84\n", + "adding: mem time35, current time 118, horizon 83\n", + "adding: mem time36, current time 118, horizon 82\n", + "adding: mem time37, current time 118, horizon 81\n", + "adding: mem time38, current time 118, horizon 80\n", + "adding: mem time39, current time 118, horizon 79\n", + "adding: mem time40, current time 118, horizon 78\n", + "adding: mem time41, current time 118, horizon 77\n", + "adding: mem time42, current time 118, horizon 76\n", + "adding: mem time43, current time 118, horizon 75\n", + "adding: mem time44, current time 118, horizon 74\n", + "adding: mem time45, current time 118, horizon 73\n", + "adding: mem time46, current time 118, horizon 72\n", + "adding: mem time47, current time 118, horizon 71\n", + "adding: mem time48, current time 118, horizon 70\n", + "adding: mem time49, current time 118, horizon 69\n", + "adding: mem time50, current time 118, horizon 68\n", + "adding: mem time51, current time 118, horizon 67\n", + "adding: mem time52, current time 118, horizon 66\n", + "adding: mem time53, current time 118, horizon 65\n", + "adding: mem time54, current time 118, horizon 64\n", + "adding: mem time55, current time 118, horizon 63\n", + "adding: mem time56, current time 118, horizon 62\n", + "adding: mem time57, current time 118, horizon 61\n", + "adding: mem time58, current time 118, horizon 60\n", + "adding: mem time59, current time 118, horizon 59\n", + "adding: mem time60, current time 118, horizon 58\n", + "adding: mem time61, current time 118, horizon 57\n", + "adding: mem time62, current time 118, horizon 56\n", + "adding: mem time63, current time 118, horizon 55\n", + "adding: mem time64, current time 118, horizon 54\n", + "adding: mem time65, current time 118, horizon 53\n", + "adding: mem time66, current time 118, horizon 52\n", + "adding: mem time67, current time 118, horizon 51\n", + "adding: mem time68, current time 118, horizon 50\n", + "adding: mem time69, current time 118, horizon 49\n", + "adding: mem time70, current time 118, horizon 48\n", + "adding: mem time71, current time 118, horizon 47\n", + "adding: mem time72, current time 118, horizon 46\n", + "adding: mem time73, current time 118, horizon 45\n", + "adding: mem time74, current time 118, horizon 44\n", + "adding: mem time75, current time 118, horizon 43\n", + "adding: mem time76, current time 118, horizon 42\n", + "adding: mem time77, current time 118, horizon 41\n", + "adding: mem time78, current time 118, horizon 40\n", + "adding: mem time79, current time 118, horizon 39\n", + "adding: mem time80, current time 118, horizon 38\n", + "adding: mem time81, current time 118, horizon 37\n", + "adding: mem time82, current time 118, horizon 36\n", + "adding: mem time83, current time 118, horizon 35\n", + "adding: mem time84, current time 118, horizon 34\n", + "adding: mem time85, current time 118, horizon 33\n", + "adding: mem time86, current time 118, horizon 32\n", + "adding: mem time87, current time 118, horizon 31\n", + "adding: mem time88, current time 118, horizon 30\n", + "adding: mem time89, current time 118, horizon 29\n", + "adding: mem time90, current time 118, horizon 28\n", + "adding: mem time91, current time 118, horizon 27\n", + "adding: mem time92, current time 118, horizon 26\n", + "adding: mem time93, current time 118, horizon 25\n", + "adding: mem time94, current time 118, horizon 24\n", + "adding: mem time95, current time 118, horizon 23\n", + "adding: mem time96, current time 118, horizon 22\n", + "adding: mem time97, current time 118, horizon 21\n", + "adding: mem time98, current time 118, horizon 20\n", + "adding: mem time99, current time 118, horizon 19\n", + "adding: mem time100, current time 118, horizon 18\n", + "adding: mem time101, current time 118, horizon 17\n", + "adding: mem time102, current time 118, horizon 16\n", + "adding: mem time103, current time 118, horizon 15\n", + "adding: mem time104, current time 118, horizon 14\n", + "adding: mem time105, current time 118, horizon 13\n", + "adding: mem time106, current time 118, horizon 12\n", + "adding: mem time107, current time 118, horizon 11\n", + "adding: mem time108, current time 118, horizon 10\n", + "adding: mem time109, current time 118, horizon 9\n", + "adding: mem time110, current time 118, horizon 8\n", + "adding: mem time111, current time 118, horizon 7\n", + "adding: mem time112, current time 118, horizon 6\n", + "adding: mem time113, current time 118, horizon 5\n", + "adding: mem time114, current time 118, horizon 4\n", + "adding: mem time115, current time 118, horizon 3\n", + "adding: mem time116, current time 118, horizon 2\n", + "adding: mem time117, current time 118, horizon 1\n", + "adding: mem time0, current time 119, horizon 119\n", + "adding: mem time1, current time 119, horizon 118\n", + "adding: mem time2, current time 119, horizon 117\n", + "adding: mem time3, current time 119, horizon 116\n", + "adding: mem time4, current time 119, horizon 115\n", + "adding: mem time5, current time 119, horizon 114\n", + "adding: mem time6, current time 119, horizon 113\n", + "adding: mem time7, current time 119, horizon 112\n", + "adding: mem time8, current time 119, horizon 111\n", + "adding: mem time9, current time 119, horizon 110\n", + "adding: mem time10, current time 119, horizon 109\n", + "adding: mem time11, current time 119, horizon 108\n", + "adding: mem time12, current time 119, horizon 107\n", + "adding: mem time13, current time 119, horizon 106\n", + "adding: mem time14, current time 119, horizon 105\n", + "adding: mem time15, current time 119, horizon 104\n", + "adding: mem time16, current time 119, horizon 103\n", + "adding: mem time17, current time 119, horizon 102\n", + "adding: mem time18, current time 119, horizon 101\n", + "adding: mem time19, current time 119, horizon 100\n", + "adding: mem time20, current time 119, horizon 99\n", + "adding: mem time21, current time 119, horizon 98\n", + "adding: mem time22, current time 119, horizon 97\n", + "adding: mem time23, current time 119, horizon 96\n", + "adding: mem time24, current time 119, horizon 95\n", + "adding: mem time25, current time 119, horizon 94\n", + "adding: mem time26, current time 119, horizon 93\n", + "adding: mem time27, current time 119, horizon 92\n", + "adding: mem time28, current time 119, horizon 91\n", + "adding: mem time29, current time 119, horizon 90\n", + "adding: mem time30, current time 119, horizon 89\n", + "adding: mem time31, current time 119, horizon 88\n", + "adding: mem time32, current time 119, horizon 87\n", + "adding: mem time33, current time 119, horizon 86\n", + "adding: mem time34, current time 119, horizon 85\n", + "adding: mem time35, current time 119, horizon 84\n", + "adding: mem time36, current time 119, horizon 83\n", + "adding: mem time37, current time 119, horizon 82\n", + "adding: mem time38, current time 119, horizon 81\n", + "adding: mem time39, current time 119, horizon 80\n", + "adding: mem time40, current time 119, horizon 79\n", + "adding: mem time41, current time 119, horizon 78\n", + "adding: mem time42, current time 119, horizon 77\n", + "adding: mem time43, current time 119, horizon 76\n", + "adding: mem time44, current time 119, horizon 75\n", + "adding: mem time45, current time 119, horizon 74\n", + "adding: mem time46, current time 119, horizon 73\n", + "adding: mem time47, current time 119, horizon 72\n", + "adding: mem time48, current time 119, horizon 71\n", + "adding: mem time49, current time 119, horizon 70\n", + "adding: mem time50, current time 119, horizon 69\n", + "adding: mem time51, current time 119, horizon 68\n", + "adding: mem time52, current time 119, horizon 67\n", + "adding: mem time53, current time 119, horizon 66\n", + "adding: mem time54, current time 119, horizon 65\n", + "adding: mem time55, current time 119, horizon 64\n", + "adding: mem time56, current time 119, horizon 63\n", + "adding: mem time57, current time 119, horizon 62\n", + "adding: mem time58, current time 119, horizon 61\n", + "adding: mem time59, current time 119, horizon 60\n", + "adding: mem time60, current time 119, horizon 59\n", + "adding: mem time61, current time 119, horizon 58\n", + "adding: mem time62, current time 119, horizon 57\n", + "adding: mem time63, current time 119, horizon 56\n", + "adding: mem time64, current time 119, horizon 55\n", + "adding: mem time65, current time 119, horizon 54\n", + "adding: mem time66, current time 119, horizon 53\n", + "adding: mem time67, current time 119, horizon 52\n", + "adding: mem time68, current time 119, horizon 51\n", + "adding: mem time69, current time 119, horizon 50\n", + "adding: mem time70, current time 119, horizon 49\n", + "adding: mem time71, current time 119, horizon 48\n", + "adding: mem time72, current time 119, horizon 47\n", + "adding: mem time73, current time 119, horizon 46\n", + "adding: mem time74, current time 119, horizon 45\n", + "adding: mem time75, current time 119, horizon 44\n", + "adding: mem time76, current time 119, horizon 43\n", + "adding: mem time77, current time 119, horizon 42\n", + "adding: mem time78, current time 119, horizon 41\n", + "adding: mem time79, current time 119, horizon 40\n", + "adding: mem time80, current time 119, horizon 39\n", + "adding: mem time81, current time 119, horizon 38\n", + "adding: mem time82, current time 119, horizon 37\n", + "adding: mem time83, current time 119, horizon 36\n", + "adding: mem time84, current time 119, horizon 35\n", + "adding: mem time85, current time 119, horizon 34\n", + "adding: mem time86, current time 119, horizon 33\n", + "adding: mem time87, current time 119, horizon 32\n", + "adding: mem time88, current time 119, horizon 31\n", + "adding: mem time89, current time 119, horizon 30\n", + "adding: mem time90, current time 119, horizon 29\n", + "adding: mem time91, current time 119, horizon 28\n", + "adding: mem time92, current time 119, horizon 27\n", + "adding: mem time93, current time 119, horizon 26\n", + "adding: mem time94, current time 119, horizon 25\n", + "adding: mem time95, current time 119, horizon 24\n", + "adding: mem time96, current time 119, horizon 23\n", + "adding: mem time97, current time 119, horizon 22\n", + "adding: mem time98, current time 119, horizon 21\n", + "adding: mem time99, current time 119, horizon 20\n", + "adding: mem time100, current time 119, horizon 19\n", + "adding: mem time101, current time 119, horizon 18\n", + "adding: mem time102, current time 119, horizon 17\n", + "adding: mem time103, current time 119, horizon 16\n", + "adding: mem time104, current time 119, horizon 15\n", + "adding: mem time105, current time 119, horizon 14\n", + "adding: mem time106, current time 119, horizon 13\n", + "adding: mem time107, current time 119, horizon 12\n", + "adding: mem time108, current time 119, horizon 11\n", + "adding: mem time109, current time 119, horizon 10\n", + "adding: mem time110, current time 119, horizon 9\n", + "adding: mem time111, current time 119, horizon 8\n", + "adding: mem time112, current time 119, horizon 7\n", + "adding: mem time113, current time 119, horizon 6\n", + "adding: mem time114, current time 119, horizon 5\n", + "adding: mem time115, current time 119, horizon 4\n", + "adding: mem time116, current time 119, horizon 3\n", + "adding: mem time117, current time 119, horizon 2\n", + "adding: mem time118, current time 119, horizon 1\n", + "adding: mem time0, current time 120, horizon 120\n", + "adding: mem time1, current time 120, horizon 119\n", + "adding: mem time2, current time 120, horizon 118\n", + "adding: mem time3, current time 120, horizon 117\n", + "adding: mem time4, current time 120, horizon 116\n", + "adding: mem time5, current time 120, horizon 115\n", + "adding: mem time6, current time 120, horizon 114\n", + "adding: mem time7, current time 120, horizon 113\n", + "adding: mem time8, current time 120, horizon 112\n", + "adding: mem time9, current time 120, horizon 111\n", + "adding: mem time10, current time 120, horizon 110\n", + "adding: mem time11, current time 120, horizon 109\n", + "adding: mem time12, current time 120, horizon 108\n", + "adding: mem time13, current time 120, horizon 107\n", + "adding: mem time14, current time 120, horizon 106\n", + "adding: mem time15, current time 120, horizon 105\n", + "adding: mem time16, current time 120, horizon 104\n", + "adding: mem time17, current time 120, horizon 103\n", + "adding: mem time18, current time 120, horizon 102\n", + "adding: mem time19, current time 120, horizon 101\n", + "adding: mem time20, current time 120, horizon 100\n", + "adding: mem time21, current time 120, horizon 99\n", + "adding: mem time22, current time 120, horizon 98\n", + "adding: mem time23, current time 120, horizon 97\n", + "adding: mem time24, current time 120, horizon 96\n", + "adding: mem time25, current time 120, horizon 95\n", + "adding: mem time26, current time 120, horizon 94\n", + "adding: mem time27, current time 120, horizon 93\n", + "adding: mem time28, current time 120, horizon 92\n", + "adding: mem time29, current time 120, horizon 91\n", + "adding: mem time30, current time 120, horizon 90\n", + "adding: mem time31, current time 120, horizon 89\n", + "adding: mem time32, current time 120, horizon 88\n", + "adding: mem time33, current time 120, horizon 87\n", + "adding: mem time34, current time 120, horizon 86\n", + "adding: mem time35, current time 120, horizon 85\n", + "adding: mem time36, current time 120, horizon 84\n", + "adding: mem time37, current time 120, horizon 83\n", + "adding: mem time38, current time 120, horizon 82\n", + "adding: mem time39, current time 120, horizon 81\n", + "adding: mem time40, current time 120, horizon 80\n", + "adding: mem time41, current time 120, horizon 79\n", + "adding: mem time42, current time 120, horizon 78\n", + "adding: mem time43, current time 120, horizon 77\n", + "adding: mem time44, current time 120, horizon 76\n", + "adding: mem time45, current time 120, horizon 75\n", + "adding: mem time46, current time 120, horizon 74\n", + "adding: mem time47, current time 120, horizon 73\n", + "adding: mem time48, current time 120, horizon 72\n", + "adding: mem time49, current time 120, horizon 71\n", + "adding: mem time50, current time 120, horizon 70\n", + "adding: mem time51, current time 120, horizon 69\n", + "adding: mem time52, current time 120, horizon 68\n", + "adding: mem time53, current time 120, horizon 67\n", + "adding: mem time54, current time 120, horizon 66\n", + "adding: mem time55, current time 120, horizon 65\n", + "adding: mem time56, current time 120, horizon 64\n", + "adding: mem time57, current time 120, horizon 63\n", + "adding: mem time58, current time 120, horizon 62\n", + "adding: mem time59, current time 120, horizon 61\n", + "adding: mem time60, current time 120, horizon 60\n", + "adding: mem time61, current time 120, horizon 59\n", + "adding: mem time62, current time 120, horizon 58\n", + "adding: mem time63, current time 120, horizon 57\n", + "adding: mem time64, current time 120, horizon 56\n", + "adding: mem time65, current time 120, horizon 55\n", + "adding: mem time66, current time 120, horizon 54\n", + "adding: mem time67, current time 120, horizon 53\n", + "adding: mem time68, current time 120, horizon 52\n", + "adding: mem time69, current time 120, horizon 51\n", + "adding: mem time70, current time 120, horizon 50\n", + "adding: mem time71, current time 120, horizon 49\n", + "adding: mem time72, current time 120, horizon 48\n", + "adding: mem time73, current time 120, horizon 47\n", + "adding: mem time74, current time 120, horizon 46\n", + "adding: mem time75, current time 120, horizon 45\n", + "adding: mem time76, current time 120, horizon 44\n", + "adding: mem time77, current time 120, horizon 43\n", + "adding: mem time78, current time 120, horizon 42\n", + "adding: mem time79, current time 120, horizon 41\n", + "adding: mem time80, current time 120, horizon 40\n", + "adding: mem time81, current time 120, horizon 39\n", + "adding: mem time82, current time 120, horizon 38\n", + "adding: mem time83, current time 120, horizon 37\n", + "adding: mem time84, current time 120, horizon 36\n", + "adding: mem time85, current time 120, horizon 35\n", + "adding: mem time86, current time 120, horizon 34\n", + "adding: mem time87, current time 120, horizon 33\n", + "adding: mem time88, current time 120, horizon 32\n", + "adding: mem time89, current time 120, horizon 31\n", + "adding: mem time90, current time 120, horizon 30\n", + "adding: mem time91, current time 120, horizon 29\n", + "adding: mem time92, current time 120, horizon 28\n", + "adding: mem time93, current time 120, horizon 27\n", + "adding: mem time94, current time 120, horizon 26\n", + "adding: mem time95, current time 120, horizon 25\n", + "adding: mem time96, current time 120, horizon 24\n", + "adding: mem time97, current time 120, horizon 23\n", + "adding: mem time98, current time 120, horizon 22\n", + "adding: mem time99, current time 120, horizon 21\n", + "adding: mem time100, current time 120, horizon 20\n", + "adding: mem time101, current time 120, horizon 19\n", + "adding: mem time102, current time 120, horizon 18\n", + "adding: mem time103, current time 120, horizon 17\n", + "adding: mem time104, current time 120, horizon 16\n", + "adding: mem time105, current time 120, horizon 15\n", + "adding: mem time106, current time 120, horizon 14\n", + "adding: mem time107, current time 120, horizon 13\n", + "adding: mem time108, current time 120, horizon 12\n", + "adding: mem time109, current time 120, horizon 11\n", + "adding: mem time110, current time 120, horizon 10\n", + "adding: mem time111, current time 120, horizon 9\n", + "adding: mem time112, current time 120, horizon 8\n", + "adding: mem time113, current time 120, horizon 7\n", + "adding: mem time114, current time 120, horizon 6\n", + "adding: mem time115, current time 120, horizon 5\n", + "adding: mem time116, current time 120, horizon 4\n", + "adding: mem time117, current time 120, horizon 3\n", + "adding: mem time118, current time 120, horizon 2\n", + "adding: mem time119, current time 120, horizon 1\n", + "adding: mem time0, current time 121, horizon 121\n", + "adding: mem time1, current time 121, horizon 120\n", + "adding: mem time2, current time 121, horizon 119\n", + "adding: mem time3, current time 121, horizon 118\n", + "adding: mem time4, current time 121, horizon 117\n", + "adding: mem time5, current time 121, horizon 116\n", + "adding: mem time6, current time 121, horizon 115\n", + "adding: mem time7, current time 121, horizon 114\n", + "adding: mem time8, current time 121, horizon 113\n", + "adding: mem time9, current time 121, horizon 112\n", + "adding: mem time10, current time 121, horizon 111\n", + "adding: mem time11, current time 121, horizon 110\n", + "adding: mem time12, current time 121, horizon 109\n", + "adding: mem time13, current time 121, horizon 108\n", + "adding: mem time14, current time 121, horizon 107\n", + "adding: mem time15, current time 121, horizon 106\n", + "adding: mem time16, current time 121, horizon 105\n", + "adding: mem time17, current time 121, horizon 104\n", + "adding: mem time18, current time 121, horizon 103\n", + "adding: mem time19, current time 121, horizon 102\n", + "adding: mem time20, current time 121, horizon 101\n", + "adding: mem time21, current time 121, horizon 100\n", + "adding: mem time22, current time 121, horizon 99\n", + "adding: mem time23, current time 121, horizon 98\n", + "adding: mem time24, current time 121, horizon 97\n", + "adding: mem time25, current time 121, horizon 96\n", + "adding: mem time26, current time 121, horizon 95\n", + "adding: mem time27, current time 121, horizon 94\n", + "adding: mem time28, current time 121, horizon 93\n", + "adding: mem time29, current time 121, horizon 92\n", + "adding: mem time30, current time 121, horizon 91\n", + "adding: mem time31, current time 121, horizon 90\n", + "adding: mem time32, current time 121, horizon 89\n", + "adding: mem time33, current time 121, horizon 88\n", + "adding: mem time34, current time 121, horizon 87\n", + "adding: mem time35, current time 121, horizon 86\n", + "adding: mem time36, current time 121, horizon 85\n", + "adding: mem time37, current time 121, horizon 84\n", + "adding: mem time38, current time 121, horizon 83\n", + "adding: mem time39, current time 121, horizon 82\n", + "adding: mem time40, current time 121, horizon 81\n", + "adding: mem time41, current time 121, horizon 80\n", + "adding: mem time42, current time 121, horizon 79\n", + "adding: mem time43, current time 121, horizon 78\n", + "adding: mem time44, current time 121, horizon 77\n", + "adding: mem time45, current time 121, horizon 76\n", + "adding: mem time46, current time 121, horizon 75\n", + "adding: mem time47, current time 121, horizon 74\n", + "adding: mem time48, current time 121, horizon 73\n", + "adding: mem time49, current time 121, horizon 72\n", + "adding: mem time50, current time 121, horizon 71\n", + "adding: mem time51, current time 121, horizon 70\n", + "adding: mem time52, current time 121, horizon 69\n", + "adding: mem time53, current time 121, horizon 68\n", + "adding: mem time54, current time 121, horizon 67\n", + "adding: mem time55, current time 121, horizon 66\n", + "adding: mem time56, current time 121, horizon 65\n", + "adding: mem time57, current time 121, horizon 64\n", + "adding: mem time58, current time 121, horizon 63\n", + "adding: mem time59, current time 121, horizon 62\n", + "adding: mem time60, current time 121, horizon 61\n", + "adding: mem time61, current time 121, horizon 60\n", + "adding: mem time62, current time 121, horizon 59\n", + "adding: mem time63, current time 121, horizon 58\n", + "adding: mem time64, current time 121, horizon 57\n", + "adding: mem time65, current time 121, horizon 56\n", + "adding: mem time66, current time 121, horizon 55\n", + "adding: mem time67, current time 121, horizon 54\n", + "adding: mem time68, current time 121, horizon 53\n", + "adding: mem time69, current time 121, horizon 52\n", + "adding: mem time70, current time 121, horizon 51\n", + "adding: mem time71, current time 121, horizon 50\n", + "adding: mem time72, current time 121, horizon 49\n", + "adding: mem time73, current time 121, horizon 48\n", + "adding: mem time74, current time 121, horizon 47\n", + "adding: mem time75, current time 121, horizon 46\n", + "adding: mem time76, current time 121, horizon 45\n", + "adding: mem time77, current time 121, horizon 44\n", + "adding: mem time78, current time 121, horizon 43\n", + "adding: mem time79, current time 121, horizon 42\n", + "adding: mem time80, current time 121, horizon 41\n", + "adding: mem time81, current time 121, horizon 40\n", + "adding: mem time82, current time 121, horizon 39\n", + "adding: mem time83, current time 121, horizon 38\n", + "adding: mem time84, current time 121, horizon 37\n", + "adding: mem time85, current time 121, horizon 36\n", + "adding: mem time86, current time 121, horizon 35\n", + "adding: mem time87, current time 121, horizon 34\n", + "adding: mem time88, current time 121, horizon 33\n", + "adding: mem time89, current time 121, horizon 32\n", + "adding: mem time90, current time 121, horizon 31\n", + "adding: mem time91, current time 121, horizon 30\n", + "adding: mem time92, current time 121, horizon 29\n", + "adding: mem time93, current time 121, horizon 28\n", + "adding: mem time94, current time 121, horizon 27\n", + "adding: mem time95, current time 121, horizon 26\n", + "adding: mem time96, current time 121, horizon 25\n", + "adding: mem time97, current time 121, horizon 24\n", + "adding: mem time98, current time 121, horizon 23\n", + "adding: mem time99, current time 121, horizon 22\n", + "adding: mem time100, current time 121, horizon 21\n", + "adding: mem time101, current time 121, horizon 20\n", + "adding: mem time102, current time 121, horizon 19\n", + "adding: mem time103, current time 121, horizon 18\n", + "adding: mem time104, current time 121, horizon 17\n", + "adding: mem time105, current time 121, horizon 16\n", + "adding: mem time106, current time 121, horizon 15\n", + "adding: mem time107, current time 121, horizon 14\n", + "adding: mem time108, current time 121, horizon 13\n", + "adding: mem time109, current time 121, horizon 12\n", + "adding: mem time110, current time 121, horizon 11\n", + "adding: mem time111, current time 121, horizon 10\n", + "adding: mem time112, current time 121, horizon 9\n", + "adding: mem time113, current time 121, horizon 8\n", + "adding: mem time114, current time 121, horizon 7\n", + "adding: mem time115, current time 121, horizon 6\n", + "adding: mem time116, current time 121, horizon 5\n", + "adding: mem time117, current time 121, horizon 4\n", + "adding: mem time118, current time 121, horizon 3\n", + "adding: mem time119, current time 121, horizon 2\n", + "adding: mem time120, current time 121, horizon 1\n", + "adding: mem time0, current time 122, horizon 122\n", + "adding: mem time1, current time 122, horizon 121\n", + "adding: mem time2, current time 122, horizon 120\n", + "adding: mem time3, current time 122, horizon 119\n", + "adding: mem time4, current time 122, horizon 118\n", + "adding: mem time5, current time 122, horizon 117\n", + "adding: mem time6, current time 122, horizon 116\n", + "adding: mem time7, current time 122, horizon 115\n", + "adding: mem time8, current time 122, horizon 114\n", + "adding: mem time9, current time 122, horizon 113\n", + "adding: mem time10, current time 122, horizon 112\n", + "adding: mem time11, current time 122, horizon 111\n", + "adding: mem time12, current time 122, horizon 110\n", + "adding: mem time13, current time 122, horizon 109\n", + "adding: mem time14, current time 122, horizon 108\n", + "adding: mem time15, current time 122, horizon 107\n", + "adding: mem time16, current time 122, horizon 106\n", + "adding: mem time17, current time 122, horizon 105\n", + "adding: mem time18, current time 122, horizon 104\n", + "adding: mem time19, current time 122, horizon 103\n", + "adding: mem time20, current time 122, horizon 102\n", + "adding: mem time21, current time 122, horizon 101\n", + "adding: mem time22, current time 122, horizon 100\n", + "adding: mem time23, current time 122, horizon 99\n", + "adding: mem time24, current time 122, horizon 98\n", + "adding: mem time25, current time 122, horizon 97\n", + "adding: mem time26, current time 122, horizon 96\n", + "adding: mem time27, current time 122, horizon 95\n", + "adding: mem time28, current time 122, horizon 94\n", + "adding: mem time29, current time 122, horizon 93\n", + "adding: mem time30, current time 122, horizon 92\n", + "adding: mem time31, current time 122, horizon 91\n", + "adding: mem time32, current time 122, horizon 90\n", + "adding: mem time33, current time 122, horizon 89\n", + "adding: mem time34, current time 122, horizon 88\n", + "adding: mem time35, current time 122, horizon 87\n", + "adding: mem time36, current time 122, horizon 86\n", + "adding: mem time37, current time 122, horizon 85\n", + "adding: mem time38, current time 122, horizon 84\n", + "adding: mem time39, current time 122, horizon 83\n", + "adding: mem time40, current time 122, horizon 82\n", + "adding: mem time41, current time 122, horizon 81\n", + "adding: mem time42, current time 122, horizon 80\n", + "adding: mem time43, current time 122, horizon 79\n", + "adding: mem time44, current time 122, horizon 78\n", + "adding: mem time45, current time 122, horizon 77\n", + "adding: mem time46, current time 122, horizon 76\n", + "adding: mem time47, current time 122, horizon 75\n", + "adding: mem time48, current time 122, horizon 74\n", + "adding: mem time49, current time 122, horizon 73\n", + "adding: mem time50, current time 122, horizon 72\n", + "adding: mem time51, current time 122, horizon 71\n", + "adding: mem time52, current time 122, horizon 70\n", + "adding: mem time53, current time 122, horizon 69\n", + "adding: mem time54, current time 122, horizon 68\n", + "adding: mem time55, current time 122, horizon 67\n", + "adding: mem time56, current time 122, horizon 66\n", + "adding: mem time57, current time 122, horizon 65\n", + "adding: mem time58, current time 122, horizon 64\n", + "adding: mem time59, current time 122, horizon 63\n", + "adding: mem time60, current time 122, horizon 62\n", + "adding: mem time61, current time 122, horizon 61\n", + "adding: mem time62, current time 122, horizon 60\n", + "adding: mem time63, current time 122, horizon 59\n", + "adding: mem time64, current time 122, horizon 58\n", + "adding: mem time65, current time 122, horizon 57\n", + "adding: mem time66, current time 122, horizon 56\n", + "adding: mem time67, current time 122, horizon 55\n", + "adding: mem time68, current time 122, horizon 54\n", + "adding: mem time69, current time 122, horizon 53\n", + "adding: mem time70, current time 122, horizon 52\n", + "adding: mem time71, current time 122, horizon 51\n", + "adding: mem time72, current time 122, horizon 50\n", + "adding: mem time73, current time 122, horizon 49\n", + "adding: mem time74, current time 122, horizon 48\n", + "adding: mem time75, current time 122, horizon 47\n", + "adding: mem time76, current time 122, horizon 46\n", + "adding: mem time77, current time 122, horizon 45\n", + "adding: mem time78, current time 122, horizon 44\n", + "adding: mem time79, current time 122, horizon 43\n", + "adding: mem time80, current time 122, horizon 42\n", + "adding: mem time81, current time 122, horizon 41\n", + "adding: mem time82, current time 122, horizon 40\n", + "adding: mem time83, current time 122, horizon 39\n", + "adding: mem time84, current time 122, horizon 38\n", + "adding: mem time85, current time 122, horizon 37\n", + "adding: mem time86, current time 122, horizon 36\n", + "adding: mem time87, current time 122, horizon 35\n", + "adding: mem time88, current time 122, horizon 34\n", + "adding: mem time89, current time 122, horizon 33\n", + "adding: mem time90, current time 122, horizon 32\n", + "adding: mem time91, current time 122, horizon 31\n", + "adding: mem time92, current time 122, horizon 30\n", + "adding: mem time93, current time 122, horizon 29\n", + "adding: mem time94, current time 122, horizon 28\n", + "adding: mem time95, current time 122, horizon 27\n", + "adding: mem time96, current time 122, horizon 26\n", + "adding: mem time97, current time 122, horizon 25\n", + "adding: mem time98, current time 122, horizon 24\n", + "adding: mem time99, current time 122, horizon 23\n", + "adding: mem time100, current time 122, horizon 22\n", + "adding: mem time101, current time 122, horizon 21\n", + "adding: mem time102, current time 122, horizon 20\n", + "adding: mem time103, current time 122, horizon 19\n", + "adding: mem time104, current time 122, horizon 18\n", + "adding: mem time105, current time 122, horizon 17\n", + "adding: mem time106, current time 122, horizon 16\n", + "adding: mem time107, current time 122, horizon 15\n", + "adding: mem time108, current time 122, horizon 14\n", + "adding: mem time109, current time 122, horizon 13\n", + "adding: mem time110, current time 122, horizon 12\n", + "adding: mem time111, current time 122, horizon 11\n", + "adding: mem time112, current time 122, horizon 10\n", + "adding: mem time113, current time 122, horizon 9\n", + "adding: mem time114, current time 122, horizon 8\n", + "adding: mem time115, current time 122, horizon 7\n", + "adding: mem time116, current time 122, horizon 6\n", + "adding: mem time117, current time 122, horizon 5\n", + "adding: mem time118, current time 122, horizon 4\n", + "adding: mem time119, current time 122, horizon 3\n", + "adding: mem time120, current time 122, horizon 2\n", + "adding: mem time121, current time 122, horizon 1\n", + "adding: mem time0, current time 123, horizon 123\n", + "adding: mem time1, current time 123, horizon 122\n", + "adding: mem time2, current time 123, horizon 121\n", + "adding: mem time3, current time 123, horizon 120\n", + "adding: mem time4, current time 123, horizon 119\n", + "adding: mem time5, current time 123, horizon 118\n", + "adding: mem time6, current time 123, horizon 117\n", + "adding: mem time7, current time 123, horizon 116\n", + "adding: mem time8, current time 123, horizon 115\n", + "adding: mem time9, current time 123, horizon 114\n", + "adding: mem time10, current time 123, horizon 113\n", + "adding: mem time11, current time 123, horizon 112\n", + "adding: mem time12, current time 123, horizon 111\n", + "adding: mem time13, current time 123, horizon 110\n", + "adding: mem time14, current time 123, horizon 109\n", + "adding: mem time15, current time 123, horizon 108\n", + "adding: mem time16, current time 123, horizon 107\n", + "adding: mem time17, current time 123, horizon 106\n", + "adding: mem time18, current time 123, horizon 105\n", + "adding: mem time19, current time 123, horizon 104\n", + "adding: mem time20, current time 123, horizon 103\n", + "adding: mem time21, current time 123, horizon 102\n", + "adding: mem time22, current time 123, horizon 101\n", + "adding: mem time23, current time 123, horizon 100\n", + "adding: mem time24, current time 123, horizon 99\n", + "adding: mem time25, current time 123, horizon 98\n", + "adding: mem time26, current time 123, horizon 97\n", + "adding: mem time27, current time 123, horizon 96\n", + "adding: mem time28, current time 123, horizon 95\n", + "adding: mem time29, current time 123, horizon 94\n", + "adding: mem time30, current time 123, horizon 93\n", + "adding: mem time31, current time 123, horizon 92\n", + "adding: mem time32, current time 123, horizon 91\n", + "adding: mem time33, current time 123, horizon 90\n", + "adding: mem time34, current time 123, horizon 89\n", + "adding: mem time35, current time 123, horizon 88\n", + "adding: mem time36, current time 123, horizon 87\n", + "adding: mem time37, current time 123, horizon 86\n", + "adding: mem time38, current time 123, horizon 85\n", + "adding: mem time39, current time 123, horizon 84\n", + "adding: mem time40, current time 123, horizon 83\n", + "adding: mem time41, current time 123, horizon 82\n", + "adding: mem time42, current time 123, horizon 81\n", + "adding: mem time43, current time 123, horizon 80\n", + "adding: mem time44, current time 123, horizon 79\n", + "adding: mem time45, current time 123, horizon 78\n", + "adding: mem time46, current time 123, horizon 77\n", + "adding: mem time47, current time 123, horizon 76\n", + "adding: mem time48, current time 123, horizon 75\n", + "adding: mem time49, current time 123, horizon 74\n", + "adding: mem time50, current time 123, horizon 73\n", + "adding: mem time51, current time 123, horizon 72\n", + "adding: mem time52, current time 123, horizon 71\n", + "adding: mem time53, current time 123, horizon 70\n", + "adding: mem time54, current time 123, horizon 69\n", + "adding: mem time55, current time 123, horizon 68\n", + "adding: mem time56, current time 123, horizon 67\n", + "adding: mem time57, current time 123, horizon 66\n", + "adding: mem time58, current time 123, horizon 65\n", + "adding: mem time59, current time 123, horizon 64\n", + "adding: mem time60, current time 123, horizon 63\n", + "adding: mem time61, current time 123, horizon 62\n", + "adding: mem time62, current time 123, horizon 61\n", + "adding: mem time63, current time 123, horizon 60\n", + "adding: mem time64, current time 123, horizon 59\n", + "adding: mem time65, current time 123, horizon 58\n", + "adding: mem time66, current time 123, horizon 57\n", + "adding: mem time67, current time 123, horizon 56\n", + "adding: mem time68, current time 123, horizon 55\n", + "adding: mem time69, current time 123, horizon 54\n", + "adding: mem time70, current time 123, horizon 53\n", + "adding: mem time71, current time 123, horizon 52\n", + "adding: mem time72, current time 123, horizon 51\n", + "adding: mem time73, current time 123, horizon 50\n", + "adding: mem time74, current time 123, horizon 49\n", + "adding: mem time75, current time 123, horizon 48\n", + "adding: mem time76, current time 123, horizon 47\n", + "adding: mem time77, current time 123, horizon 46\n", + "adding: mem time78, current time 123, horizon 45\n", + "adding: mem time79, current time 123, horizon 44\n", + "adding: mem time80, current time 123, horizon 43\n", + "adding: mem time81, current time 123, horizon 42\n", + "adding: mem time82, current time 123, horizon 41\n", + "adding: mem time83, current time 123, horizon 40\n", + "adding: mem time84, current time 123, horizon 39\n", + "adding: mem time85, current time 123, horizon 38\n", + "adding: mem time86, current time 123, horizon 37\n", + "adding: mem time87, current time 123, horizon 36\n", + "adding: mem time88, current time 123, horizon 35\n", + "adding: mem time89, current time 123, horizon 34\n", + "adding: mem time90, current time 123, horizon 33\n", + "adding: mem time91, current time 123, horizon 32\n", + "adding: mem time92, current time 123, horizon 31\n", + "adding: mem time93, current time 123, horizon 30\n", + "adding: mem time94, current time 123, horizon 29\n", + "adding: mem time95, current time 123, horizon 28\n", + "adding: mem time96, current time 123, horizon 27\n", + "adding: mem time97, current time 123, horizon 26\n", + "adding: mem time98, current time 123, horizon 25\n", + "adding: mem time99, current time 123, horizon 24\n", + "adding: mem time100, current time 123, horizon 23\n", + "adding: mem time101, current time 123, horizon 22\n", + "adding: mem time102, current time 123, horizon 21\n", + "adding: mem time103, current time 123, horizon 20\n", + "adding: mem time104, current time 123, horizon 19\n", + "adding: mem time105, current time 123, horizon 18\n", + "adding: mem time106, current time 123, horizon 17\n", + "adding: mem time107, current time 123, horizon 16\n", + "adding: mem time108, current time 123, horizon 15\n", + "adding: mem time109, current time 123, horizon 14\n", + "adding: mem time110, current time 123, horizon 13\n", + "adding: mem time111, current time 123, horizon 12\n", + "adding: mem time112, current time 123, horizon 11\n", + "adding: mem time113, current time 123, horizon 10\n", + "adding: mem time114, current time 123, horizon 9\n", + "adding: mem time115, current time 123, horizon 8\n", + "adding: mem time116, current time 123, horizon 7\n", + "adding: mem time117, current time 123, horizon 6\n", + "adding: mem time118, current time 123, horizon 5\n", + "adding: mem time119, current time 123, horizon 4\n", + "adding: mem time120, current time 123, horizon 3\n", + "adding: mem time121, current time 123, horizon 2\n", + "adding: mem time122, current time 123, horizon 1\n", + "adding: mem time0, current time 124, horizon 124\n", + "adding: mem time1, current time 124, horizon 123\n", + "adding: mem time2, current time 124, horizon 122\n", + "adding: mem time3, current time 124, horizon 121\n", + "adding: mem time4, current time 124, horizon 120\n", + "adding: mem time5, current time 124, horizon 119\n", + "adding: mem time6, current time 124, horizon 118\n", + "adding: mem time7, current time 124, horizon 117\n", + "adding: mem time8, current time 124, horizon 116\n", + "adding: mem time9, current time 124, horizon 115\n", + "adding: mem time10, current time 124, horizon 114\n", + "adding: mem time11, current time 124, horizon 113\n", + "adding: mem time12, current time 124, horizon 112\n", + "adding: mem time13, current time 124, horizon 111\n", + "adding: mem time14, current time 124, horizon 110\n", + "adding: mem time15, current time 124, horizon 109\n", + "adding: mem time16, current time 124, horizon 108\n", + "adding: mem time17, current time 124, horizon 107\n", + "adding: mem time18, current time 124, horizon 106\n", + "adding: mem time19, current time 124, horizon 105\n", + "adding: mem time20, current time 124, horizon 104\n", + "adding: mem time21, current time 124, horizon 103\n", + "adding: mem time22, current time 124, horizon 102\n", + "adding: mem time23, current time 124, horizon 101\n", + "adding: mem time24, current time 124, horizon 100\n", + "adding: mem time25, current time 124, horizon 99\n", + "adding: mem time26, current time 124, horizon 98\n", + "adding: mem time27, current time 124, horizon 97\n", + "adding: mem time28, current time 124, horizon 96\n", + "adding: mem time29, current time 124, horizon 95\n", + "adding: mem time30, current time 124, horizon 94\n", + "adding: mem time31, current time 124, horizon 93\n", + "adding: mem time32, current time 124, horizon 92\n", + "adding: mem time33, current time 124, horizon 91\n", + "adding: mem time34, current time 124, horizon 90\n", + "adding: mem time35, current time 124, horizon 89\n", + "adding: mem time36, current time 124, horizon 88\n", + "adding: mem time37, current time 124, horizon 87\n", + "adding: mem time38, current time 124, horizon 86\n", + "adding: mem time39, current time 124, horizon 85\n", + "adding: mem time40, current time 124, horizon 84\n", + "adding: mem time41, current time 124, horizon 83\n", + "adding: mem time42, current time 124, horizon 82\n", + "adding: mem time43, current time 124, horizon 81\n", + "adding: mem time44, current time 124, horizon 80\n", + "adding: mem time45, current time 124, horizon 79\n", + "adding: mem time46, current time 124, horizon 78\n", + "adding: mem time47, current time 124, horizon 77\n", + "adding: mem time48, current time 124, horizon 76\n", + "adding: mem time49, current time 124, horizon 75\n", + "adding: mem time50, current time 124, horizon 74\n", + "adding: mem time51, current time 124, horizon 73\n", + "adding: mem time52, current time 124, horizon 72\n", + "adding: mem time53, current time 124, horizon 71\n", + "adding: mem time54, current time 124, horizon 70\n", + "adding: mem time55, current time 124, horizon 69\n", + "adding: mem time56, current time 124, horizon 68\n", + "adding: mem time57, current time 124, horizon 67\n", + "adding: mem time58, current time 124, horizon 66\n", + "adding: mem time59, current time 124, horizon 65\n", + "adding: mem time60, current time 124, horizon 64\n", + "adding: mem time61, current time 124, horizon 63\n", + "adding: mem time62, current time 124, horizon 62\n", + "adding: mem time63, current time 124, horizon 61\n", + "adding: mem time64, current time 124, horizon 60\n", + "adding: mem time65, current time 124, horizon 59\n", + "adding: mem time66, current time 124, horizon 58\n", + "adding: mem time67, current time 124, horizon 57\n", + "adding: mem time68, current time 124, horizon 56\n", + "adding: mem time69, current time 124, horizon 55\n", + "adding: mem time70, current time 124, horizon 54\n", + "adding: mem time71, current time 124, horizon 53\n", + "adding: mem time72, current time 124, horizon 52\n", + "adding: mem time73, current time 124, horizon 51\n", + "adding: mem time74, current time 124, horizon 50\n", + "adding: mem time75, current time 124, horizon 49\n", + "adding: mem time76, current time 124, horizon 48\n", + "adding: mem time77, current time 124, horizon 47\n", + "adding: mem time78, current time 124, horizon 46\n", + "adding: mem time79, current time 124, horizon 45\n", + "adding: mem time80, current time 124, horizon 44\n", + "adding: mem time81, current time 124, horizon 43\n", + "adding: mem time82, current time 124, horizon 42\n", + "adding: mem time83, current time 124, horizon 41\n", + "adding: mem time84, current time 124, horizon 40\n", + "adding: mem time85, current time 124, horizon 39\n", + "adding: mem time86, current time 124, horizon 38\n", + "adding: mem time87, current time 124, horizon 37\n", + "adding: mem time88, current time 124, horizon 36\n", + "adding: mem time89, current time 124, horizon 35\n", + "adding: mem time90, current time 124, horizon 34\n", + "adding: mem time91, current time 124, horizon 33\n", + "adding: mem time92, current time 124, horizon 32\n", + "adding: mem time93, current time 124, horizon 31\n", + "adding: mem time94, current time 124, horizon 30\n", + "adding: mem time95, current time 124, horizon 29\n", + "adding: mem time96, current time 124, horizon 28\n", + "adding: mem time97, current time 124, horizon 27\n", + "adding: mem time98, current time 124, horizon 26\n", + "adding: mem time99, current time 124, horizon 25\n", + "adding: mem time100, current time 124, horizon 24\n", + "adding: mem time101, current time 124, horizon 23\n", + "adding: mem time102, current time 124, horizon 22\n", + "adding: mem time103, current time 124, horizon 21\n", + "adding: mem time104, current time 124, horizon 20\n", + "adding: mem time105, current time 124, horizon 19\n", + "adding: mem time106, current time 124, horizon 18\n", + "adding: mem time107, current time 124, horizon 17\n", + "adding: mem time108, current time 124, horizon 16\n", + "adding: mem time109, current time 124, horizon 15\n", + "adding: mem time110, current time 124, horizon 14\n", + "adding: mem time111, current time 124, horizon 13\n", + "adding: mem time112, current time 124, horizon 12\n", + "adding: mem time113, current time 124, horizon 11\n", + "adding: mem time114, current time 124, horizon 10\n", + "adding: mem time115, current time 124, horizon 9\n", + "adding: mem time116, current time 124, horizon 8\n", + "adding: mem time117, current time 124, horizon 7\n", + "adding: mem time118, current time 124, horizon 6\n", + "adding: mem time119, current time 124, horizon 5\n", + "adding: mem time120, current time 124, horizon 4\n", + "adding: mem time121, current time 124, horizon 3\n", + "adding: mem time122, current time 124, horizon 2\n", + "adding: mem time123, current time 124, horizon 1\n", + "adding: mem time0, current time 125, horizon 125\n", + "adding: mem time1, current time 125, horizon 124\n", + "adding: mem time2, current time 125, horizon 123\n", + "adding: mem time3, current time 125, horizon 122\n", + "adding: mem time4, current time 125, horizon 121\n", + "adding: mem time5, current time 125, horizon 120\n", + "adding: mem time6, current time 125, horizon 119\n", + "adding: mem time7, current time 125, horizon 118\n", + "adding: mem time8, current time 125, horizon 117\n", + "adding: mem time9, current time 125, horizon 116\n", + "adding: mem time10, current time 125, horizon 115\n", + "adding: mem time11, current time 125, horizon 114\n", + "adding: mem time12, current time 125, horizon 113\n", + "adding: mem time13, current time 125, horizon 112\n", + "adding: mem time14, current time 125, horizon 111\n", + "adding: mem time15, current time 125, horizon 110\n", + "adding: mem time16, current time 125, horizon 109\n", + "adding: mem time17, current time 125, horizon 108\n", + "adding: mem time18, current time 125, horizon 107\n", + "adding: mem time19, current time 125, horizon 106\n", + "adding: mem time20, current time 125, horizon 105\n", + "adding: mem time21, current time 125, horizon 104\n", + "adding: mem time22, current time 125, horizon 103\n", + "adding: mem time23, current time 125, horizon 102\n", + "adding: mem time24, current time 125, horizon 101\n", + "adding: mem time25, current time 125, horizon 100\n", + "adding: mem time26, current time 125, horizon 99\n", + "adding: mem time27, current time 125, horizon 98\n", + "adding: mem time28, current time 125, horizon 97\n", + "adding: mem time29, current time 125, horizon 96\n", + "adding: mem time30, current time 125, horizon 95\n", + "adding: mem time31, current time 125, horizon 94\n", + "adding: mem time32, current time 125, horizon 93\n", + "adding: mem time33, current time 125, horizon 92\n", + "adding: mem time34, current time 125, horizon 91\n", + "adding: mem time35, current time 125, horizon 90\n", + "adding: mem time36, current time 125, horizon 89\n", + "adding: mem time37, current time 125, horizon 88\n", + "adding: mem time38, current time 125, horizon 87\n", + "adding: mem time39, current time 125, horizon 86\n", + "adding: mem time40, current time 125, horizon 85\n", + "adding: mem time41, current time 125, horizon 84\n", + "adding: mem time42, current time 125, horizon 83\n", + "adding: mem time43, current time 125, horizon 82\n", + "adding: mem time44, current time 125, horizon 81\n", + "adding: mem time45, current time 125, horizon 80\n", + "adding: mem time46, current time 125, horizon 79\n", + "adding: mem time47, current time 125, horizon 78\n", + "adding: mem time48, current time 125, horizon 77\n", + "adding: mem time49, current time 125, horizon 76\n", + "adding: mem time50, current time 125, horizon 75\n", + "adding: mem time51, current time 125, horizon 74\n", + "adding: mem time52, current time 125, horizon 73\n", + "adding: mem time53, current time 125, horizon 72\n", + "adding: mem time54, current time 125, horizon 71\n", + "adding: mem time55, current time 125, horizon 70\n", + "adding: mem time56, current time 125, horizon 69\n", + "adding: mem time57, current time 125, horizon 68\n", + "adding: mem time58, current time 125, horizon 67\n", + "adding: mem time59, current time 125, horizon 66\n", + "adding: mem time60, current time 125, horizon 65\n", + "adding: mem time61, current time 125, horizon 64\n", + "adding: mem time62, current time 125, horizon 63\n", + "adding: mem time63, current time 125, horizon 62\n", + "adding: mem time64, current time 125, horizon 61\n", + "adding: mem time65, current time 125, horizon 60\n", + "adding: mem time66, current time 125, horizon 59\n", + "adding: mem time67, current time 125, horizon 58\n", + "adding: mem time68, current time 125, horizon 57\n", + "adding: mem time69, current time 125, horizon 56\n", + "adding: mem time70, current time 125, horizon 55\n", + "adding: mem time71, current time 125, horizon 54\n", + "adding: mem time72, current time 125, horizon 53\n", + "adding: mem time73, current time 125, horizon 52\n", + "adding: mem time74, current time 125, horizon 51\n", + "adding: mem time75, current time 125, horizon 50\n", + "adding: mem time76, current time 125, horizon 49\n", + "adding: mem time77, current time 125, horizon 48\n", + "adding: mem time78, current time 125, horizon 47\n", + "adding: mem time79, current time 125, horizon 46\n", + "adding: mem time80, current time 125, horizon 45\n", + "adding: mem time81, current time 125, horizon 44\n", + "adding: mem time82, current time 125, horizon 43\n", + "adding: mem time83, current time 125, horizon 42\n", + "adding: mem time84, current time 125, horizon 41\n", + "adding: mem time85, current time 125, horizon 40\n", + "adding: mem time86, current time 125, horizon 39\n", + "adding: mem time87, current time 125, horizon 38\n", + "adding: mem time88, current time 125, horizon 37\n", + "adding: mem time89, current time 125, horizon 36\n", + "adding: mem time90, current time 125, horizon 35\n", + "adding: mem time91, current time 125, horizon 34\n", + "adding: mem time92, current time 125, horizon 33\n", + "adding: mem time93, current time 125, horizon 32\n", + "adding: mem time94, current time 125, horizon 31\n", + "adding: mem time95, current time 125, horizon 30\n", + "adding: mem time96, current time 125, horizon 29\n", + "adding: mem time97, current time 125, horizon 28\n", + "adding: mem time98, current time 125, horizon 27\n", + "adding: mem time99, current time 125, horizon 26\n", + "adding: mem time100, current time 125, horizon 25\n", + "adding: mem time101, current time 125, horizon 24\n", + "adding: mem time102, current time 125, horizon 23\n", + "adding: mem time103, current time 125, horizon 22\n", + "adding: mem time104, current time 125, horizon 21\n", + "adding: mem time105, current time 125, horizon 20\n", + "adding: mem time106, current time 125, horizon 19\n", + "adding: mem time107, current time 125, horizon 18\n", + "adding: mem time108, current time 125, horizon 17\n", + "adding: mem time109, current time 125, horizon 16\n", + "adding: mem time110, current time 125, horizon 15\n", + "adding: mem time111, current time 125, horizon 14\n", + "adding: mem time112, current time 125, horizon 13\n", + "adding: mem time113, current time 125, horizon 12\n", + "adding: mem time114, current time 125, horizon 11\n", + "adding: mem time115, current time 125, horizon 10\n", + "adding: mem time116, current time 125, horizon 9\n", + "adding: mem time117, current time 125, horizon 8\n", + "adding: mem time118, current time 125, horizon 7\n", + "adding: mem time119, current time 125, horizon 6\n", + "adding: mem time120, current time 125, horizon 5\n", + "adding: mem time121, current time 125, horizon 4\n", + "adding: mem time122, current time 125, horizon 3\n", + "adding: mem time123, current time 125, horizon 2\n", + "adding: mem time124, current time 125, horizon 1\n", + "adding: mem time0, current time 126, horizon 126\n", + "adding: mem time1, current time 126, horizon 125\n", + "adding: mem time2, current time 126, horizon 124\n", + "adding: mem time3, current time 126, horizon 123\n", + "adding: mem time4, current time 126, horizon 122\n", + "adding: mem time5, current time 126, horizon 121\n", + "adding: mem time6, current time 126, horizon 120\n", + "adding: mem time7, current time 126, horizon 119\n", + "adding: mem time8, current time 126, horizon 118\n", + "adding: mem time9, current time 126, horizon 117\n", + "adding: mem time10, current time 126, horizon 116\n", + "adding: mem time11, current time 126, horizon 115\n", + "adding: mem time12, current time 126, horizon 114\n", + "adding: mem time13, current time 126, horizon 113\n", + "adding: mem time14, current time 126, horizon 112\n", + "adding: mem time15, current time 126, horizon 111\n", + "adding: mem time16, current time 126, horizon 110\n", + "adding: mem time17, current time 126, horizon 109\n", + "adding: mem time18, current time 126, horizon 108\n", + "adding: mem time19, current time 126, horizon 107\n", + "adding: mem time20, current time 126, horizon 106\n", + "adding: mem time21, current time 126, horizon 105\n", + "adding: mem time22, current time 126, horizon 104\n", + "adding: mem time23, current time 126, horizon 103\n", + "adding: mem time24, current time 126, horizon 102\n", + "adding: mem time25, current time 126, horizon 101\n", + "adding: mem time26, current time 126, horizon 100\n", + "adding: mem time27, current time 126, horizon 99\n", + "adding: mem time28, current time 126, horizon 98\n", + "adding: mem time29, current time 126, horizon 97\n", + "adding: mem time30, current time 126, horizon 96\n", + "adding: mem time31, current time 126, horizon 95\n", + "adding: mem time32, current time 126, horizon 94\n", + "adding: mem time33, current time 126, horizon 93\n", + "adding: mem time34, current time 126, horizon 92\n", + "adding: mem time35, current time 126, horizon 91\n", + "adding: mem time36, current time 126, horizon 90\n", + "adding: mem time37, current time 126, horizon 89\n", + "adding: mem time38, current time 126, horizon 88\n", + "adding: mem time39, current time 126, horizon 87\n", + "adding: mem time40, current time 126, horizon 86\n", + "adding: mem time41, current time 126, horizon 85\n", + "adding: mem time42, current time 126, horizon 84\n", + "adding: mem time43, current time 126, horizon 83\n", + "adding: mem time44, current time 126, horizon 82\n", + "adding: mem time45, current time 126, horizon 81\n", + "adding: mem time46, current time 126, horizon 80\n", + "adding: mem time47, current time 126, horizon 79\n", + "adding: mem time48, current time 126, horizon 78\n", + "adding: mem time49, current time 126, horizon 77\n", + "adding: mem time50, current time 126, horizon 76\n", + "adding: mem time51, current time 126, horizon 75\n", + "adding: mem time52, current time 126, horizon 74\n", + "adding: mem time53, current time 126, horizon 73\n", + "adding: mem time54, current time 126, horizon 72\n", + "adding: mem time55, current time 126, horizon 71\n", + "adding: mem time56, current time 126, horizon 70\n", + "adding: mem time57, current time 126, horizon 69\n", + "adding: mem time58, current time 126, horizon 68\n", + "adding: mem time59, current time 126, horizon 67\n", + "adding: mem time60, current time 126, horizon 66\n", + "adding: mem time61, current time 126, horizon 65\n", + "adding: mem time62, current time 126, horizon 64\n", + "adding: mem time63, current time 126, horizon 63\n", + "adding: mem time64, current time 126, horizon 62\n", + "adding: mem time65, current time 126, horizon 61\n", + "adding: mem time66, current time 126, horizon 60\n", + "adding: mem time67, current time 126, horizon 59\n", + "adding: mem time68, current time 126, horizon 58\n", + "adding: mem time69, current time 126, horizon 57\n", + "adding: mem time70, current time 126, horizon 56\n", + "adding: mem time71, current time 126, horizon 55\n", + "adding: mem time72, current time 126, horizon 54\n", + "adding: mem time73, current time 126, horizon 53\n", + "adding: mem time74, current time 126, horizon 52\n", + "adding: mem time75, current time 126, horizon 51\n", + "adding: mem time76, current time 126, horizon 50\n", + "adding: mem time77, current time 126, horizon 49\n", + "adding: mem time78, current time 126, horizon 48\n", + "adding: mem time79, current time 126, horizon 47\n", + "adding: mem time80, current time 126, horizon 46\n", + "adding: mem time81, current time 126, horizon 45\n", + "adding: mem time82, current time 126, horizon 44\n", + "adding: mem time83, current time 126, horizon 43\n", + "adding: mem time84, current time 126, horizon 42\n", + "adding: mem time85, current time 126, horizon 41\n", + "adding: mem time86, current time 126, horizon 40\n", + "adding: mem time87, current time 126, horizon 39\n", + "adding: mem time88, current time 126, horizon 38\n", + "adding: mem time89, current time 126, horizon 37\n", + "adding: mem time90, current time 126, horizon 36\n", + "adding: mem time91, current time 126, horizon 35\n", + "adding: mem time92, current time 126, horizon 34\n", + "adding: mem time93, current time 126, horizon 33\n", + "adding: mem time94, current time 126, horizon 32\n", + "adding: mem time95, current time 126, horizon 31\n", + "adding: mem time96, current time 126, horizon 30\n", + "adding: mem time97, current time 126, horizon 29\n", + "adding: mem time98, current time 126, horizon 28\n", + "adding: mem time99, current time 126, horizon 27\n", + "adding: mem time100, current time 126, horizon 26\n", + "adding: mem time101, current time 126, horizon 25\n", + "adding: mem time102, current time 126, horizon 24\n", + "adding: mem time103, current time 126, horizon 23\n", + "adding: mem time104, current time 126, horizon 22\n", + "adding: mem time105, current time 126, horizon 21\n", + "adding: mem time106, current time 126, horizon 20\n", + "adding: mem time107, current time 126, horizon 19\n", + "adding: mem time108, current time 126, horizon 18\n", + "adding: mem time109, current time 126, horizon 17\n", + "adding: mem time110, current time 126, horizon 16\n", + "adding: mem time111, current time 126, horizon 15\n", + "adding: mem time112, current time 126, horizon 14\n", + "adding: mem time113, current time 126, horizon 13\n", + "adding: mem time114, current time 126, horizon 12\n", + "adding: mem time115, current time 126, horizon 11\n", + "adding: mem time116, current time 126, horizon 10\n", + "adding: mem time117, current time 126, horizon 9\n", + "adding: mem time118, current time 126, horizon 8\n", + "adding: mem time119, current time 126, horizon 7\n", + "adding: mem time120, current time 126, horizon 6\n", + "adding: mem time121, current time 126, horizon 5\n", + "adding: mem time122, current time 126, horizon 4\n", + "adding: mem time123, current time 126, horizon 3\n", + "adding: mem time124, current time 126, horizon 2\n", + "adding: mem time125, current time 126, horizon 1\n", + "adding: mem time0, current time 127, horizon 127\n", + "adding: mem time1, current time 127, horizon 126\n", + "adding: mem time2, current time 127, horizon 125\n", + "adding: mem time3, current time 127, horizon 124\n", + "adding: mem time4, current time 127, horizon 123\n", + "adding: mem time5, current time 127, horizon 122\n", + "adding: mem time6, current time 127, horizon 121\n", + "adding: mem time7, current time 127, horizon 120\n", + "adding: mem time8, current time 127, horizon 119\n", + "adding: mem time9, current time 127, horizon 118\n", + "adding: mem time10, current time 127, horizon 117\n", + "adding: mem time11, current time 127, horizon 116\n", + "adding: mem time12, current time 127, horizon 115\n", + "adding: mem time13, current time 127, horizon 114\n", + "adding: mem time14, current time 127, horizon 113\n", + "adding: mem time15, current time 127, horizon 112\n", + "adding: mem time16, current time 127, horizon 111\n", + "adding: mem time17, current time 127, horizon 110\n", + "adding: mem time18, current time 127, horizon 109\n", + "adding: mem time19, current time 127, horizon 108\n", + "adding: mem time20, current time 127, horizon 107\n", + "adding: mem time21, current time 127, horizon 106\n", + "adding: mem time22, current time 127, horizon 105\n", + "adding: mem time23, current time 127, horizon 104\n", + "adding: mem time24, current time 127, horizon 103\n", + "adding: mem time25, current time 127, horizon 102\n", + "adding: mem time26, current time 127, horizon 101\n", + "adding: mem time27, current time 127, horizon 100\n", + "adding: mem time28, current time 127, horizon 99\n", + "adding: mem time29, current time 127, horizon 98\n", + "adding: mem time30, current time 127, horizon 97\n", + "adding: mem time31, current time 127, horizon 96\n", + "adding: mem time32, current time 127, horizon 95\n", + "adding: mem time33, current time 127, horizon 94\n", + "adding: mem time34, current time 127, horizon 93\n", + "adding: mem time35, current time 127, horizon 92\n", + "adding: mem time36, current time 127, horizon 91\n", + "adding: mem time37, current time 127, horizon 90\n", + "adding: mem time38, current time 127, horizon 89\n", + "adding: mem time39, current time 127, horizon 88\n", + "adding: mem time40, current time 127, horizon 87\n", + "adding: mem time41, current time 127, horizon 86\n", + "adding: mem time42, current time 127, horizon 85\n", + "adding: mem time43, current time 127, horizon 84\n", + "adding: mem time44, current time 127, horizon 83\n", + "adding: mem time45, current time 127, horizon 82\n", + "adding: mem time46, current time 127, horizon 81\n", + "adding: mem time47, current time 127, horizon 80\n", + "adding: mem time48, current time 127, horizon 79\n", + "adding: mem time49, current time 127, horizon 78\n", + "adding: mem time50, current time 127, horizon 77\n", + "adding: mem time51, current time 127, horizon 76\n", + "adding: mem time52, current time 127, horizon 75\n", + "adding: mem time53, current time 127, horizon 74\n", + "adding: mem time54, current time 127, horizon 73\n", + "adding: mem time55, current time 127, horizon 72\n", + "adding: mem time56, current time 127, horizon 71\n", + "adding: mem time57, current time 127, horizon 70\n", + "adding: mem time58, current time 127, horizon 69\n", + "adding: mem time59, current time 127, horizon 68\n", + "adding: mem time60, current time 127, horizon 67\n", + "adding: mem time61, current time 127, horizon 66\n", + "adding: mem time62, current time 127, horizon 65\n", + "adding: mem time63, current time 127, horizon 64\n", + "adding: mem time64, current time 127, horizon 63\n", + "adding: mem time65, current time 127, horizon 62\n", + "adding: mem time66, current time 127, horizon 61\n", + "adding: mem time67, current time 127, horizon 60\n", + "adding: mem time68, current time 127, horizon 59\n", + "adding: mem time69, current time 127, horizon 58\n", + "adding: mem time70, current time 127, horizon 57\n", + "adding: mem time71, current time 127, horizon 56\n", + "adding: mem time72, current time 127, horizon 55\n", + "adding: mem time73, current time 127, horizon 54\n", + "adding: mem time74, current time 127, horizon 53\n", + "adding: mem time75, current time 127, horizon 52\n", + "adding: mem time76, current time 127, horizon 51\n", + "adding: mem time77, current time 127, horizon 50\n", + "adding: mem time78, current time 127, horizon 49\n", + "adding: mem time79, current time 127, horizon 48\n", + "adding: mem time80, current time 127, horizon 47\n", + "adding: mem time81, current time 127, horizon 46\n", + "adding: mem time82, current time 127, horizon 45\n", + "adding: mem time83, current time 127, horizon 44\n", + "adding: mem time84, current time 127, horizon 43\n", + "adding: mem time85, current time 127, horizon 42\n", + "adding: mem time86, current time 127, horizon 41\n", + "adding: mem time87, current time 127, horizon 40\n", + "adding: mem time88, current time 127, horizon 39\n", + "adding: mem time89, current time 127, horizon 38\n", + "adding: mem time90, current time 127, horizon 37\n", + "adding: mem time91, current time 127, horizon 36\n", + "adding: mem time92, current time 127, horizon 35\n", + "adding: mem time93, current time 127, horizon 34\n", + "adding: mem time94, current time 127, horizon 33\n", + "adding: mem time95, current time 127, horizon 32\n", + "adding: mem time96, current time 127, horizon 31\n", + "adding: mem time97, current time 127, horizon 30\n", + "adding: mem time98, current time 127, horizon 29\n", + "adding: mem time99, current time 127, horizon 28\n", + "adding: mem time100, current time 127, horizon 27\n", + "adding: mem time101, current time 127, horizon 26\n", + "adding: mem time102, current time 127, horizon 25\n", + "adding: mem time103, current time 127, horizon 24\n", + "adding: mem time104, current time 127, horizon 23\n", + "adding: mem time105, current time 127, horizon 22\n", + "adding: mem time106, current time 127, horizon 21\n", + "adding: mem time107, current time 127, horizon 20\n", + "adding: mem time108, current time 127, horizon 19\n", + "adding: mem time109, current time 127, horizon 18\n", + "adding: mem time110, current time 127, horizon 17\n", + "adding: mem time111, current time 127, horizon 16\n", + "adding: mem time112, current time 127, horizon 15\n", + "adding: mem time113, current time 127, horizon 14\n", + "adding: mem time114, current time 127, horizon 13\n", + "adding: mem time115, current time 127, horizon 12\n", + "adding: mem time116, current time 127, horizon 11\n", + "adding: mem time117, current time 127, horizon 10\n", + "adding: mem time118, current time 127, horizon 9\n", + "adding: mem time119, current time 127, horizon 8\n", + "adding: mem time120, current time 127, horizon 7\n", + "adding: mem time121, current time 127, horizon 6\n", + "adding: mem time122, current time 127, horizon 5\n", + "adding: mem time123, current time 127, horizon 4\n", + "adding: mem time124, current time 127, horizon 3\n", + "adding: mem time125, current time 127, horizon 2\n", + "adding: mem time126, current time 127, horizon 1\n", + "adding: mem time0, current time 128, horizon 128\n", + "adding: mem time1, current time 128, horizon 127\n", + "adding: mem time2, current time 128, horizon 126\n", + "adding: mem time3, current time 128, horizon 125\n", + "adding: mem time4, current time 128, horizon 124\n", + "adding: mem time5, current time 128, horizon 123\n", + "adding: mem time6, current time 128, horizon 122\n", + "adding: mem time7, current time 128, horizon 121\n", + "adding: mem time8, current time 128, horizon 120\n", + "adding: mem time9, current time 128, horizon 119\n", + "adding: mem time10, current time 128, horizon 118\n", + "adding: mem time11, current time 128, horizon 117\n", + "adding: mem time12, current time 128, horizon 116\n", + "adding: mem time13, current time 128, horizon 115\n", + "adding: mem time14, current time 128, horizon 114\n", + "adding: mem time15, current time 128, horizon 113\n", + "adding: mem time16, current time 128, horizon 112\n", + "adding: mem time17, current time 128, horizon 111\n", + "adding: mem time18, current time 128, horizon 110\n", + "adding: mem time19, current time 128, horizon 109\n", + "adding: mem time20, current time 128, horizon 108\n", + "adding: mem time21, current time 128, horizon 107\n", + "adding: mem time22, current time 128, horizon 106\n", + "adding: mem time23, current time 128, horizon 105\n", + "adding: mem time24, current time 128, horizon 104\n", + "adding: mem time25, current time 128, horizon 103\n", + "adding: mem time26, current time 128, horizon 102\n", + "adding: mem time27, current time 128, horizon 101\n", + "adding: mem time28, current time 128, horizon 100\n", + "adding: mem time29, current time 128, horizon 99\n", + "adding: mem time30, current time 128, horizon 98\n", + "adding: mem time31, current time 128, horizon 97\n", + "adding: mem time32, current time 128, horizon 96\n", + "adding: mem time33, current time 128, horizon 95\n", + "adding: mem time34, current time 128, horizon 94\n", + "adding: mem time35, current time 128, horizon 93\n", + "adding: mem time36, current time 128, horizon 92\n", + "adding: mem time37, current time 128, horizon 91\n", + "adding: mem time38, current time 128, horizon 90\n", + "adding: mem time39, current time 128, horizon 89\n", + "adding: mem time40, current time 128, horizon 88\n", + "adding: mem time41, current time 128, horizon 87\n", + "adding: mem time42, current time 128, horizon 86\n", + "adding: mem time43, current time 128, horizon 85\n", + "adding: mem time44, current time 128, horizon 84\n", + "adding: mem time45, current time 128, horizon 83\n", + "adding: mem time46, current time 128, horizon 82\n", + "adding: mem time47, current time 128, horizon 81\n", + "adding: mem time48, current time 128, horizon 80\n", + "adding: mem time49, current time 128, horizon 79\n", + "adding: mem time50, current time 128, horizon 78\n", + "adding: mem time51, current time 128, horizon 77\n", + "adding: mem time52, current time 128, horizon 76\n", + "adding: mem time53, current time 128, horizon 75\n", + "adding: mem time54, current time 128, horizon 74\n", + "adding: mem time55, current time 128, horizon 73\n", + "adding: mem time56, current time 128, horizon 72\n", + "adding: mem time57, current time 128, horizon 71\n", + "adding: mem time58, current time 128, horizon 70\n", + "adding: mem time59, current time 128, horizon 69\n", + "adding: mem time60, current time 128, horizon 68\n", + "adding: mem time61, current time 128, horizon 67\n", + "adding: mem time62, current time 128, horizon 66\n", + "adding: mem time63, current time 128, horizon 65\n", + "adding: mem time64, current time 128, horizon 64\n", + "adding: mem time65, current time 128, horizon 63\n", + "adding: mem time66, current time 128, horizon 62\n", + "adding: mem time67, current time 128, horizon 61\n", + "adding: mem time68, current time 128, horizon 60\n", + "adding: mem time69, current time 128, horizon 59\n", + "adding: mem time70, current time 128, horizon 58\n", + "adding: mem time71, current time 128, horizon 57\n", + "adding: mem time72, current time 128, horizon 56\n", + "adding: mem time73, current time 128, horizon 55\n", + "adding: mem time74, current time 128, horizon 54\n", + "adding: mem time75, current time 128, horizon 53\n", + "adding: mem time76, current time 128, horizon 52\n", + "adding: mem time77, current time 128, horizon 51\n", + "adding: mem time78, current time 128, horizon 50\n", + "adding: mem time79, current time 128, horizon 49\n", + "adding: mem time80, current time 128, horizon 48\n", + "adding: mem time81, current time 128, horizon 47\n", + "adding: mem time82, current time 128, horizon 46\n", + "adding: mem time83, current time 128, horizon 45\n", + "adding: mem time84, current time 128, horizon 44\n", + "adding: mem time85, current time 128, horizon 43\n", + "adding: mem time86, current time 128, horizon 42\n", + "adding: mem time87, current time 128, horizon 41\n", + "adding: mem time88, current time 128, horizon 40\n", + "adding: mem time89, current time 128, horizon 39\n", + "adding: mem time90, current time 128, horizon 38\n", + "adding: mem time91, current time 128, horizon 37\n", + "adding: mem time92, current time 128, horizon 36\n", + "adding: mem time93, current time 128, horizon 35\n", + "adding: mem time94, current time 128, horizon 34\n", + "adding: mem time95, current time 128, horizon 33\n", + "adding: mem time96, current time 128, horizon 32\n", + "adding: mem time97, current time 128, horizon 31\n", + "adding: mem time98, current time 128, horizon 30\n", + "adding: mem time99, current time 128, horizon 29\n", + "adding: mem time100, current time 128, horizon 28\n", + "adding: mem time101, current time 128, horizon 27\n", + "adding: mem time102, current time 128, horizon 26\n", + "adding: mem time103, current time 128, horizon 25\n", + "adding: mem time104, current time 128, horizon 24\n", + "adding: mem time105, current time 128, horizon 23\n", + "adding: mem time106, current time 128, horizon 22\n", + "adding: mem time107, current time 128, horizon 21\n", + "adding: mem time108, current time 128, horizon 20\n", + "adding: mem time109, current time 128, horizon 19\n", + "adding: mem time110, current time 128, horizon 18\n", + "adding: mem time111, current time 128, horizon 17\n", + "adding: mem time112, current time 128, horizon 16\n", + "adding: mem time113, current time 128, horizon 15\n", + "adding: mem time114, current time 128, horizon 14\n", + "adding: mem time115, current time 128, horizon 13\n", + "adding: mem time116, current time 128, horizon 12\n", + "adding: mem time117, current time 128, horizon 11\n", + "adding: mem time118, current time 128, horizon 10\n", + "adding: mem time119, current time 128, horizon 9\n", + "adding: mem time120, current time 128, horizon 8\n", + "adding: mem time121, current time 128, horizon 7\n", + "adding: mem time122, current time 128, horizon 6\n", + "adding: mem time123, current time 128, horizon 5\n", + "adding: mem time124, current time 128, horizon 4\n", + "adding: mem time125, current time 128, horizon 3\n", + "adding: mem time126, current time 128, horizon 2\n", + "adding: mem time127, current time 128, horizon 1\n", + "adding: mem time0, current time 129, horizon 129\n", + "adding: mem time1, current time 129, horizon 128\n", + "adding: mem time2, current time 129, horizon 127\n", + "adding: mem time3, current time 129, horizon 126\n", + "adding: mem time4, current time 129, horizon 125\n", + "adding: mem time5, current time 129, horizon 124\n", + "adding: mem time6, current time 129, horizon 123\n", + "adding: mem time7, current time 129, horizon 122\n", + "adding: mem time8, current time 129, horizon 121\n", + "adding: mem time9, current time 129, horizon 120\n", + "adding: mem time10, current time 129, horizon 119\n", + "adding: mem time11, current time 129, horizon 118\n", + "adding: mem time12, current time 129, horizon 117\n", + "adding: mem time13, current time 129, horizon 116\n", + "adding: mem time14, current time 129, horizon 115\n", + "adding: mem time15, current time 129, horizon 114\n", + "adding: mem time16, current time 129, horizon 113\n", + "adding: mem time17, current time 129, horizon 112\n", + "adding: mem time18, current time 129, horizon 111\n", + "adding: mem time19, current time 129, horizon 110\n", + "adding: mem time20, current time 129, horizon 109\n", + "adding: mem time21, current time 129, horizon 108\n", + "adding: mem time22, current time 129, horizon 107\n", + "adding: mem time23, current time 129, horizon 106\n", + "adding: mem time24, current time 129, horizon 105\n", + "adding: mem time25, current time 129, horizon 104\n", + "adding: mem time26, current time 129, horizon 103\n", + "adding: mem time27, current time 129, horizon 102\n", + "adding: mem time28, current time 129, horizon 101\n", + "adding: mem time29, current time 129, horizon 100\n", + "adding: mem time30, current time 129, horizon 99\n", + "adding: mem time31, current time 129, horizon 98\n", + "adding: mem time32, current time 129, horizon 97\n", + "adding: mem time33, current time 129, horizon 96\n", + "adding: mem time34, current time 129, horizon 95\n", + "adding: mem time35, current time 129, horizon 94\n", + "adding: mem time36, current time 129, horizon 93\n", + "adding: mem time37, current time 129, horizon 92\n", + "adding: mem time38, current time 129, horizon 91\n", + "adding: mem time39, current time 129, horizon 90\n", + "adding: mem time40, current time 129, horizon 89\n", + "adding: mem time41, current time 129, horizon 88\n", + "adding: mem time42, current time 129, horizon 87\n", + "adding: mem time43, current time 129, horizon 86\n", + "adding: mem time44, current time 129, horizon 85\n", + "adding: mem time45, current time 129, horizon 84\n", + "adding: mem time46, current time 129, horizon 83\n", + "adding: mem time47, current time 129, horizon 82\n", + "adding: mem time48, current time 129, horizon 81\n", + "adding: mem time49, current time 129, horizon 80\n", + "adding: mem time50, current time 129, horizon 79\n", + "adding: mem time51, current time 129, horizon 78\n", + "adding: mem time52, current time 129, horizon 77\n", + "adding: mem time53, current time 129, horizon 76\n", + "adding: mem time54, current time 129, horizon 75\n", + "adding: mem time55, current time 129, horizon 74\n", + "adding: mem time56, current time 129, horizon 73\n", + "adding: mem time57, current time 129, horizon 72\n", + "adding: mem time58, current time 129, horizon 71\n", + "adding: mem time59, current time 129, horizon 70\n", + "adding: mem time60, current time 129, horizon 69\n", + "adding: mem time61, current time 129, horizon 68\n", + "adding: mem time62, current time 129, horizon 67\n", + "adding: mem time63, current time 129, horizon 66\n", + "adding: mem time64, current time 129, horizon 65\n", + "adding: mem time65, current time 129, horizon 64\n", + "adding: mem time66, current time 129, horizon 63\n", + "adding: mem time67, current time 129, horizon 62\n", + "adding: mem time68, current time 129, horizon 61\n", + "adding: mem time69, current time 129, horizon 60\n", + "adding: mem time70, current time 129, horizon 59\n", + "adding: mem time71, current time 129, horizon 58\n", + "adding: mem time72, current time 129, horizon 57\n", + "adding: mem time73, current time 129, horizon 56\n", + "adding: mem time74, current time 129, horizon 55\n", + "adding: mem time75, current time 129, horizon 54\n", + "adding: mem time76, current time 129, horizon 53\n", + "adding: mem time77, current time 129, horizon 52\n", + "adding: mem time78, current time 129, horizon 51\n", + "adding: mem time79, current time 129, horizon 50\n", + "adding: mem time80, current time 129, horizon 49\n", + "adding: mem time81, current time 129, horizon 48\n", + "adding: mem time82, current time 129, horizon 47\n", + "adding: mem time83, current time 129, horizon 46\n", + "adding: mem time84, current time 129, horizon 45\n", + "adding: mem time85, current time 129, horizon 44\n", + "adding: mem time86, current time 129, horizon 43\n", + "adding: mem time87, current time 129, horizon 42\n", + "adding: mem time88, current time 129, horizon 41\n", + "adding: mem time89, current time 129, horizon 40\n", + "adding: mem time90, current time 129, horizon 39\n", + "adding: mem time91, current time 129, horizon 38\n", + "adding: mem time92, current time 129, horizon 37\n", + "adding: mem time93, current time 129, horizon 36\n", + "adding: mem time94, current time 129, horizon 35\n", + "adding: mem time95, current time 129, horizon 34\n", + "adding: mem time96, current time 129, horizon 33\n", + "adding: mem time97, current time 129, horizon 32\n", + "adding: mem time98, current time 129, horizon 31\n", + "adding: mem time99, current time 129, horizon 30\n", + "adding: mem time100, current time 129, horizon 29\n", + "adding: mem time101, current time 129, horizon 28\n", + "adding: mem time102, current time 129, horizon 27\n", + "adding: mem time103, current time 129, horizon 26\n", + "adding: mem time104, current time 129, horizon 25\n", + "adding: mem time105, current time 129, horizon 24\n", + "adding: mem time106, current time 129, horizon 23\n", + "adding: mem time107, current time 129, horizon 22\n", + "adding: mem time108, current time 129, horizon 21\n", + "adding: mem time109, current time 129, horizon 20\n", + "adding: mem time110, current time 129, horizon 19\n", + "adding: mem time111, current time 129, horizon 18\n", + "adding: mem time112, current time 129, horizon 17\n", + "adding: mem time113, current time 129, horizon 16\n", + "adding: mem time114, current time 129, horizon 15\n", + "adding: mem time115, current time 129, horizon 14\n", + "adding: mem time116, current time 129, horizon 13\n", + "adding: mem time117, current time 129, horizon 12\n", + "adding: mem time118, current time 129, horizon 11\n", + "adding: mem time119, current time 129, horizon 10\n", + "adding: mem time120, current time 129, horizon 9\n", + "adding: mem time121, current time 129, horizon 8\n", + "adding: mem time122, current time 129, horizon 7\n", + "adding: mem time123, current time 129, horizon 6\n", + "adding: mem time124, current time 129, horizon 5\n", + "adding: mem time125, current time 129, horizon 4\n", + "adding: mem time126, current time 129, horizon 3\n", + "adding: mem time127, current time 129, horizon 2\n", + "adding: mem time128, current time 129, horizon 1\n", + "adding: mem time0, current time 130, horizon 130\n", + "adding: mem time1, current time 130, horizon 129\n", + "adding: mem time2, current time 130, horizon 128\n", + "adding: mem time3, current time 130, horizon 127\n", + "adding: mem time4, current time 130, horizon 126\n", + "adding: mem time5, current time 130, horizon 125\n", + "adding: mem time6, current time 130, horizon 124\n", + "adding: mem time7, current time 130, horizon 123\n", + "adding: mem time8, current time 130, horizon 122\n", + "adding: mem time9, current time 130, horizon 121\n", + "adding: mem time10, current time 130, horizon 120\n", + "adding: mem time11, current time 130, horizon 119\n", + "adding: mem time12, current time 130, horizon 118\n", + "adding: mem time13, current time 130, horizon 117\n", + "adding: mem time14, current time 130, horizon 116\n", + "adding: mem time15, current time 130, horizon 115\n", + "adding: mem time16, current time 130, horizon 114\n", + "adding: mem time17, current time 130, horizon 113\n", + "adding: mem time18, current time 130, horizon 112\n", + "adding: mem time19, current time 130, horizon 111\n", + "adding: mem time20, current time 130, horizon 110\n", + "adding: mem time21, current time 130, horizon 109\n", + "adding: mem time22, current time 130, horizon 108\n", + "adding: mem time23, current time 130, horizon 107\n", + "adding: mem time24, current time 130, horizon 106\n", + "adding: mem time25, current time 130, horizon 105\n", + "adding: mem time26, current time 130, horizon 104\n", + "adding: mem time27, current time 130, horizon 103\n", + "adding: mem time28, current time 130, horizon 102\n", + "adding: mem time29, current time 130, horizon 101\n", + "adding: mem time30, current time 130, horizon 100\n", + "adding: mem time31, current time 130, horizon 99\n", + "adding: mem time32, current time 130, horizon 98\n", + "adding: mem time33, current time 130, horizon 97\n", + "adding: mem time34, current time 130, horizon 96\n", + "adding: mem time35, current time 130, horizon 95\n", + "adding: mem time36, current time 130, horizon 94\n", + "adding: mem time37, current time 130, horizon 93\n", + "adding: mem time38, current time 130, horizon 92\n", + "adding: mem time39, current time 130, horizon 91\n", + "adding: mem time40, current time 130, horizon 90\n", + "adding: mem time41, current time 130, horizon 89\n", + "adding: mem time42, current time 130, horizon 88\n", + "adding: mem time43, current time 130, horizon 87\n", + "adding: mem time44, current time 130, horizon 86\n", + "adding: mem time45, current time 130, horizon 85\n", + "adding: mem time46, current time 130, horizon 84\n", + "adding: mem time47, current time 130, horizon 83\n", + "adding: mem time48, current time 130, horizon 82\n", + "adding: mem time49, current time 130, horizon 81\n", + "adding: mem time50, current time 130, horizon 80\n", + "adding: mem time51, current time 130, horizon 79\n", + "adding: mem time52, current time 130, horizon 78\n", + "adding: mem time53, current time 130, horizon 77\n", + "adding: mem time54, current time 130, horizon 76\n", + "adding: mem time55, current time 130, horizon 75\n", + "adding: mem time56, current time 130, horizon 74\n", + "adding: mem time57, current time 130, horizon 73\n", + "adding: mem time58, current time 130, horizon 72\n", + "adding: mem time59, current time 130, horizon 71\n", + "adding: mem time60, current time 130, horizon 70\n", + "adding: mem time61, current time 130, horizon 69\n", + "adding: mem time62, current time 130, horizon 68\n", + "adding: mem time63, current time 130, horizon 67\n", + "adding: mem time64, current time 130, horizon 66\n", + "adding: mem time65, current time 130, horizon 65\n", + "adding: mem time66, current time 130, horizon 64\n", + "adding: mem time67, current time 130, horizon 63\n", + "adding: mem time68, current time 130, horizon 62\n", + "adding: mem time69, current time 130, horizon 61\n", + "adding: mem time70, current time 130, horizon 60\n", + "adding: mem time71, current time 130, horizon 59\n", + "adding: mem time72, current time 130, horizon 58\n", + "adding: mem time73, current time 130, horizon 57\n", + "adding: mem time74, current time 130, horizon 56\n", + "adding: mem time75, current time 130, horizon 55\n", + "adding: mem time76, current time 130, horizon 54\n", + "adding: mem time77, current time 130, horizon 53\n", + "adding: mem time78, current time 130, horizon 52\n", + "adding: mem time79, current time 130, horizon 51\n", + "adding: mem time80, current time 130, horizon 50\n", + "adding: mem time81, current time 130, horizon 49\n", + "adding: mem time82, current time 130, horizon 48\n", + "adding: mem time83, current time 130, horizon 47\n", + "adding: mem time84, current time 130, horizon 46\n", + "adding: mem time85, current time 130, horizon 45\n", + "adding: mem time86, current time 130, horizon 44\n", + "adding: mem time87, current time 130, horizon 43\n", + "adding: mem time88, current time 130, horizon 42\n", + "adding: mem time89, current time 130, horizon 41\n", + "adding: mem time90, current time 130, horizon 40\n", + "adding: mem time91, current time 130, horizon 39\n", + "adding: mem time92, current time 130, horizon 38\n", + "adding: mem time93, current time 130, horizon 37\n", + "adding: mem time94, current time 130, horizon 36\n", + "adding: mem time95, current time 130, horizon 35\n", + "adding: mem time96, current time 130, horizon 34\n", + "adding: mem time97, current time 130, horizon 33\n", + "adding: mem time98, current time 130, horizon 32\n", + "adding: mem time99, current time 130, horizon 31\n", + "adding: mem time100, current time 130, horizon 30\n", + "adding: mem time101, current time 130, horizon 29\n", + "adding: mem time102, current time 130, horizon 28\n", + "adding: mem time103, current time 130, horizon 27\n", + "adding: mem time104, current time 130, horizon 26\n", + "adding: mem time105, current time 130, horizon 25\n", + "adding: mem time106, current time 130, horizon 24\n", + "adding: mem time107, current time 130, horizon 23\n", + "adding: mem time108, current time 130, horizon 22\n", + "adding: mem time109, current time 130, horizon 21\n", + "adding: mem time110, current time 130, horizon 20\n", + "adding: mem time111, current time 130, horizon 19\n", + "adding: mem time112, current time 130, horizon 18\n", + "adding: mem time113, current time 130, horizon 17\n", + "adding: mem time114, current time 130, horizon 16\n", + "adding: mem time115, current time 130, horizon 15\n", + "adding: mem time116, current time 130, horizon 14\n", + "adding: mem time117, current time 130, horizon 13\n", + "adding: mem time118, current time 130, horizon 12\n", + "adding: mem time119, current time 130, horizon 11\n", + "adding: mem time120, current time 130, horizon 10\n", + "adding: mem time121, current time 130, horizon 9\n", + "adding: mem time122, current time 130, horizon 8\n", + "adding: mem time123, current time 130, horizon 7\n", + "adding: mem time124, current time 130, horizon 6\n", + "adding: mem time125, current time 130, horizon 5\n", + "adding: mem time126, current time 130, horizon 4\n", + "adding: mem time127, current time 130, horizon 3\n", + "adding: mem time128, current time 130, horizon 2\n", + "adding: mem time129, current time 130, horizon 1\n", + "adding: mem time0, current time 131, horizon 131\n", + "adding: mem time1, current time 131, horizon 130\n", + "adding: mem time2, current time 131, horizon 129\n", + "adding: mem time3, current time 131, horizon 128\n", + "adding: mem time4, current time 131, horizon 127\n", + "adding: mem time5, current time 131, horizon 126\n", + "adding: mem time6, current time 131, horizon 125\n", + "adding: mem time7, current time 131, horizon 124\n", + "adding: mem time8, current time 131, horizon 123\n", + "adding: mem time9, current time 131, horizon 122\n", + "adding: mem time10, current time 131, horizon 121\n", + "adding: mem time11, current time 131, horizon 120\n", + "adding: mem time12, current time 131, horizon 119\n", + "adding: mem time13, current time 131, horizon 118\n", + "adding: mem time14, current time 131, horizon 117\n", + "adding: mem time15, current time 131, horizon 116\n", + "adding: mem time16, current time 131, horizon 115\n", + "adding: mem time17, current time 131, horizon 114\n", + "adding: mem time18, current time 131, horizon 113\n", + "adding: mem time19, current time 131, horizon 112\n", + "adding: mem time20, current time 131, horizon 111\n", + "adding: mem time21, current time 131, horizon 110\n", + "adding: mem time22, current time 131, horizon 109\n", + "adding: mem time23, current time 131, horizon 108\n", + "adding: mem time24, current time 131, horizon 107\n", + "adding: mem time25, current time 131, horizon 106\n", + "adding: mem time26, current time 131, horizon 105\n", + "adding: mem time27, current time 131, horizon 104\n", + "adding: mem time28, current time 131, horizon 103\n", + "adding: mem time29, current time 131, horizon 102\n", + "adding: mem time30, current time 131, horizon 101\n", + "adding: mem time31, current time 131, horizon 100\n", + "adding: mem time32, current time 131, horizon 99\n", + "adding: mem time33, current time 131, horizon 98\n", + "adding: mem time34, current time 131, horizon 97\n", + "adding: mem time35, current time 131, horizon 96\n", + "adding: mem time36, current time 131, horizon 95\n", + "adding: mem time37, current time 131, horizon 94\n", + "adding: mem time38, current time 131, horizon 93\n", + "adding: mem time39, current time 131, horizon 92\n", + "adding: mem time40, current time 131, horizon 91\n", + "adding: mem time41, current time 131, horizon 90\n", + "adding: mem time42, current time 131, horizon 89\n", + "adding: mem time43, current time 131, horizon 88\n", + "adding: mem time44, current time 131, horizon 87\n", + "adding: mem time45, current time 131, horizon 86\n", + "adding: mem time46, current time 131, horizon 85\n", + "adding: mem time47, current time 131, horizon 84\n", + "adding: mem time48, current time 131, horizon 83\n", + "adding: mem time49, current time 131, horizon 82\n", + "adding: mem time50, current time 131, horizon 81\n", + "adding: mem time51, current time 131, horizon 80\n", + "adding: mem time52, current time 131, horizon 79\n", + "adding: mem time53, current time 131, horizon 78\n", + "adding: mem time54, current time 131, horizon 77\n", + "adding: mem time55, current time 131, horizon 76\n", + "adding: mem time56, current time 131, horizon 75\n", + "adding: mem time57, current time 131, horizon 74\n", + "adding: mem time58, current time 131, horizon 73\n", + "adding: mem time59, current time 131, horizon 72\n", + "adding: mem time60, current time 131, horizon 71\n", + "adding: mem time61, current time 131, horizon 70\n", + "adding: mem time62, current time 131, horizon 69\n", + "adding: mem time63, current time 131, horizon 68\n", + "adding: mem time64, current time 131, horizon 67\n", + "adding: mem time65, current time 131, horizon 66\n", + "adding: mem time66, current time 131, horizon 65\n", + "adding: mem time67, current time 131, horizon 64\n", + "adding: mem time68, current time 131, horizon 63\n", + "adding: mem time69, current time 131, horizon 62\n", + "adding: mem time70, current time 131, horizon 61\n", + "adding: mem time71, current time 131, horizon 60\n", + "adding: mem time72, current time 131, horizon 59\n", + "adding: mem time73, current time 131, horizon 58\n", + "adding: mem time74, current time 131, horizon 57\n", + "adding: mem time75, current time 131, horizon 56\n", + "adding: mem time76, current time 131, horizon 55\n", + "adding: mem time77, current time 131, horizon 54\n", + "adding: mem time78, current time 131, horizon 53\n", + "adding: mem time79, current time 131, horizon 52\n", + "adding: mem time80, current time 131, horizon 51\n", + "adding: mem time81, current time 131, horizon 50\n", + "adding: mem time82, current time 131, horizon 49\n", + "adding: mem time83, current time 131, horizon 48\n", + "adding: mem time84, current time 131, horizon 47\n", + "adding: mem time85, current time 131, horizon 46\n", + "adding: mem time86, current time 131, horizon 45\n", + "adding: mem time87, current time 131, horizon 44\n", + "adding: mem time88, current time 131, horizon 43\n", + "adding: mem time89, current time 131, horizon 42\n", + "adding: mem time90, current time 131, horizon 41\n", + "adding: mem time91, current time 131, horizon 40\n", + "adding: mem time92, current time 131, horizon 39\n", + "adding: mem time93, current time 131, horizon 38\n", + "adding: mem time94, current time 131, horizon 37\n", + "adding: mem time95, current time 131, horizon 36\n", + "adding: mem time96, current time 131, horizon 35\n", + "adding: mem time97, current time 131, horizon 34\n", + "adding: mem time98, current time 131, horizon 33\n", + "adding: mem time99, current time 131, horizon 32\n", + "adding: mem time100, current time 131, horizon 31\n", + "adding: mem time101, current time 131, horizon 30\n", + "adding: mem time102, current time 131, horizon 29\n", + "adding: mem time103, current time 131, horizon 28\n", + "adding: mem time104, current time 131, horizon 27\n", + "adding: mem time105, current time 131, horizon 26\n", + "adding: mem time106, current time 131, horizon 25\n", + "adding: mem time107, current time 131, horizon 24\n", + "adding: mem time108, current time 131, horizon 23\n", + "adding: mem time109, current time 131, horizon 22\n", + "adding: mem time110, current time 131, horizon 21\n", + "adding: mem time111, current time 131, horizon 20\n", + "adding: mem time112, current time 131, horizon 19\n", + "adding: mem time113, current time 131, horizon 18\n", + "adding: mem time114, current time 131, horizon 17\n", + "adding: mem time115, current time 131, horizon 16\n", + "adding: mem time116, current time 131, horizon 15\n", + "adding: mem time117, current time 131, horizon 14\n", + "adding: mem time118, current time 131, horizon 13\n", + "adding: mem time119, current time 131, horizon 12\n", + "adding: mem time120, current time 131, horizon 11\n", + "adding: mem time121, current time 131, horizon 10\n", + "adding: mem time122, current time 131, horizon 9\n", + "adding: mem time123, current time 131, horizon 8\n", + "adding: mem time124, current time 131, horizon 7\n", + "adding: mem time125, current time 131, horizon 6\n", + "adding: mem time126, current time 131, horizon 5\n", + "adding: mem time127, current time 131, horizon 4\n", + "adding: mem time128, current time 131, horizon 3\n", + "adding: mem time129, current time 131, horizon 2\n", + "adding: mem time130, current time 131, horizon 1\n", + "adding: mem time0, current time 132, horizon 132\n", + "adding: mem time1, current time 132, horizon 131\n", + "adding: mem time2, current time 132, horizon 130\n", + "adding: mem time3, current time 132, horizon 129\n", + "adding: mem time4, current time 132, horizon 128\n", + "adding: mem time5, current time 132, horizon 127\n", + "adding: mem time6, current time 132, horizon 126\n", + "adding: mem time7, current time 132, horizon 125\n", + "adding: mem time8, current time 132, horizon 124\n", + "adding: mem time9, current time 132, horizon 123\n", + "adding: mem time10, current time 132, horizon 122\n", + "adding: mem time11, current time 132, horizon 121\n", + "adding: mem time12, current time 132, horizon 120\n", + "adding: mem time13, current time 132, horizon 119\n", + "adding: mem time14, current time 132, horizon 118\n", + "adding: mem time15, current time 132, horizon 117\n", + "adding: mem time16, current time 132, horizon 116\n", + "adding: mem time17, current time 132, horizon 115\n", + "adding: mem time18, current time 132, horizon 114\n", + "adding: mem time19, current time 132, horizon 113\n", + "adding: mem time20, current time 132, horizon 112\n", + "adding: mem time21, current time 132, horizon 111\n", + "adding: mem time22, current time 132, horizon 110\n", + "adding: mem time23, current time 132, horizon 109\n", + "adding: mem time24, current time 132, horizon 108\n", + "adding: mem time25, current time 132, horizon 107\n", + "adding: mem time26, current time 132, horizon 106\n", + "adding: mem time27, current time 132, horizon 105\n", + "adding: mem time28, current time 132, horizon 104\n", + "adding: mem time29, current time 132, horizon 103\n", + "adding: mem time30, current time 132, horizon 102\n", + "adding: mem time31, current time 132, horizon 101\n", + "adding: mem time32, current time 132, horizon 100\n", + "adding: mem time33, current time 132, horizon 99\n", + "adding: mem time34, current time 132, horizon 98\n", + "adding: mem time35, current time 132, horizon 97\n", + "adding: mem time36, current time 132, horizon 96\n", + "adding: mem time37, current time 132, horizon 95\n", + "adding: mem time38, current time 132, horizon 94\n", + "adding: mem time39, current time 132, horizon 93\n", + "adding: mem time40, current time 132, horizon 92\n", + "adding: mem time41, current time 132, horizon 91\n", + "adding: mem time42, current time 132, horizon 90\n", + "adding: mem time43, current time 132, horizon 89\n", + "adding: mem time44, current time 132, horizon 88\n", + "adding: mem time45, current time 132, horizon 87\n", + "adding: mem time46, current time 132, horizon 86\n", + "adding: mem time47, current time 132, horizon 85\n", + "adding: mem time48, current time 132, horizon 84\n", + "adding: mem time49, current time 132, horizon 83\n", + "adding: mem time50, current time 132, horizon 82\n", + "adding: mem time51, current time 132, horizon 81\n", + "adding: mem time52, current time 132, horizon 80\n", + "adding: mem time53, current time 132, horizon 79\n", + "adding: mem time54, current time 132, horizon 78\n", + "adding: mem time55, current time 132, horizon 77\n", + "adding: mem time56, current time 132, horizon 76\n", + "adding: mem time57, current time 132, horizon 75\n", + "adding: mem time58, current time 132, horizon 74\n", + "adding: mem time59, current time 132, horizon 73\n", + "adding: mem time60, current time 132, horizon 72\n", + "adding: mem time61, current time 132, horizon 71\n", + "adding: mem time62, current time 132, horizon 70\n", + "adding: mem time63, current time 132, horizon 69\n", + "adding: mem time64, current time 132, horizon 68\n", + "adding: mem time65, current time 132, horizon 67\n", + "adding: mem time66, current time 132, horizon 66\n", + "adding: mem time67, current time 132, horizon 65\n", + "adding: mem time68, current time 132, horizon 64\n", + "adding: mem time69, current time 132, horizon 63\n", + "adding: mem time70, current time 132, horizon 62\n", + "adding: mem time71, current time 132, horizon 61\n", + "adding: mem time72, current time 132, horizon 60\n", + "adding: mem time73, current time 132, horizon 59\n", + "adding: mem time74, current time 132, horizon 58\n", + "adding: mem time75, current time 132, horizon 57\n", + "adding: mem time76, current time 132, horizon 56\n", + "adding: mem time77, current time 132, horizon 55\n", + "adding: mem time78, current time 132, horizon 54\n", + "adding: mem time79, current time 132, horizon 53\n", + "adding: mem time80, current time 132, horizon 52\n", + "adding: mem time81, current time 132, horizon 51\n", + "adding: mem time82, current time 132, horizon 50\n", + "adding: mem time83, current time 132, horizon 49\n", + "adding: mem time84, current time 132, horizon 48\n", + "adding: mem time85, current time 132, horizon 47\n", + "adding: mem time86, current time 132, horizon 46\n", + "adding: mem time87, current time 132, horizon 45\n", + "adding: mem time88, current time 132, horizon 44\n", + "adding: mem time89, current time 132, horizon 43\n", + "adding: mem time90, current time 132, horizon 42\n", + "adding: mem time91, current time 132, horizon 41\n", + "adding: mem time92, current time 132, horizon 40\n", + "adding: mem time93, current time 132, horizon 39\n", + "adding: mem time94, current time 132, horizon 38\n", + "adding: mem time95, current time 132, horizon 37\n", + "adding: mem time96, current time 132, horizon 36\n", + "adding: mem time97, current time 132, horizon 35\n", + "adding: mem time98, current time 132, horizon 34\n", + "adding: mem time99, current time 132, horizon 33\n", + "adding: mem time100, current time 132, horizon 32\n", + "adding: mem time101, current time 132, horizon 31\n", + "adding: mem time102, current time 132, horizon 30\n", + "adding: mem time103, current time 132, horizon 29\n", + "adding: mem time104, current time 132, horizon 28\n", + "adding: mem time105, current time 132, horizon 27\n", + "adding: mem time106, current time 132, horizon 26\n", + "adding: mem time107, current time 132, horizon 25\n", + "adding: mem time108, current time 132, horizon 24\n", + "adding: mem time109, current time 132, horizon 23\n", + "adding: mem time110, current time 132, horizon 22\n", + "adding: mem time111, current time 132, horizon 21\n", + "adding: mem time112, current time 132, horizon 20\n", + "adding: mem time113, current time 132, horizon 19\n", + "adding: mem time114, current time 132, horizon 18\n", + "adding: mem time115, current time 132, horizon 17\n", + "adding: mem time116, current time 132, horizon 16\n", + "adding: mem time117, current time 132, horizon 15\n", + "adding: mem time118, current time 132, horizon 14\n", + "adding: mem time119, current time 132, horizon 13\n", + "adding: mem time120, current time 132, horizon 12\n", + "adding: mem time121, current time 132, horizon 11\n", + "adding: mem time122, current time 132, horizon 10\n", + "adding: mem time123, current time 132, horizon 9\n", + "adding: mem time124, current time 132, horizon 8\n", + "adding: mem time125, current time 132, horizon 7\n", + "adding: mem time126, current time 132, horizon 6\n", + "adding: mem time127, current time 132, horizon 5\n", + "adding: mem time128, current time 132, horizon 4\n", + "adding: mem time129, current time 132, horizon 3\n", + "adding: mem time130, current time 132, horizon 2\n", + "adding: mem time131, current time 132, horizon 1\n", + "adding: mem time0, current time 133, horizon 133\n", + "adding: mem time1, current time 133, horizon 132\n", + "adding: mem time2, current time 133, horizon 131\n", + "adding: mem time3, current time 133, horizon 130\n", + "adding: mem time4, current time 133, horizon 129\n", + "adding: mem time5, current time 133, horizon 128\n", + "adding: mem time6, current time 133, horizon 127\n", + "adding: mem time7, current time 133, horizon 126\n", + "adding: mem time8, current time 133, horizon 125\n", + "adding: mem time9, current time 133, horizon 124\n", + "adding: mem time10, current time 133, horizon 123\n", + "adding: mem time11, current time 133, horizon 122\n", + "adding: mem time12, current time 133, horizon 121\n", + "adding: mem time13, current time 133, horizon 120\n", + "adding: mem time14, current time 133, horizon 119\n", + "adding: mem time15, current time 133, horizon 118\n", + "adding: mem time16, current time 133, horizon 117\n", + "adding: mem time17, current time 133, horizon 116\n", + "adding: mem time18, current time 133, horizon 115\n", + "adding: mem time19, current time 133, horizon 114\n", + "adding: mem time20, current time 133, horizon 113\n", + "adding: mem time21, current time 133, horizon 112\n", + "adding: mem time22, current time 133, horizon 111\n", + "adding: mem time23, current time 133, horizon 110\n", + "adding: mem time24, current time 133, horizon 109\n", + "adding: mem time25, current time 133, horizon 108\n", + "adding: mem time26, current time 133, horizon 107\n", + "adding: mem time27, current time 133, horizon 106\n", + "adding: mem time28, current time 133, horizon 105\n", + "adding: mem time29, current time 133, horizon 104\n", + "adding: mem time30, current time 133, horizon 103\n", + "adding: mem time31, current time 133, horizon 102\n", + "adding: mem time32, current time 133, horizon 101\n", + "adding: mem time33, current time 133, horizon 100\n", + "adding: mem time34, current time 133, horizon 99\n", + "adding: mem time35, current time 133, horizon 98\n", + "adding: mem time36, current time 133, horizon 97\n", + "adding: mem time37, current time 133, horizon 96\n", + "adding: mem time38, current time 133, horizon 95\n", + "adding: mem time39, current time 133, horizon 94\n", + "adding: mem time40, current time 133, horizon 93\n", + "adding: mem time41, current time 133, horizon 92\n", + "adding: mem time42, current time 133, horizon 91\n", + "adding: mem time43, current time 133, horizon 90\n", + "adding: mem time44, current time 133, horizon 89\n", + "adding: mem time45, current time 133, horizon 88\n", + "adding: mem time46, current time 133, horizon 87\n", + "adding: mem time47, current time 133, horizon 86\n", + "adding: mem time48, current time 133, horizon 85\n", + "adding: mem time49, current time 133, horizon 84\n", + "adding: mem time50, current time 133, horizon 83\n", + "adding: mem time51, current time 133, horizon 82\n", + "adding: mem time52, current time 133, horizon 81\n", + "adding: mem time53, current time 133, horizon 80\n", + "adding: mem time54, current time 133, horizon 79\n", + "adding: mem time55, current time 133, horizon 78\n", + "adding: mem time56, current time 133, horizon 77\n", + "adding: mem time57, current time 133, horizon 76\n", + "adding: mem time58, current time 133, horizon 75\n", + "adding: mem time59, current time 133, horizon 74\n", + "adding: mem time60, current time 133, horizon 73\n", + "adding: mem time61, current time 133, horizon 72\n", + "adding: mem time62, current time 133, horizon 71\n", + "adding: mem time63, current time 133, horizon 70\n", + "adding: mem time64, current time 133, horizon 69\n", + "adding: mem time65, current time 133, horizon 68\n", + "adding: mem time66, current time 133, horizon 67\n", + "adding: mem time67, current time 133, horizon 66\n", + "adding: mem time68, current time 133, horizon 65\n", + "adding: mem time69, current time 133, horizon 64\n", + "adding: mem time70, current time 133, horizon 63\n", + "adding: mem time71, current time 133, horizon 62\n", + "adding: mem time72, current time 133, horizon 61\n", + "adding: mem time73, current time 133, horizon 60\n", + "adding: mem time74, current time 133, horizon 59\n", + "adding: mem time75, current time 133, horizon 58\n", + "adding: mem time76, current time 133, horizon 57\n", + "adding: mem time77, current time 133, horizon 56\n", + "adding: mem time78, current time 133, horizon 55\n", + "adding: mem time79, current time 133, horizon 54\n", + "adding: mem time80, current time 133, horizon 53\n", + "adding: mem time81, current time 133, horizon 52\n", + "adding: mem time82, current time 133, horizon 51\n", + "adding: mem time83, current time 133, horizon 50\n", + "adding: mem time84, current time 133, horizon 49\n", + "adding: mem time85, current time 133, horizon 48\n", + "adding: mem time86, current time 133, horizon 47\n", + "adding: mem time87, current time 133, horizon 46\n", + "adding: mem time88, current time 133, horizon 45\n", + "adding: mem time89, current time 133, horizon 44\n", + "adding: mem time90, current time 133, horizon 43\n", + "adding: mem time91, current time 133, horizon 42\n", + "adding: mem time92, current time 133, horizon 41\n", + "adding: mem time93, current time 133, horizon 40\n", + "adding: mem time94, current time 133, horizon 39\n", + "adding: mem time95, current time 133, horizon 38\n", + "adding: mem time96, current time 133, horizon 37\n", + "adding: mem time97, current time 133, horizon 36\n", + "adding: mem time98, current time 133, horizon 35\n", + "adding: mem time99, current time 133, horizon 34\n", + "adding: mem time100, current time 133, horizon 33\n", + "adding: mem time101, current time 133, horizon 32\n", + "adding: mem time102, current time 133, horizon 31\n", + "adding: mem time103, current time 133, horizon 30\n", + "adding: mem time104, current time 133, horizon 29\n", + "adding: mem time105, current time 133, horizon 28\n", + "adding: mem time106, current time 133, horizon 27\n", + "adding: mem time107, current time 133, horizon 26\n", + "adding: mem time108, current time 133, horizon 25\n", + "adding: mem time109, current time 133, horizon 24\n", + "adding: mem time110, current time 133, horizon 23\n", + "adding: mem time111, current time 133, horizon 22\n", + "adding: mem time112, current time 133, horizon 21\n", + "adding: mem time113, current time 133, horizon 20\n", + "adding: mem time114, current time 133, horizon 19\n", + "adding: mem time115, current time 133, horizon 18\n", + "adding: mem time116, current time 133, horizon 17\n", + "adding: mem time117, current time 133, horizon 16\n", + "adding: mem time118, current time 133, horizon 15\n", + "adding: mem time119, current time 133, horizon 14\n", + "adding: mem time120, current time 133, horizon 13\n", + "adding: mem time121, current time 133, horizon 12\n", + "adding: mem time122, current time 133, horizon 11\n", + "adding: mem time123, current time 133, horizon 10\n", + "adding: mem time124, current time 133, horizon 9\n", + "adding: mem time125, current time 133, horizon 8\n", + "adding: mem time126, current time 133, horizon 7\n", + "adding: mem time127, current time 133, horizon 6\n", + "adding: mem time128, current time 133, horizon 5\n", + "adding: mem time129, current time 133, horizon 4\n", + "adding: mem time130, current time 133, horizon 3\n", + "adding: mem time131, current time 133, horizon 2\n", + "adding: mem time132, current time 133, horizon 1\n", + "adding: mem time0, current time 134, horizon 134\n", + "adding: mem time1, current time 134, horizon 133\n", + "adding: mem time2, current time 134, horizon 132\n", + "adding: mem time3, current time 134, horizon 131\n", + "adding: mem time4, current time 134, horizon 130\n", + "adding: mem time5, current time 134, horizon 129\n", + "adding: mem time6, current time 134, horizon 128\n", + "adding: mem time7, current time 134, horizon 127\n", + "adding: mem time8, current time 134, horizon 126\n", + "adding: mem time9, current time 134, horizon 125\n", + "adding: mem time10, current time 134, horizon 124\n", + "adding: mem time11, current time 134, horizon 123\n", + "adding: mem time12, current time 134, horizon 122\n", + "adding: mem time13, current time 134, horizon 121\n", + "adding: mem time14, current time 134, horizon 120\n", + "adding: mem time15, current time 134, horizon 119\n", + "adding: mem time16, current time 134, horizon 118\n", + "adding: mem time17, current time 134, horizon 117\n", + "adding: mem time18, current time 134, horizon 116\n", + "adding: mem time19, current time 134, horizon 115\n", + "adding: mem time20, current time 134, horizon 114\n", + "adding: mem time21, current time 134, horizon 113\n", + "adding: mem time22, current time 134, horizon 112\n", + "adding: mem time23, current time 134, horizon 111\n", + "adding: mem time24, current time 134, horizon 110\n", + "adding: mem time25, current time 134, horizon 109\n", + "adding: mem time26, current time 134, horizon 108\n", + "adding: mem time27, current time 134, horizon 107\n", + "adding: mem time28, current time 134, horizon 106\n", + "adding: mem time29, current time 134, horizon 105\n", + "adding: mem time30, current time 134, horizon 104\n", + "adding: mem time31, current time 134, horizon 103\n", + "adding: mem time32, current time 134, horizon 102\n", + "adding: mem time33, current time 134, horizon 101\n", + "adding: mem time34, current time 134, horizon 100\n", + "adding: mem time35, current time 134, horizon 99\n", + "adding: mem time36, current time 134, horizon 98\n", + "adding: mem time37, current time 134, horizon 97\n", + "adding: mem time38, current time 134, horizon 96\n", + "adding: mem time39, current time 134, horizon 95\n", + "adding: mem time40, current time 134, horizon 94\n", + "adding: mem time41, current time 134, horizon 93\n", + "adding: mem time42, current time 134, horizon 92\n", + "adding: mem time43, current time 134, horizon 91\n", + "adding: mem time44, current time 134, horizon 90\n", + "adding: mem time45, current time 134, horizon 89\n", + "adding: mem time46, current time 134, horizon 88\n", + "adding: mem time47, current time 134, horizon 87\n", + "adding: mem time48, current time 134, horizon 86\n", + "adding: mem time49, current time 134, horizon 85\n", + "adding: mem time50, current time 134, horizon 84\n", + "adding: mem time51, current time 134, horizon 83\n", + "adding: mem time52, current time 134, horizon 82\n", + "adding: mem time53, current time 134, horizon 81\n", + "adding: mem time54, current time 134, horizon 80\n", + "adding: mem time55, current time 134, horizon 79\n", + "adding: mem time56, current time 134, horizon 78\n", + "adding: mem time57, current time 134, horizon 77\n", + "adding: mem time58, current time 134, horizon 76\n", + "adding: mem time59, current time 134, horizon 75\n", + "adding: mem time60, current time 134, horizon 74\n", + "adding: mem time61, current time 134, horizon 73\n", + "adding: mem time62, current time 134, horizon 72\n", + "adding: mem time63, current time 134, horizon 71\n", + "adding: mem time64, current time 134, horizon 70\n", + "adding: mem time65, current time 134, horizon 69\n", + "adding: mem time66, current time 134, horizon 68\n", + "adding: mem time67, current time 134, horizon 67\n", + "adding: mem time68, current time 134, horizon 66\n", + "adding: mem time69, current time 134, horizon 65\n", + "adding: mem time70, current time 134, horizon 64\n", + "adding: mem time71, current time 134, horizon 63\n", + "adding: mem time72, current time 134, horizon 62\n", + "adding: mem time73, current time 134, horizon 61\n", + "adding: mem time74, current time 134, horizon 60\n", + "adding: mem time75, current time 134, horizon 59\n", + "adding: mem time76, current time 134, horizon 58\n", + "adding: mem time77, current time 134, horizon 57\n", + "adding: mem time78, current time 134, horizon 56\n", + "adding: mem time79, current time 134, horizon 55\n", + "adding: mem time80, current time 134, horizon 54\n", + "adding: mem time81, current time 134, horizon 53\n", + "adding: mem time82, current time 134, horizon 52\n", + "adding: mem time83, current time 134, horizon 51\n", + "adding: mem time84, current time 134, horizon 50\n", + "adding: mem time85, current time 134, horizon 49\n", + "adding: mem time86, current time 134, horizon 48\n", + "adding: mem time87, current time 134, horizon 47\n", + "adding: mem time88, current time 134, horizon 46\n", + "adding: mem time89, current time 134, horizon 45\n", + "adding: mem time90, current time 134, horizon 44\n", + "adding: mem time91, current time 134, horizon 43\n", + "adding: mem time92, current time 134, horizon 42\n", + "adding: mem time93, current time 134, horizon 41\n", + "adding: mem time94, current time 134, horizon 40\n", + "adding: mem time95, current time 134, horizon 39\n", + "adding: mem time96, current time 134, horizon 38\n", + "adding: mem time97, current time 134, horizon 37\n", + "adding: mem time98, current time 134, horizon 36\n", + "adding: mem time99, current time 134, horizon 35\n", + "adding: mem time100, current time 134, horizon 34\n", + "adding: mem time101, current time 134, horizon 33\n", + "adding: mem time102, current time 134, horizon 32\n", + "adding: mem time103, current time 134, horizon 31\n", + "adding: mem time104, current time 134, horizon 30\n", + "adding: mem time105, current time 134, horizon 29\n", + "adding: mem time106, current time 134, horizon 28\n", + "adding: mem time107, current time 134, horizon 27\n", + "adding: mem time108, current time 134, horizon 26\n", + "adding: mem time109, current time 134, horizon 25\n", + "adding: mem time110, current time 134, horizon 24\n", + "adding: mem time111, current time 134, horizon 23\n", + "adding: mem time112, current time 134, horizon 22\n", + "adding: mem time113, current time 134, horizon 21\n", + "adding: mem time114, current time 134, horizon 20\n", + "adding: mem time115, current time 134, horizon 19\n", + "adding: mem time116, current time 134, horizon 18\n", + "adding: mem time117, current time 134, horizon 17\n", + "adding: mem time118, current time 134, horizon 16\n", + "adding: mem time119, current time 134, horizon 15\n", + "adding: mem time120, current time 134, horizon 14\n", + "adding: mem time121, current time 134, horizon 13\n", + "adding: mem time122, current time 134, horizon 12\n", + "adding: mem time123, current time 134, horizon 11\n", + "adding: mem time124, current time 134, horizon 10\n", + "adding: mem time125, current time 134, horizon 9\n", + "adding: mem time126, current time 134, horizon 8\n", + "adding: mem time127, current time 134, horizon 7\n", + "adding: mem time128, current time 134, horizon 6\n", + "adding: mem time129, current time 134, horizon 5\n", + "adding: mem time130, current time 134, horizon 4\n", + "adding: mem time131, current time 134, horizon 3\n", + "adding: mem time132, current time 134, horizon 2\n", + "adding: mem time133, current time 134, horizon 1\n", + "adding: mem time0, current time 135, horizon 135\n", + "adding: mem time1, current time 135, horizon 134\n", + "adding: mem time2, current time 135, horizon 133\n", + "adding: mem time3, current time 135, horizon 132\n", + "adding: mem time4, current time 135, horizon 131\n", + "adding: mem time5, current time 135, horizon 130\n", + "adding: mem time6, current time 135, horizon 129\n", + "adding: mem time7, current time 135, horizon 128\n", + "adding: mem time8, current time 135, horizon 127\n", + "adding: mem time9, current time 135, horizon 126\n", + "adding: mem time10, current time 135, horizon 125\n", + "adding: mem time11, current time 135, horizon 124\n", + "adding: mem time12, current time 135, horizon 123\n", + "adding: mem time13, current time 135, horizon 122\n", + "adding: mem time14, current time 135, horizon 121\n", + "adding: mem time15, current time 135, horizon 120\n", + "adding: mem time16, current time 135, horizon 119\n", + "adding: mem time17, current time 135, horizon 118\n", + "adding: mem time18, current time 135, horizon 117\n", + "adding: mem time19, current time 135, horizon 116\n", + "adding: mem time20, current time 135, horizon 115\n", + "adding: mem time21, current time 135, horizon 114\n", + "adding: mem time22, current time 135, horizon 113\n", + "adding: mem time23, current time 135, horizon 112\n", + "adding: mem time24, current time 135, horizon 111\n", + "adding: mem time25, current time 135, horizon 110\n", + "adding: mem time26, current time 135, horizon 109\n", + "adding: mem time27, current time 135, horizon 108\n", + "adding: mem time28, current time 135, horizon 107\n", + "adding: mem time29, current time 135, horizon 106\n", + "adding: mem time30, current time 135, horizon 105\n", + "adding: mem time31, current time 135, horizon 104\n", + "adding: mem time32, current time 135, horizon 103\n", + "adding: mem time33, current time 135, horizon 102\n", + "adding: mem time34, current time 135, horizon 101\n", + "adding: mem time35, current time 135, horizon 100\n", + "adding: mem time36, current time 135, horizon 99\n", + "adding: mem time37, current time 135, horizon 98\n", + "adding: mem time38, current time 135, horizon 97\n", + "adding: mem time39, current time 135, horizon 96\n", + "adding: mem time40, current time 135, horizon 95\n", + "adding: mem time41, current time 135, horizon 94\n", + "adding: mem time42, current time 135, horizon 93\n", + "adding: mem time43, current time 135, horizon 92\n", + "adding: mem time44, current time 135, horizon 91\n", + "adding: mem time45, current time 135, horizon 90\n", + "adding: mem time46, current time 135, horizon 89\n", + "adding: mem time47, current time 135, horizon 88\n", + "adding: mem time48, current time 135, horizon 87\n", + "adding: mem time49, current time 135, horizon 86\n", + "adding: mem time50, current time 135, horizon 85\n", + "adding: mem time51, current time 135, horizon 84\n", + "adding: mem time52, current time 135, horizon 83\n", + "adding: mem time53, current time 135, horizon 82\n", + "adding: mem time54, current time 135, horizon 81\n", + "adding: mem time55, current time 135, horizon 80\n", + "adding: mem time56, current time 135, horizon 79\n", + "adding: mem time57, current time 135, horizon 78\n", + "adding: mem time58, current time 135, horizon 77\n", + "adding: mem time59, current time 135, horizon 76\n", + "adding: mem time60, current time 135, horizon 75\n", + "adding: mem time61, current time 135, horizon 74\n", + "adding: mem time62, current time 135, horizon 73\n", + "adding: mem time63, current time 135, horizon 72\n", + "adding: mem time64, current time 135, horizon 71\n", + "adding: mem time65, current time 135, horizon 70\n", + "adding: mem time66, current time 135, horizon 69\n", + "adding: mem time67, current time 135, horizon 68\n", + "adding: mem time68, current time 135, horizon 67\n", + "adding: mem time69, current time 135, horizon 66\n", + "adding: mem time70, current time 135, horizon 65\n", + "adding: mem time71, current time 135, horizon 64\n", + "adding: mem time72, current time 135, horizon 63\n", + "adding: mem time73, current time 135, horizon 62\n", + "adding: mem time74, current time 135, horizon 61\n", + "adding: mem time75, current time 135, horizon 60\n", + "adding: mem time76, current time 135, horizon 59\n", + "adding: mem time77, current time 135, horizon 58\n", + "adding: mem time78, current time 135, horizon 57\n", + "adding: mem time79, current time 135, horizon 56\n", + "adding: mem time80, current time 135, horizon 55\n", + "adding: mem time81, current time 135, horizon 54\n", + "adding: mem time82, current time 135, horizon 53\n", + "adding: mem time83, current time 135, horizon 52\n", + "adding: mem time84, current time 135, horizon 51\n", + "adding: mem time85, current time 135, horizon 50\n", + "adding: mem time86, current time 135, horizon 49\n", + "adding: mem time87, current time 135, horizon 48\n", + "adding: mem time88, current time 135, horizon 47\n", + "adding: mem time89, current time 135, horizon 46\n", + "adding: mem time90, current time 135, horizon 45\n", + "adding: mem time91, current time 135, horizon 44\n", + "adding: mem time92, current time 135, horizon 43\n", + "adding: mem time93, current time 135, horizon 42\n", + "adding: mem time94, current time 135, horizon 41\n", + "adding: mem time95, current time 135, horizon 40\n", + "adding: mem time96, current time 135, horizon 39\n", + "adding: mem time97, current time 135, horizon 38\n", + "adding: mem time98, current time 135, horizon 37\n", + "adding: mem time99, current time 135, horizon 36\n", + "adding: mem time100, current time 135, horizon 35\n", + "adding: mem time101, current time 135, horizon 34\n", + "adding: mem time102, current time 135, horizon 33\n", + "adding: mem time103, current time 135, horizon 32\n", + "adding: mem time104, current time 135, horizon 31\n", + "adding: mem time105, current time 135, horizon 30\n", + "adding: mem time106, current time 135, horizon 29\n", + "adding: mem time107, current time 135, horizon 28\n", + "adding: mem time108, current time 135, horizon 27\n", + "adding: mem time109, current time 135, horizon 26\n", + "adding: mem time110, current time 135, horizon 25\n", + "adding: mem time111, current time 135, horizon 24\n", + "adding: mem time112, current time 135, horizon 23\n", + "adding: mem time113, current time 135, horizon 22\n", + "adding: mem time114, current time 135, horizon 21\n", + "adding: mem time115, current time 135, horizon 20\n", + "adding: mem time116, current time 135, horizon 19\n", + "adding: mem time117, current time 135, horizon 18\n", + "adding: mem time118, current time 135, horizon 17\n", + "adding: mem time119, current time 135, horizon 16\n", + "adding: mem time120, current time 135, horizon 15\n", + "adding: mem time121, current time 135, horizon 14\n", + "adding: mem time122, current time 135, horizon 13\n", + "adding: mem time123, current time 135, horizon 12\n", + "adding: mem time124, current time 135, horizon 11\n", + "adding: mem time125, current time 135, horizon 10\n", + "adding: mem time126, current time 135, horizon 9\n", + "adding: mem time127, current time 135, horizon 8\n", + "adding: mem time128, current time 135, horizon 7\n", + "adding: mem time129, current time 135, horizon 6\n", + "adding: mem time130, current time 135, horizon 5\n", + "adding: mem time131, current time 135, horizon 4\n", + "adding: mem time132, current time 135, horizon 3\n", + "adding: mem time133, current time 135, horizon 2\n", + "adding: mem time134, current time 135, horizon 1\n", + "adding: mem time0, current time 136, horizon 136\n", + "adding: mem time1, current time 136, horizon 135\n", + "adding: mem time2, current time 136, horizon 134\n", + "adding: mem time3, current time 136, horizon 133\n", + "adding: mem time4, current time 136, horizon 132\n", + "adding: mem time5, current time 136, horizon 131\n", + "adding: mem time6, current time 136, horizon 130\n", + "adding: mem time7, current time 136, horizon 129\n", + "adding: mem time8, current time 136, horizon 128\n", + "adding: mem time9, current time 136, horizon 127\n", + "adding: mem time10, current time 136, horizon 126\n", + "adding: mem time11, current time 136, horizon 125\n", + "adding: mem time12, current time 136, horizon 124\n", + "adding: mem time13, current time 136, horizon 123\n", + "adding: mem time14, current time 136, horizon 122\n", + "adding: mem time15, current time 136, horizon 121\n", + "adding: mem time16, current time 136, horizon 120\n", + "adding: mem time17, current time 136, horizon 119\n", + "adding: mem time18, current time 136, horizon 118\n", + "adding: mem time19, current time 136, horizon 117\n", + "adding: mem time20, current time 136, horizon 116\n", + "adding: mem time21, current time 136, horizon 115\n", + "adding: mem time22, current time 136, horizon 114\n", + "adding: mem time23, current time 136, horizon 113\n", + "adding: mem time24, current time 136, horizon 112\n", + "adding: mem time25, current time 136, horizon 111\n", + "adding: mem time26, current time 136, horizon 110\n", + "adding: mem time27, current time 136, horizon 109\n", + "adding: mem time28, current time 136, horizon 108\n", + "adding: mem time29, current time 136, horizon 107\n", + "adding: mem time30, current time 136, horizon 106\n", + "adding: mem time31, current time 136, horizon 105\n", + "adding: mem time32, current time 136, horizon 104\n", + "adding: mem time33, current time 136, horizon 103\n", + "adding: mem time34, current time 136, horizon 102\n", + "adding: mem time35, current time 136, horizon 101\n", + "adding: mem time36, current time 136, horizon 100\n", + "adding: mem time37, current time 136, horizon 99\n", + "adding: mem time38, current time 136, horizon 98\n", + "adding: mem time39, current time 136, horizon 97\n", + "adding: mem time40, current time 136, horizon 96\n", + "adding: mem time41, current time 136, horizon 95\n", + "adding: mem time42, current time 136, horizon 94\n", + "adding: mem time43, current time 136, horizon 93\n", + "adding: mem time44, current time 136, horizon 92\n", + "adding: mem time45, current time 136, horizon 91\n", + "adding: mem time46, current time 136, horizon 90\n", + "adding: mem time47, current time 136, horizon 89\n", + "adding: mem time48, current time 136, horizon 88\n", + "adding: mem time49, current time 136, horizon 87\n", + "adding: mem time50, current time 136, horizon 86\n", + "adding: mem time51, current time 136, horizon 85\n", + "adding: mem time52, current time 136, horizon 84\n", + "adding: mem time53, current time 136, horizon 83\n", + "adding: mem time54, current time 136, horizon 82\n", + "adding: mem time55, current time 136, horizon 81\n", + "adding: mem time56, current time 136, horizon 80\n", + "adding: mem time57, current time 136, horizon 79\n", + "adding: mem time58, current time 136, horizon 78\n", + "adding: mem time59, current time 136, horizon 77\n", + "adding: mem time60, current time 136, horizon 76\n", + "adding: mem time61, current time 136, horizon 75\n", + "adding: mem time62, current time 136, horizon 74\n", + "adding: mem time63, current time 136, horizon 73\n", + "adding: mem time64, current time 136, horizon 72\n", + "adding: mem time65, current time 136, horizon 71\n", + "adding: mem time66, current time 136, horizon 70\n", + "adding: mem time67, current time 136, horizon 69\n", + "adding: mem time68, current time 136, horizon 68\n", + "adding: mem time69, current time 136, horizon 67\n", + "adding: mem time70, current time 136, horizon 66\n", + "adding: mem time71, current time 136, horizon 65\n", + "adding: mem time72, current time 136, horizon 64\n", + "adding: mem time73, current time 136, horizon 63\n", + "adding: mem time74, current time 136, horizon 62\n", + "adding: mem time75, current time 136, horizon 61\n", + "adding: mem time76, current time 136, horizon 60\n", + "adding: mem time77, current time 136, horizon 59\n", + "adding: mem time78, current time 136, horizon 58\n", + "adding: mem time79, current time 136, horizon 57\n", + "adding: mem time80, current time 136, horizon 56\n", + "adding: mem time81, current time 136, horizon 55\n", + "adding: mem time82, current time 136, horizon 54\n", + "adding: mem time83, current time 136, horizon 53\n", + "adding: mem time84, current time 136, horizon 52\n", + "adding: mem time85, current time 136, horizon 51\n", + "adding: mem time86, current time 136, horizon 50\n", + "adding: mem time87, current time 136, horizon 49\n", + "adding: mem time88, current time 136, horizon 48\n", + "adding: mem time89, current time 136, horizon 47\n", + "adding: mem time90, current time 136, horizon 46\n", + "adding: mem time91, current time 136, horizon 45\n", + "adding: mem time92, current time 136, horizon 44\n", + "adding: mem time93, current time 136, horizon 43\n", + "adding: mem time94, current time 136, horizon 42\n", + "adding: mem time95, current time 136, horizon 41\n", + "adding: mem time96, current time 136, horizon 40\n", + "adding: mem time97, current time 136, horizon 39\n", + "adding: mem time98, current time 136, horizon 38\n", + "adding: mem time99, current time 136, horizon 37\n", + "adding: mem time100, current time 136, horizon 36\n", + "adding: mem time101, current time 136, horizon 35\n", + "adding: mem time102, current time 136, horizon 34\n", + "adding: mem time103, current time 136, horizon 33\n", + "adding: mem time104, current time 136, horizon 32\n", + "adding: mem time105, current time 136, horizon 31\n", + "adding: mem time106, current time 136, horizon 30\n", + "adding: mem time107, current time 136, horizon 29\n", + "adding: mem time108, current time 136, horizon 28\n", + "adding: mem time109, current time 136, horizon 27\n", + "adding: mem time110, current time 136, horizon 26\n", + "adding: mem time111, current time 136, horizon 25\n", + "adding: mem time112, current time 136, horizon 24\n", + "adding: mem time113, current time 136, horizon 23\n", + "adding: mem time114, current time 136, horizon 22\n", + "adding: mem time115, current time 136, horizon 21\n", + "adding: mem time116, current time 136, horizon 20\n", + "adding: mem time117, current time 136, horizon 19\n", + "adding: mem time118, current time 136, horizon 18\n", + "adding: mem time119, current time 136, horizon 17\n", + "adding: mem time120, current time 136, horizon 16\n", + "adding: mem time121, current time 136, horizon 15\n", + "adding: mem time122, current time 136, horizon 14\n", + "adding: mem time123, current time 136, horizon 13\n", + "adding: mem time124, current time 136, horizon 12\n", + "adding: mem time125, current time 136, horizon 11\n", + "adding: mem time126, current time 136, horizon 10\n", + "adding: mem time127, current time 136, horizon 9\n", + "adding: mem time128, current time 136, horizon 8\n", + "adding: mem time129, current time 136, horizon 7\n", + "adding: mem time130, current time 136, horizon 6\n", + "adding: mem time131, current time 136, horizon 5\n", + "adding: mem time132, current time 136, horizon 4\n", + "adding: mem time133, current time 136, horizon 3\n", + "adding: mem time134, current time 136, horizon 2\n", + "adding: mem time135, current time 136, horizon 1\n", + "adding: mem time0, current time 137, horizon 137\n", + "adding: mem time1, current time 137, horizon 136\n", + "adding: mem time2, current time 137, horizon 135\n", + "adding: mem time3, current time 137, horizon 134\n", + "adding: mem time4, current time 137, horizon 133\n", + "adding: mem time5, current time 137, horizon 132\n", + "adding: mem time6, current time 137, horizon 131\n", + "adding: mem time7, current time 137, horizon 130\n", + "adding: mem time8, current time 137, horizon 129\n", + "adding: mem time9, current time 137, horizon 128\n", + "adding: mem time10, current time 137, horizon 127\n", + "adding: mem time11, current time 137, horizon 126\n", + "adding: mem time12, current time 137, horizon 125\n", + "adding: mem time13, current time 137, horizon 124\n", + "adding: mem time14, current time 137, horizon 123\n", + "adding: mem time15, current time 137, horizon 122\n", + "adding: mem time16, current time 137, horizon 121\n", + "adding: mem time17, current time 137, horizon 120\n", + "adding: mem time18, current time 137, horizon 119\n", + "adding: mem time19, current time 137, horizon 118\n", + "adding: mem time20, current time 137, horizon 117\n", + "adding: mem time21, current time 137, horizon 116\n", + "adding: mem time22, current time 137, horizon 115\n", + "adding: mem time23, current time 137, horizon 114\n", + "adding: mem time24, current time 137, horizon 113\n", + "adding: mem time25, current time 137, horizon 112\n", + "adding: mem time26, current time 137, horizon 111\n", + "adding: mem time27, current time 137, horizon 110\n", + "adding: mem time28, current time 137, horizon 109\n", + "adding: mem time29, current time 137, horizon 108\n", + "adding: mem time30, current time 137, horizon 107\n", + "adding: mem time31, current time 137, horizon 106\n", + "adding: mem time32, current time 137, horizon 105\n", + "adding: mem time33, current time 137, horizon 104\n", + "adding: mem time34, current time 137, horizon 103\n", + "adding: mem time35, current time 137, horizon 102\n", + "adding: mem time36, current time 137, horizon 101\n", + "adding: mem time37, current time 137, horizon 100\n", + "adding: mem time38, current time 137, horizon 99\n", + "adding: mem time39, current time 137, horizon 98\n", + "adding: mem time40, current time 137, horizon 97\n", + "adding: mem time41, current time 137, horizon 96\n", + "adding: mem time42, current time 137, horizon 95\n", + "adding: mem time43, current time 137, horizon 94\n", + "adding: mem time44, current time 137, horizon 93\n", + "adding: mem time45, current time 137, horizon 92\n", + "adding: mem time46, current time 137, horizon 91\n", + "adding: mem time47, current time 137, horizon 90\n", + "adding: mem time48, current time 137, horizon 89\n", + "adding: mem time49, current time 137, horizon 88\n", + "adding: mem time50, current time 137, horizon 87\n", + "adding: mem time51, current time 137, horizon 86\n", + "adding: mem time52, current time 137, horizon 85\n", + "adding: mem time53, current time 137, horizon 84\n", + "adding: mem time54, current time 137, horizon 83\n", + "adding: mem time55, current time 137, horizon 82\n", + "adding: mem time56, current time 137, horizon 81\n", + "adding: mem time57, current time 137, horizon 80\n", + "adding: mem time58, current time 137, horizon 79\n", + "adding: mem time59, current time 137, horizon 78\n", + "adding: mem time60, current time 137, horizon 77\n", + "adding: mem time61, current time 137, horizon 76\n", + "adding: mem time62, current time 137, horizon 75\n", + "adding: mem time63, current time 137, horizon 74\n", + "adding: mem time64, current time 137, horizon 73\n", + "adding: mem time65, current time 137, horizon 72\n", + "adding: mem time66, current time 137, horizon 71\n", + "adding: mem time67, current time 137, horizon 70\n", + "adding: mem time68, current time 137, horizon 69\n", + "adding: mem time69, current time 137, horizon 68\n", + "adding: mem time70, current time 137, horizon 67\n", + "adding: mem time71, current time 137, horizon 66\n", + "adding: mem time72, current time 137, horizon 65\n", + "adding: mem time73, current time 137, horizon 64\n", + "adding: mem time74, current time 137, horizon 63\n", + "adding: mem time75, current time 137, horizon 62\n", + "adding: mem time76, current time 137, horizon 61\n", + "adding: mem time77, current time 137, horizon 60\n", + "adding: mem time78, current time 137, horizon 59\n", + "adding: mem time79, current time 137, horizon 58\n", + "adding: mem time80, current time 137, horizon 57\n", + "adding: mem time81, current time 137, horizon 56\n", + "adding: mem time82, current time 137, horizon 55\n", + "adding: mem time83, current time 137, horizon 54\n", + "adding: mem time84, current time 137, horizon 53\n", + "adding: mem time85, current time 137, horizon 52\n", + "adding: mem time86, current time 137, horizon 51\n", + "adding: mem time87, current time 137, horizon 50\n", + "adding: mem time88, current time 137, horizon 49\n", + "adding: mem time89, current time 137, horizon 48\n", + "adding: mem time90, current time 137, horizon 47\n", + "adding: mem time91, current time 137, horizon 46\n", + "adding: mem time92, current time 137, horizon 45\n", + "adding: mem time93, current time 137, horizon 44\n", + "adding: mem time94, current time 137, horizon 43\n", + "adding: mem time95, current time 137, horizon 42\n", + "adding: mem time96, current time 137, horizon 41\n", + "adding: mem time97, current time 137, horizon 40\n", + "adding: mem time98, current time 137, horizon 39\n", + "adding: mem time99, current time 137, horizon 38\n", + "adding: mem time100, current time 137, horizon 37\n", + "adding: mem time101, current time 137, horizon 36\n", + "adding: mem time102, current time 137, horizon 35\n", + "adding: mem time103, current time 137, horizon 34\n", + "adding: mem time104, current time 137, horizon 33\n", + "adding: mem time105, current time 137, horizon 32\n", + "adding: mem time106, current time 137, horizon 31\n", + "adding: mem time107, current time 137, horizon 30\n", + "adding: mem time108, current time 137, horizon 29\n", + "adding: mem time109, current time 137, horizon 28\n", + "adding: mem time110, current time 137, horizon 27\n", + "adding: mem time111, current time 137, horizon 26\n", + "adding: mem time112, current time 137, horizon 25\n", + "adding: mem time113, current time 137, horizon 24\n", + "adding: mem time114, current time 137, horizon 23\n", + "adding: mem time115, current time 137, horizon 22\n", + "adding: mem time116, current time 137, horizon 21\n", + "adding: mem time117, current time 137, horizon 20\n", + "adding: mem time118, current time 137, horizon 19\n", + "adding: mem time119, current time 137, horizon 18\n", + "adding: mem time120, current time 137, horizon 17\n", + "adding: mem time121, current time 137, horizon 16\n", + "adding: mem time122, current time 137, horizon 15\n", + "adding: mem time123, current time 137, horizon 14\n", + "adding: mem time124, current time 137, horizon 13\n", + "adding: mem time125, current time 137, horizon 12\n", + "adding: mem time126, current time 137, horizon 11\n", + "adding: mem time127, current time 137, horizon 10\n", + "adding: mem time128, current time 137, horizon 9\n", + "adding: mem time129, current time 137, horizon 8\n", + "adding: mem time130, current time 137, horizon 7\n", + "adding: mem time131, current time 137, horizon 6\n", + "adding: mem time132, current time 137, horizon 5\n", + "adding: mem time133, current time 137, horizon 4\n", + "adding: mem time134, current time 137, horizon 3\n", + "adding: mem time135, current time 137, horizon 2\n", + "adding: mem time136, current time 137, horizon 1\n", + "adding: mem time0, current time 138, horizon 138\n", + "adding: mem time1, current time 138, horizon 137\n", + "adding: mem time2, current time 138, horizon 136\n", + "adding: mem time3, current time 138, horizon 135\n", + "adding: mem time4, current time 138, horizon 134\n", + "adding: mem time5, current time 138, horizon 133\n", + "adding: mem time6, current time 138, horizon 132\n", + "adding: mem time7, current time 138, horizon 131\n", + "adding: mem time8, current time 138, horizon 130\n", + "adding: mem time9, current time 138, horizon 129\n", + "adding: mem time10, current time 138, horizon 128\n", + "adding: mem time11, current time 138, horizon 127\n", + "adding: mem time12, current time 138, horizon 126\n", + "adding: mem time13, current time 138, horizon 125\n", + "adding: mem time14, current time 138, horizon 124\n", + "adding: mem time15, current time 138, horizon 123\n", + "adding: mem time16, current time 138, horizon 122\n", + "adding: mem time17, current time 138, horizon 121\n", + "adding: mem time18, current time 138, horizon 120\n", + "adding: mem time19, current time 138, horizon 119\n", + "adding: mem time20, current time 138, horizon 118\n", + "adding: mem time21, current time 138, horizon 117\n", + "adding: mem time22, current time 138, horizon 116\n", + "adding: mem time23, current time 138, horizon 115\n", + "adding: mem time24, current time 138, horizon 114\n", + "adding: mem time25, current time 138, horizon 113\n", + "adding: mem time26, current time 138, horizon 112\n", + "adding: mem time27, current time 138, horizon 111\n", + "adding: mem time28, current time 138, horizon 110\n", + "adding: mem time29, current time 138, horizon 109\n", + "adding: mem time30, current time 138, horizon 108\n", + "adding: mem time31, current time 138, horizon 107\n", + "adding: mem time32, current time 138, horizon 106\n", + "adding: mem time33, current time 138, horizon 105\n", + "adding: mem time34, current time 138, horizon 104\n", + "adding: mem time35, current time 138, horizon 103\n", + "adding: mem time36, current time 138, horizon 102\n", + "adding: mem time37, current time 138, horizon 101\n", + "adding: mem time38, current time 138, horizon 100\n", + "adding: mem time39, current time 138, horizon 99\n", + "adding: mem time40, current time 138, horizon 98\n", + "adding: mem time41, current time 138, horizon 97\n", + "adding: mem time42, current time 138, horizon 96\n", + "adding: mem time43, current time 138, horizon 95\n", + "adding: mem time44, current time 138, horizon 94\n", + "adding: mem time45, current time 138, horizon 93\n", + "adding: mem time46, current time 138, horizon 92\n", + "adding: mem time47, current time 138, horizon 91\n", + "adding: mem time48, current time 138, horizon 90\n", + "adding: mem time49, current time 138, horizon 89\n", + "adding: mem time50, current time 138, horizon 88\n", + "adding: mem time51, current time 138, horizon 87\n", + "adding: mem time52, current time 138, horizon 86\n", + "adding: mem time53, current time 138, horizon 85\n", + "adding: mem time54, current time 138, horizon 84\n", + "adding: mem time55, current time 138, horizon 83\n", + "adding: mem time56, current time 138, horizon 82\n", + "adding: mem time57, current time 138, horizon 81\n", + "adding: mem time58, current time 138, horizon 80\n", + "adding: mem time59, current time 138, horizon 79\n", + "adding: mem time60, current time 138, horizon 78\n", + "adding: mem time61, current time 138, horizon 77\n", + "adding: mem time62, current time 138, horizon 76\n", + "adding: mem time63, current time 138, horizon 75\n", + "adding: mem time64, current time 138, horizon 74\n", + "adding: mem time65, current time 138, horizon 73\n", + "adding: mem time66, current time 138, horizon 72\n", + "adding: mem time67, current time 138, horizon 71\n", + "adding: mem time68, current time 138, horizon 70\n", + "adding: mem time69, current time 138, horizon 69\n", + "adding: mem time70, current time 138, horizon 68\n", + "adding: mem time71, current time 138, horizon 67\n", + "adding: mem time72, current time 138, horizon 66\n", + "adding: mem time73, current time 138, horizon 65\n", + "adding: mem time74, current time 138, horizon 64\n", + "adding: mem time75, current time 138, horizon 63\n", + "adding: mem time76, current time 138, horizon 62\n", + "adding: mem time77, current time 138, horizon 61\n", + "adding: mem time78, current time 138, horizon 60\n", + "adding: mem time79, current time 138, horizon 59\n", + "adding: mem time80, current time 138, horizon 58\n", + "adding: mem time81, current time 138, horizon 57\n", + "adding: mem time82, current time 138, horizon 56\n", + "adding: mem time83, current time 138, horizon 55\n", + "adding: mem time84, current time 138, horizon 54\n", + "adding: mem time85, current time 138, horizon 53\n", + "adding: mem time86, current time 138, horizon 52\n", + "adding: mem time87, current time 138, horizon 51\n", + "adding: mem time88, current time 138, horizon 50\n", + "adding: mem time89, current time 138, horizon 49\n", + "adding: mem time90, current time 138, horizon 48\n", + "adding: mem time91, current time 138, horizon 47\n", + "adding: mem time92, current time 138, horizon 46\n", + "adding: mem time93, current time 138, horizon 45\n", + "adding: mem time94, current time 138, horizon 44\n", + "adding: mem time95, current time 138, horizon 43\n", + "adding: mem time96, current time 138, horizon 42\n", + "adding: mem time97, current time 138, horizon 41\n", + "adding: mem time98, current time 138, horizon 40\n", + "adding: mem time99, current time 138, horizon 39\n", + "adding: mem time100, current time 138, horizon 38\n", + "adding: mem time101, current time 138, horizon 37\n", + "adding: mem time102, current time 138, horizon 36\n", + "adding: mem time103, current time 138, horizon 35\n", + "adding: mem time104, current time 138, horizon 34\n", + "adding: mem time105, current time 138, horizon 33\n", + "adding: mem time106, current time 138, horizon 32\n", + "adding: mem time107, current time 138, horizon 31\n", + "adding: mem time108, current time 138, horizon 30\n", + "adding: mem time109, current time 138, horizon 29\n", + "adding: mem time110, current time 138, horizon 28\n", + "adding: mem time111, current time 138, horizon 27\n", + "adding: mem time112, current time 138, horizon 26\n", + "adding: mem time113, current time 138, horizon 25\n", + "adding: mem time114, current time 138, horizon 24\n", + "adding: mem time115, current time 138, horizon 23\n", + "adding: mem time116, current time 138, horizon 22\n", + "adding: mem time117, current time 138, horizon 21\n", + "adding: mem time118, current time 138, horizon 20\n", + "adding: mem time119, current time 138, horizon 19\n", + "adding: mem time120, current time 138, horizon 18\n", + "adding: mem time121, current time 138, horizon 17\n", + "adding: mem time122, current time 138, horizon 16\n", + "adding: mem time123, current time 138, horizon 15\n", + "adding: mem time124, current time 138, horizon 14\n", + "adding: mem time125, current time 138, horizon 13\n", + "adding: mem time126, current time 138, horizon 12\n", + "adding: mem time127, current time 138, horizon 11\n", + "adding: mem time128, current time 138, horizon 10\n", + "adding: mem time129, current time 138, horizon 9\n", + "adding: mem time130, current time 138, horizon 8\n", + "adding: mem time131, current time 138, horizon 7\n", + "adding: mem time132, current time 138, horizon 6\n", + "adding: mem time133, current time 138, horizon 5\n", + "adding: mem time134, current time 138, horizon 4\n", + "adding: mem time135, current time 138, horizon 3\n", + "adding: mem time136, current time 138, horizon 2\n", + "adding: mem time137, current time 138, horizon 1\n", + "adding: mem time0, current time 139, horizon 139\n", + "adding: mem time1, current time 139, horizon 138\n", + "adding: mem time2, current time 139, horizon 137\n", + "adding: mem time3, current time 139, horizon 136\n", + "adding: mem time4, current time 139, horizon 135\n", + "adding: mem time5, current time 139, horizon 134\n", + "adding: mem time6, current time 139, horizon 133\n", + "adding: mem time7, current time 139, horizon 132\n", + "adding: mem time8, current time 139, horizon 131\n", + "adding: mem time9, current time 139, horizon 130\n", + "adding: mem time10, current time 139, horizon 129\n", + "adding: mem time11, current time 139, horizon 128\n", + "adding: mem time12, current time 139, horizon 127\n", + "adding: mem time13, current time 139, horizon 126\n", + "adding: mem time14, current time 139, horizon 125\n", + "adding: mem time15, current time 139, horizon 124\n", + "adding: mem time16, current time 139, horizon 123\n", + "adding: mem time17, current time 139, horizon 122\n", + "adding: mem time18, current time 139, horizon 121\n", + "adding: mem time19, current time 139, horizon 120\n", + "adding: mem time20, current time 139, horizon 119\n", + "adding: mem time21, current time 139, horizon 118\n", + "adding: mem time22, current time 139, horizon 117\n", + "adding: mem time23, current time 139, horizon 116\n", + "adding: mem time24, current time 139, horizon 115\n", + "adding: mem time25, current time 139, horizon 114\n", + "adding: mem time26, current time 139, horizon 113\n", + "adding: mem time27, current time 139, horizon 112\n", + "adding: mem time28, current time 139, horizon 111\n", + "adding: mem time29, current time 139, horizon 110\n", + "adding: mem time30, current time 139, horizon 109\n", + "adding: mem time31, current time 139, horizon 108\n", + "adding: mem time32, current time 139, horizon 107\n", + "adding: mem time33, current time 139, horizon 106\n", + "adding: mem time34, current time 139, horizon 105\n", + "adding: mem time35, current time 139, horizon 104\n", + "adding: mem time36, current time 139, horizon 103\n", + "adding: mem time37, current time 139, horizon 102\n", + "adding: mem time38, current time 139, horizon 101\n", + "adding: mem time39, current time 139, horizon 100\n", + "adding: mem time40, current time 139, horizon 99\n", + "adding: mem time41, current time 139, horizon 98\n", + "adding: mem time42, current time 139, horizon 97\n", + "adding: mem time43, current time 139, horizon 96\n", + "adding: mem time44, current time 139, horizon 95\n", + "adding: mem time45, current time 139, horizon 94\n", + "adding: mem time46, current time 139, horizon 93\n", + "adding: mem time47, current time 139, horizon 92\n", + "adding: mem time48, current time 139, horizon 91\n", + "adding: mem time49, current time 139, horizon 90\n", + "adding: mem time50, current time 139, horizon 89\n", + "adding: mem time51, current time 139, horizon 88\n", + "adding: mem time52, current time 139, horizon 87\n", + "adding: mem time53, current time 139, horizon 86\n", + "adding: mem time54, current time 139, horizon 85\n", + "adding: mem time55, current time 139, horizon 84\n", + "adding: mem time56, current time 139, horizon 83\n", + "adding: mem time57, current time 139, horizon 82\n", + "adding: mem time58, current time 139, horizon 81\n", + "adding: mem time59, current time 139, horizon 80\n", + "adding: mem time60, current time 139, horizon 79\n", + "adding: mem time61, current time 139, horizon 78\n", + "adding: mem time62, current time 139, horizon 77\n", + "adding: mem time63, current time 139, horizon 76\n", + "adding: mem time64, current time 139, horizon 75\n", + "adding: mem time65, current time 139, horizon 74\n", + "adding: mem time66, current time 139, horizon 73\n", + "adding: mem time67, current time 139, horizon 72\n", + "adding: mem time68, current time 139, horizon 71\n", + "adding: mem time69, current time 139, horizon 70\n", + "adding: mem time70, current time 139, horizon 69\n", + "adding: mem time71, current time 139, horizon 68\n", + "adding: mem time72, current time 139, horizon 67\n", + "adding: mem time73, current time 139, horizon 66\n", + "adding: mem time74, current time 139, horizon 65\n", + "adding: mem time75, current time 139, horizon 64\n", + "adding: mem time76, current time 139, horizon 63\n", + "adding: mem time77, current time 139, horizon 62\n", + "adding: mem time78, current time 139, horizon 61\n", + "adding: mem time79, current time 139, horizon 60\n", + "adding: mem time80, current time 139, horizon 59\n", + "adding: mem time81, current time 139, horizon 58\n", + "adding: mem time82, current time 139, horizon 57\n", + "adding: mem time83, current time 139, horizon 56\n", + "adding: mem time84, current time 139, horizon 55\n", + "adding: mem time85, current time 139, horizon 54\n", + "adding: mem time86, current time 139, horizon 53\n", + "adding: mem time87, current time 139, horizon 52\n", + "adding: mem time88, current time 139, horizon 51\n", + "adding: mem time89, current time 139, horizon 50\n", + "adding: mem time90, current time 139, horizon 49\n", + "adding: mem time91, current time 139, horizon 48\n", + "adding: mem time92, current time 139, horizon 47\n", + "adding: mem time93, current time 139, horizon 46\n", + "adding: mem time94, current time 139, horizon 45\n", + "adding: mem time95, current time 139, horizon 44\n", + "adding: mem time96, current time 139, horizon 43\n", + "adding: mem time97, current time 139, horizon 42\n", + "adding: mem time98, current time 139, horizon 41\n", + "adding: mem time99, current time 139, horizon 40\n", + "adding: mem time100, current time 139, horizon 39\n", + "adding: mem time101, current time 139, horizon 38\n", + "adding: mem time102, current time 139, horizon 37\n", + "adding: mem time103, current time 139, horizon 36\n", + "adding: mem time104, current time 139, horizon 35\n", + "adding: mem time105, current time 139, horizon 34\n", + "adding: mem time106, current time 139, horizon 33\n", + "adding: mem time107, current time 139, horizon 32\n", + "adding: mem time108, current time 139, horizon 31\n", + "adding: mem time109, current time 139, horizon 30\n", + "adding: mem time110, current time 139, horizon 29\n", + "adding: mem time111, current time 139, horizon 28\n", + "adding: mem time112, current time 139, horizon 27\n", + "adding: mem time113, current time 139, horizon 26\n", + "adding: mem time114, current time 139, horizon 25\n", + "adding: mem time115, current time 139, horizon 24\n", + "adding: mem time116, current time 139, horizon 23\n", + "adding: mem time117, current time 139, horizon 22\n", + "adding: mem time118, current time 139, horizon 21\n", + "adding: mem time119, current time 139, horizon 20\n", + "adding: mem time120, current time 139, horizon 19\n", + "adding: mem time121, current time 139, horizon 18\n", + "adding: mem time122, current time 139, horizon 17\n", + "adding: mem time123, current time 139, horizon 16\n", + "adding: mem time124, current time 139, horizon 15\n", + "adding: mem time125, current time 139, horizon 14\n", + "adding: mem time126, current time 139, horizon 13\n", + "adding: mem time127, current time 139, horizon 12\n", + "adding: mem time128, current time 139, horizon 11\n", + "adding: mem time129, current time 139, horizon 10\n", + "adding: mem time130, current time 139, horizon 9\n", + "adding: mem time131, current time 139, horizon 8\n", + "adding: mem time132, current time 139, horizon 7\n", + "adding: mem time133, current time 139, horizon 6\n", + "adding: mem time134, current time 139, horizon 5\n", + "adding: mem time135, current time 139, horizon 4\n", + "adding: mem time136, current time 139, horizon 3\n", + "adding: mem time137, current time 139, horizon 2\n", + "adding: mem time138, current time 139, horizon 1\n", + "adding: mem time0, current time 140, horizon 140\n", + "adding: mem time1, current time 140, horizon 139\n", + "adding: mem time2, current time 140, horizon 138\n", + "adding: mem time3, current time 140, horizon 137\n", + "adding: mem time4, current time 140, horizon 136\n", + "adding: mem time5, current time 140, horizon 135\n", + "adding: mem time6, current time 140, horizon 134\n", + "adding: mem time7, current time 140, horizon 133\n", + "adding: mem time8, current time 140, horizon 132\n", + "adding: mem time9, current time 140, horizon 131\n", + "adding: mem time10, current time 140, horizon 130\n", + "adding: mem time11, current time 140, horizon 129\n", + "adding: mem time12, current time 140, horizon 128\n", + "adding: mem time13, current time 140, horizon 127\n", + "adding: mem time14, current time 140, horizon 126\n", + "adding: mem time15, current time 140, horizon 125\n", + "adding: mem time16, current time 140, horizon 124\n", + "adding: mem time17, current time 140, horizon 123\n", + "adding: mem time18, current time 140, horizon 122\n", + "adding: mem time19, current time 140, horizon 121\n", + "adding: mem time20, current time 140, horizon 120\n", + "adding: mem time21, current time 140, horizon 119\n", + "adding: mem time22, current time 140, horizon 118\n", + "adding: mem time23, current time 140, horizon 117\n", + "adding: mem time24, current time 140, horizon 116\n", + "adding: mem time25, current time 140, horizon 115\n", + "adding: mem time26, current time 140, horizon 114\n", + "adding: mem time27, current time 140, horizon 113\n", + "adding: mem time28, current time 140, horizon 112\n", + "adding: mem time29, current time 140, horizon 111\n", + "adding: mem time30, current time 140, horizon 110\n", + "adding: mem time31, current time 140, horizon 109\n", + "adding: mem time32, current time 140, horizon 108\n", + "adding: mem time33, current time 140, horizon 107\n", + "adding: mem time34, current time 140, horizon 106\n", + "adding: mem time35, current time 140, horizon 105\n", + "adding: mem time36, current time 140, horizon 104\n", + "adding: mem time37, current time 140, horizon 103\n", + "adding: mem time38, current time 140, horizon 102\n", + "adding: mem time39, current time 140, horizon 101\n", + "adding: mem time40, current time 140, horizon 100\n", + "adding: mem time41, current time 140, horizon 99\n", + "adding: mem time42, current time 140, horizon 98\n", + "adding: mem time43, current time 140, horizon 97\n", + "adding: mem time44, current time 140, horizon 96\n", + "adding: mem time45, current time 140, horizon 95\n", + "adding: mem time46, current time 140, horizon 94\n", + "adding: mem time47, current time 140, horizon 93\n", + "adding: mem time48, current time 140, horizon 92\n", + "adding: mem time49, current time 140, horizon 91\n", + "adding: mem time50, current time 140, horizon 90\n", + "adding: mem time51, current time 140, horizon 89\n", + "adding: mem time52, current time 140, horizon 88\n", + "adding: mem time53, current time 140, horizon 87\n", + "adding: mem time54, current time 140, horizon 86\n", + "adding: mem time55, current time 140, horizon 85\n", + "adding: mem time56, current time 140, horizon 84\n", + "adding: mem time57, current time 140, horizon 83\n", + "adding: mem time58, current time 140, horizon 82\n", + "adding: mem time59, current time 140, horizon 81\n", + "adding: mem time60, current time 140, horizon 80\n", + "adding: mem time61, current time 140, horizon 79\n", + "adding: mem time62, current time 140, horizon 78\n", + "adding: mem time63, current time 140, horizon 77\n", + "adding: mem time64, current time 140, horizon 76\n", + "adding: mem time65, current time 140, horizon 75\n", + "adding: mem time66, current time 140, horizon 74\n", + "adding: mem time67, current time 140, horizon 73\n", + "adding: mem time68, current time 140, horizon 72\n", + "adding: mem time69, current time 140, horizon 71\n", + "adding: mem time70, current time 140, horizon 70\n", + "adding: mem time71, current time 140, horizon 69\n", + "adding: mem time72, current time 140, horizon 68\n", + "adding: mem time73, current time 140, horizon 67\n", + "adding: mem time74, current time 140, horizon 66\n", + "adding: mem time75, current time 140, horizon 65\n", + "adding: mem time76, current time 140, horizon 64\n", + "adding: mem time77, current time 140, horizon 63\n", + "adding: mem time78, current time 140, horizon 62\n", + "adding: mem time79, current time 140, horizon 61\n", + "adding: mem time80, current time 140, horizon 60\n", + "adding: mem time81, current time 140, horizon 59\n", + "adding: mem time82, current time 140, horizon 58\n", + "adding: mem time83, current time 140, horizon 57\n", + "adding: mem time84, current time 140, horizon 56\n", + "adding: mem time85, current time 140, horizon 55\n", + "adding: mem time86, current time 140, horizon 54\n", + "adding: mem time87, current time 140, horizon 53\n", + "adding: mem time88, current time 140, horizon 52\n", + "adding: mem time89, current time 140, horizon 51\n", + "adding: mem time90, current time 140, horizon 50\n", + "adding: mem time91, current time 140, horizon 49\n", + "adding: mem time92, current time 140, horizon 48\n", + "adding: mem time93, current time 140, horizon 47\n", + "adding: mem time94, current time 140, horizon 46\n", + "adding: mem time95, current time 140, horizon 45\n", + "adding: mem time96, current time 140, horizon 44\n", + "adding: mem time97, current time 140, horizon 43\n", + "adding: mem time98, current time 140, horizon 42\n", + "adding: mem time99, current time 140, horizon 41\n", + "adding: mem time100, current time 140, horizon 40\n", + "adding: mem time101, current time 140, horizon 39\n", + "adding: mem time102, current time 140, horizon 38\n", + "adding: mem time103, current time 140, horizon 37\n", + "adding: mem time104, current time 140, horizon 36\n", + "adding: mem time105, current time 140, horizon 35\n", + "adding: mem time106, current time 140, horizon 34\n", + "adding: mem time107, current time 140, horizon 33\n", + "adding: mem time108, current time 140, horizon 32\n", + "adding: mem time109, current time 140, horizon 31\n", + "adding: mem time110, current time 140, horizon 30\n", + "adding: mem time111, current time 140, horizon 29\n", + "adding: mem time112, current time 140, horizon 28\n", + "adding: mem time113, current time 140, horizon 27\n", + "adding: mem time114, current time 140, horizon 26\n", + "adding: mem time115, current time 140, horizon 25\n", + "adding: mem time116, current time 140, horizon 24\n", + "adding: mem time117, current time 140, horizon 23\n", + "adding: mem time118, current time 140, horizon 22\n", + "adding: mem time119, current time 140, horizon 21\n", + "adding: mem time120, current time 140, horizon 20\n", + "adding: mem time121, current time 140, horizon 19\n", + "adding: mem time122, current time 140, horizon 18\n", + "adding: mem time123, current time 140, horizon 17\n", + "adding: mem time124, current time 140, horizon 16\n", + "adding: mem time125, current time 140, horizon 15\n", + "adding: mem time126, current time 140, horizon 14\n", + "adding: mem time127, current time 140, horizon 13\n", + "adding: mem time128, current time 140, horizon 12\n", + "adding: mem time129, current time 140, horizon 11\n", + "adding: mem time130, current time 140, horizon 10\n", + "adding: mem time131, current time 140, horizon 9\n", + "adding: mem time132, current time 140, horizon 8\n", + "adding: mem time133, current time 140, horizon 7\n", + "adding: mem time134, current time 140, horizon 6\n", + "adding: mem time135, current time 140, horizon 5\n", + "adding: mem time136, current time 140, horizon 4\n", + "adding: mem time137, current time 140, horizon 3\n", + "adding: mem time138, current time 140, horizon 2\n", + "adding: mem time139, current time 140, horizon 1\n", + "adding: mem time0, current time 141, horizon 141\n", + "adding: mem time1, current time 141, horizon 140\n", + "adding: mem time2, current time 141, horizon 139\n", + "adding: mem time3, current time 141, horizon 138\n", + "adding: mem time4, current time 141, horizon 137\n", + "adding: mem time5, current time 141, horizon 136\n", + "adding: mem time6, current time 141, horizon 135\n", + "adding: mem time7, current time 141, horizon 134\n", + "adding: mem time8, current time 141, horizon 133\n", + "adding: mem time9, current time 141, horizon 132\n", + "adding: mem time10, current time 141, horizon 131\n", + "adding: mem time11, current time 141, horizon 130\n", + "adding: mem time12, current time 141, horizon 129\n", + "adding: mem time13, current time 141, horizon 128\n", + "adding: mem time14, current time 141, horizon 127\n", + "adding: mem time15, current time 141, horizon 126\n", + "adding: mem time16, current time 141, horizon 125\n", + "adding: mem time17, current time 141, horizon 124\n", + "adding: mem time18, current time 141, horizon 123\n", + "adding: mem time19, current time 141, horizon 122\n", + "adding: mem time20, current time 141, horizon 121\n", + "adding: mem time21, current time 141, horizon 120\n", + "adding: mem time22, current time 141, horizon 119\n", + "adding: mem time23, current time 141, horizon 118\n", + "adding: mem time24, current time 141, horizon 117\n", + "adding: mem time25, current time 141, horizon 116\n", + "adding: mem time26, current time 141, horizon 115\n", + "adding: mem time27, current time 141, horizon 114\n", + "adding: mem time28, current time 141, horizon 113\n", + "adding: mem time29, current time 141, horizon 112\n", + "adding: mem time30, current time 141, horizon 111\n", + "adding: mem time31, current time 141, horizon 110\n", + "adding: mem time32, current time 141, horizon 109\n", + "adding: mem time33, current time 141, horizon 108\n", + "adding: mem time34, current time 141, horizon 107\n", + "adding: mem time35, current time 141, horizon 106\n", + "adding: mem time36, current time 141, horizon 105\n", + "adding: mem time37, current time 141, horizon 104\n", + "adding: mem time38, current time 141, horizon 103\n", + "adding: mem time39, current time 141, horizon 102\n", + "adding: mem time40, current time 141, horizon 101\n", + "adding: mem time41, current time 141, horizon 100\n", + "adding: mem time42, current time 141, horizon 99\n", + "adding: mem time43, current time 141, horizon 98\n", + "adding: mem time44, current time 141, horizon 97\n", + "adding: mem time45, current time 141, horizon 96\n", + "adding: mem time46, current time 141, horizon 95\n", + "adding: mem time47, current time 141, horizon 94\n", + "adding: mem time48, current time 141, horizon 93\n", + "adding: mem time49, current time 141, horizon 92\n", + "adding: mem time50, current time 141, horizon 91\n", + "adding: mem time51, current time 141, horizon 90\n", + "adding: mem time52, current time 141, horizon 89\n", + "adding: mem time53, current time 141, horizon 88\n", + "adding: mem time54, current time 141, horizon 87\n", + "adding: mem time55, current time 141, horizon 86\n", + "adding: mem time56, current time 141, horizon 85\n", + "adding: mem time57, current time 141, horizon 84\n", + "adding: mem time58, current time 141, horizon 83\n", + "adding: mem time59, current time 141, horizon 82\n", + "adding: mem time60, current time 141, horizon 81\n", + "adding: mem time61, current time 141, horizon 80\n", + "adding: mem time62, current time 141, horizon 79\n", + "adding: mem time63, current time 141, horizon 78\n", + "adding: mem time64, current time 141, horizon 77\n", + "adding: mem time65, current time 141, horizon 76\n", + "adding: mem time66, current time 141, horizon 75\n", + "adding: mem time67, current time 141, horizon 74\n", + "adding: mem time68, current time 141, horizon 73\n", + "adding: mem time69, current time 141, horizon 72\n", + "adding: mem time70, current time 141, horizon 71\n", + "adding: mem time71, current time 141, horizon 70\n", + "adding: mem time72, current time 141, horizon 69\n", + "adding: mem time73, current time 141, horizon 68\n", + "adding: mem time74, current time 141, horizon 67\n", + "adding: mem time75, current time 141, horizon 66\n", + "adding: mem time76, current time 141, horizon 65\n", + "adding: mem time77, current time 141, horizon 64\n", + "adding: mem time78, current time 141, horizon 63\n", + "adding: mem time79, current time 141, horizon 62\n", + "adding: mem time80, current time 141, horizon 61\n", + "adding: mem time81, current time 141, horizon 60\n", + "adding: mem time82, current time 141, horizon 59\n", + "adding: mem time83, current time 141, horizon 58\n", + "adding: mem time84, current time 141, horizon 57\n", + "adding: mem time85, current time 141, horizon 56\n", + "adding: mem time86, current time 141, horizon 55\n", + "adding: mem time87, current time 141, horizon 54\n", + "adding: mem time88, current time 141, horizon 53\n", + "adding: mem time89, current time 141, horizon 52\n", + "adding: mem time90, current time 141, horizon 51\n", + "adding: mem time91, current time 141, horizon 50\n", + "adding: mem time92, current time 141, horizon 49\n", + "adding: mem time93, current time 141, horizon 48\n", + "adding: mem time94, current time 141, horizon 47\n", + "adding: mem time95, current time 141, horizon 46\n", + "adding: mem time96, current time 141, horizon 45\n", + "adding: mem time97, current time 141, horizon 44\n", + "adding: mem time98, current time 141, horizon 43\n", + "adding: mem time99, current time 141, horizon 42\n", + "adding: mem time100, current time 141, horizon 41\n", + "adding: mem time101, current time 141, horizon 40\n", + "adding: mem time102, current time 141, horizon 39\n", + "adding: mem time103, current time 141, horizon 38\n", + "adding: mem time104, current time 141, horizon 37\n", + "adding: mem time105, current time 141, horizon 36\n", + "adding: mem time106, current time 141, horizon 35\n", + "adding: mem time107, current time 141, horizon 34\n", + "adding: mem time108, current time 141, horizon 33\n", + "adding: mem time109, current time 141, horizon 32\n", + "adding: mem time110, current time 141, horizon 31\n", + "adding: mem time111, current time 141, horizon 30\n", + "adding: mem time112, current time 141, horizon 29\n", + "adding: mem time113, current time 141, horizon 28\n", + "adding: mem time114, current time 141, horizon 27\n", + "adding: mem time115, current time 141, horizon 26\n", + "adding: mem time116, current time 141, horizon 25\n", + "adding: mem time117, current time 141, horizon 24\n", + "adding: mem time118, current time 141, horizon 23\n", + "adding: mem time119, current time 141, horizon 22\n", + "adding: mem time120, current time 141, horizon 21\n", + "adding: mem time121, current time 141, horizon 20\n", + "adding: mem time122, current time 141, horizon 19\n", + "adding: mem time123, current time 141, horizon 18\n", + "adding: mem time124, current time 141, horizon 17\n", + "adding: mem time125, current time 141, horizon 16\n", + "adding: mem time126, current time 141, horizon 15\n", + "adding: mem time127, current time 141, horizon 14\n", + "adding: mem time128, current time 141, horizon 13\n", + "adding: mem time129, current time 141, horizon 12\n", + "adding: mem time130, current time 141, horizon 11\n", + "adding: mem time131, current time 141, horizon 10\n", + "adding: mem time132, current time 141, horizon 9\n", + "adding: mem time133, current time 141, horizon 8\n", + "adding: mem time134, current time 141, horizon 7\n", + "adding: mem time135, current time 141, horizon 6\n", + "adding: mem time136, current time 141, horizon 5\n", + "adding: mem time137, current time 141, horizon 4\n", + "adding: mem time138, current time 141, horizon 3\n", + "adding: mem time139, current time 141, horizon 2\n", + "adding: mem time140, current time 141, horizon 1\n", + "adding: mem time0, current time 142, horizon 142\n", + "adding: mem time1, current time 142, horizon 141\n", + "adding: mem time2, current time 142, horizon 140\n", + "adding: mem time3, current time 142, horizon 139\n", + "adding: mem time4, current time 142, horizon 138\n", + "adding: mem time5, current time 142, horizon 137\n", + "adding: mem time6, current time 142, horizon 136\n", + "adding: mem time7, current time 142, horizon 135\n", + "adding: mem time8, current time 142, horizon 134\n", + "adding: mem time9, current time 142, horizon 133\n", + "adding: mem time10, current time 142, horizon 132\n", + "adding: mem time11, current time 142, horizon 131\n", + "adding: mem time12, current time 142, horizon 130\n", + "adding: mem time13, current time 142, horizon 129\n", + "adding: mem time14, current time 142, horizon 128\n", + "adding: mem time15, current time 142, horizon 127\n", + "adding: mem time16, current time 142, horizon 126\n", + "adding: mem time17, current time 142, horizon 125\n", + "adding: mem time18, current time 142, horizon 124\n", + "adding: mem time19, current time 142, horizon 123\n", + "adding: mem time20, current time 142, horizon 122\n", + "adding: mem time21, current time 142, horizon 121\n", + "adding: mem time22, current time 142, horizon 120\n", + "adding: mem time23, current time 142, horizon 119\n", + "adding: mem time24, current time 142, horizon 118\n", + "adding: mem time25, current time 142, horizon 117\n", + "adding: mem time26, current time 142, horizon 116\n", + "adding: mem time27, current time 142, horizon 115\n", + "adding: mem time28, current time 142, horizon 114\n", + "adding: mem time29, current time 142, horizon 113\n", + "adding: mem time30, current time 142, horizon 112\n", + "adding: mem time31, current time 142, horizon 111\n", + "adding: mem time32, current time 142, horizon 110\n", + "adding: mem time33, current time 142, horizon 109\n", + "adding: mem time34, current time 142, horizon 108\n", + "adding: mem time35, current time 142, horizon 107\n", + "adding: mem time36, current time 142, horizon 106\n", + "adding: mem time37, current time 142, horizon 105\n", + "adding: mem time38, current time 142, horizon 104\n", + "adding: mem time39, current time 142, horizon 103\n", + "adding: mem time40, current time 142, horizon 102\n", + "adding: mem time41, current time 142, horizon 101\n", + "adding: mem time42, current time 142, horizon 100\n", + "adding: mem time43, current time 142, horizon 99\n", + "adding: mem time44, current time 142, horizon 98\n", + "adding: mem time45, current time 142, horizon 97\n", + "adding: mem time46, current time 142, horizon 96\n", + "adding: mem time47, current time 142, horizon 95\n", + "adding: mem time48, current time 142, horizon 94\n", + "adding: mem time49, current time 142, horizon 93\n", + "adding: mem time50, current time 142, horizon 92\n", + "adding: mem time51, current time 142, horizon 91\n", + "adding: mem time52, current time 142, horizon 90\n", + "adding: mem time53, current time 142, horizon 89\n", + "adding: mem time54, current time 142, horizon 88\n", + "adding: mem time55, current time 142, horizon 87\n", + "adding: mem time56, current time 142, horizon 86\n", + "adding: mem time57, current time 142, horizon 85\n", + "adding: mem time58, current time 142, horizon 84\n", + "adding: mem time59, current time 142, horizon 83\n", + "adding: mem time60, current time 142, horizon 82\n", + "adding: mem time61, current time 142, horizon 81\n", + "adding: mem time62, current time 142, horizon 80\n", + "adding: mem time63, current time 142, horizon 79\n", + "adding: mem time64, current time 142, horizon 78\n", + "adding: mem time65, current time 142, horizon 77\n", + "adding: mem time66, current time 142, horizon 76\n", + "adding: mem time67, current time 142, horizon 75\n", + "adding: mem time68, current time 142, horizon 74\n", + "adding: mem time69, current time 142, horizon 73\n", + "adding: mem time70, current time 142, horizon 72\n", + "adding: mem time71, current time 142, horizon 71\n", + "adding: mem time72, current time 142, horizon 70\n", + "adding: mem time73, current time 142, horizon 69\n", + "adding: mem time74, current time 142, horizon 68\n", + "adding: mem time75, current time 142, horizon 67\n", + "adding: mem time76, current time 142, horizon 66\n", + "adding: mem time77, current time 142, horizon 65\n", + "adding: mem time78, current time 142, horizon 64\n", + "adding: mem time79, current time 142, horizon 63\n", + "adding: mem time80, current time 142, horizon 62\n", + "adding: mem time81, current time 142, horizon 61\n", + "adding: mem time82, current time 142, horizon 60\n", + "adding: mem time83, current time 142, horizon 59\n", + "adding: mem time84, current time 142, horizon 58\n", + "adding: mem time85, current time 142, horizon 57\n", + "adding: mem time86, current time 142, horizon 56\n", + "adding: mem time87, current time 142, horizon 55\n", + "adding: mem time88, current time 142, horizon 54\n", + "adding: mem time89, current time 142, horizon 53\n", + "adding: mem time90, current time 142, horizon 52\n", + "adding: mem time91, current time 142, horizon 51\n", + "adding: mem time92, current time 142, horizon 50\n", + "adding: mem time93, current time 142, horizon 49\n", + "adding: mem time94, current time 142, horizon 48\n", + "adding: mem time95, current time 142, horizon 47\n", + "adding: mem time96, current time 142, horizon 46\n", + "adding: mem time97, current time 142, horizon 45\n", + "adding: mem time98, current time 142, horizon 44\n", + "adding: mem time99, current time 142, horizon 43\n", + "adding: mem time100, current time 142, horizon 42\n", + "adding: mem time101, current time 142, horizon 41\n", + "adding: mem time102, current time 142, horizon 40\n", + "adding: mem time103, current time 142, horizon 39\n", + "adding: mem time104, current time 142, horizon 38\n", + "adding: mem time105, current time 142, horizon 37\n", + "adding: mem time106, current time 142, horizon 36\n", + "adding: mem time107, current time 142, horizon 35\n", + "adding: mem time108, current time 142, horizon 34\n", + "adding: mem time109, current time 142, horizon 33\n", + "adding: mem time110, current time 142, horizon 32\n", + "adding: mem time111, current time 142, horizon 31\n", + "adding: mem time112, current time 142, horizon 30\n", + "adding: mem time113, current time 142, horizon 29\n", + "adding: mem time114, current time 142, horizon 28\n", + "adding: mem time115, current time 142, horizon 27\n", + "adding: mem time116, current time 142, horizon 26\n", + "adding: mem time117, current time 142, horizon 25\n", + "adding: mem time118, current time 142, horizon 24\n", + "adding: mem time119, current time 142, horizon 23\n", + "adding: mem time120, current time 142, horizon 22\n", + "adding: mem time121, current time 142, horizon 21\n", + "adding: mem time122, current time 142, horizon 20\n", + "adding: mem time123, current time 142, horizon 19\n", + "adding: mem time124, current time 142, horizon 18\n", + "adding: mem time125, current time 142, horizon 17\n", + "adding: mem time126, current time 142, horizon 16\n", + "adding: mem time127, current time 142, horizon 15\n", + "adding: mem time128, current time 142, horizon 14\n", + "adding: mem time129, current time 142, horizon 13\n", + "adding: mem time130, current time 142, horizon 12\n", + "adding: mem time131, current time 142, horizon 11\n", + "adding: mem time132, current time 142, horizon 10\n", + "adding: mem time133, current time 142, horizon 9\n", + "adding: mem time134, current time 142, horizon 8\n", + "adding: mem time135, current time 142, horizon 7\n", + "adding: mem time136, current time 142, horizon 6\n", + "adding: mem time137, current time 142, horizon 5\n", + "adding: mem time138, current time 142, horizon 4\n", + "adding: mem time139, current time 142, horizon 3\n", + "adding: mem time140, current time 142, horizon 2\n", + "adding: mem time141, current time 142, horizon 1\n", + "adding: mem time0, current time 143, horizon 143\n", + "adding: mem time1, current time 143, horizon 142\n", + "adding: mem time2, current time 143, horizon 141\n", + "adding: mem time3, current time 143, horizon 140\n", + "adding: mem time4, current time 143, horizon 139\n", + "adding: mem time5, current time 143, horizon 138\n", + "adding: mem time6, current time 143, horizon 137\n", + "adding: mem time7, current time 143, horizon 136\n", + "adding: mem time8, current time 143, horizon 135\n", + "adding: mem time9, current time 143, horizon 134\n", + "adding: mem time10, current time 143, horizon 133\n", + "adding: mem time11, current time 143, horizon 132\n", + "adding: mem time12, current time 143, horizon 131\n", + "adding: mem time13, current time 143, horizon 130\n", + "adding: mem time14, current time 143, horizon 129\n", + "adding: mem time15, current time 143, horizon 128\n", + "adding: mem time16, current time 143, horizon 127\n", + "adding: mem time17, current time 143, horizon 126\n", + "adding: mem time18, current time 143, horizon 125\n", + "adding: mem time19, current time 143, horizon 124\n", + "adding: mem time20, current time 143, horizon 123\n", + "adding: mem time21, current time 143, horizon 122\n", + "adding: mem time22, current time 143, horizon 121\n", + "adding: mem time23, current time 143, horizon 120\n", + "adding: mem time24, current time 143, horizon 119\n", + "adding: mem time25, current time 143, horizon 118\n", + "adding: mem time26, current time 143, horizon 117\n", + "adding: mem time27, current time 143, horizon 116\n", + "adding: mem time28, current time 143, horizon 115\n", + "adding: mem time29, current time 143, horizon 114\n", + "adding: mem time30, current time 143, horizon 113\n", + "adding: mem time31, current time 143, horizon 112\n", + "adding: mem time32, current time 143, horizon 111\n", + "adding: mem time33, current time 143, horizon 110\n", + "adding: mem time34, current time 143, horizon 109\n", + "adding: mem time35, current time 143, horizon 108\n", + "adding: mem time36, current time 143, horizon 107\n", + "adding: mem time37, current time 143, horizon 106\n", + "adding: mem time38, current time 143, horizon 105\n", + "adding: mem time39, current time 143, horizon 104\n", + "adding: mem time40, current time 143, horizon 103\n", + "adding: mem time41, current time 143, horizon 102\n", + "adding: mem time42, current time 143, horizon 101\n", + "adding: mem time43, current time 143, horizon 100\n", + "adding: mem time44, current time 143, horizon 99\n", + "adding: mem time45, current time 143, horizon 98\n", + "adding: mem time46, current time 143, horizon 97\n", + "adding: mem time47, current time 143, horizon 96\n", + "adding: mem time48, current time 143, horizon 95\n", + "adding: mem time49, current time 143, horizon 94\n", + "adding: mem time50, current time 143, horizon 93\n", + "adding: mem time51, current time 143, horizon 92\n", + "adding: mem time52, current time 143, horizon 91\n", + "adding: mem time53, current time 143, horizon 90\n", + "adding: mem time54, current time 143, horizon 89\n", + "adding: mem time55, current time 143, horizon 88\n", + "adding: mem time56, current time 143, horizon 87\n", + "adding: mem time57, current time 143, horizon 86\n", + "adding: mem time58, current time 143, horizon 85\n", + "adding: mem time59, current time 143, horizon 84\n", + "adding: mem time60, current time 143, horizon 83\n", + "adding: mem time61, current time 143, horizon 82\n", + "adding: mem time62, current time 143, horizon 81\n", + "adding: mem time63, current time 143, horizon 80\n", + "adding: mem time64, current time 143, horizon 79\n", + "adding: mem time65, current time 143, horizon 78\n", + "adding: mem time66, current time 143, horizon 77\n", + "adding: mem time67, current time 143, horizon 76\n", + "adding: mem time68, current time 143, horizon 75\n", + "adding: mem time69, current time 143, horizon 74\n", + "adding: mem time70, current time 143, horizon 73\n", + "adding: mem time71, current time 143, horizon 72\n", + "adding: mem time72, current time 143, horizon 71\n", + "adding: mem time73, current time 143, horizon 70\n", + "adding: mem time74, current time 143, horizon 69\n", + "adding: mem time75, current time 143, horizon 68\n", + "adding: mem time76, current time 143, horizon 67\n", + "adding: mem time77, current time 143, horizon 66\n", + "adding: mem time78, current time 143, horizon 65\n", + "adding: mem time79, current time 143, horizon 64\n", + "adding: mem time80, current time 143, horizon 63\n", + "adding: mem time81, current time 143, horizon 62\n", + "adding: mem time82, current time 143, horizon 61\n", + "adding: mem time83, current time 143, horizon 60\n", + "adding: mem time84, current time 143, horizon 59\n", + "adding: mem time85, current time 143, horizon 58\n", + "adding: mem time86, current time 143, horizon 57\n", + "adding: mem time87, current time 143, horizon 56\n", + "adding: mem time88, current time 143, horizon 55\n", + "adding: mem time89, current time 143, horizon 54\n", + "adding: mem time90, current time 143, horizon 53\n", + "adding: mem time91, current time 143, horizon 52\n", + "adding: mem time92, current time 143, horizon 51\n", + "adding: mem time93, current time 143, horizon 50\n", + "adding: mem time94, current time 143, horizon 49\n", + "adding: mem time95, current time 143, horizon 48\n", + "adding: mem time96, current time 143, horizon 47\n", + "adding: mem time97, current time 143, horizon 46\n", + "adding: mem time98, current time 143, horizon 45\n", + "adding: mem time99, current time 143, horizon 44\n", + "adding: mem time100, current time 143, horizon 43\n", + "adding: mem time101, current time 143, horizon 42\n", + "adding: mem time102, current time 143, horizon 41\n", + "adding: mem time103, current time 143, horizon 40\n", + "adding: mem time104, current time 143, horizon 39\n", + "adding: mem time105, current time 143, horizon 38\n", + "adding: mem time106, current time 143, horizon 37\n", + "adding: mem time107, current time 143, horizon 36\n", + "adding: mem time108, current time 143, horizon 35\n", + "adding: mem time109, current time 143, horizon 34\n", + "adding: mem time110, current time 143, horizon 33\n", + "adding: mem time111, current time 143, horizon 32\n", + "adding: mem time112, current time 143, horizon 31\n", + "adding: mem time113, current time 143, horizon 30\n", + "adding: mem time114, current time 143, horizon 29\n", + "adding: mem time115, current time 143, horizon 28\n", + "adding: mem time116, current time 143, horizon 27\n", + "adding: mem time117, current time 143, horizon 26\n", + "adding: mem time118, current time 143, horizon 25\n", + "adding: mem time119, current time 143, horizon 24\n", + "adding: mem time120, current time 143, horizon 23\n", + "adding: mem time121, current time 143, horizon 22\n", + "adding: mem time122, current time 143, horizon 21\n", + "adding: mem time123, current time 143, horizon 20\n", + "adding: mem time124, current time 143, horizon 19\n", + "adding: mem time125, current time 143, horizon 18\n", + "adding: mem time126, current time 143, horizon 17\n", + "adding: mem time127, current time 143, horizon 16\n", + "adding: mem time128, current time 143, horizon 15\n", + "adding: mem time129, current time 143, horizon 14\n", + "adding: mem time130, current time 143, horizon 13\n", + "adding: mem time131, current time 143, horizon 12\n", + "adding: mem time132, current time 143, horizon 11\n", + "adding: mem time133, current time 143, horizon 10\n", + "adding: mem time134, current time 143, horizon 9\n", + "adding: mem time135, current time 143, horizon 8\n", + "adding: mem time136, current time 143, horizon 7\n", + "adding: mem time137, current time 143, horizon 6\n", + "adding: mem time138, current time 143, horizon 5\n", + "adding: mem time139, current time 143, horizon 4\n", + "adding: mem time140, current time 143, horizon 3\n", + "adding: mem time141, current time 143, horizon 2\n", + "adding: mem time142, current time 143, horizon 1\n", + "adding: mem time0, current time 144, horizon 144\n", + "adding: mem time1, current time 144, horizon 143\n", + "adding: mem time2, current time 144, horizon 142\n", + "adding: mem time3, current time 144, horizon 141\n", + "adding: mem time4, current time 144, horizon 140\n", + "adding: mem time5, current time 144, horizon 139\n", + "adding: mem time6, current time 144, horizon 138\n", + "adding: mem time7, current time 144, horizon 137\n", + "adding: mem time8, current time 144, horizon 136\n", + "adding: mem time9, current time 144, horizon 135\n", + "adding: mem time10, current time 144, horizon 134\n", + "adding: mem time11, current time 144, horizon 133\n", + "adding: mem time12, current time 144, horizon 132\n", + "adding: mem time13, current time 144, horizon 131\n", + "adding: mem time14, current time 144, horizon 130\n", + "adding: mem time15, current time 144, horizon 129\n", + "adding: mem time16, current time 144, horizon 128\n", + "adding: mem time17, current time 144, horizon 127\n", + "adding: mem time18, current time 144, horizon 126\n", + "adding: mem time19, current time 144, horizon 125\n", + "adding: mem time20, current time 144, horizon 124\n", + "adding: mem time21, current time 144, horizon 123\n", + "adding: mem time22, current time 144, horizon 122\n", + "adding: mem time23, current time 144, horizon 121\n", + "adding: mem time24, current time 144, horizon 120\n", + "adding: mem time25, current time 144, horizon 119\n", + "adding: mem time26, current time 144, horizon 118\n", + "adding: mem time27, current time 144, horizon 117\n", + "adding: mem time28, current time 144, horizon 116\n", + "adding: mem time29, current time 144, horizon 115\n", + "adding: mem time30, current time 144, horizon 114\n", + "adding: mem time31, current time 144, horizon 113\n", + "adding: mem time32, current time 144, horizon 112\n", + "adding: mem time33, current time 144, horizon 111\n", + "adding: mem time34, current time 144, horizon 110\n", + "adding: mem time35, current time 144, horizon 109\n", + "adding: mem time36, current time 144, horizon 108\n", + "adding: mem time37, current time 144, horizon 107\n", + "adding: mem time38, current time 144, horizon 106\n", + "adding: mem time39, current time 144, horizon 105\n", + "adding: mem time40, current time 144, horizon 104\n", + "adding: mem time41, current time 144, horizon 103\n", + "adding: mem time42, current time 144, horizon 102\n", + "adding: mem time43, current time 144, horizon 101\n", + "adding: mem time44, current time 144, horizon 100\n", + "adding: mem time45, current time 144, horizon 99\n", + "adding: mem time46, current time 144, horizon 98\n", + "adding: mem time47, current time 144, horizon 97\n", + "adding: mem time48, current time 144, horizon 96\n", + "adding: mem time49, current time 144, horizon 95\n", + "adding: mem time50, current time 144, horizon 94\n", + "adding: mem time51, current time 144, horizon 93\n", + "adding: mem time52, current time 144, horizon 92\n", + "adding: mem time53, current time 144, horizon 91\n", + "adding: mem time54, current time 144, horizon 90\n", + "adding: mem time55, current time 144, horizon 89\n", + "adding: mem time56, current time 144, horizon 88\n", + "adding: mem time57, current time 144, horizon 87\n", + "adding: mem time58, current time 144, horizon 86\n", + "adding: mem time59, current time 144, horizon 85\n", + "adding: mem time60, current time 144, horizon 84\n", + "adding: mem time61, current time 144, horizon 83\n", + "adding: mem time62, current time 144, horizon 82\n", + "adding: mem time63, current time 144, horizon 81\n", + "adding: mem time64, current time 144, horizon 80\n", + "adding: mem time65, current time 144, horizon 79\n", + "adding: mem time66, current time 144, horizon 78\n", + "adding: mem time67, current time 144, horizon 77\n", + "adding: mem time68, current time 144, horizon 76\n", + "adding: mem time69, current time 144, horizon 75\n", + "adding: mem time70, current time 144, horizon 74\n", + "adding: mem time71, current time 144, horizon 73\n", + "adding: mem time72, current time 144, horizon 72\n", + "adding: mem time73, current time 144, horizon 71\n", + "adding: mem time74, current time 144, horizon 70\n", + "adding: mem time75, current time 144, horizon 69\n", + "adding: mem time76, current time 144, horizon 68\n", + "adding: mem time77, current time 144, horizon 67\n", + "adding: mem time78, current time 144, horizon 66\n", + "adding: mem time79, current time 144, horizon 65\n", + "adding: mem time80, current time 144, horizon 64\n", + "adding: mem time81, current time 144, horizon 63\n", + "adding: mem time82, current time 144, horizon 62\n", + "adding: mem time83, current time 144, horizon 61\n", + "adding: mem time84, current time 144, horizon 60\n", + "adding: mem time85, current time 144, horizon 59\n", + "adding: mem time86, current time 144, horizon 58\n", + "adding: mem time87, current time 144, horizon 57\n", + "adding: mem time88, current time 144, horizon 56\n", + "adding: mem time89, current time 144, horizon 55\n", + "adding: mem time90, current time 144, horizon 54\n", + "adding: mem time91, current time 144, horizon 53\n", + "adding: mem time92, current time 144, horizon 52\n", + "adding: mem time93, current time 144, horizon 51\n", + "adding: mem time94, current time 144, horizon 50\n", + "adding: mem time95, current time 144, horizon 49\n", + "adding: mem time96, current time 144, horizon 48\n", + "adding: mem time97, current time 144, horizon 47\n", + "adding: mem time98, current time 144, horizon 46\n", + "adding: mem time99, current time 144, horizon 45\n", + "adding: mem time100, current time 144, horizon 44\n", + "adding: mem time101, current time 144, horizon 43\n", + "adding: mem time102, current time 144, horizon 42\n", + "adding: mem time103, current time 144, horizon 41\n", + "adding: mem time104, current time 144, horizon 40\n", + "adding: mem time105, current time 144, horizon 39\n", + "adding: mem time106, current time 144, horizon 38\n", + "adding: mem time107, current time 144, horizon 37\n", + "adding: mem time108, current time 144, horizon 36\n", + "adding: mem time109, current time 144, horizon 35\n", + "adding: mem time110, current time 144, horizon 34\n", + "adding: mem time111, current time 144, horizon 33\n", + "adding: mem time112, current time 144, horizon 32\n", + "adding: mem time113, current time 144, horizon 31\n", + "adding: mem time114, current time 144, horizon 30\n", + "adding: mem time115, current time 144, horizon 29\n", + "adding: mem time116, current time 144, horizon 28\n", + "adding: mem time117, current time 144, horizon 27\n", + "adding: mem time118, current time 144, horizon 26\n", + "adding: mem time119, current time 144, horizon 25\n", + "adding: mem time120, current time 144, horizon 24\n", + "adding: mem time121, current time 144, horizon 23\n", + "adding: mem time122, current time 144, horizon 22\n", + "adding: mem time123, current time 144, horizon 21\n", + "adding: mem time124, current time 144, horizon 20\n", + "adding: mem time125, current time 144, horizon 19\n", + "adding: mem time126, current time 144, horizon 18\n", + "adding: mem time127, current time 144, horizon 17\n", + "adding: mem time128, current time 144, horizon 16\n", + "adding: mem time129, current time 144, horizon 15\n", + "adding: mem time130, current time 144, horizon 14\n", + "adding: mem time131, current time 144, horizon 13\n", + "adding: mem time132, current time 144, horizon 12\n", + "adding: mem time133, current time 144, horizon 11\n", + "adding: mem time134, current time 144, horizon 10\n", + "adding: mem time135, current time 144, horizon 9\n", + "adding: mem time136, current time 144, horizon 8\n", + "adding: mem time137, current time 144, horizon 7\n", + "adding: mem time138, current time 144, horizon 6\n", + "adding: mem time139, current time 144, horizon 5\n", + "adding: mem time140, current time 144, horizon 4\n", + "adding: mem time141, current time 144, horizon 3\n", + "adding: mem time142, current time 144, horizon 2\n", + "adding: mem time143, current time 144, horizon 1\n", + "adding: mem time0, current time 145, horizon 145\n", + "adding: mem time1, current time 145, horizon 144\n", + "adding: mem time2, current time 145, horizon 143\n", + "adding: mem time3, current time 145, horizon 142\n", + "adding: mem time4, current time 145, horizon 141\n", + "adding: mem time5, current time 145, horizon 140\n", + "adding: mem time6, current time 145, horizon 139\n", + "adding: mem time7, current time 145, horizon 138\n", + "adding: mem time8, current time 145, horizon 137\n", + "adding: mem time9, current time 145, horizon 136\n", + "adding: mem time10, current time 145, horizon 135\n", + "adding: mem time11, current time 145, horizon 134\n", + "adding: mem time12, current time 145, horizon 133\n", + "adding: mem time13, current time 145, horizon 132\n", + "adding: mem time14, current time 145, horizon 131\n", + "adding: mem time15, current time 145, horizon 130\n", + "adding: mem time16, current time 145, horizon 129\n", + "adding: mem time17, current time 145, horizon 128\n", + "adding: mem time18, current time 145, horizon 127\n", + "adding: mem time19, current time 145, horizon 126\n", + "adding: mem time20, current time 145, horizon 125\n", + "adding: mem time21, current time 145, horizon 124\n", + "adding: mem time22, current time 145, horizon 123\n", + "adding: mem time23, current time 145, horizon 122\n", + "adding: mem time24, current time 145, horizon 121\n", + "adding: mem time25, current time 145, horizon 120\n", + "adding: mem time26, current time 145, horizon 119\n", + "adding: mem time27, current time 145, horizon 118\n", + "adding: mem time28, current time 145, horizon 117\n", + "adding: mem time29, current time 145, horizon 116\n", + "adding: mem time30, current time 145, horizon 115\n", + "adding: mem time31, current time 145, horizon 114\n", + "adding: mem time32, current time 145, horizon 113\n", + "adding: mem time33, current time 145, horizon 112\n", + "adding: mem time34, current time 145, horizon 111\n", + "adding: mem time35, current time 145, horizon 110\n", + "adding: mem time36, current time 145, horizon 109\n", + "adding: mem time37, current time 145, horizon 108\n", + "adding: mem time38, current time 145, horizon 107\n", + "adding: mem time39, current time 145, horizon 106\n", + "adding: mem time40, current time 145, horizon 105\n", + "adding: mem time41, current time 145, horizon 104\n", + "adding: mem time42, current time 145, horizon 103\n", + "adding: mem time43, current time 145, horizon 102\n", + "adding: mem time44, current time 145, horizon 101\n", + "adding: mem time45, current time 145, horizon 100\n", + "adding: mem time46, current time 145, horizon 99\n", + "adding: mem time47, current time 145, horizon 98\n", + "adding: mem time48, current time 145, horizon 97\n", + "adding: mem time49, current time 145, horizon 96\n", + "adding: mem time50, current time 145, horizon 95\n", + "adding: mem time51, current time 145, horizon 94\n", + "adding: mem time52, current time 145, horizon 93\n", + "adding: mem time53, current time 145, horizon 92\n", + "adding: mem time54, current time 145, horizon 91\n", + "adding: mem time55, current time 145, horizon 90\n", + "adding: mem time56, current time 145, horizon 89\n", + "adding: mem time57, current time 145, horizon 88\n", + "adding: mem time58, current time 145, horizon 87\n", + "adding: mem time59, current time 145, horizon 86\n", + "adding: mem time60, current time 145, horizon 85\n", + "adding: mem time61, current time 145, horizon 84\n", + "adding: mem time62, current time 145, horizon 83\n", + "adding: mem time63, current time 145, horizon 82\n", + "adding: mem time64, current time 145, horizon 81\n", + "adding: mem time65, current time 145, horizon 80\n", + "adding: mem time66, current time 145, horizon 79\n", + "adding: mem time67, current time 145, horizon 78\n", + "adding: mem time68, current time 145, horizon 77\n", + "adding: mem time69, current time 145, horizon 76\n", + "adding: mem time70, current time 145, horizon 75\n", + "adding: mem time71, current time 145, horizon 74\n", + "adding: mem time72, current time 145, horizon 73\n", + "adding: mem time73, current time 145, horizon 72\n", + "adding: mem time74, current time 145, horizon 71\n", + "adding: mem time75, current time 145, horizon 70\n", + "adding: mem time76, current time 145, horizon 69\n", + "adding: mem time77, current time 145, horizon 68\n", + "adding: mem time78, current time 145, horizon 67\n", + "adding: mem time79, current time 145, horizon 66\n", + "adding: mem time80, current time 145, horizon 65\n", + "adding: mem time81, current time 145, horizon 64\n", + "adding: mem time82, current time 145, horizon 63\n", + "adding: mem time83, current time 145, horizon 62\n", + "adding: mem time84, current time 145, horizon 61\n", + "adding: mem time85, current time 145, horizon 60\n", + "adding: mem time86, current time 145, horizon 59\n", + "adding: mem time87, current time 145, horizon 58\n", + "adding: mem time88, current time 145, horizon 57\n", + "adding: mem time89, current time 145, horizon 56\n", + "adding: mem time90, current time 145, horizon 55\n", + "adding: mem time91, current time 145, horizon 54\n", + "adding: mem time92, current time 145, horizon 53\n", + "adding: mem time93, current time 145, horizon 52\n", + "adding: mem time94, current time 145, horizon 51\n", + "adding: mem time95, current time 145, horizon 50\n", + "adding: mem time96, current time 145, horizon 49\n", + "adding: mem time97, current time 145, horizon 48\n", + "adding: mem time98, current time 145, horizon 47\n", + "adding: mem time99, current time 145, horizon 46\n", + "adding: mem time100, current time 145, horizon 45\n", + "adding: mem time101, current time 145, horizon 44\n", + "adding: mem time102, current time 145, horizon 43\n", + "adding: mem time103, current time 145, horizon 42\n", + "adding: mem time104, current time 145, horizon 41\n", + "adding: mem time105, current time 145, horizon 40\n", + "adding: mem time106, current time 145, horizon 39\n", + "adding: mem time107, current time 145, horizon 38\n", + "adding: mem time108, current time 145, horizon 37\n", + "adding: mem time109, current time 145, horizon 36\n", + "adding: mem time110, current time 145, horizon 35\n", + "adding: mem time111, current time 145, horizon 34\n", + "adding: mem time112, current time 145, horizon 33\n", + "adding: mem time113, current time 145, horizon 32\n", + "adding: mem time114, current time 145, horizon 31\n", + "adding: mem time115, current time 145, horizon 30\n", + "adding: mem time116, current time 145, horizon 29\n", + "adding: mem time117, current time 145, horizon 28\n", + "adding: mem time118, current time 145, horizon 27\n", + "adding: mem time119, current time 145, horizon 26\n", + "adding: mem time120, current time 145, horizon 25\n", + "adding: mem time121, current time 145, horizon 24\n", + "adding: mem time122, current time 145, horizon 23\n", + "adding: mem time123, current time 145, horizon 22\n", + "adding: mem time124, current time 145, horizon 21\n", + "adding: mem time125, current time 145, horizon 20\n", + "adding: mem time126, current time 145, horizon 19\n", + "adding: mem time127, current time 145, horizon 18\n", + "adding: mem time128, current time 145, horizon 17\n", + "adding: mem time129, current time 145, horizon 16\n", + "adding: mem time130, current time 145, horizon 15\n", + "adding: mem time131, current time 145, horizon 14\n", + "adding: mem time132, current time 145, horizon 13\n", + "adding: mem time133, current time 145, horizon 12\n", + "adding: mem time134, current time 145, horizon 11\n", + "adding: mem time135, current time 145, horizon 10\n", + "adding: mem time136, current time 145, horizon 9\n", + "adding: mem time137, current time 145, horizon 8\n", + "adding: mem time138, current time 145, horizon 7\n", + "adding: mem time139, current time 145, horizon 6\n", + "adding: mem time140, current time 145, horizon 5\n", + "adding: mem time141, current time 145, horizon 4\n", + "adding: mem time142, current time 145, horizon 3\n", + "adding: mem time143, current time 145, horizon 2\n", + "adding: mem time144, current time 145, horizon 1\n", + "adding: mem time0, current time 146, horizon 146\n", + "adding: mem time1, current time 146, horizon 145\n", + "adding: mem time2, current time 146, horizon 144\n", + "adding: mem time3, current time 146, horizon 143\n", + "adding: mem time4, current time 146, horizon 142\n", + "adding: mem time5, current time 146, horizon 141\n", + "adding: mem time6, current time 146, horizon 140\n", + "adding: mem time7, current time 146, horizon 139\n", + "adding: mem time8, current time 146, horizon 138\n", + "adding: mem time9, current time 146, horizon 137\n", + "adding: mem time10, current time 146, horizon 136\n", + "adding: mem time11, current time 146, horizon 135\n", + "adding: mem time12, current time 146, horizon 134\n", + "adding: mem time13, current time 146, horizon 133\n", + "adding: mem time14, current time 146, horizon 132\n", + "adding: mem time15, current time 146, horizon 131\n", + "adding: mem time16, current time 146, horizon 130\n", + "adding: mem time17, current time 146, horizon 129\n", + "adding: mem time18, current time 146, horizon 128\n", + "adding: mem time19, current time 146, horizon 127\n", + "adding: mem time20, current time 146, horizon 126\n", + "adding: mem time21, current time 146, horizon 125\n", + "adding: mem time22, current time 146, horizon 124\n", + "adding: mem time23, current time 146, horizon 123\n", + "adding: mem time24, current time 146, horizon 122\n", + "adding: mem time25, current time 146, horizon 121\n", + "adding: mem time26, current time 146, horizon 120\n", + "adding: mem time27, current time 146, horizon 119\n", + "adding: mem time28, current time 146, horizon 118\n", + "adding: mem time29, current time 146, horizon 117\n", + "adding: mem time30, current time 146, horizon 116\n", + "adding: mem time31, current time 146, horizon 115\n", + "adding: mem time32, current time 146, horizon 114\n", + "adding: mem time33, current time 146, horizon 113\n", + "adding: mem time34, current time 146, horizon 112\n", + "adding: mem time35, current time 146, horizon 111\n", + "adding: mem time36, current time 146, horizon 110\n", + "adding: mem time37, current time 146, horizon 109\n", + "adding: mem time38, current time 146, horizon 108\n", + "adding: mem time39, current time 146, horizon 107\n", + "adding: mem time40, current time 146, horizon 106\n", + "adding: mem time41, current time 146, horizon 105\n", + "adding: mem time42, current time 146, horizon 104\n", + "adding: mem time43, current time 146, horizon 103\n", + "adding: mem time44, current time 146, horizon 102\n", + "adding: mem time45, current time 146, horizon 101\n", + "adding: mem time46, current time 146, horizon 100\n", + "adding: mem time47, current time 146, horizon 99\n", + "adding: mem time48, current time 146, horizon 98\n", + "adding: mem time49, current time 146, horizon 97\n", + "adding: mem time50, current time 146, horizon 96\n", + "adding: mem time51, current time 146, horizon 95\n", + "adding: mem time52, current time 146, horizon 94\n", + "adding: mem time53, current time 146, horizon 93\n", + "adding: mem time54, current time 146, horizon 92\n", + "adding: mem time55, current time 146, horizon 91\n", + "adding: mem time56, current time 146, horizon 90\n", + "adding: mem time57, current time 146, horizon 89\n", + "adding: mem time58, current time 146, horizon 88\n", + "adding: mem time59, current time 146, horizon 87\n", + "adding: mem time60, current time 146, horizon 86\n", + "adding: mem time61, current time 146, horizon 85\n", + "adding: mem time62, current time 146, horizon 84\n", + "adding: mem time63, current time 146, horizon 83\n", + "adding: mem time64, current time 146, horizon 82\n", + "adding: mem time65, current time 146, horizon 81\n", + "adding: mem time66, current time 146, horizon 80\n", + "adding: mem time67, current time 146, horizon 79\n", + "adding: mem time68, current time 146, horizon 78\n", + "adding: mem time69, current time 146, horizon 77\n", + "adding: mem time70, current time 146, horizon 76\n", + "adding: mem time71, current time 146, horizon 75\n", + "adding: mem time72, current time 146, horizon 74\n", + "adding: mem time73, current time 146, horizon 73\n", + "adding: mem time74, current time 146, horizon 72\n", + "adding: mem time75, current time 146, horizon 71\n", + "adding: mem time76, current time 146, horizon 70\n", + "adding: mem time77, current time 146, horizon 69\n", + "adding: mem time78, current time 146, horizon 68\n", + "adding: mem time79, current time 146, horizon 67\n", + "adding: mem time80, current time 146, horizon 66\n", + "adding: mem time81, current time 146, horizon 65\n", + "adding: mem time82, current time 146, horizon 64\n", + "adding: mem time83, current time 146, horizon 63\n", + "adding: mem time84, current time 146, horizon 62\n", + "adding: mem time85, current time 146, horizon 61\n", + "adding: mem time86, current time 146, horizon 60\n", + "adding: mem time87, current time 146, horizon 59\n", + "adding: mem time88, current time 146, horizon 58\n", + "adding: mem time89, current time 146, horizon 57\n", + "adding: mem time90, current time 146, horizon 56\n", + "adding: mem time91, current time 146, horizon 55\n", + "adding: mem time92, current time 146, horizon 54\n", + "adding: mem time93, current time 146, horizon 53\n", + "adding: mem time94, current time 146, horizon 52\n", + "adding: mem time95, current time 146, horizon 51\n", + "adding: mem time96, current time 146, horizon 50\n", + "adding: mem time97, current time 146, horizon 49\n", + "adding: mem time98, current time 146, horizon 48\n", + "adding: mem time99, current time 146, horizon 47\n", + "adding: mem time100, current time 146, horizon 46\n", + "adding: mem time101, current time 146, horizon 45\n", + "adding: mem time102, current time 146, horizon 44\n", + "adding: mem time103, current time 146, horizon 43\n", + "adding: mem time104, current time 146, horizon 42\n", + "adding: mem time105, current time 146, horizon 41\n", + "adding: mem time106, current time 146, horizon 40\n", + "adding: mem time107, current time 146, horizon 39\n", + "adding: mem time108, current time 146, horizon 38\n", + "adding: mem time109, current time 146, horizon 37\n", + "adding: mem time110, current time 146, horizon 36\n", + "adding: mem time111, current time 146, horizon 35\n", + "adding: mem time112, current time 146, horizon 34\n", + "adding: mem time113, current time 146, horizon 33\n", + "adding: mem time114, current time 146, horizon 32\n", + "adding: mem time115, current time 146, horizon 31\n", + "adding: mem time116, current time 146, horizon 30\n", + "adding: mem time117, current time 146, horizon 29\n", + "adding: mem time118, current time 146, horizon 28\n", + "adding: mem time119, current time 146, horizon 27\n", + "adding: mem time120, current time 146, horizon 26\n", + "adding: mem time121, current time 146, horizon 25\n", + "adding: mem time122, current time 146, horizon 24\n", + "adding: mem time123, current time 146, horizon 23\n", + "adding: mem time124, current time 146, horizon 22\n", + "adding: mem time125, current time 146, horizon 21\n", + "adding: mem time126, current time 146, horizon 20\n", + "adding: mem time127, current time 146, horizon 19\n", + "adding: mem time128, current time 146, horizon 18\n", + "adding: mem time129, current time 146, horizon 17\n", + "adding: mem time130, current time 146, horizon 16\n", + "adding: mem time131, current time 146, horizon 15\n", + "adding: mem time132, current time 146, horizon 14\n", + "adding: mem time133, current time 146, horizon 13\n", + "adding: mem time134, current time 146, horizon 12\n", + "adding: mem time135, current time 146, horizon 11\n", + "adding: mem time136, current time 146, horizon 10\n", + "adding: mem time137, current time 146, horizon 9\n", + "adding: mem time138, current time 146, horizon 8\n", + "adding: mem time139, current time 146, horizon 7\n", + "adding: mem time140, current time 146, horizon 6\n", + "adding: mem time141, current time 146, horizon 5\n", + "adding: mem time142, current time 146, horizon 4\n", + "adding: mem time143, current time 146, horizon 3\n", + "adding: mem time144, current time 146, horizon 2\n", + "adding: mem time145, current time 146, horizon 1\n", + "adding: mem time0, current time 147, horizon 147\n", + "adding: mem time1, current time 147, horizon 146\n", + "adding: mem time2, current time 147, horizon 145\n", + "adding: mem time3, current time 147, horizon 144\n", + "adding: mem time4, current time 147, horizon 143\n", + "adding: mem time5, current time 147, horizon 142\n", + "adding: mem time6, current time 147, horizon 141\n", + "adding: mem time7, current time 147, horizon 140\n", + "adding: mem time8, current time 147, horizon 139\n", + "adding: mem time9, current time 147, horizon 138\n", + "adding: mem time10, current time 147, horizon 137\n", + "adding: mem time11, current time 147, horizon 136\n", + "adding: mem time12, current time 147, horizon 135\n", + "adding: mem time13, current time 147, horizon 134\n", + "adding: mem time14, current time 147, horizon 133\n", + "adding: mem time15, current time 147, horizon 132\n", + "adding: mem time16, current time 147, horizon 131\n", + "adding: mem time17, current time 147, horizon 130\n", + "adding: mem time18, current time 147, horizon 129\n", + "adding: mem time19, current time 147, horizon 128\n", + "adding: mem time20, current time 147, horizon 127\n", + "adding: mem time21, current time 147, horizon 126\n", + "adding: mem time22, current time 147, horizon 125\n", + "adding: mem time23, current time 147, horizon 124\n", + "adding: mem time24, current time 147, horizon 123\n", + "adding: mem time25, current time 147, horizon 122\n", + "adding: mem time26, current time 147, horizon 121\n", + "adding: mem time27, current time 147, horizon 120\n", + "adding: mem time28, current time 147, horizon 119\n", + "adding: mem time29, current time 147, horizon 118\n", + "adding: mem time30, current time 147, horizon 117\n", + "adding: mem time31, current time 147, horizon 116\n", + "adding: mem time32, current time 147, horizon 115\n", + "adding: mem time33, current time 147, horizon 114\n", + "adding: mem time34, current time 147, horizon 113\n", + "adding: mem time35, current time 147, horizon 112\n", + "adding: mem time36, current time 147, horizon 111\n", + "adding: mem time37, current time 147, horizon 110\n", + "adding: mem time38, current time 147, horizon 109\n", + "adding: mem time39, current time 147, horizon 108\n", + "adding: mem time40, current time 147, horizon 107\n", + "adding: mem time41, current time 147, horizon 106\n", + "adding: mem time42, current time 147, horizon 105\n", + "adding: mem time43, current time 147, horizon 104\n", + "adding: mem time44, current time 147, horizon 103\n", + "adding: mem time45, current time 147, horizon 102\n", + "adding: mem time46, current time 147, horizon 101\n", + "adding: mem time47, current time 147, horizon 100\n", + "adding: mem time48, current time 147, horizon 99\n", + "adding: mem time49, current time 147, horizon 98\n", + "adding: mem time50, current time 147, horizon 97\n", + "adding: mem time51, current time 147, horizon 96\n", + "adding: mem time52, current time 147, horizon 95\n", + "adding: mem time53, current time 147, horizon 94\n", + "adding: mem time54, current time 147, horizon 93\n", + "adding: mem time55, current time 147, horizon 92\n", + "adding: mem time56, current time 147, horizon 91\n", + "adding: mem time57, current time 147, horizon 90\n", + "adding: mem time58, current time 147, horizon 89\n", + "adding: mem time59, current time 147, horizon 88\n", + "adding: mem time60, current time 147, horizon 87\n", + "adding: mem time61, current time 147, horizon 86\n", + "adding: mem time62, current time 147, horizon 85\n", + "adding: mem time63, current time 147, horizon 84\n", + "adding: mem time64, current time 147, horizon 83\n", + "adding: mem time65, current time 147, horizon 82\n", + "adding: mem time66, current time 147, horizon 81\n", + "adding: mem time67, current time 147, horizon 80\n", + "adding: mem time68, current time 147, horizon 79\n", + "adding: mem time69, current time 147, horizon 78\n", + "adding: mem time70, current time 147, horizon 77\n", + "adding: mem time71, current time 147, horizon 76\n", + "adding: mem time72, current time 147, horizon 75\n", + "adding: mem time73, current time 147, horizon 74\n", + "adding: mem time74, current time 147, horizon 73\n", + "adding: mem time75, current time 147, horizon 72\n", + "adding: mem time76, current time 147, horizon 71\n", + "adding: mem time77, current time 147, horizon 70\n", + "adding: mem time78, current time 147, horizon 69\n", + "adding: mem time79, current time 147, horizon 68\n", + "adding: mem time80, current time 147, horizon 67\n", + "adding: mem time81, current time 147, horizon 66\n", + "adding: mem time82, current time 147, horizon 65\n", + "adding: mem time83, current time 147, horizon 64\n", + "adding: mem time84, current time 147, horizon 63\n", + "adding: mem time85, current time 147, horizon 62\n", + "adding: mem time86, current time 147, horizon 61\n", + "adding: mem time87, current time 147, horizon 60\n", + "adding: mem time88, current time 147, horizon 59\n", + "adding: mem time89, current time 147, horizon 58\n", + "adding: mem time90, current time 147, horizon 57\n", + "adding: mem time91, current time 147, horizon 56\n", + "adding: mem time92, current time 147, horizon 55\n", + "adding: mem time93, current time 147, horizon 54\n", + "adding: mem time94, current time 147, horizon 53\n", + "adding: mem time95, current time 147, horizon 52\n", + "adding: mem time96, current time 147, horizon 51\n", + "adding: mem time97, current time 147, horizon 50\n", + "adding: mem time98, current time 147, horizon 49\n", + "adding: mem time99, current time 147, horizon 48\n", + "adding: mem time100, current time 147, horizon 47\n", + "adding: mem time101, current time 147, horizon 46\n", + "adding: mem time102, current time 147, horizon 45\n", + "adding: mem time103, current time 147, horizon 44\n", + "adding: mem time104, current time 147, horizon 43\n", + "adding: mem time105, current time 147, horizon 42\n", + "adding: mem time106, current time 147, horizon 41\n", + "adding: mem time107, current time 147, horizon 40\n", + "adding: mem time108, current time 147, horizon 39\n", + "adding: mem time109, current time 147, horizon 38\n", + "adding: mem time110, current time 147, horizon 37\n", + "adding: mem time111, current time 147, horizon 36\n", + "adding: mem time112, current time 147, horizon 35\n", + "adding: mem time113, current time 147, horizon 34\n", + "adding: mem time114, current time 147, horizon 33\n", + "adding: mem time115, current time 147, horizon 32\n", + "adding: mem time116, current time 147, horizon 31\n", + "adding: mem time117, current time 147, horizon 30\n", + "adding: mem time118, current time 147, horizon 29\n", + "adding: mem time119, current time 147, horizon 28\n", + "adding: mem time120, current time 147, horizon 27\n", + "adding: mem time121, current time 147, horizon 26\n", + "adding: mem time122, current time 147, horizon 25\n", + "adding: mem time123, current time 147, horizon 24\n", + "adding: mem time124, current time 147, horizon 23\n", + "adding: mem time125, current time 147, horizon 22\n", + "adding: mem time126, current time 147, horizon 21\n", + "adding: mem time127, current time 147, horizon 20\n", + "adding: mem time128, current time 147, horizon 19\n", + "adding: mem time129, current time 147, horizon 18\n", + "adding: mem time130, current time 147, horizon 17\n", + "adding: mem time131, current time 147, horizon 16\n", + "adding: mem time132, current time 147, horizon 15\n", + "adding: mem time133, current time 147, horizon 14\n", + "adding: mem time134, current time 147, horizon 13\n", + "adding: mem time135, current time 147, horizon 12\n", + "adding: mem time136, current time 147, horizon 11\n", + "adding: mem time137, current time 147, horizon 10\n", + "adding: mem time138, current time 147, horizon 9\n", + "adding: mem time139, current time 147, horizon 8\n", + "adding: mem time140, current time 147, horizon 7\n", + "adding: mem time141, current time 147, horizon 6\n", + "adding: mem time142, current time 147, horizon 5\n", + "adding: mem time143, current time 147, horizon 4\n", + "adding: mem time144, current time 147, horizon 3\n", + "adding: mem time145, current time 147, horizon 2\n", + "adding: mem time146, current time 147, horizon 1\n", + "adding: mem time0, current time 148, horizon 148\n", + "adding: mem time1, current time 148, horizon 147\n", + "adding: mem time2, current time 148, horizon 146\n", + "adding: mem time3, current time 148, horizon 145\n", + "adding: mem time4, current time 148, horizon 144\n", + "adding: mem time5, current time 148, horizon 143\n", + "adding: mem time6, current time 148, horizon 142\n", + "adding: mem time7, current time 148, horizon 141\n", + "adding: mem time8, current time 148, horizon 140\n", + "adding: mem time9, current time 148, horizon 139\n", + "adding: mem time10, current time 148, horizon 138\n", + "adding: mem time11, current time 148, horizon 137\n", + "adding: mem time12, current time 148, horizon 136\n", + "adding: mem time13, current time 148, horizon 135\n", + "adding: mem time14, current time 148, horizon 134\n", + "adding: mem time15, current time 148, horizon 133\n", + "adding: mem time16, current time 148, horizon 132\n", + "adding: mem time17, current time 148, horizon 131\n", + "adding: mem time18, current time 148, horizon 130\n", + "adding: mem time19, current time 148, horizon 129\n", + "adding: mem time20, current time 148, horizon 128\n", + "adding: mem time21, current time 148, horizon 127\n", + "adding: mem time22, current time 148, horizon 126\n", + "adding: mem time23, current time 148, horizon 125\n", + "adding: mem time24, current time 148, horizon 124\n", + "adding: mem time25, current time 148, horizon 123\n", + "adding: mem time26, current time 148, horizon 122\n", + "adding: mem time27, current time 148, horizon 121\n", + "adding: mem time28, current time 148, horizon 120\n", + "adding: mem time29, current time 148, horizon 119\n", + "adding: mem time30, current time 148, horizon 118\n", + "adding: mem time31, current time 148, horizon 117\n", + "adding: mem time32, current time 148, horizon 116\n", + "adding: mem time33, current time 148, horizon 115\n", + "adding: mem time34, current time 148, horizon 114\n", + "adding: mem time35, current time 148, horizon 113\n", + "adding: mem time36, current time 148, horizon 112\n", + "adding: mem time37, current time 148, horizon 111\n", + "adding: mem time38, current time 148, horizon 110\n", + "adding: mem time39, current time 148, horizon 109\n", + "adding: mem time40, current time 148, horizon 108\n", + "adding: mem time41, current time 148, horizon 107\n", + "adding: mem time42, current time 148, horizon 106\n", + "adding: mem time43, current time 148, horizon 105\n", + "adding: mem time44, current time 148, horizon 104\n", + "adding: mem time45, current time 148, horizon 103\n", + "adding: mem time46, current time 148, horizon 102\n", + "adding: mem time47, current time 148, horizon 101\n", + "adding: mem time48, current time 148, horizon 100\n", + "adding: mem time49, current time 148, horizon 99\n", + "adding: mem time50, current time 148, horizon 98\n", + "adding: mem time51, current time 148, horizon 97\n", + "adding: mem time52, current time 148, horizon 96\n", + "adding: mem time53, current time 148, horizon 95\n", + "adding: mem time54, current time 148, horizon 94\n", + "adding: mem time55, current time 148, horizon 93\n", + "adding: mem time56, current time 148, horizon 92\n", + "adding: mem time57, current time 148, horizon 91\n", + "adding: mem time58, current time 148, horizon 90\n", + "adding: mem time59, current time 148, horizon 89\n", + "adding: mem time60, current time 148, horizon 88\n", + "adding: mem time61, current time 148, horizon 87\n", + "adding: mem time62, current time 148, horizon 86\n", + "adding: mem time63, current time 148, horizon 85\n", + "adding: mem time64, current time 148, horizon 84\n", + "adding: mem time65, current time 148, horizon 83\n", + "adding: mem time66, current time 148, horizon 82\n", + "adding: mem time67, current time 148, horizon 81\n", + "adding: mem time68, current time 148, horizon 80\n", + "adding: mem time69, current time 148, horizon 79\n", + "adding: mem time70, current time 148, horizon 78\n", + "adding: mem time71, current time 148, horizon 77\n", + "adding: mem time72, current time 148, horizon 76\n", + "adding: mem time73, current time 148, horizon 75\n", + "adding: mem time74, current time 148, horizon 74\n", + "adding: mem time75, current time 148, horizon 73\n", + "adding: mem time76, current time 148, horizon 72\n", + "adding: mem time77, current time 148, horizon 71\n", + "adding: mem time78, current time 148, horizon 70\n", + "adding: mem time79, current time 148, horizon 69\n", + "adding: mem time80, current time 148, horizon 68\n", + "adding: mem time81, current time 148, horizon 67\n", + "adding: mem time82, current time 148, horizon 66\n", + "adding: mem time83, current time 148, horizon 65\n", + "adding: mem time84, current time 148, horizon 64\n", + "adding: mem time85, current time 148, horizon 63\n", + "adding: mem time86, current time 148, horizon 62\n", + "adding: mem time87, current time 148, horizon 61\n", + "adding: mem time88, current time 148, horizon 60\n", + "adding: mem time89, current time 148, horizon 59\n", + "adding: mem time90, current time 148, horizon 58\n", + "adding: mem time91, current time 148, horizon 57\n", + "adding: mem time92, current time 148, horizon 56\n", + "adding: mem time93, current time 148, horizon 55\n", + "adding: mem time94, current time 148, horizon 54\n", + "adding: mem time95, current time 148, horizon 53\n", + "adding: mem time96, current time 148, horizon 52\n", + "adding: mem time97, current time 148, horizon 51\n", + "adding: mem time98, current time 148, horizon 50\n", + "adding: mem time99, current time 148, horizon 49\n", + "adding: mem time100, current time 148, horizon 48\n", + "adding: mem time101, current time 148, horizon 47\n", + "adding: mem time102, current time 148, horizon 46\n", + "adding: mem time103, current time 148, horizon 45\n", + "adding: mem time104, current time 148, horizon 44\n", + "adding: mem time105, current time 148, horizon 43\n", + "adding: mem time106, current time 148, horizon 42\n", + "adding: mem time107, current time 148, horizon 41\n", + "adding: mem time108, current time 148, horizon 40\n", + "adding: mem time109, current time 148, horizon 39\n", + "adding: mem time110, current time 148, horizon 38\n", + "adding: mem time111, current time 148, horizon 37\n", + "adding: mem time112, current time 148, horizon 36\n", + "adding: mem time113, current time 148, horizon 35\n", + "adding: mem time114, current time 148, horizon 34\n", + "adding: mem time115, current time 148, horizon 33\n", + "adding: mem time116, current time 148, horizon 32\n", + "adding: mem time117, current time 148, horizon 31\n", + "adding: mem time118, current time 148, horizon 30\n", + "adding: mem time119, current time 148, horizon 29\n", + "adding: mem time120, current time 148, horizon 28\n", + "adding: mem time121, current time 148, horizon 27\n", + "adding: mem time122, current time 148, horizon 26\n", + "adding: mem time123, current time 148, horizon 25\n", + "adding: mem time124, current time 148, horizon 24\n", + "adding: mem time125, current time 148, horizon 23\n", + "adding: mem time126, current time 148, horizon 22\n", + "adding: mem time127, current time 148, horizon 21\n", + "adding: mem time128, current time 148, horizon 20\n", + "adding: mem time129, current time 148, horizon 19\n", + "adding: mem time130, current time 148, horizon 18\n", + "adding: mem time131, current time 148, horizon 17\n", + "adding: mem time132, current time 148, horizon 16\n", + "adding: mem time133, current time 148, horizon 15\n", + "adding: mem time134, current time 148, horizon 14\n", + "adding: mem time135, current time 148, horizon 13\n", + "adding: mem time136, current time 148, horizon 12\n", + "adding: mem time137, current time 148, horizon 11\n", + "adding: mem time138, current time 148, horizon 10\n", + "adding: mem time139, current time 148, horizon 9\n", + "adding: mem time140, current time 148, horizon 8\n", + "adding: mem time141, current time 148, horizon 7\n", + "adding: mem time142, current time 148, horizon 6\n", + "adding: mem time143, current time 148, horizon 5\n", + "adding: mem time144, current time 148, horizon 4\n", + "adding: mem time145, current time 148, horizon 3\n", + "adding: mem time146, current time 148, horizon 2\n", + "adding: mem time147, current time 148, horizon 1\n", + "adding: mem time0, current time 149, horizon 149\n", + "adding: mem time1, current time 149, horizon 148\n", + "adding: mem time2, current time 149, horizon 147\n", + "adding: mem time3, current time 149, horizon 146\n", + "adding: mem time4, current time 149, horizon 145\n", + "adding: mem time5, current time 149, horizon 144\n", + "adding: mem time6, current time 149, horizon 143\n", + "adding: mem time7, current time 149, horizon 142\n", + "adding: mem time8, current time 149, horizon 141\n", + "adding: mem time9, current time 149, horizon 140\n", + "adding: mem time10, current time 149, horizon 139\n", + "adding: mem time11, current time 149, horizon 138\n", + "adding: mem time12, current time 149, horizon 137\n", + "adding: mem time13, current time 149, horizon 136\n", + "adding: mem time14, current time 149, horizon 135\n", + "adding: mem time15, current time 149, horizon 134\n", + "adding: mem time16, current time 149, horizon 133\n", + "adding: mem time17, current time 149, horizon 132\n", + "adding: mem time18, current time 149, horizon 131\n", + "adding: mem time19, current time 149, horizon 130\n", + "adding: mem time20, current time 149, horizon 129\n", + "adding: mem time21, current time 149, horizon 128\n", + "adding: mem time22, current time 149, horizon 127\n", + "adding: mem time23, current time 149, horizon 126\n", + "adding: mem time24, current time 149, horizon 125\n", + "adding: mem time25, current time 149, horizon 124\n", + "adding: mem time26, current time 149, horizon 123\n", + "adding: mem time27, current time 149, horizon 122\n", + "adding: mem time28, current time 149, horizon 121\n", + "adding: mem time29, current time 149, horizon 120\n", + "adding: mem time30, current time 149, horizon 119\n", + "adding: mem time31, current time 149, horizon 118\n", + "adding: mem time32, current time 149, horizon 117\n", + "adding: mem time33, current time 149, horizon 116\n", + "adding: mem time34, current time 149, horizon 115\n", + "adding: mem time35, current time 149, horizon 114\n", + "adding: mem time36, current time 149, horizon 113\n", + "adding: mem time37, current time 149, horizon 112\n", + "adding: mem time38, current time 149, horizon 111\n", + "adding: mem time39, current time 149, horizon 110\n", + "adding: mem time40, current time 149, horizon 109\n", + "adding: mem time41, current time 149, horizon 108\n", + "adding: mem time42, current time 149, horizon 107\n", + "adding: mem time43, current time 149, horizon 106\n", + "adding: mem time44, current time 149, horizon 105\n", + "adding: mem time45, current time 149, horizon 104\n", + "adding: mem time46, current time 149, horizon 103\n", + "adding: mem time47, current time 149, horizon 102\n", + "adding: mem time48, current time 149, horizon 101\n", + "adding: mem time49, current time 149, horizon 100\n", + "adding: mem time50, current time 149, horizon 99\n", + "adding: mem time51, current time 149, horizon 98\n", + "adding: mem time52, current time 149, horizon 97\n", + "adding: mem time53, current time 149, horizon 96\n", + "adding: mem time54, current time 149, horizon 95\n", + "adding: mem time55, current time 149, horizon 94\n", + "adding: mem time56, current time 149, horizon 93\n", + "adding: mem time57, current time 149, horizon 92\n", + "adding: mem time58, current time 149, horizon 91\n", + "adding: mem time59, current time 149, horizon 90\n", + "adding: mem time60, current time 149, horizon 89\n", + "adding: mem time61, current time 149, horizon 88\n", + "adding: mem time62, current time 149, horizon 87\n", + "adding: mem time63, current time 149, horizon 86\n", + "adding: mem time64, current time 149, horizon 85\n", + "adding: mem time65, current time 149, horizon 84\n", + "adding: mem time66, current time 149, horizon 83\n", + "adding: mem time67, current time 149, horizon 82\n", + "adding: mem time68, current time 149, horizon 81\n", + "adding: mem time69, current time 149, horizon 80\n", + "adding: mem time70, current time 149, horizon 79\n", + "adding: mem time71, current time 149, horizon 78\n", + "adding: mem time72, current time 149, horizon 77\n", + "adding: mem time73, current time 149, horizon 76\n", + "adding: mem time74, current time 149, horizon 75\n", + "adding: mem time75, current time 149, horizon 74\n", + "adding: mem time76, current time 149, horizon 73\n", + "adding: mem time77, current time 149, horizon 72\n", + "adding: mem time78, current time 149, horizon 71\n", + "adding: mem time79, current time 149, horizon 70\n", + "adding: mem time80, current time 149, horizon 69\n", + "adding: mem time81, current time 149, horizon 68\n", + "adding: mem time82, current time 149, horizon 67\n", + "adding: mem time83, current time 149, horizon 66\n", + "adding: mem time84, current time 149, horizon 65\n", + "adding: mem time85, current time 149, horizon 64\n", + "adding: mem time86, current time 149, horizon 63\n", + "adding: mem time87, current time 149, horizon 62\n", + "adding: mem time88, current time 149, horizon 61\n", + "adding: mem time89, current time 149, horizon 60\n", + "adding: mem time90, current time 149, horizon 59\n", + "adding: mem time91, current time 149, horizon 58\n", + "adding: mem time92, current time 149, horizon 57\n", + "adding: mem time93, current time 149, horizon 56\n", + "adding: mem time94, current time 149, horizon 55\n", + "adding: mem time95, current time 149, horizon 54\n", + "adding: mem time96, current time 149, horizon 53\n", + "adding: mem time97, current time 149, horizon 52\n", + "adding: mem time98, current time 149, horizon 51\n", + "adding: mem time99, current time 149, horizon 50\n", + "adding: mem time100, current time 149, horizon 49\n", + "adding: mem time101, current time 149, horizon 48\n", + "adding: mem time102, current time 149, horizon 47\n", + "adding: mem time103, current time 149, horizon 46\n", + "adding: mem time104, current time 149, horizon 45\n", + "adding: mem time105, current time 149, horizon 44\n", + "adding: mem time106, current time 149, horizon 43\n", + "adding: mem time107, current time 149, horizon 42\n", + "adding: mem time108, current time 149, horizon 41\n", + "adding: mem time109, current time 149, horizon 40\n", + "adding: mem time110, current time 149, horizon 39\n", + "adding: mem time111, current time 149, horizon 38\n", + "adding: mem time112, current time 149, horizon 37\n", + "adding: mem time113, current time 149, horizon 36\n", + "adding: mem time114, current time 149, horizon 35\n", + "adding: mem time115, current time 149, horizon 34\n", + "adding: mem time116, current time 149, horizon 33\n", + "adding: mem time117, current time 149, horizon 32\n", + "adding: mem time118, current time 149, horizon 31\n", + "adding: mem time119, current time 149, horizon 30\n", + "adding: mem time120, current time 149, horizon 29\n", + "adding: mem time121, current time 149, horizon 28\n", + "adding: mem time122, current time 149, horizon 27\n", + "adding: mem time123, current time 149, horizon 26\n", + "adding: mem time124, current time 149, horizon 25\n", + "adding: mem time125, current time 149, horizon 24\n", + "adding: mem time126, current time 149, horizon 23\n", + "adding: mem time127, current time 149, horizon 22\n", + "adding: mem time128, current time 149, horizon 21\n", + "adding: mem time129, current time 149, horizon 20\n", + "adding: mem time130, current time 149, horizon 19\n", + "adding: mem time131, current time 149, horizon 18\n", + "adding: mem time132, current time 149, horizon 17\n", + "adding: mem time133, current time 149, horizon 16\n", + "adding: mem time134, current time 149, horizon 15\n", + "adding: mem time135, current time 149, horizon 14\n", + "adding: mem time136, current time 149, horizon 13\n", + "adding: mem time137, current time 149, horizon 12\n", + "adding: mem time138, current time 149, horizon 11\n", + "adding: mem time139, current time 149, horizon 10\n", + "adding: mem time140, current time 149, horizon 9\n", + "adding: mem time141, current time 149, horizon 8\n", + "adding: mem time142, current time 149, horizon 7\n", + "adding: mem time143, current time 149, horizon 6\n", + "adding: mem time144, current time 149, horizon 5\n", + "adding: mem time145, current time 149, horizon 4\n", + "adding: mem time146, current time 149, horizon 3\n", + "adding: mem time147, current time 149, horizon 2\n", + "adding: mem time148, current time 149, horizon 1\n", + "adding: mem time0, current time 150, horizon 150\n", + "adding: mem time1, current time 150, horizon 149\n", + "adding: mem time2, current time 150, horizon 148\n", + "adding: mem time3, current time 150, horizon 147\n", + "adding: mem time4, current time 150, horizon 146\n", + "adding: mem time5, current time 150, horizon 145\n", + "adding: mem time6, current time 150, horizon 144\n", + "adding: mem time7, current time 150, horizon 143\n", + "adding: mem time8, current time 150, horizon 142\n", + "adding: mem time9, current time 150, horizon 141\n", + "adding: mem time10, current time 150, horizon 140\n", + "adding: mem time11, current time 150, horizon 139\n", + "adding: mem time12, current time 150, horizon 138\n", + "adding: mem time13, current time 150, horizon 137\n", + "adding: mem time14, current time 150, horizon 136\n", + "adding: mem time15, current time 150, horizon 135\n", + "adding: mem time16, current time 150, horizon 134\n", + "adding: mem time17, current time 150, horizon 133\n", + "adding: mem time18, current time 150, horizon 132\n", + "adding: mem time19, current time 150, horizon 131\n", + "adding: mem time20, current time 150, horizon 130\n", + "adding: mem time21, current time 150, horizon 129\n", + "adding: mem time22, current time 150, horizon 128\n", + "adding: mem time23, current time 150, horizon 127\n", + "adding: mem time24, current time 150, horizon 126\n", + "adding: mem time25, current time 150, horizon 125\n", + "adding: mem time26, current time 150, horizon 124\n", + "adding: mem time27, current time 150, horizon 123\n", + "adding: mem time28, current time 150, horizon 122\n", + "adding: mem time29, current time 150, horizon 121\n", + "adding: mem time30, current time 150, horizon 120\n", + "adding: mem time31, current time 150, horizon 119\n", + "adding: mem time32, current time 150, horizon 118\n", + "adding: mem time33, current time 150, horizon 117\n", + "adding: mem time34, current time 150, horizon 116\n", + "adding: mem time35, current time 150, horizon 115\n", + "adding: mem time36, current time 150, horizon 114\n", + "adding: mem time37, current time 150, horizon 113\n", + "adding: mem time38, current time 150, horizon 112\n", + "adding: mem time39, current time 150, horizon 111\n", + "adding: mem time40, current time 150, horizon 110\n", + "adding: mem time41, current time 150, horizon 109\n", + "adding: mem time42, current time 150, horizon 108\n", + "adding: mem time43, current time 150, horizon 107\n", + "adding: mem time44, current time 150, horizon 106\n", + "adding: mem time45, current time 150, horizon 105\n", + "adding: mem time46, current time 150, horizon 104\n", + "adding: mem time47, current time 150, horizon 103\n", + "adding: mem time48, current time 150, horizon 102\n", + "adding: mem time49, current time 150, horizon 101\n", + "adding: mem time50, current time 150, horizon 100\n", + "adding: mem time51, current time 150, horizon 99\n", + "adding: mem time52, current time 150, horizon 98\n", + "adding: mem time53, current time 150, horizon 97\n", + "adding: mem time54, current time 150, horizon 96\n", + "adding: mem time55, current time 150, horizon 95\n", + "adding: mem time56, current time 150, horizon 94\n", + "adding: mem time57, current time 150, horizon 93\n", + "adding: mem time58, current time 150, horizon 92\n", + "adding: mem time59, current time 150, horizon 91\n", + "adding: mem time60, current time 150, horizon 90\n", + "adding: mem time61, current time 150, horizon 89\n", + "adding: mem time62, current time 150, horizon 88\n", + "adding: mem time63, current time 150, horizon 87\n", + "adding: mem time64, current time 150, horizon 86\n", + "adding: mem time65, current time 150, horizon 85\n", + "adding: mem time66, current time 150, horizon 84\n", + "adding: mem time67, current time 150, horizon 83\n", + "adding: mem time68, current time 150, horizon 82\n", + "adding: mem time69, current time 150, horizon 81\n", + "adding: mem time70, current time 150, horizon 80\n", + "adding: mem time71, current time 150, horizon 79\n", + "adding: mem time72, current time 150, horizon 78\n", + "adding: mem time73, current time 150, horizon 77\n", + "adding: mem time74, current time 150, horizon 76\n", + "adding: mem time75, current time 150, horizon 75\n", + "adding: mem time76, current time 150, horizon 74\n", + "adding: mem time77, current time 150, horizon 73\n", + "adding: mem time78, current time 150, horizon 72\n", + "adding: mem time79, current time 150, horizon 71\n", + "adding: mem time80, current time 150, horizon 70\n", + "adding: mem time81, current time 150, horizon 69\n", + "adding: mem time82, current time 150, horizon 68\n", + "adding: mem time83, current time 150, horizon 67\n", + "adding: mem time84, current time 150, horizon 66\n", + "adding: mem time85, current time 150, horizon 65\n", + "adding: mem time86, current time 150, horizon 64\n", + "adding: mem time87, current time 150, horizon 63\n", + "adding: mem time88, current time 150, horizon 62\n", + "adding: mem time89, current time 150, horizon 61\n", + "adding: mem time90, current time 150, horizon 60\n", + "adding: mem time91, current time 150, horizon 59\n", + "adding: mem time92, current time 150, horizon 58\n", + "adding: mem time93, current time 150, horizon 57\n", + "adding: mem time94, current time 150, horizon 56\n", + "adding: mem time95, current time 150, horizon 55\n", + "adding: mem time96, current time 150, horizon 54\n", + "adding: mem time97, current time 150, horizon 53\n", + "adding: mem time98, current time 150, horizon 52\n", + "adding: mem time99, current time 150, horizon 51\n", + "adding: mem time100, current time 150, horizon 50\n", + "adding: mem time101, current time 150, horizon 49\n", + "adding: mem time102, current time 150, horizon 48\n", + "adding: mem time103, current time 150, horizon 47\n", + "adding: mem time104, current time 150, horizon 46\n", + "adding: mem time105, current time 150, horizon 45\n", + "adding: mem time106, current time 150, horizon 44\n", + "adding: mem time107, current time 150, horizon 43\n", + "adding: mem time108, current time 150, horizon 42\n", + "adding: mem time109, current time 150, horizon 41\n", + "adding: mem time110, current time 150, horizon 40\n", + "adding: mem time111, current time 150, horizon 39\n", + "adding: mem time112, current time 150, horizon 38\n", + "adding: mem time113, current time 150, horizon 37\n", + "adding: mem time114, current time 150, horizon 36\n", + "adding: mem time115, current time 150, horizon 35\n", + "adding: mem time116, current time 150, horizon 34\n", + "adding: mem time117, current time 150, horizon 33\n", + "adding: mem time118, current time 150, horizon 32\n", + "adding: mem time119, current time 150, horizon 31\n", + "adding: mem time120, current time 150, horizon 30\n", + "adding: mem time121, current time 150, horizon 29\n", + "adding: mem time122, current time 150, horizon 28\n", + "adding: mem time123, current time 150, horizon 27\n", + "adding: mem time124, current time 150, horizon 26\n", + "adding: mem time125, current time 150, horizon 25\n", + "adding: mem time126, current time 150, horizon 24\n", + "adding: mem time127, current time 150, horizon 23\n", + "adding: mem time128, current time 150, horizon 22\n", + "adding: mem time129, current time 150, horizon 21\n", + "adding: mem time130, current time 150, horizon 20\n", + "adding: mem time131, current time 150, horizon 19\n", + "adding: mem time132, current time 150, horizon 18\n", + "adding: mem time133, current time 150, horizon 17\n", + "adding: mem time134, current time 150, horizon 16\n", + "adding: mem time135, current time 150, horizon 15\n", + "adding: mem time136, current time 150, horizon 14\n", + "adding: mem time137, current time 150, horizon 13\n", + "adding: mem time138, current time 150, horizon 12\n", + "adding: mem time139, current time 150, horizon 11\n", + "adding: mem time140, current time 150, horizon 10\n", + "adding: mem time141, current time 150, horizon 9\n", + "adding: mem time142, current time 150, horizon 8\n", + "adding: mem time143, current time 150, horizon 7\n", + "adding: mem time144, current time 150, horizon 6\n", + "adding: mem time145, current time 150, horizon 5\n", + "adding: mem time146, current time 150, horizon 4\n", + "adding: mem time147, current time 150, horizon 3\n", + "adding: mem time148, current time 150, horizon 2\n", + "adding: mem time149, current time 150, horizon 1\n", + "adding: mem time0, current time 151, horizon 151\n", + "adding: mem time1, current time 151, horizon 150\n", + "adding: mem time2, current time 151, horizon 149\n", + "adding: mem time3, current time 151, horizon 148\n", + "adding: mem time4, current time 151, horizon 147\n", + "adding: mem time5, current time 151, horizon 146\n", + "adding: mem time6, current time 151, horizon 145\n", + "adding: mem time7, current time 151, horizon 144\n", + "adding: mem time8, current time 151, horizon 143\n", + "adding: mem time9, current time 151, horizon 142\n", + "adding: mem time10, current time 151, horizon 141\n", + "adding: mem time11, current time 151, horizon 140\n", + "adding: mem time12, current time 151, horizon 139\n", + "adding: mem time13, current time 151, horizon 138\n", + "adding: mem time14, current time 151, horizon 137\n", + "adding: mem time15, current time 151, horizon 136\n", + "adding: mem time16, current time 151, horizon 135\n", + "adding: mem time17, current time 151, horizon 134\n", + "adding: mem time18, current time 151, horizon 133\n", + "adding: mem time19, current time 151, horizon 132\n", + "adding: mem time20, current time 151, horizon 131\n", + "adding: mem time21, current time 151, horizon 130\n", + "adding: mem time22, current time 151, horizon 129\n", + "adding: mem time23, current time 151, horizon 128\n", + "adding: mem time24, current time 151, horizon 127\n", + "adding: mem time25, current time 151, horizon 126\n", + "adding: mem time26, current time 151, horizon 125\n", + "adding: mem time27, current time 151, horizon 124\n", + "adding: mem time28, current time 151, horizon 123\n", + "adding: mem time29, current time 151, horizon 122\n", + "adding: mem time30, current time 151, horizon 121\n", + "adding: mem time31, current time 151, horizon 120\n", + "adding: mem time32, current time 151, horizon 119\n", + "adding: mem time33, current time 151, horizon 118\n", + "adding: mem time34, current time 151, horizon 117\n", + "adding: mem time35, current time 151, horizon 116\n", + "adding: mem time36, current time 151, horizon 115\n", + "adding: mem time37, current time 151, horizon 114\n", + "adding: mem time38, current time 151, horizon 113\n", + "adding: mem time39, current time 151, horizon 112\n", + "adding: mem time40, current time 151, horizon 111\n", + "adding: mem time41, current time 151, horizon 110\n", + "adding: mem time42, current time 151, horizon 109\n", + "adding: mem time43, current time 151, horizon 108\n", + "adding: mem time44, current time 151, horizon 107\n", + "adding: mem time45, current time 151, horizon 106\n", + "adding: mem time46, current time 151, horizon 105\n", + "adding: mem time47, current time 151, horizon 104\n", + "adding: mem time48, current time 151, horizon 103\n", + "adding: mem time49, current time 151, horizon 102\n", + "adding: mem time50, current time 151, horizon 101\n", + "adding: mem time51, current time 151, horizon 100\n", + "adding: mem time52, current time 151, horizon 99\n", + "adding: mem time53, current time 151, horizon 98\n", + "adding: mem time54, current time 151, horizon 97\n", + "adding: mem time55, current time 151, horizon 96\n", + "adding: mem time56, current time 151, horizon 95\n", + "adding: mem time57, current time 151, horizon 94\n", + "adding: mem time58, current time 151, horizon 93\n", + "adding: mem time59, current time 151, horizon 92\n", + "adding: mem time60, current time 151, horizon 91\n", + "adding: mem time61, current time 151, horizon 90\n", + "adding: mem time62, current time 151, horizon 89\n", + "adding: mem time63, current time 151, horizon 88\n", + "adding: mem time64, current time 151, horizon 87\n", + "adding: mem time65, current time 151, horizon 86\n", + "adding: mem time66, current time 151, horizon 85\n", + "adding: mem time67, current time 151, horizon 84\n", + "adding: mem time68, current time 151, horizon 83\n", + "adding: mem time69, current time 151, horizon 82\n", + "adding: mem time70, current time 151, horizon 81\n", + "adding: mem time71, current time 151, horizon 80\n", + "adding: mem time72, current time 151, horizon 79\n", + "adding: mem time73, current time 151, horizon 78\n", + "adding: mem time74, current time 151, horizon 77\n", + "adding: mem time75, current time 151, horizon 76\n", + "adding: mem time76, current time 151, horizon 75\n", + "adding: mem time77, current time 151, horizon 74\n", + "adding: mem time78, current time 151, horizon 73\n", + "adding: mem time79, current time 151, horizon 72\n", + "adding: mem time80, current time 151, horizon 71\n", + "adding: mem time81, current time 151, horizon 70\n", + "adding: mem time82, current time 151, horizon 69\n", + "adding: mem time83, current time 151, horizon 68\n", + "adding: mem time84, current time 151, horizon 67\n", + "adding: mem time85, current time 151, horizon 66\n", + "adding: mem time86, current time 151, horizon 65\n", + "adding: mem time87, current time 151, horizon 64\n", + "adding: mem time88, current time 151, horizon 63\n", + "adding: mem time89, current time 151, horizon 62\n", + "adding: mem time90, current time 151, horizon 61\n", + "adding: mem time91, current time 151, horizon 60\n", + "adding: mem time92, current time 151, horizon 59\n", + "adding: mem time93, current time 151, horizon 58\n", + "adding: mem time94, current time 151, horizon 57\n", + "adding: mem time95, current time 151, horizon 56\n", + "adding: mem time96, current time 151, horizon 55\n", + "adding: mem time97, current time 151, horizon 54\n", + "adding: mem time98, current time 151, horizon 53\n", + "adding: mem time99, current time 151, horizon 52\n", + "adding: mem time100, current time 151, horizon 51\n", + "adding: mem time101, current time 151, horizon 50\n", + "adding: mem time102, current time 151, horizon 49\n", + "adding: mem time103, current time 151, horizon 48\n", + "adding: mem time104, current time 151, horizon 47\n", + "adding: mem time105, current time 151, horizon 46\n", + "adding: mem time106, current time 151, horizon 45\n", + "adding: mem time107, current time 151, horizon 44\n", + "adding: mem time108, current time 151, horizon 43\n", + "adding: mem time109, current time 151, horizon 42\n", + "adding: mem time110, current time 151, horizon 41\n", + "adding: mem time111, current time 151, horizon 40\n", + "adding: mem time112, current time 151, horizon 39\n", + "adding: mem time113, current time 151, horizon 38\n", + "adding: mem time114, current time 151, horizon 37\n", + "adding: mem time115, current time 151, horizon 36\n", + "adding: mem time116, current time 151, horizon 35\n", + "adding: mem time117, current time 151, horizon 34\n", + "adding: mem time118, current time 151, horizon 33\n", + "adding: mem time119, current time 151, horizon 32\n", + "adding: mem time120, current time 151, horizon 31\n", + "adding: mem time121, current time 151, horizon 30\n", + "adding: mem time122, current time 151, horizon 29\n", + "adding: mem time123, current time 151, horizon 28\n", + "adding: mem time124, current time 151, horizon 27\n", + "adding: mem time125, current time 151, horizon 26\n", + "adding: mem time126, current time 151, horizon 25\n", + "adding: mem time127, current time 151, horizon 24\n", + "adding: mem time128, current time 151, horizon 23\n", + "adding: mem time129, current time 151, horizon 22\n", + "adding: mem time130, current time 151, horizon 21\n", + "adding: mem time131, current time 151, horizon 20\n", + "adding: mem time132, current time 151, horizon 19\n", + "adding: mem time133, current time 151, horizon 18\n", + "adding: mem time134, current time 151, horizon 17\n", + "adding: mem time135, current time 151, horizon 16\n", + "adding: mem time136, current time 151, horizon 15\n", + "adding: mem time137, current time 151, horizon 14\n", + "adding: mem time138, current time 151, horizon 13\n", + "adding: mem time139, current time 151, horizon 12\n", + "adding: mem time140, current time 151, horizon 11\n", + "adding: mem time141, current time 151, horizon 10\n", + "adding: mem time142, current time 151, horizon 9\n", + "adding: mem time143, current time 151, horizon 8\n", + "adding: mem time144, current time 151, horizon 7\n", + "adding: mem time145, current time 151, horizon 6\n", + "adding: mem time146, current time 151, horizon 5\n", + "adding: mem time147, current time 151, horizon 4\n", + "adding: mem time148, current time 151, horizon 3\n", + "adding: mem time149, current time 151, horizon 2\n", + "adding: mem time150, current time 151, horizon 1\n", + "adding: mem time0, current time 152, horizon 152\n", + "adding: mem time1, current time 152, horizon 151\n", + "adding: mem time2, current time 152, horizon 150\n", + "adding: mem time3, current time 152, horizon 149\n", + "adding: mem time4, current time 152, horizon 148\n", + "adding: mem time5, current time 152, horizon 147\n", + "adding: mem time6, current time 152, horizon 146\n", + "adding: mem time7, current time 152, horizon 145\n", + "adding: mem time8, current time 152, horizon 144\n", + "adding: mem time9, current time 152, horizon 143\n", + "adding: mem time10, current time 152, horizon 142\n", + "adding: mem time11, current time 152, horizon 141\n", + "adding: mem time12, current time 152, horizon 140\n", + "adding: mem time13, current time 152, horizon 139\n", + "adding: mem time14, current time 152, horizon 138\n", + "adding: mem time15, current time 152, horizon 137\n", + "adding: mem time16, current time 152, horizon 136\n", + "adding: mem time17, current time 152, horizon 135\n", + "adding: mem time18, current time 152, horizon 134\n", + "adding: mem time19, current time 152, horizon 133\n", + "adding: mem time20, current time 152, horizon 132\n", + "adding: mem time21, current time 152, horizon 131\n", + "adding: mem time22, current time 152, horizon 130\n", + "adding: mem time23, current time 152, horizon 129\n", + "adding: mem time24, current time 152, horizon 128\n", + "adding: mem time25, current time 152, horizon 127\n", + "adding: mem time26, current time 152, horizon 126\n", + "adding: mem time27, current time 152, horizon 125\n", + "adding: mem time28, current time 152, horizon 124\n", + "adding: mem time29, current time 152, horizon 123\n", + "adding: mem time30, current time 152, horizon 122\n", + "adding: mem time31, current time 152, horizon 121\n", + "adding: mem time32, current time 152, horizon 120\n", + "adding: mem time33, current time 152, horizon 119\n", + "adding: mem time34, current time 152, horizon 118\n", + "adding: mem time35, current time 152, horizon 117\n", + "adding: mem time36, current time 152, horizon 116\n", + "adding: mem time37, current time 152, horizon 115\n", + "adding: mem time38, current time 152, horizon 114\n", + "adding: mem time39, current time 152, horizon 113\n", + "adding: mem time40, current time 152, horizon 112\n", + "adding: mem time41, current time 152, horizon 111\n", + "adding: mem time42, current time 152, horizon 110\n", + "adding: mem time43, current time 152, horizon 109\n", + "adding: mem time44, current time 152, horizon 108\n", + "adding: mem time45, current time 152, horizon 107\n", + "adding: mem time46, current time 152, horizon 106\n", + "adding: mem time47, current time 152, horizon 105\n", + "adding: mem time48, current time 152, horizon 104\n", + "adding: mem time49, current time 152, horizon 103\n", + "adding: mem time50, current time 152, horizon 102\n", + "adding: mem time51, current time 152, horizon 101\n", + "adding: mem time52, current time 152, horizon 100\n", + "adding: mem time53, current time 152, horizon 99\n", + "adding: mem time54, current time 152, horizon 98\n", + "adding: mem time55, current time 152, horizon 97\n", + "adding: mem time56, current time 152, horizon 96\n", + "adding: mem time57, current time 152, horizon 95\n", + "adding: mem time58, current time 152, horizon 94\n", + "adding: mem time59, current time 152, horizon 93\n", + "adding: mem time60, current time 152, horizon 92\n", + "adding: mem time61, current time 152, horizon 91\n", + "adding: mem time62, current time 152, horizon 90\n", + "adding: mem time63, current time 152, horizon 89\n", + "adding: mem time64, current time 152, horizon 88\n", + "adding: mem time65, current time 152, horizon 87\n", + "adding: mem time66, current time 152, horizon 86\n", + "adding: mem time67, current time 152, horizon 85\n", + "adding: mem time68, current time 152, horizon 84\n", + "adding: mem time69, current time 152, horizon 83\n", + "adding: mem time70, current time 152, horizon 82\n", + "adding: mem time71, current time 152, horizon 81\n", + "adding: mem time72, current time 152, horizon 80\n", + "adding: mem time73, current time 152, horizon 79\n", + "adding: mem time74, current time 152, horizon 78\n", + "adding: mem time75, current time 152, horizon 77\n", + "adding: mem time76, current time 152, horizon 76\n", + "adding: mem time77, current time 152, horizon 75\n", + "adding: mem time78, current time 152, horizon 74\n", + "adding: mem time79, current time 152, horizon 73\n", + "adding: mem time80, current time 152, horizon 72\n", + "adding: mem time81, current time 152, horizon 71\n", + "adding: mem time82, current time 152, horizon 70\n", + "adding: mem time83, current time 152, horizon 69\n", + "adding: mem time84, current time 152, horizon 68\n", + "adding: mem time85, current time 152, horizon 67\n", + "adding: mem time86, current time 152, horizon 66\n", + "adding: mem time87, current time 152, horizon 65\n", + "adding: mem time88, current time 152, horizon 64\n", + "adding: mem time89, current time 152, horizon 63\n", + "adding: mem time90, current time 152, horizon 62\n", + "adding: mem time91, current time 152, horizon 61\n", + "adding: mem time92, current time 152, horizon 60\n", + "adding: mem time93, current time 152, horizon 59\n", + "adding: mem time94, current time 152, horizon 58\n", + "adding: mem time95, current time 152, horizon 57\n", + "adding: mem time96, current time 152, horizon 56\n", + "adding: mem time97, current time 152, horizon 55\n", + "adding: mem time98, current time 152, horizon 54\n", + "adding: mem time99, current time 152, horizon 53\n", + "adding: mem time100, current time 152, horizon 52\n", + "adding: mem time101, current time 152, horizon 51\n", + "adding: mem time102, current time 152, horizon 50\n", + "adding: mem time103, current time 152, horizon 49\n", + "adding: mem time104, current time 152, horizon 48\n", + "adding: mem time105, current time 152, horizon 47\n", + "adding: mem time106, current time 152, horizon 46\n", + "adding: mem time107, current time 152, horizon 45\n", + "adding: mem time108, current time 152, horizon 44\n", + "adding: mem time109, current time 152, horizon 43\n", + "adding: mem time110, current time 152, horizon 42\n", + "adding: mem time111, current time 152, horizon 41\n", + "adding: mem time112, current time 152, horizon 40\n", + "adding: mem time113, current time 152, horizon 39\n", + "adding: mem time114, current time 152, horizon 38\n", + "adding: mem time115, current time 152, horizon 37\n", + "adding: mem time116, current time 152, horizon 36\n", + "adding: mem time117, current time 152, horizon 35\n", + "adding: mem time118, current time 152, horizon 34\n", + "adding: mem time119, current time 152, horizon 33\n", + "adding: mem time120, current time 152, horizon 32\n", + "adding: mem time121, current time 152, horizon 31\n", + "adding: mem time122, current time 152, horizon 30\n", + "adding: mem time123, current time 152, horizon 29\n", + "adding: mem time124, current time 152, horizon 28\n", + "adding: mem time125, current time 152, horizon 27\n", + "adding: mem time126, current time 152, horizon 26\n", + "adding: mem time127, current time 152, horizon 25\n", + "adding: mem time128, current time 152, horizon 24\n", + "adding: mem time129, current time 152, horizon 23\n", + "adding: mem time130, current time 152, horizon 22\n", + "adding: mem time131, current time 152, horizon 21\n", + "adding: mem time132, current time 152, horizon 20\n", + "adding: mem time133, current time 152, horizon 19\n", + "adding: mem time134, current time 152, horizon 18\n", + "adding: mem time135, current time 152, horizon 17\n", + "adding: mem time136, current time 152, horizon 16\n", + "adding: mem time137, current time 152, horizon 15\n", + "adding: mem time138, current time 152, horizon 14\n", + "adding: mem time139, current time 152, horizon 13\n", + "adding: mem time140, current time 152, horizon 12\n", + "adding: mem time141, current time 152, horizon 11\n", + "adding: mem time142, current time 152, horizon 10\n", + "adding: mem time143, current time 152, horizon 9\n", + "adding: mem time144, current time 152, horizon 8\n", + "adding: mem time145, current time 152, horizon 7\n", + "adding: mem time146, current time 152, horizon 6\n", + "adding: mem time147, current time 152, horizon 5\n", + "adding: mem time148, current time 152, horizon 4\n", + "adding: mem time149, current time 152, horizon 3\n", + "adding: mem time150, current time 152, horizon 2\n", + "adding: mem time151, current time 152, horizon 1\n", + "adding: mem time0, current time 153, horizon 153\n", + "adding: mem time1, current time 153, horizon 152\n", + "adding: mem time2, current time 153, horizon 151\n", + "adding: mem time3, current time 153, horizon 150\n", + "adding: mem time4, current time 153, horizon 149\n", + "adding: mem time5, current time 153, horizon 148\n", + "adding: mem time6, current time 153, horizon 147\n", + "adding: mem time7, current time 153, horizon 146\n", + "adding: mem time8, current time 153, horizon 145\n", + "adding: mem time9, current time 153, horizon 144\n", + "adding: mem time10, current time 153, horizon 143\n", + "adding: mem time11, current time 153, horizon 142\n", + "adding: mem time12, current time 153, horizon 141\n", + "adding: mem time13, current time 153, horizon 140\n", + "adding: mem time14, current time 153, horizon 139\n", + "adding: mem time15, current time 153, horizon 138\n", + "adding: mem time16, current time 153, horizon 137\n", + "adding: mem time17, current time 153, horizon 136\n", + "adding: mem time18, current time 153, horizon 135\n", + "adding: mem time19, current time 153, horizon 134\n", + "adding: mem time20, current time 153, horizon 133\n", + "adding: mem time21, current time 153, horizon 132\n", + "adding: mem time22, current time 153, horizon 131\n", + "adding: mem time23, current time 153, horizon 130\n", + "adding: mem time24, current time 153, horizon 129\n", + "adding: mem time25, current time 153, horizon 128\n", + "adding: mem time26, current time 153, horizon 127\n", + "adding: mem time27, current time 153, horizon 126\n", + "adding: mem time28, current time 153, horizon 125\n", + "adding: mem time29, current time 153, horizon 124\n", + "adding: mem time30, current time 153, horizon 123\n", + "adding: mem time31, current time 153, horizon 122\n", + "adding: mem time32, current time 153, horizon 121\n", + "adding: mem time33, current time 153, horizon 120\n", + "adding: mem time34, current time 153, horizon 119\n", + "adding: mem time35, current time 153, horizon 118\n", + "adding: mem time36, current time 153, horizon 117\n", + "adding: mem time37, current time 153, horizon 116\n", + "adding: mem time38, current time 153, horizon 115\n", + "adding: mem time39, current time 153, horizon 114\n", + "adding: mem time40, current time 153, horizon 113\n", + "adding: mem time41, current time 153, horizon 112\n", + "adding: mem time42, current time 153, horizon 111\n", + "adding: mem time43, current time 153, horizon 110\n", + "adding: mem time44, current time 153, horizon 109\n", + "adding: mem time45, current time 153, horizon 108\n", + "adding: mem time46, current time 153, horizon 107\n", + "adding: mem time47, current time 153, horizon 106\n", + "adding: mem time48, current time 153, horizon 105\n", + "adding: mem time49, current time 153, horizon 104\n", + "adding: mem time50, current time 153, horizon 103\n", + "adding: mem time51, current time 153, horizon 102\n", + "adding: mem time52, current time 153, horizon 101\n", + "adding: mem time53, current time 153, horizon 100\n", + "adding: mem time54, current time 153, horizon 99\n", + "adding: mem time55, current time 153, horizon 98\n", + "adding: mem time56, current time 153, horizon 97\n", + "adding: mem time57, current time 153, horizon 96\n", + "adding: mem time58, current time 153, horizon 95\n", + "adding: mem time59, current time 153, horizon 94\n", + "adding: mem time60, current time 153, horizon 93\n", + "adding: mem time61, current time 153, horizon 92\n", + "adding: mem time62, current time 153, horizon 91\n", + "adding: mem time63, current time 153, horizon 90\n", + "adding: mem time64, current time 153, horizon 89\n", + "adding: mem time65, current time 153, horizon 88\n", + "adding: mem time66, current time 153, horizon 87\n", + "adding: mem time67, current time 153, horizon 86\n", + "adding: mem time68, current time 153, horizon 85\n", + "adding: mem time69, current time 153, horizon 84\n", + "adding: mem time70, current time 153, horizon 83\n", + "adding: mem time71, current time 153, horizon 82\n", + "adding: mem time72, current time 153, horizon 81\n", + "adding: mem time73, current time 153, horizon 80\n", + "adding: mem time74, current time 153, horizon 79\n", + "adding: mem time75, current time 153, horizon 78\n", + "adding: mem time76, current time 153, horizon 77\n", + "adding: mem time77, current time 153, horizon 76\n", + "adding: mem time78, current time 153, horizon 75\n", + "adding: mem time79, current time 153, horizon 74\n", + "adding: mem time80, current time 153, horizon 73\n", + "adding: mem time81, current time 153, horizon 72\n", + "adding: mem time82, current time 153, horizon 71\n", + "adding: mem time83, current time 153, horizon 70\n", + "adding: mem time84, current time 153, horizon 69\n", + "adding: mem time85, current time 153, horizon 68\n", + "adding: mem time86, current time 153, horizon 67\n", + "adding: mem time87, current time 153, horizon 66\n", + "adding: mem time88, current time 153, horizon 65\n", + "adding: mem time89, current time 153, horizon 64\n", + "adding: mem time90, current time 153, horizon 63\n", + "adding: mem time91, current time 153, horizon 62\n", + "adding: mem time92, current time 153, horizon 61\n", + "adding: mem time93, current time 153, horizon 60\n", + "adding: mem time94, current time 153, horizon 59\n", + "adding: mem time95, current time 153, horizon 58\n", + "adding: mem time96, current time 153, horizon 57\n", + "adding: mem time97, current time 153, horizon 56\n", + "adding: mem time98, current time 153, horizon 55\n", + "adding: mem time99, current time 153, horizon 54\n", + "adding: mem time100, current time 153, horizon 53\n", + "adding: mem time101, current time 153, horizon 52\n", + "adding: mem time102, current time 153, horizon 51\n", + "adding: mem time103, current time 153, horizon 50\n", + "adding: mem time104, current time 153, horizon 49\n", + "adding: mem time105, current time 153, horizon 48\n", + "adding: mem time106, current time 153, horizon 47\n", + "adding: mem time107, current time 153, horizon 46\n", + "adding: mem time108, current time 153, horizon 45\n", + "adding: mem time109, current time 153, horizon 44\n", + "adding: mem time110, current time 153, horizon 43\n", + "adding: mem time111, current time 153, horizon 42\n", + "adding: mem time112, current time 153, horizon 41\n", + "adding: mem time113, current time 153, horizon 40\n", + "adding: mem time114, current time 153, horizon 39\n", + "adding: mem time115, current time 153, horizon 38\n", + "adding: mem time116, current time 153, horizon 37\n", + "adding: mem time117, current time 153, horizon 36\n", + "adding: mem time118, current time 153, horizon 35\n", + "adding: mem time119, current time 153, horizon 34\n", + "adding: mem time120, current time 153, horizon 33\n", + "adding: mem time121, current time 153, horizon 32\n", + "adding: mem time122, current time 153, horizon 31\n", + "adding: mem time123, current time 153, horizon 30\n", + "adding: mem time124, current time 153, horizon 29\n", + "adding: mem time125, current time 153, horizon 28\n", + "adding: mem time126, current time 153, horizon 27\n", + "adding: mem time127, current time 153, horizon 26\n", + "adding: mem time128, current time 153, horizon 25\n", + "adding: mem time129, current time 153, horizon 24\n", + "adding: mem time130, current time 153, horizon 23\n", + "adding: mem time131, current time 153, horizon 22\n", + "adding: mem time132, current time 153, horizon 21\n", + "adding: mem time133, current time 153, horizon 20\n", + "adding: mem time134, current time 153, horizon 19\n", + "adding: mem time135, current time 153, horizon 18\n", + "adding: mem time136, current time 153, horizon 17\n", + "adding: mem time137, current time 153, horizon 16\n", + "adding: mem time138, current time 153, horizon 15\n", + "adding: mem time139, current time 153, horizon 14\n", + "adding: mem time140, current time 153, horizon 13\n", + "adding: mem time141, current time 153, horizon 12\n", + "adding: mem time142, current time 153, horizon 11\n", + "adding: mem time143, current time 153, horizon 10\n", + "adding: mem time144, current time 153, horizon 9\n", + "adding: mem time145, current time 153, horizon 8\n", + "adding: mem time146, current time 153, horizon 7\n", + "adding: mem time147, current time 153, horizon 6\n", + "adding: mem time148, current time 153, horizon 5\n", + "adding: mem time149, current time 153, horizon 4\n", + "adding: mem time150, current time 153, horizon 3\n", + "adding: mem time151, current time 153, horizon 2\n", + "adding: mem time152, current time 153, horizon 1\n", + "adding: mem time0, current time 154, horizon 154\n", + "adding: mem time1, current time 154, horizon 153\n", + "adding: mem time2, current time 154, horizon 152\n", + "adding: mem time3, current time 154, horizon 151\n", + "adding: mem time4, current time 154, horizon 150\n", + "adding: mem time5, current time 154, horizon 149\n", + "adding: mem time6, current time 154, horizon 148\n", + "adding: mem time7, current time 154, horizon 147\n", + "adding: mem time8, current time 154, horizon 146\n", + "adding: mem time9, current time 154, horizon 145\n", + "adding: mem time10, current time 154, horizon 144\n", + "adding: mem time11, current time 154, horizon 143\n", + "adding: mem time12, current time 154, horizon 142\n", + "adding: mem time13, current time 154, horizon 141\n", + "adding: mem time14, current time 154, horizon 140\n", + "adding: mem time15, current time 154, horizon 139\n", + "adding: mem time16, current time 154, horizon 138\n", + "adding: mem time17, current time 154, horizon 137\n", + "adding: mem time18, current time 154, horizon 136\n", + "adding: mem time19, current time 154, horizon 135\n", + "adding: mem time20, current time 154, horizon 134\n", + "adding: mem time21, current time 154, horizon 133\n", + "adding: mem time22, current time 154, horizon 132\n", + "adding: mem time23, current time 154, horizon 131\n", + "adding: mem time24, current time 154, horizon 130\n", + "adding: mem time25, current time 154, horizon 129\n", + "adding: mem time26, current time 154, horizon 128\n", + "adding: mem time27, current time 154, horizon 127\n", + "adding: mem time28, current time 154, horizon 126\n", + "adding: mem time29, current time 154, horizon 125\n", + "adding: mem time30, current time 154, horizon 124\n", + "adding: mem time31, current time 154, horizon 123\n", + "adding: mem time32, current time 154, horizon 122\n", + "adding: mem time33, current time 154, horizon 121\n", + "adding: mem time34, current time 154, horizon 120\n", + "adding: mem time35, current time 154, horizon 119\n", + "adding: mem time36, current time 154, horizon 118\n", + "adding: mem time37, current time 154, horizon 117\n", + "adding: mem time38, current time 154, horizon 116\n", + "adding: mem time39, current time 154, horizon 115\n", + "adding: mem time40, current time 154, horizon 114\n", + "adding: mem time41, current time 154, horizon 113\n", + "adding: mem time42, current time 154, horizon 112\n", + "adding: mem time43, current time 154, horizon 111\n", + "adding: mem time44, current time 154, horizon 110\n", + "adding: mem time45, current time 154, horizon 109\n", + "adding: mem time46, current time 154, horizon 108\n", + "adding: mem time47, current time 154, horizon 107\n", + "adding: mem time48, current time 154, horizon 106\n", + "adding: mem time49, current time 154, horizon 105\n", + "adding: mem time50, current time 154, horizon 104\n", + "adding: mem time51, current time 154, horizon 103\n", + "adding: mem time52, current time 154, horizon 102\n", + "adding: mem time53, current time 154, horizon 101\n", + "adding: mem time54, current time 154, horizon 100\n", + "adding: mem time55, current time 154, horizon 99\n", + "adding: mem time56, current time 154, horizon 98\n", + "adding: mem time57, current time 154, horizon 97\n", + "adding: mem time58, current time 154, horizon 96\n", + "adding: mem time59, current time 154, horizon 95\n", + "adding: mem time60, current time 154, horizon 94\n", + "adding: mem time61, current time 154, horizon 93\n", + "adding: mem time62, current time 154, horizon 92\n", + "adding: mem time63, current time 154, horizon 91\n", + "adding: mem time64, current time 154, horizon 90\n", + "adding: mem time65, current time 154, horizon 89\n", + "adding: mem time66, current time 154, horizon 88\n", + "adding: mem time67, current time 154, horizon 87\n", + "adding: mem time68, current time 154, horizon 86\n", + "adding: mem time69, current time 154, horizon 85\n", + "adding: mem time70, current time 154, horizon 84\n", + "adding: mem time71, current time 154, horizon 83\n", + "adding: mem time72, current time 154, horizon 82\n", + "adding: mem time73, current time 154, horizon 81\n", + "adding: mem time74, current time 154, horizon 80\n", + "adding: mem time75, current time 154, horizon 79\n", + "adding: mem time76, current time 154, horizon 78\n", + "adding: mem time77, current time 154, horizon 77\n", + "adding: mem time78, current time 154, horizon 76\n", + "adding: mem time79, current time 154, horizon 75\n", + "adding: mem time80, current time 154, horizon 74\n", + "adding: mem time81, current time 154, horizon 73\n", + "adding: mem time82, current time 154, horizon 72\n", + "adding: mem time83, current time 154, horizon 71\n", + "adding: mem time84, current time 154, horizon 70\n", + "adding: mem time85, current time 154, horizon 69\n", + "adding: mem time86, current time 154, horizon 68\n", + "adding: mem time87, current time 154, horizon 67\n", + "adding: mem time88, current time 154, horizon 66\n", + "adding: mem time89, current time 154, horizon 65\n", + "adding: mem time90, current time 154, horizon 64\n", + "adding: mem time91, current time 154, horizon 63\n", + "adding: mem time92, current time 154, horizon 62\n", + "adding: mem time93, current time 154, horizon 61\n", + "adding: mem time94, current time 154, horizon 60\n", + "adding: mem time95, current time 154, horizon 59\n", + "adding: mem time96, current time 154, horizon 58\n", + "adding: mem time97, current time 154, horizon 57\n", + "adding: mem time98, current time 154, horizon 56\n", + "adding: mem time99, current time 154, horizon 55\n", + "adding: mem time100, current time 154, horizon 54\n", + "adding: mem time101, current time 154, horizon 53\n", + "adding: mem time102, current time 154, horizon 52\n", + "adding: mem time103, current time 154, horizon 51\n", + "adding: mem time104, current time 154, horizon 50\n", + "adding: mem time105, current time 154, horizon 49\n", + "adding: mem time106, current time 154, horizon 48\n", + "adding: mem time107, current time 154, horizon 47\n", + "adding: mem time108, current time 154, horizon 46\n", + "adding: mem time109, current time 154, horizon 45\n", + "adding: mem time110, current time 154, horizon 44\n", + "adding: mem time111, current time 154, horizon 43\n", + "adding: mem time112, current time 154, horizon 42\n", + "adding: mem time113, current time 154, horizon 41\n", + "adding: mem time114, current time 154, horizon 40\n", + "adding: mem time115, current time 154, horizon 39\n", + "adding: mem time116, current time 154, horizon 38\n", + "adding: mem time117, current time 154, horizon 37\n", + "adding: mem time118, current time 154, horizon 36\n", + "adding: mem time119, current time 154, horizon 35\n", + "adding: mem time120, current time 154, horizon 34\n", + "adding: mem time121, current time 154, horizon 33\n", + "adding: mem time122, current time 154, horizon 32\n", + "adding: mem time123, current time 154, horizon 31\n", + "adding: mem time124, current time 154, horizon 30\n", + "adding: mem time125, current time 154, horizon 29\n", + "adding: mem time126, current time 154, horizon 28\n", + "adding: mem time127, current time 154, horizon 27\n", + "adding: mem time128, current time 154, horizon 26\n", + "adding: mem time129, current time 154, horizon 25\n", + "adding: mem time130, current time 154, horizon 24\n", + "adding: mem time131, current time 154, horizon 23\n", + "adding: mem time132, current time 154, horizon 22\n", + "adding: mem time133, current time 154, horizon 21\n", + "adding: mem time134, current time 154, horizon 20\n", + "adding: mem time135, current time 154, horizon 19\n", + "adding: mem time136, current time 154, horizon 18\n", + "adding: mem time137, current time 154, horizon 17\n", + "adding: mem time138, current time 154, horizon 16\n", + "adding: mem time139, current time 154, horizon 15\n", + "adding: mem time140, current time 154, horizon 14\n", + "adding: mem time141, current time 154, horizon 13\n", + "adding: mem time142, current time 154, horizon 12\n", + "adding: mem time143, current time 154, horizon 11\n", + "adding: mem time144, current time 154, horizon 10\n", + "adding: mem time145, current time 154, horizon 9\n", + "adding: mem time146, current time 154, horizon 8\n", + "adding: mem time147, current time 154, horizon 7\n", + "adding: mem time148, current time 154, horizon 6\n", + "adding: mem time149, current time 154, horizon 5\n", + "adding: mem time150, current time 154, horizon 4\n", + "adding: mem time151, current time 154, horizon 3\n", + "adding: mem time152, current time 154, horizon 2\n", + "adding: mem time153, current time 154, horizon 1\n", + "adding: mem time0, current time 155, horizon 155\n", + "adding: mem time1, current time 155, horizon 154\n", + "adding: mem time2, current time 155, horizon 153\n", + "adding: mem time3, current time 155, horizon 152\n", + "adding: mem time4, current time 155, horizon 151\n", + "adding: mem time5, current time 155, horizon 150\n", + "adding: mem time6, current time 155, horizon 149\n", + "adding: mem time7, current time 155, horizon 148\n", + "adding: mem time8, current time 155, horizon 147\n", + "adding: mem time9, current time 155, horizon 146\n", + "adding: mem time10, current time 155, horizon 145\n", + "adding: mem time11, current time 155, horizon 144\n", + "adding: mem time12, current time 155, horizon 143\n", + "adding: mem time13, current time 155, horizon 142\n", + "adding: mem time14, current time 155, horizon 141\n", + "adding: mem time15, current time 155, horizon 140\n", + "adding: mem time16, current time 155, horizon 139\n", + "adding: mem time17, current time 155, horizon 138\n", + "adding: mem time18, current time 155, horizon 137\n", + "adding: mem time19, current time 155, horizon 136\n", + "adding: mem time20, current time 155, horizon 135\n", + "adding: mem time21, current time 155, horizon 134\n", + "adding: mem time22, current time 155, horizon 133\n", + "adding: mem time23, current time 155, horizon 132\n", + "adding: mem time24, current time 155, horizon 131\n", + "adding: mem time25, current time 155, horizon 130\n", + "adding: mem time26, current time 155, horizon 129\n", + "adding: mem time27, current time 155, horizon 128\n", + "adding: mem time28, current time 155, horizon 127\n", + "adding: mem time29, current time 155, horizon 126\n", + "adding: mem time30, current time 155, horizon 125\n", + "adding: mem time31, current time 155, horizon 124\n", + "adding: mem time32, current time 155, horizon 123\n", + "adding: mem time33, current time 155, horizon 122\n", + "adding: mem time34, current time 155, horizon 121\n", + "adding: mem time35, current time 155, horizon 120\n", + "adding: mem time36, current time 155, horizon 119\n", + "adding: mem time37, current time 155, horizon 118\n", + "adding: mem time38, current time 155, horizon 117\n", + "adding: mem time39, current time 155, horizon 116\n", + "adding: mem time40, current time 155, horizon 115\n", + "adding: mem time41, current time 155, horizon 114\n", + "adding: mem time42, current time 155, horizon 113\n", + "adding: mem time43, current time 155, horizon 112\n", + "adding: mem time44, current time 155, horizon 111\n", + "adding: mem time45, current time 155, horizon 110\n", + "adding: mem time46, current time 155, horizon 109\n", + "adding: mem time47, current time 155, horizon 108\n", + "adding: mem time48, current time 155, horizon 107\n", + "adding: mem time49, current time 155, horizon 106\n", + "adding: mem time50, current time 155, horizon 105\n", + "adding: mem time51, current time 155, horizon 104\n", + "adding: mem time52, current time 155, horizon 103\n", + "adding: mem time53, current time 155, horizon 102\n", + "adding: mem time54, current time 155, horizon 101\n", + "adding: mem time55, current time 155, horizon 100\n", + "adding: mem time56, current time 155, horizon 99\n", + "adding: mem time57, current time 155, horizon 98\n", + "adding: mem time58, current time 155, horizon 97\n", + "adding: mem time59, current time 155, horizon 96\n", + "adding: mem time60, current time 155, horizon 95\n", + "adding: mem time61, current time 155, horizon 94\n", + "adding: mem time62, current time 155, horizon 93\n", + "adding: mem time63, current time 155, horizon 92\n", + "adding: mem time64, current time 155, horizon 91\n", + "adding: mem time65, current time 155, horizon 90\n", + "adding: mem time66, current time 155, horizon 89\n", + "adding: mem time67, current time 155, horizon 88\n", + "adding: mem time68, current time 155, horizon 87\n", + "adding: mem time69, current time 155, horizon 86\n", + "adding: mem time70, current time 155, horizon 85\n", + "adding: mem time71, current time 155, horizon 84\n", + "adding: mem time72, current time 155, horizon 83\n", + "adding: mem time73, current time 155, horizon 82\n", + "adding: mem time74, current time 155, horizon 81\n", + "adding: mem time75, current time 155, horizon 80\n", + "adding: mem time76, current time 155, horizon 79\n", + "adding: mem time77, current time 155, horizon 78\n", + "adding: mem time78, current time 155, horizon 77\n", + "adding: mem time79, current time 155, horizon 76\n", + "adding: mem time80, current time 155, horizon 75\n", + "adding: mem time81, current time 155, horizon 74\n", + "adding: mem time82, current time 155, horizon 73\n", + "adding: mem time83, current time 155, horizon 72\n", + "adding: mem time84, current time 155, horizon 71\n", + "adding: mem time85, current time 155, horizon 70\n", + "adding: mem time86, current time 155, horizon 69\n", + "adding: mem time87, current time 155, horizon 68\n", + "adding: mem time88, current time 155, horizon 67\n", + "adding: mem time89, current time 155, horizon 66\n", + "adding: mem time90, current time 155, horizon 65\n", + "adding: mem time91, current time 155, horizon 64\n", + "adding: mem time92, current time 155, horizon 63\n", + "adding: mem time93, current time 155, horizon 62\n", + "adding: mem time94, current time 155, horizon 61\n", + "adding: mem time95, current time 155, horizon 60\n", + "adding: mem time96, current time 155, horizon 59\n", + "adding: mem time97, current time 155, horizon 58\n", + "adding: mem time98, current time 155, horizon 57\n", + "adding: mem time99, current time 155, horizon 56\n", + "adding: mem time100, current time 155, horizon 55\n", + "adding: mem time101, current time 155, horizon 54\n", + "adding: mem time102, current time 155, horizon 53\n", + "adding: mem time103, current time 155, horizon 52\n", + "adding: mem time104, current time 155, horizon 51\n", + "adding: mem time105, current time 155, horizon 50\n", + "adding: mem time106, current time 155, horizon 49\n", + "adding: mem time107, current time 155, horizon 48\n", + "adding: mem time108, current time 155, horizon 47\n", + "adding: mem time109, current time 155, horizon 46\n", + "adding: mem time110, current time 155, horizon 45\n", + "adding: mem time111, current time 155, horizon 44\n", + "adding: mem time112, current time 155, horizon 43\n", + "adding: mem time113, current time 155, horizon 42\n", + "adding: mem time114, current time 155, horizon 41\n", + "adding: mem time115, current time 155, horizon 40\n", + "adding: mem time116, current time 155, horizon 39\n", + "adding: mem time117, current time 155, horizon 38\n", + "adding: mem time118, current time 155, horizon 37\n", + "adding: mem time119, current time 155, horizon 36\n", + "adding: mem time120, current time 155, horizon 35\n", + "adding: mem time121, current time 155, horizon 34\n", + "adding: mem time122, current time 155, horizon 33\n", + "adding: mem time123, current time 155, horizon 32\n", + "adding: mem time124, current time 155, horizon 31\n", + "adding: mem time125, current time 155, horizon 30\n", + "adding: mem time126, current time 155, horizon 29\n", + "adding: mem time127, current time 155, horizon 28\n", + "adding: mem time128, current time 155, horizon 27\n", + "adding: mem time129, current time 155, horizon 26\n", + "adding: mem time130, current time 155, horizon 25\n", + "adding: mem time131, current time 155, horizon 24\n", + "adding: mem time132, current time 155, horizon 23\n", + "adding: mem time133, current time 155, horizon 22\n", + "adding: mem time134, current time 155, horizon 21\n", + "adding: mem time135, current time 155, horizon 20\n", + "adding: mem time136, current time 155, horizon 19\n", + "adding: mem time137, current time 155, horizon 18\n", + "adding: mem time138, current time 155, horizon 17\n", + "adding: mem time139, current time 155, horizon 16\n", + "adding: mem time140, current time 155, horizon 15\n", + "adding: mem time141, current time 155, horizon 14\n", + "adding: mem time142, current time 155, horizon 13\n", + "adding: mem time143, current time 155, horizon 12\n", + "adding: mem time144, current time 155, horizon 11\n", + "adding: mem time145, current time 155, horizon 10\n", + "adding: mem time146, current time 155, horizon 9\n", + "adding: mem time147, current time 155, horizon 8\n", + "adding: mem time148, current time 155, horizon 7\n", + "adding: mem time149, current time 155, horizon 6\n", + "adding: mem time150, current time 155, horizon 5\n", + "adding: mem time151, current time 155, horizon 4\n", + "adding: mem time152, current time 155, horizon 3\n", + "adding: mem time153, current time 155, horizon 2\n", + "adding: mem time154, current time 155, horizon 1\n", + "adding: mem time0, current time 156, horizon 156\n", + "adding: mem time1, current time 156, horizon 155\n", + "adding: mem time2, current time 156, horizon 154\n", + "adding: mem time3, current time 156, horizon 153\n", + "adding: mem time4, current time 156, horizon 152\n", + "adding: mem time5, current time 156, horizon 151\n", + "adding: mem time6, current time 156, horizon 150\n", + "adding: mem time7, current time 156, horizon 149\n", + "adding: mem time8, current time 156, horizon 148\n", + "adding: mem time9, current time 156, horizon 147\n", + "adding: mem time10, current time 156, horizon 146\n", + "adding: mem time11, current time 156, horizon 145\n", + "adding: mem time12, current time 156, horizon 144\n", + "adding: mem time13, current time 156, horizon 143\n", + "adding: mem time14, current time 156, horizon 142\n", + "adding: mem time15, current time 156, horizon 141\n", + "adding: mem time16, current time 156, horizon 140\n", + "adding: mem time17, current time 156, horizon 139\n", + "adding: mem time18, current time 156, horizon 138\n", + "adding: mem time19, current time 156, horizon 137\n", + "adding: mem time20, current time 156, horizon 136\n", + "adding: mem time21, current time 156, horizon 135\n", + "adding: mem time22, current time 156, horizon 134\n", + "adding: mem time23, current time 156, horizon 133\n", + "adding: mem time24, current time 156, horizon 132\n", + "adding: mem time25, current time 156, horizon 131\n", + "adding: mem time26, current time 156, horizon 130\n", + "adding: mem time27, current time 156, horizon 129\n", + "adding: mem time28, current time 156, horizon 128\n", + "adding: mem time29, current time 156, horizon 127\n", + "adding: mem time30, current time 156, horizon 126\n", + "adding: mem time31, current time 156, horizon 125\n", + "adding: mem time32, current time 156, horizon 124\n", + "adding: mem time33, current time 156, horizon 123\n", + "adding: mem time34, current time 156, horizon 122\n", + "adding: mem time35, current time 156, horizon 121\n", + "adding: mem time36, current time 156, horizon 120\n", + "adding: mem time37, current time 156, horizon 119\n", + "adding: mem time38, current time 156, horizon 118\n", + "adding: mem time39, current time 156, horizon 117\n", + "adding: mem time40, current time 156, horizon 116\n", + "adding: mem time41, current time 156, horizon 115\n", + "adding: mem time42, current time 156, horizon 114\n", + "adding: mem time43, current time 156, horizon 113\n", + "adding: mem time44, current time 156, horizon 112\n", + "adding: mem time45, current time 156, horizon 111\n", + "adding: mem time46, current time 156, horizon 110\n", + "adding: mem time47, current time 156, horizon 109\n", + "adding: mem time48, current time 156, horizon 108\n", + "adding: mem time49, current time 156, horizon 107\n", + "adding: mem time50, current time 156, horizon 106\n", + "adding: mem time51, current time 156, horizon 105\n", + "adding: mem time52, current time 156, horizon 104\n", + "adding: mem time53, current time 156, horizon 103\n", + "adding: mem time54, current time 156, horizon 102\n", + "adding: mem time55, current time 156, horizon 101\n", + "adding: mem time56, current time 156, horizon 100\n", + "adding: mem time57, current time 156, horizon 99\n", + "adding: mem time58, current time 156, horizon 98\n", + "adding: mem time59, current time 156, horizon 97\n", + "adding: mem time60, current time 156, horizon 96\n", + "adding: mem time61, current time 156, horizon 95\n", + "adding: mem time62, current time 156, horizon 94\n", + "adding: mem time63, current time 156, horizon 93\n", + "adding: mem time64, current time 156, horizon 92\n", + "adding: mem time65, current time 156, horizon 91\n", + "adding: mem time66, current time 156, horizon 90\n", + "adding: mem time67, current time 156, horizon 89\n", + "adding: mem time68, current time 156, horizon 88\n", + "adding: mem time69, current time 156, horizon 87\n", + "adding: mem time70, current time 156, horizon 86\n", + "adding: mem time71, current time 156, horizon 85\n", + "adding: mem time72, current time 156, horizon 84\n", + "adding: mem time73, current time 156, horizon 83\n", + "adding: mem time74, current time 156, horizon 82\n", + "adding: mem time75, current time 156, horizon 81\n", + "adding: mem time76, current time 156, horizon 80\n", + "adding: mem time77, current time 156, horizon 79\n", + "adding: mem time78, current time 156, horizon 78\n", + "adding: mem time79, current time 156, horizon 77\n", + "adding: mem time80, current time 156, horizon 76\n", + "adding: mem time81, current time 156, horizon 75\n", + "adding: mem time82, current time 156, horizon 74\n", + "adding: mem time83, current time 156, horizon 73\n", + "adding: mem time84, current time 156, horizon 72\n", + "adding: mem time85, current time 156, horizon 71\n", + "adding: mem time86, current time 156, horizon 70\n", + "adding: mem time87, current time 156, horizon 69\n", + "adding: mem time88, current time 156, horizon 68\n", + "adding: mem time89, current time 156, horizon 67\n", + "adding: mem time90, current time 156, horizon 66\n", + "adding: mem time91, current time 156, horizon 65\n", + "adding: mem time92, current time 156, horizon 64\n", + "adding: mem time93, current time 156, horizon 63\n", + "adding: mem time94, current time 156, horizon 62\n", + "adding: mem time95, current time 156, horizon 61\n", + "adding: mem time96, current time 156, horizon 60\n", + "adding: mem time97, current time 156, horizon 59\n", + "adding: mem time98, current time 156, horizon 58\n", + "adding: mem time99, current time 156, horizon 57\n", + "adding: mem time100, current time 156, horizon 56\n", + "adding: mem time101, current time 156, horizon 55\n", + "adding: mem time102, current time 156, horizon 54\n", + "adding: mem time103, current time 156, horizon 53\n", + "adding: mem time104, current time 156, horizon 52\n", + "adding: mem time105, current time 156, horizon 51\n", + "adding: mem time106, current time 156, horizon 50\n", + "adding: mem time107, current time 156, horizon 49\n", + "adding: mem time108, current time 156, horizon 48\n", + "adding: mem time109, current time 156, horizon 47\n", + "adding: mem time110, current time 156, horizon 46\n", + "adding: mem time111, current time 156, horizon 45\n", + "adding: mem time112, current time 156, horizon 44\n", + "adding: mem time113, current time 156, horizon 43\n", + "adding: mem time114, current time 156, horizon 42\n", + "adding: mem time115, current time 156, horizon 41\n", + "adding: mem time116, current time 156, horizon 40\n", + "adding: mem time117, current time 156, horizon 39\n", + "adding: mem time118, current time 156, horizon 38\n", + "adding: mem time119, current time 156, horizon 37\n", + "adding: mem time120, current time 156, horizon 36\n", + "adding: mem time121, current time 156, horizon 35\n", + "adding: mem time122, current time 156, horizon 34\n", + "adding: mem time123, current time 156, horizon 33\n", + "adding: mem time124, current time 156, horizon 32\n", + "adding: mem time125, current time 156, horizon 31\n", + "adding: mem time126, current time 156, horizon 30\n", + "adding: mem time127, current time 156, horizon 29\n", + "adding: mem time128, current time 156, horizon 28\n", + "adding: mem time129, current time 156, horizon 27\n", + "adding: mem time130, current time 156, horizon 26\n", + "adding: mem time131, current time 156, horizon 25\n", + "adding: mem time132, current time 156, horizon 24\n", + "adding: mem time133, current time 156, horizon 23\n", + "adding: mem time134, current time 156, horizon 22\n", + "adding: mem time135, current time 156, horizon 21\n", + "adding: mem time136, current time 156, horizon 20\n", + "adding: mem time137, current time 156, horizon 19\n", + "adding: mem time138, current time 156, horizon 18\n", + "adding: mem time139, current time 156, horizon 17\n", + "adding: mem time140, current time 156, horizon 16\n", + "adding: mem time141, current time 156, horizon 15\n", + "adding: mem time142, current time 156, horizon 14\n", + "adding: mem time143, current time 156, horizon 13\n", + "adding: mem time144, current time 156, horizon 12\n", + "adding: mem time145, current time 156, horizon 11\n", + "adding: mem time146, current time 156, horizon 10\n", + "adding: mem time147, current time 156, horizon 9\n", + "adding: mem time148, current time 156, horizon 8\n", + "adding: mem time149, current time 156, horizon 7\n", + "adding: mem time150, current time 156, horizon 6\n", + "adding: mem time151, current time 156, horizon 5\n", + "adding: mem time152, current time 156, horizon 4\n", + "adding: mem time153, current time 156, horizon 3\n", + "adding: mem time154, current time 156, horizon 2\n", + "adding: mem time155, current time 156, horizon 1\n", + "adding: mem time0, current time 157, horizon 157\n", + "adding: mem time1, current time 157, horizon 156\n", + "adding: mem time2, current time 157, horizon 155\n", + "adding: mem time3, current time 157, horizon 154\n", + "adding: mem time4, current time 157, horizon 153\n", + "adding: mem time5, current time 157, horizon 152\n", + "adding: mem time6, current time 157, horizon 151\n", + "adding: mem time7, current time 157, horizon 150\n", + "adding: mem time8, current time 157, horizon 149\n", + "adding: mem time9, current time 157, horizon 148\n", + "adding: mem time10, current time 157, horizon 147\n", + "adding: mem time11, current time 157, horizon 146\n", + "adding: mem time12, current time 157, horizon 145\n", + "adding: mem time13, current time 157, horizon 144\n", + "adding: mem time14, current time 157, horizon 143\n", + "adding: mem time15, current time 157, horizon 142\n", + "adding: mem time16, current time 157, horizon 141\n", + "adding: mem time17, current time 157, horizon 140\n", + "adding: mem time18, current time 157, horizon 139\n", + "adding: mem time19, current time 157, horizon 138\n", + "adding: mem time20, current time 157, horizon 137\n", + "adding: mem time21, current time 157, horizon 136\n", + "adding: mem time22, current time 157, horizon 135\n", + "adding: mem time23, current time 157, horizon 134\n", + "adding: mem time24, current time 157, horizon 133\n", + "adding: mem time25, current time 157, horizon 132\n", + "adding: mem time26, current time 157, horizon 131\n", + "adding: mem time27, current time 157, horizon 130\n", + "adding: mem time28, current time 157, horizon 129\n", + "adding: mem time29, current time 157, horizon 128\n", + "adding: mem time30, current time 157, horizon 127\n", + "adding: mem time31, current time 157, horizon 126\n", + "adding: mem time32, current time 157, horizon 125\n", + "adding: mem time33, current time 157, horizon 124\n", + "adding: mem time34, current time 157, horizon 123\n", + "adding: mem time35, current time 157, horizon 122\n", + "adding: mem time36, current time 157, horizon 121\n", + "adding: mem time37, current time 157, horizon 120\n", + "adding: mem time38, current time 157, horizon 119\n", + "adding: mem time39, current time 157, horizon 118\n", + "adding: mem time40, current time 157, horizon 117\n", + "adding: mem time41, current time 157, horizon 116\n", + "adding: mem time42, current time 157, horizon 115\n", + "adding: mem time43, current time 157, horizon 114\n", + "adding: mem time44, current time 157, horizon 113\n", + "adding: mem time45, current time 157, horizon 112\n", + "adding: mem time46, current time 157, horizon 111\n", + "adding: mem time47, current time 157, horizon 110\n", + "adding: mem time48, current time 157, horizon 109\n", + "adding: mem time49, current time 157, horizon 108\n", + "adding: mem time50, current time 157, horizon 107\n", + "adding: mem time51, current time 157, horizon 106\n", + "adding: mem time52, current time 157, horizon 105\n", + "adding: mem time53, current time 157, horizon 104\n", + "adding: mem time54, current time 157, horizon 103\n", + "adding: mem time55, current time 157, horizon 102\n", + "adding: mem time56, current time 157, horizon 101\n", + "adding: mem time57, current time 157, horizon 100\n", + "adding: mem time58, current time 157, horizon 99\n", + "adding: mem time59, current time 157, horizon 98\n", + "adding: mem time60, current time 157, horizon 97\n", + "adding: mem time61, current time 157, horizon 96\n", + "adding: mem time62, current time 157, horizon 95\n", + "adding: mem time63, current time 157, horizon 94\n", + "adding: mem time64, current time 157, horizon 93\n", + "adding: mem time65, current time 157, horizon 92\n", + "adding: mem time66, current time 157, horizon 91\n", + "adding: mem time67, current time 157, horizon 90\n", + "adding: mem time68, current time 157, horizon 89\n", + "adding: mem time69, current time 157, horizon 88\n", + "adding: mem time70, current time 157, horizon 87\n", + "adding: mem time71, current time 157, horizon 86\n", + "adding: mem time72, current time 157, horizon 85\n", + "adding: mem time73, current time 157, horizon 84\n", + "adding: mem time74, current time 157, horizon 83\n", + "adding: mem time75, current time 157, horizon 82\n", + "adding: mem time76, current time 157, horizon 81\n", + "adding: mem time77, current time 157, horizon 80\n", + "adding: mem time78, current time 157, horizon 79\n", + "adding: mem time79, current time 157, horizon 78\n", + "adding: mem time80, current time 157, horizon 77\n", + "adding: mem time81, current time 157, horizon 76\n", + "adding: mem time82, current time 157, horizon 75\n", + "adding: mem time83, current time 157, horizon 74\n", + "adding: mem time84, current time 157, horizon 73\n", + "adding: mem time85, current time 157, horizon 72\n", + "adding: mem time86, current time 157, horizon 71\n", + "adding: mem time87, current time 157, horizon 70\n", + "adding: mem time88, current time 157, horizon 69\n", + "adding: mem time89, current time 157, horizon 68\n", + "adding: mem time90, current time 157, horizon 67\n", + "adding: mem time91, current time 157, horizon 66\n", + "adding: mem time92, current time 157, horizon 65\n", + "adding: mem time93, current time 157, horizon 64\n", + "adding: mem time94, current time 157, horizon 63\n", + "adding: mem time95, current time 157, horizon 62\n", + "adding: mem time96, current time 157, horizon 61\n", + "adding: mem time97, current time 157, horizon 60\n", + "adding: mem time98, current time 157, horizon 59\n", + "adding: mem time99, current time 157, horizon 58\n", + "adding: mem time100, current time 157, horizon 57\n", + "adding: mem time101, current time 157, horizon 56\n", + "adding: mem time102, current time 157, horizon 55\n", + "adding: mem time103, current time 157, horizon 54\n", + "adding: mem time104, current time 157, horizon 53\n", + "adding: mem time105, current time 157, horizon 52\n", + "adding: mem time106, current time 157, horizon 51\n", + "adding: mem time107, current time 157, horizon 50\n", + "adding: mem time108, current time 157, horizon 49\n", + "adding: mem time109, current time 157, horizon 48\n", + "adding: mem time110, current time 157, horizon 47\n", + "adding: mem time111, current time 157, horizon 46\n", + "adding: mem time112, current time 157, horizon 45\n", + "adding: mem time113, current time 157, horizon 44\n", + "adding: mem time114, current time 157, horizon 43\n", + "adding: mem time115, current time 157, horizon 42\n", + "adding: mem time116, current time 157, horizon 41\n", + "adding: mem time117, current time 157, horizon 40\n", + "adding: mem time118, current time 157, horizon 39\n", + "adding: mem time119, current time 157, horizon 38\n", + "adding: mem time120, current time 157, horizon 37\n", + "adding: mem time121, current time 157, horizon 36\n", + "adding: mem time122, current time 157, horizon 35\n", + "adding: mem time123, current time 157, horizon 34\n", + "adding: mem time124, current time 157, horizon 33\n", + "adding: mem time125, current time 157, horizon 32\n", + "adding: mem time126, current time 157, horizon 31\n", + "adding: mem time127, current time 157, horizon 30\n", + "adding: mem time128, current time 157, horizon 29\n", + "adding: mem time129, current time 157, horizon 28\n", + "adding: mem time130, current time 157, horizon 27\n", + "adding: mem time131, current time 157, horizon 26\n", + "adding: mem time132, current time 157, horizon 25\n", + "adding: mem time133, current time 157, horizon 24\n", + "adding: mem time134, current time 157, horizon 23\n", + "adding: mem time135, current time 157, horizon 22\n", + "adding: mem time136, current time 157, horizon 21\n", + "adding: mem time137, current time 157, horizon 20\n", + "adding: mem time138, current time 157, horizon 19\n", + "adding: mem time139, current time 157, horizon 18\n", + "adding: mem time140, current time 157, horizon 17\n", + "adding: mem time141, current time 157, horizon 16\n", + "adding: mem time142, current time 157, horizon 15\n", + "adding: mem time143, current time 157, horizon 14\n", + "adding: mem time144, current time 157, horizon 13\n", + "adding: mem time145, current time 157, horizon 12\n", + "adding: mem time146, current time 157, horizon 11\n", + "adding: mem time147, current time 157, horizon 10\n", + "adding: mem time148, current time 157, horizon 9\n", + "adding: mem time149, current time 157, horizon 8\n", + "adding: mem time150, current time 157, horizon 7\n", + "adding: mem time151, current time 157, horizon 6\n", + "adding: mem time152, current time 157, horizon 5\n", + "adding: mem time153, current time 157, horizon 4\n", + "adding: mem time154, current time 157, horizon 3\n", + "adding: mem time155, current time 157, horizon 2\n", + "adding: mem time156, current time 157, horizon 1\n", + "adding: mem time0, current time 158, horizon 158\n", + "adding: mem time1, current time 158, horizon 157\n", + "adding: mem time2, current time 158, horizon 156\n", + "adding: mem time3, current time 158, horizon 155\n", + "adding: mem time4, current time 158, horizon 154\n", + "adding: mem time5, current time 158, horizon 153\n", + "adding: mem time6, current time 158, horizon 152\n", + "adding: mem time7, current time 158, horizon 151\n", + "adding: mem time8, current time 158, horizon 150\n", + "adding: mem time9, current time 158, horizon 149\n", + "adding: mem time10, current time 158, horizon 148\n", + "adding: mem time11, current time 158, horizon 147\n", + "adding: mem time12, current time 158, horizon 146\n", + "adding: mem time13, current time 158, horizon 145\n", + "adding: mem time14, current time 158, horizon 144\n", + "adding: mem time15, current time 158, horizon 143\n", + "adding: mem time16, current time 158, horizon 142\n", + "adding: mem time17, current time 158, horizon 141\n", + "adding: mem time18, current time 158, horizon 140\n", + "adding: mem time19, current time 158, horizon 139\n", + "adding: mem time20, current time 158, horizon 138\n", + "adding: mem time21, current time 158, horizon 137\n", + "adding: mem time22, current time 158, horizon 136\n", + "adding: mem time23, current time 158, horizon 135\n", + "adding: mem time24, current time 158, horizon 134\n", + "adding: mem time25, current time 158, horizon 133\n", + "adding: mem time26, current time 158, horizon 132\n", + "adding: mem time27, current time 158, horizon 131\n", + "adding: mem time28, current time 158, horizon 130\n", + "adding: mem time29, current time 158, horizon 129\n", + "adding: mem time30, current time 158, horizon 128\n", + "adding: mem time31, current time 158, horizon 127\n", + "adding: mem time32, current time 158, horizon 126\n", + "adding: mem time33, current time 158, horizon 125\n", + "adding: mem time34, current time 158, horizon 124\n", + "adding: mem time35, current time 158, horizon 123\n", + "adding: mem time36, current time 158, horizon 122\n", + "adding: mem time37, current time 158, horizon 121\n", + "adding: mem time38, current time 158, horizon 120\n", + "adding: mem time39, current time 158, horizon 119\n", + "adding: mem time40, current time 158, horizon 118\n", + "adding: mem time41, current time 158, horizon 117\n", + "adding: mem time42, current time 158, horizon 116\n", + "adding: mem time43, current time 158, horizon 115\n", + "adding: mem time44, current time 158, horizon 114\n", + "adding: mem time45, current time 158, horizon 113\n", + "adding: mem time46, current time 158, horizon 112\n", + "adding: mem time47, current time 158, horizon 111\n", + "adding: mem time48, current time 158, horizon 110\n", + "adding: mem time49, current time 158, horizon 109\n", + "adding: mem time50, current time 158, horizon 108\n", + "adding: mem time51, current time 158, horizon 107\n", + "adding: mem time52, current time 158, horizon 106\n", + "adding: mem time53, current time 158, horizon 105\n", + "adding: mem time54, current time 158, horizon 104\n", + "adding: mem time55, current time 158, horizon 103\n", + "adding: mem time56, current time 158, horizon 102\n", + "adding: mem time57, current time 158, horizon 101\n", + "adding: mem time58, current time 158, horizon 100\n", + "adding: mem time59, current time 158, horizon 99\n", + "adding: mem time60, current time 158, horizon 98\n", + "adding: mem time61, current time 158, horizon 97\n", + "adding: mem time62, current time 158, horizon 96\n", + "adding: mem time63, current time 158, horizon 95\n", + "adding: mem time64, current time 158, horizon 94\n", + "adding: mem time65, current time 158, horizon 93\n", + "adding: mem time66, current time 158, horizon 92\n", + "adding: mem time67, current time 158, horizon 91\n", + "adding: mem time68, current time 158, horizon 90\n", + "adding: mem time69, current time 158, horizon 89\n", + "adding: mem time70, current time 158, horizon 88\n", + "adding: mem time71, current time 158, horizon 87\n", + "adding: mem time72, current time 158, horizon 86\n", + "adding: mem time73, current time 158, horizon 85\n", + "adding: mem time74, current time 158, horizon 84\n", + "adding: mem time75, current time 158, horizon 83\n", + "adding: mem time76, current time 158, horizon 82\n", + "adding: mem time77, current time 158, horizon 81\n", + "adding: mem time78, current time 158, horizon 80\n", + "adding: mem time79, current time 158, horizon 79\n", + "adding: mem time80, current time 158, horizon 78\n", + "adding: mem time81, current time 158, horizon 77\n", + "adding: mem time82, current time 158, horizon 76\n", + "adding: mem time83, current time 158, horizon 75\n", + "adding: mem time84, current time 158, horizon 74\n", + "adding: mem time85, current time 158, horizon 73\n", + "adding: mem time86, current time 158, horizon 72\n", + "adding: mem time87, current time 158, horizon 71\n", + "adding: mem time88, current time 158, horizon 70\n", + "adding: mem time89, current time 158, horizon 69\n", + "adding: mem time90, current time 158, horizon 68\n", + "adding: mem time91, current time 158, horizon 67\n", + "adding: mem time92, current time 158, horizon 66\n", + "adding: mem time93, current time 158, horizon 65\n", + "adding: mem time94, current time 158, horizon 64\n", + "adding: mem time95, current time 158, horizon 63\n", + "adding: mem time96, current time 158, horizon 62\n", + "adding: mem time97, current time 158, horizon 61\n", + "adding: mem time98, current time 158, horizon 60\n", + "adding: mem time99, current time 158, horizon 59\n", + "adding: mem time100, current time 158, horizon 58\n", + "adding: mem time101, current time 158, horizon 57\n", + "adding: mem time102, current time 158, horizon 56\n", + "adding: mem time103, current time 158, horizon 55\n", + "adding: mem time104, current time 158, horizon 54\n", + "adding: mem time105, current time 158, horizon 53\n", + "adding: mem time106, current time 158, horizon 52\n", + "adding: mem time107, current time 158, horizon 51\n", + "adding: mem time108, current time 158, horizon 50\n", + "adding: mem time109, current time 158, horizon 49\n", + "adding: mem time110, current time 158, horizon 48\n", + "adding: mem time111, current time 158, horizon 47\n", + "adding: mem time112, current time 158, horizon 46\n", + "adding: mem time113, current time 158, horizon 45\n", + "adding: mem time114, current time 158, horizon 44\n", + "adding: mem time115, current time 158, horizon 43\n", + "adding: mem time116, current time 158, horizon 42\n", + "adding: mem time117, current time 158, horizon 41\n", + "adding: mem time118, current time 158, horizon 40\n", + "adding: mem time119, current time 158, horizon 39\n", + "adding: mem time120, current time 158, horizon 38\n", + "adding: mem time121, current time 158, horizon 37\n", + "adding: mem time122, current time 158, horizon 36\n", + "adding: mem time123, current time 158, horizon 35\n", + "adding: mem time124, current time 158, horizon 34\n", + "adding: mem time125, current time 158, horizon 33\n", + "adding: mem time126, current time 158, horizon 32\n", + "adding: mem time127, current time 158, horizon 31\n", + "adding: mem time128, current time 158, horizon 30\n", + "adding: mem time129, current time 158, horizon 29\n", + "adding: mem time130, current time 158, horizon 28\n", + "adding: mem time131, current time 158, horizon 27\n", + "adding: mem time132, current time 158, horizon 26\n", + "adding: mem time133, current time 158, horizon 25\n", + "adding: mem time134, current time 158, horizon 24\n", + "adding: mem time135, current time 158, horizon 23\n", + "adding: mem time136, current time 158, horizon 22\n", + "adding: mem time137, current time 158, horizon 21\n", + "adding: mem time138, current time 158, horizon 20\n", + "adding: mem time139, current time 158, horizon 19\n", + "adding: mem time140, current time 158, horizon 18\n", + "adding: mem time141, current time 158, horizon 17\n", + "adding: mem time142, current time 158, horizon 16\n", + "adding: mem time143, current time 158, horizon 15\n", + "adding: mem time144, current time 158, horizon 14\n", + "adding: mem time145, current time 158, horizon 13\n", + "adding: mem time146, current time 158, horizon 12\n", + "adding: mem time147, current time 158, horizon 11\n", + "adding: mem time148, current time 158, horizon 10\n", + "adding: mem time149, current time 158, horizon 9\n", + "adding: mem time150, current time 158, horizon 8\n", + "adding: mem time151, current time 158, horizon 7\n", + "adding: mem time152, current time 158, horizon 6\n", + "adding: mem time153, current time 158, horizon 5\n", + "adding: mem time154, current time 158, horizon 4\n", + "adding: mem time155, current time 158, horizon 3\n", + "adding: mem time156, current time 158, horizon 2\n", + "adding: mem time157, current time 158, horizon 1\n", + "adding: mem time0, current time 159, horizon 159\n", + "adding: mem time1, current time 159, horizon 158\n", + "adding: mem time2, current time 159, horizon 157\n", + "adding: mem time3, current time 159, horizon 156\n", + "adding: mem time4, current time 159, horizon 155\n", + "adding: mem time5, current time 159, horizon 154\n", + "adding: mem time6, current time 159, horizon 153\n", + "adding: mem time7, current time 159, horizon 152\n", + "adding: mem time8, current time 159, horizon 151\n", + "adding: mem time9, current time 159, horizon 150\n", + "adding: mem time10, current time 159, horizon 149\n", + "adding: mem time11, current time 159, horizon 148\n", + "adding: mem time12, current time 159, horizon 147\n", + "adding: mem time13, current time 159, horizon 146\n", + "adding: mem time14, current time 159, horizon 145\n", + "adding: mem time15, current time 159, horizon 144\n", + "adding: mem time16, current time 159, horizon 143\n", + "adding: mem time17, current time 159, horizon 142\n", + "adding: mem time18, current time 159, horizon 141\n", + "adding: mem time19, current time 159, horizon 140\n", + "adding: mem time20, current time 159, horizon 139\n", + "adding: mem time21, current time 159, horizon 138\n", + "adding: mem time22, current time 159, horizon 137\n", + "adding: mem time23, current time 159, horizon 136\n", + "adding: mem time24, current time 159, horizon 135\n", + "adding: mem time25, current time 159, horizon 134\n", + "adding: mem time26, current time 159, horizon 133\n", + "adding: mem time27, current time 159, horizon 132\n", + "adding: mem time28, current time 159, horizon 131\n", + "adding: mem time29, current time 159, horizon 130\n", + "adding: mem time30, current time 159, horizon 129\n", + "adding: mem time31, current time 159, horizon 128\n", + "adding: mem time32, current time 159, horizon 127\n", + "adding: mem time33, current time 159, horizon 126\n", + "adding: mem time34, current time 159, horizon 125\n", + "adding: mem time35, current time 159, horizon 124\n", + "adding: mem time36, current time 159, horizon 123\n", + "adding: mem time37, current time 159, horizon 122\n", + "adding: mem time38, current time 159, horizon 121\n", + "adding: mem time39, current time 159, horizon 120\n", + "adding: mem time40, current time 159, horizon 119\n", + "adding: mem time41, current time 159, horizon 118\n", + "adding: mem time42, current time 159, horizon 117\n", + "adding: mem time43, current time 159, horizon 116\n", + "adding: mem time44, current time 159, horizon 115\n", + "adding: mem time45, current time 159, horizon 114\n", + "adding: mem time46, current time 159, horizon 113\n", + "adding: mem time47, current time 159, horizon 112\n", + "adding: mem time48, current time 159, horizon 111\n", + "adding: mem time49, current time 159, horizon 110\n", + "adding: mem time50, current time 159, horizon 109\n", + "adding: mem time51, current time 159, horizon 108\n", + "adding: mem time52, current time 159, horizon 107\n", + "adding: mem time53, current time 159, horizon 106\n", + "adding: mem time54, current time 159, horizon 105\n", + "adding: mem time55, current time 159, horizon 104\n", + "adding: mem time56, current time 159, horizon 103\n", + "adding: mem time57, current time 159, horizon 102\n", + "adding: mem time58, current time 159, horizon 101\n", + "adding: mem time59, current time 159, horizon 100\n", + "adding: mem time60, current time 159, horizon 99\n", + "adding: mem time61, current time 159, horizon 98\n", + "adding: mem time62, current time 159, horizon 97\n", + "adding: mem time63, current time 159, horizon 96\n", + "adding: mem time64, current time 159, horizon 95\n", + "adding: mem time65, current time 159, horizon 94\n", + "adding: mem time66, current time 159, horizon 93\n", + "adding: mem time67, current time 159, horizon 92\n", + "adding: mem time68, current time 159, horizon 91\n", + "adding: mem time69, current time 159, horizon 90\n", + "adding: mem time70, current time 159, horizon 89\n", + "adding: mem time71, current time 159, horizon 88\n", + "adding: mem time72, current time 159, horizon 87\n", + "adding: mem time73, current time 159, horizon 86\n", + "adding: mem time74, current time 159, horizon 85\n", + "adding: mem time75, current time 159, horizon 84\n", + "adding: mem time76, current time 159, horizon 83\n", + "adding: mem time77, current time 159, horizon 82\n", + "adding: mem time78, current time 159, horizon 81\n", + "adding: mem time79, current time 159, horizon 80\n", + "adding: mem time80, current time 159, horizon 79\n", + "adding: mem time81, current time 159, horizon 78\n", + "adding: mem time82, current time 159, horizon 77\n", + "adding: mem time83, current time 159, horizon 76\n", + "adding: mem time84, current time 159, horizon 75\n", + "adding: mem time85, current time 159, horizon 74\n", + "adding: mem time86, current time 159, horizon 73\n", + "adding: mem time87, current time 159, horizon 72\n", + "adding: mem time88, current time 159, horizon 71\n", + "adding: mem time89, current time 159, horizon 70\n", + "adding: mem time90, current time 159, horizon 69\n", + "adding: mem time91, current time 159, horizon 68\n", + "adding: mem time92, current time 159, horizon 67\n", + "adding: mem time93, current time 159, horizon 66\n", + "adding: mem time94, current time 159, horizon 65\n", + "adding: mem time95, current time 159, horizon 64\n", + "adding: mem time96, current time 159, horizon 63\n", + "adding: mem time97, current time 159, horizon 62\n", + "adding: mem time98, current time 159, horizon 61\n", + "adding: mem time99, current time 159, horizon 60\n", + "adding: mem time100, current time 159, horizon 59\n", + "adding: mem time101, current time 159, horizon 58\n", + "adding: mem time102, current time 159, horizon 57\n", + "adding: mem time103, current time 159, horizon 56\n", + "adding: mem time104, current time 159, horizon 55\n", + "adding: mem time105, current time 159, horizon 54\n", + "adding: mem time106, current time 159, horizon 53\n", + "adding: mem time107, current time 159, horizon 52\n", + "adding: mem time108, current time 159, horizon 51\n", + "adding: mem time109, current time 159, horizon 50\n", + "adding: mem time110, current time 159, horizon 49\n", + "adding: mem time111, current time 159, horizon 48\n", + "adding: mem time112, current time 159, horizon 47\n", + "adding: mem time113, current time 159, horizon 46\n", + "adding: mem time114, current time 159, horizon 45\n", + "adding: mem time115, current time 159, horizon 44\n", + "adding: mem time116, current time 159, horizon 43\n", + "adding: mem time117, current time 159, horizon 42\n", + "adding: mem time118, current time 159, horizon 41\n", + "adding: mem time119, current time 159, horizon 40\n", + "adding: mem time120, current time 159, horizon 39\n", + "adding: mem time121, current time 159, horizon 38\n", + "adding: mem time122, current time 159, horizon 37\n", + "adding: mem time123, current time 159, horizon 36\n", + "adding: mem time124, current time 159, horizon 35\n", + "adding: mem time125, current time 159, horizon 34\n", + "adding: mem time126, current time 159, horizon 33\n", + "adding: mem time127, current time 159, horizon 32\n", + "adding: mem time128, current time 159, horizon 31\n", + "adding: mem time129, current time 159, horizon 30\n", + "adding: mem time130, current time 159, horizon 29\n", + "adding: mem time131, current time 159, horizon 28\n", + "adding: mem time132, current time 159, horizon 27\n", + "adding: mem time133, current time 159, horizon 26\n", + "adding: mem time134, current time 159, horizon 25\n", + "adding: mem time135, current time 159, horizon 24\n", + "adding: mem time136, current time 159, horizon 23\n", + "adding: mem time137, current time 159, horizon 22\n", + "adding: mem time138, current time 159, horizon 21\n", + "adding: mem time139, current time 159, horizon 20\n", + "adding: mem time140, current time 159, horizon 19\n", + "adding: mem time141, current time 159, horizon 18\n", + "adding: mem time142, current time 159, horizon 17\n", + "adding: mem time143, current time 159, horizon 16\n", + "adding: mem time144, current time 159, horizon 15\n", + "adding: mem time145, current time 159, horizon 14\n", + "adding: mem time146, current time 159, horizon 13\n", + "adding: mem time147, current time 159, horizon 12\n", + "adding: mem time148, current time 159, horizon 11\n", + "adding: mem time149, current time 159, horizon 10\n", + "adding: mem time150, current time 159, horizon 9\n", + "adding: mem time151, current time 159, horizon 8\n", + "adding: mem time152, current time 159, horizon 7\n", + "adding: mem time153, current time 159, horizon 6\n", + "adding: mem time154, current time 159, horizon 5\n", + "adding: mem time155, current time 159, horizon 4\n", + "adding: mem time156, current time 159, horizon 3\n", + "adding: mem time157, current time 159, horizon 2\n", + "adding: mem time158, current time 159, horizon 1\n", + "adding: mem time0, current time 160, horizon 160\n", + "adding: mem time1, current time 160, horizon 159\n", + "adding: mem time2, current time 160, horizon 158\n", + "adding: mem time3, current time 160, horizon 157\n", + "adding: mem time4, current time 160, horizon 156\n", + "adding: mem time5, current time 160, horizon 155\n", + "adding: mem time6, current time 160, horizon 154\n", + "adding: mem time7, current time 160, horizon 153\n", + "adding: mem time8, current time 160, horizon 152\n", + "adding: mem time9, current time 160, horizon 151\n", + "adding: mem time10, current time 160, horizon 150\n", + "adding: mem time11, current time 160, horizon 149\n", + "adding: mem time12, current time 160, horizon 148\n", + "adding: mem time13, current time 160, horizon 147\n", + "adding: mem time14, current time 160, horizon 146\n", + "adding: mem time15, current time 160, horizon 145\n", + "adding: mem time16, current time 160, horizon 144\n", + "adding: mem time17, current time 160, horizon 143\n", + "adding: mem time18, current time 160, horizon 142\n", + "adding: mem time19, current time 160, horizon 141\n", + "adding: mem time20, current time 160, horizon 140\n", + "adding: mem time21, current time 160, horizon 139\n", + "adding: mem time22, current time 160, horizon 138\n", + "adding: mem time23, current time 160, horizon 137\n", + "adding: mem time24, current time 160, horizon 136\n", + "adding: mem time25, current time 160, horizon 135\n", + "adding: mem time26, current time 160, horizon 134\n", + "adding: mem time27, current time 160, horizon 133\n", + "adding: mem time28, current time 160, horizon 132\n", + "adding: mem time29, current time 160, horizon 131\n", + "adding: mem time30, current time 160, horizon 130\n", + "adding: mem time31, current time 160, horizon 129\n", + "adding: mem time32, current time 160, horizon 128\n", + "adding: mem time33, current time 160, horizon 127\n", + "adding: mem time34, current time 160, horizon 126\n", + "adding: mem time35, current time 160, horizon 125\n", + "adding: mem time36, current time 160, horizon 124\n", + "adding: mem time37, current time 160, horizon 123\n", + "adding: mem time38, current time 160, horizon 122\n", + "adding: mem time39, current time 160, horizon 121\n", + "adding: mem time40, current time 160, horizon 120\n", + "adding: mem time41, current time 160, horizon 119\n", + "adding: mem time42, current time 160, horizon 118\n", + "adding: mem time43, current time 160, horizon 117\n", + "adding: mem time44, current time 160, horizon 116\n", + "adding: mem time45, current time 160, horizon 115\n", + "adding: mem time46, current time 160, horizon 114\n", + "adding: mem time47, current time 160, horizon 113\n", + "adding: mem time48, current time 160, horizon 112\n", + "adding: mem time49, current time 160, horizon 111\n", + "adding: mem time50, current time 160, horizon 110\n", + "adding: mem time51, current time 160, horizon 109\n", + "adding: mem time52, current time 160, horizon 108\n", + "adding: mem time53, current time 160, horizon 107\n", + "adding: mem time54, current time 160, horizon 106\n", + "adding: mem time55, current time 160, horizon 105\n", + "adding: mem time56, current time 160, horizon 104\n", + "adding: mem time57, current time 160, horizon 103\n", + "adding: mem time58, current time 160, horizon 102\n", + "adding: mem time59, current time 160, horizon 101\n", + "adding: mem time60, current time 160, horizon 100\n", + "adding: mem time61, current time 160, horizon 99\n", + "adding: mem time62, current time 160, horizon 98\n", + "adding: mem time63, current time 160, horizon 97\n", + "adding: mem time64, current time 160, horizon 96\n", + "adding: mem time65, current time 160, horizon 95\n", + "adding: mem time66, current time 160, horizon 94\n", + "adding: mem time67, current time 160, horizon 93\n", + "adding: mem time68, current time 160, horizon 92\n", + "adding: mem time69, current time 160, horizon 91\n", + "adding: mem time70, current time 160, horizon 90\n", + "adding: mem time71, current time 160, horizon 89\n", + "adding: mem time72, current time 160, horizon 88\n", + "adding: mem time73, current time 160, horizon 87\n", + "adding: mem time74, current time 160, horizon 86\n", + "adding: mem time75, current time 160, horizon 85\n", + "adding: mem time76, current time 160, horizon 84\n", + "adding: mem time77, current time 160, horizon 83\n", + "adding: mem time78, current time 160, horizon 82\n", + "adding: mem time79, current time 160, horizon 81\n", + "adding: mem time80, current time 160, horizon 80\n", + "adding: mem time81, current time 160, horizon 79\n", + "adding: mem time82, current time 160, horizon 78\n", + "adding: mem time83, current time 160, horizon 77\n", + "adding: mem time84, current time 160, horizon 76\n", + "adding: mem time85, current time 160, horizon 75\n", + "adding: mem time86, current time 160, horizon 74\n", + "adding: mem time87, current time 160, horizon 73\n", + "adding: mem time88, current time 160, horizon 72\n", + "adding: mem time89, current time 160, horizon 71\n", + "adding: mem time90, current time 160, horizon 70\n", + "adding: mem time91, current time 160, horizon 69\n", + "adding: mem time92, current time 160, horizon 68\n", + "adding: mem time93, current time 160, horizon 67\n", + "adding: mem time94, current time 160, horizon 66\n", + "adding: mem time95, current time 160, horizon 65\n", + "adding: mem time96, current time 160, horizon 64\n", + "adding: mem time97, current time 160, horizon 63\n", + "adding: mem time98, current time 160, horizon 62\n", + "adding: mem time99, current time 160, horizon 61\n", + "adding: mem time100, current time 160, horizon 60\n", + "adding: mem time101, current time 160, horizon 59\n", + "adding: mem time102, current time 160, horizon 58\n", + "adding: mem time103, current time 160, horizon 57\n", + "adding: mem time104, current time 160, horizon 56\n", + "adding: mem time105, current time 160, horizon 55\n", + "adding: mem time106, current time 160, horizon 54\n", + "adding: mem time107, current time 160, horizon 53\n", + "adding: mem time108, current time 160, horizon 52\n", + "adding: mem time109, current time 160, horizon 51\n", + "adding: mem time110, current time 160, horizon 50\n", + "adding: mem time111, current time 160, horizon 49\n", + "adding: mem time112, current time 160, horizon 48\n", + "adding: mem time113, current time 160, horizon 47\n", + "adding: mem time114, current time 160, horizon 46\n", + "adding: mem time115, current time 160, horizon 45\n", + "adding: mem time116, current time 160, horizon 44\n", + "adding: mem time117, current time 160, horizon 43\n", + "adding: mem time118, current time 160, horizon 42\n", + "adding: mem time119, current time 160, horizon 41\n", + "adding: mem time120, current time 160, horizon 40\n", + "adding: mem time121, current time 160, horizon 39\n", + "adding: mem time122, current time 160, horizon 38\n", + "adding: mem time123, current time 160, horizon 37\n", + "adding: mem time124, current time 160, horizon 36\n", + "adding: mem time125, current time 160, horizon 35\n", + "adding: mem time126, current time 160, horizon 34\n", + "adding: mem time127, current time 160, horizon 33\n", + "adding: mem time128, current time 160, horizon 32\n", + "adding: mem time129, current time 160, horizon 31\n", + "adding: mem time130, current time 160, horizon 30\n", + "adding: mem time131, current time 160, horizon 29\n", + "adding: mem time132, current time 160, horizon 28\n", + "adding: mem time133, current time 160, horizon 27\n", + "adding: mem time134, current time 160, horizon 26\n", + "adding: mem time135, current time 160, horizon 25\n", + "adding: mem time136, current time 160, horizon 24\n", + "adding: mem time137, current time 160, horizon 23\n", + "adding: mem time138, current time 160, horizon 22\n", + "adding: mem time139, current time 160, horizon 21\n", + "adding: mem time140, current time 160, horizon 20\n", + "adding: mem time141, current time 160, horizon 19\n", + "adding: mem time142, current time 160, horizon 18\n", + "adding: mem time143, current time 160, horizon 17\n", + "adding: mem time144, current time 160, horizon 16\n", + "adding: mem time145, current time 160, horizon 15\n", + "adding: mem time146, current time 160, horizon 14\n", + "adding: mem time147, current time 160, horizon 13\n", + "adding: mem time148, current time 160, horizon 12\n", + "adding: mem time149, current time 160, horizon 11\n", + "adding: mem time150, current time 160, horizon 10\n", + "adding: mem time151, current time 160, horizon 9\n", + "adding: mem time152, current time 160, horizon 8\n", + "adding: mem time153, current time 160, horizon 7\n", + "adding: mem time154, current time 160, horizon 6\n", + "adding: mem time155, current time 160, horizon 5\n", + "adding: mem time156, current time 160, horizon 4\n", + "adding: mem time157, current time 160, horizon 3\n", + "adding: mem time158, current time 160, horizon 2\n", + "adding: mem time159, current time 160, horizon 1\n", + "adding: mem time0, current time 161, horizon 161\n", + "adding: mem time1, current time 161, horizon 160\n", + "adding: mem time2, current time 161, horizon 159\n", + "adding: mem time3, current time 161, horizon 158\n", + "adding: mem time4, current time 161, horizon 157\n", + "adding: mem time5, current time 161, horizon 156\n", + "adding: mem time6, current time 161, horizon 155\n", + "adding: mem time7, current time 161, horizon 154\n", + "adding: mem time8, current time 161, horizon 153\n", + "adding: mem time9, current time 161, horizon 152\n", + "adding: mem time10, current time 161, horizon 151\n", + "adding: mem time11, current time 161, horizon 150\n", + "adding: mem time12, current time 161, horizon 149\n", + "adding: mem time13, current time 161, horizon 148\n", + "adding: mem time14, current time 161, horizon 147\n", + "adding: mem time15, current time 161, horizon 146\n", + "adding: mem time16, current time 161, horizon 145\n", + "adding: mem time17, current time 161, horizon 144\n", + "adding: mem time18, current time 161, horizon 143\n", + "adding: mem time19, current time 161, horizon 142\n", + "adding: mem time20, current time 161, horizon 141\n", + "adding: mem time21, current time 161, horizon 140\n", + "adding: mem time22, current time 161, horizon 139\n", + "adding: mem time23, current time 161, horizon 138\n", + "adding: mem time24, current time 161, horizon 137\n", + "adding: mem time25, current time 161, horizon 136\n", + "adding: mem time26, current time 161, horizon 135\n", + "adding: mem time27, current time 161, horizon 134\n", + "adding: mem time28, current time 161, horizon 133\n", + "adding: mem time29, current time 161, horizon 132\n", + "adding: mem time30, current time 161, horizon 131\n", + "adding: mem time31, current time 161, horizon 130\n", + "adding: mem time32, current time 161, horizon 129\n", + "adding: mem time33, current time 161, horizon 128\n", + "adding: mem time34, current time 161, horizon 127\n", + "adding: mem time35, current time 161, horizon 126\n", + "adding: mem time36, current time 161, horizon 125\n", + "adding: mem time37, current time 161, horizon 124\n", + "adding: mem time38, current time 161, horizon 123\n", + "adding: mem time39, current time 161, horizon 122\n", + "adding: mem time40, current time 161, horizon 121\n", + "adding: mem time41, current time 161, horizon 120\n", + "adding: mem time42, current time 161, horizon 119\n", + "adding: mem time43, current time 161, horizon 118\n", + "adding: mem time44, current time 161, horizon 117\n", + "adding: mem time45, current time 161, horizon 116\n", + "adding: mem time46, current time 161, horizon 115\n", + "adding: mem time47, current time 161, horizon 114\n", + "adding: mem time48, current time 161, horizon 113\n", + "adding: mem time49, current time 161, horizon 112\n", + "adding: mem time50, current time 161, horizon 111\n", + "adding: mem time51, current time 161, horizon 110\n", + "adding: mem time52, current time 161, horizon 109\n", + "adding: mem time53, current time 161, horizon 108\n", + "adding: mem time54, current time 161, horizon 107\n", + "adding: mem time55, current time 161, horizon 106\n", + "adding: mem time56, current time 161, horizon 105\n", + "adding: mem time57, current time 161, horizon 104\n", + "adding: mem time58, current time 161, horizon 103\n", + "adding: mem time59, current time 161, horizon 102\n", + "adding: mem time60, current time 161, horizon 101\n", + "adding: mem time61, current time 161, horizon 100\n", + "adding: mem time62, current time 161, horizon 99\n", + "adding: mem time63, current time 161, horizon 98\n", + "adding: mem time64, current time 161, horizon 97\n", + "adding: mem time65, current time 161, horizon 96\n", + "adding: mem time66, current time 161, horizon 95\n", + "adding: mem time67, current time 161, horizon 94\n", + "adding: mem time68, current time 161, horizon 93\n", + "adding: mem time69, current time 161, horizon 92\n", + "adding: mem time70, current time 161, horizon 91\n", + "adding: mem time71, current time 161, horizon 90\n", + "adding: mem time72, current time 161, horizon 89\n", + "adding: mem time73, current time 161, horizon 88\n", + "adding: mem time74, current time 161, horizon 87\n", + "adding: mem time75, current time 161, horizon 86\n", + "adding: mem time76, current time 161, horizon 85\n", + "adding: mem time77, current time 161, horizon 84\n", + "adding: mem time78, current time 161, horizon 83\n", + "adding: mem time79, current time 161, horizon 82\n", + "adding: mem time80, current time 161, horizon 81\n", + "adding: mem time81, current time 161, horizon 80\n", + "adding: mem time82, current time 161, horizon 79\n", + "adding: mem time83, current time 161, horizon 78\n", + "adding: mem time84, current time 161, horizon 77\n", + "adding: mem time85, current time 161, horizon 76\n", + "adding: mem time86, current time 161, horizon 75\n", + "adding: mem time87, current time 161, horizon 74\n", + "adding: mem time88, current time 161, horizon 73\n", + "adding: mem time89, current time 161, horizon 72\n", + "adding: mem time90, current time 161, horizon 71\n", + "adding: mem time91, current time 161, horizon 70\n", + "adding: mem time92, current time 161, horizon 69\n", + "adding: mem time93, current time 161, horizon 68\n", + "adding: mem time94, current time 161, horizon 67\n", + "adding: mem time95, current time 161, horizon 66\n", + "adding: mem time96, current time 161, horizon 65\n", + "adding: mem time97, current time 161, horizon 64\n", + "adding: mem time98, current time 161, horizon 63\n", + "adding: mem time99, current time 161, horizon 62\n", + "adding: mem time100, current time 161, horizon 61\n", + "adding: mem time101, current time 161, horizon 60\n", + "adding: mem time102, current time 161, horizon 59\n", + "adding: mem time103, current time 161, horizon 58\n", + "adding: mem time104, current time 161, horizon 57\n", + "adding: mem time105, current time 161, horizon 56\n", + "adding: mem time106, current time 161, horizon 55\n", + "adding: mem time107, current time 161, horizon 54\n", + "adding: mem time108, current time 161, horizon 53\n", + "adding: mem time109, current time 161, horizon 52\n", + "adding: mem time110, current time 161, horizon 51\n", + "adding: mem time111, current time 161, horizon 50\n", + "adding: mem time112, current time 161, horizon 49\n", + "adding: mem time113, current time 161, horizon 48\n", + "adding: mem time114, current time 161, horizon 47\n", + "adding: mem time115, current time 161, horizon 46\n", + "adding: mem time116, current time 161, horizon 45\n", + "adding: mem time117, current time 161, horizon 44\n", + "adding: mem time118, current time 161, horizon 43\n", + "adding: mem time119, current time 161, horizon 42\n", + "adding: mem time120, current time 161, horizon 41\n", + "adding: mem time121, current time 161, horizon 40\n", + "adding: mem time122, current time 161, horizon 39\n", + "adding: mem time123, current time 161, horizon 38\n", + "adding: mem time124, current time 161, horizon 37\n", + "adding: mem time125, current time 161, horizon 36\n", + "adding: mem time126, current time 161, horizon 35\n", + "adding: mem time127, current time 161, horizon 34\n", + "adding: mem time128, current time 161, horizon 33\n", + "adding: mem time129, current time 161, horizon 32\n", + "adding: mem time130, current time 161, horizon 31\n", + "adding: mem time131, current time 161, horizon 30\n", + "adding: mem time132, current time 161, horizon 29\n", + "adding: mem time133, current time 161, horizon 28\n", + "adding: mem time134, current time 161, horizon 27\n", + "adding: mem time135, current time 161, horizon 26\n", + "adding: mem time136, current time 161, horizon 25\n", + "adding: mem time137, current time 161, horizon 24\n", + "adding: mem time138, current time 161, horizon 23\n", + "adding: mem time139, current time 161, horizon 22\n", + "adding: mem time140, current time 161, horizon 21\n", + "adding: mem time141, current time 161, horizon 20\n", + "adding: mem time142, current time 161, horizon 19\n", + "adding: mem time143, current time 161, horizon 18\n", + "adding: mem time144, current time 161, horizon 17\n", + "adding: mem time145, current time 161, horizon 16\n", + "adding: mem time146, current time 161, horizon 15\n", + "adding: mem time147, current time 161, horizon 14\n", + "adding: mem time148, current time 161, horizon 13\n", + "adding: mem time149, current time 161, horizon 12\n", + "adding: mem time150, current time 161, horizon 11\n", + "adding: mem time151, current time 161, horizon 10\n", + "adding: mem time152, current time 161, horizon 9\n", + "adding: mem time153, current time 161, horizon 8\n", + "adding: mem time154, current time 161, horizon 7\n", + "adding: mem time155, current time 161, horizon 6\n", + "adding: mem time156, current time 161, horizon 5\n", + "adding: mem time157, current time 161, horizon 4\n", + "adding: mem time158, current time 161, horizon 3\n", + "adding: mem time159, current time 161, horizon 2\n", + "adding: mem time160, current time 161, horizon 1\n", + "adding: mem time0, current time 162, horizon 162\n", + "adding: mem time1, current time 162, horizon 161\n", + "adding: mem time2, current time 162, horizon 160\n", + "adding: mem time3, current time 162, horizon 159\n", + "adding: mem time4, current time 162, horizon 158\n", + "adding: mem time5, current time 162, horizon 157\n", + "adding: mem time6, current time 162, horizon 156\n", + "adding: mem time7, current time 162, horizon 155\n", + "adding: mem time8, current time 162, horizon 154\n", + "adding: mem time9, current time 162, horizon 153\n", + "adding: mem time10, current time 162, horizon 152\n", + "adding: mem time11, current time 162, horizon 151\n", + "adding: mem time12, current time 162, horizon 150\n", + "adding: mem time13, current time 162, horizon 149\n", + "adding: mem time14, current time 162, horizon 148\n", + "adding: mem time15, current time 162, horizon 147\n", + "adding: mem time16, current time 162, horizon 146\n", + "adding: mem time17, current time 162, horizon 145\n", + "adding: mem time18, current time 162, horizon 144\n", + "adding: mem time19, current time 162, horizon 143\n", + "adding: mem time20, current time 162, horizon 142\n", + "adding: mem time21, current time 162, horizon 141\n", + "adding: mem time22, current time 162, horizon 140\n", + "adding: mem time23, current time 162, horizon 139\n", + "adding: mem time24, current time 162, horizon 138\n", + "adding: mem time25, current time 162, horizon 137\n", + "adding: mem time26, current time 162, horizon 136\n", + "adding: mem time27, current time 162, horizon 135\n", + "adding: mem time28, current time 162, horizon 134\n", + "adding: mem time29, current time 162, horizon 133\n", + "adding: mem time30, current time 162, horizon 132\n", + "adding: mem time31, current time 162, horizon 131\n", + "adding: mem time32, current time 162, horizon 130\n", + "adding: mem time33, current time 162, horizon 129\n", + "adding: mem time34, current time 162, horizon 128\n", + "adding: mem time35, current time 162, horizon 127\n", + "adding: mem time36, current time 162, horizon 126\n", + "adding: mem time37, current time 162, horizon 125\n", + "adding: mem time38, current time 162, horizon 124\n", + "adding: mem time39, current time 162, horizon 123\n", + "adding: mem time40, current time 162, horizon 122\n", + "adding: mem time41, current time 162, horizon 121\n", + "adding: mem time42, current time 162, horizon 120\n", + "adding: mem time43, current time 162, horizon 119\n", + "adding: mem time44, current time 162, horizon 118\n", + "adding: mem time45, current time 162, horizon 117\n", + "adding: mem time46, current time 162, horizon 116\n", + "adding: mem time47, current time 162, horizon 115\n", + "adding: mem time48, current time 162, horizon 114\n", + "adding: mem time49, current time 162, horizon 113\n", + "adding: mem time50, current time 162, horizon 112\n", + "adding: mem time51, current time 162, horizon 111\n", + "adding: mem time52, current time 162, horizon 110\n", + "adding: mem time53, current time 162, horizon 109\n", + "adding: mem time54, current time 162, horizon 108\n", + "adding: mem time55, current time 162, horizon 107\n", + "adding: mem time56, current time 162, horizon 106\n", + "adding: mem time57, current time 162, horizon 105\n", + "adding: mem time58, current time 162, horizon 104\n", + "adding: mem time59, current time 162, horizon 103\n", + "adding: mem time60, current time 162, horizon 102\n", + "adding: mem time61, current time 162, horizon 101\n", + "adding: mem time62, current time 162, horizon 100\n", + "adding: mem time63, current time 162, horizon 99\n", + "adding: mem time64, current time 162, horizon 98\n", + "adding: mem time65, current time 162, horizon 97\n", + "adding: mem time66, current time 162, horizon 96\n", + "adding: mem time67, current time 162, horizon 95\n", + "adding: mem time68, current time 162, horizon 94\n", + "adding: mem time69, current time 162, horizon 93\n", + "adding: mem time70, current time 162, horizon 92\n", + "adding: mem time71, current time 162, horizon 91\n", + "adding: mem time72, current time 162, horizon 90\n", + "adding: mem time73, current time 162, horizon 89\n", + "adding: mem time74, current time 162, horizon 88\n", + "adding: mem time75, current time 162, horizon 87\n", + "adding: mem time76, current time 162, horizon 86\n", + "adding: mem time77, current time 162, horizon 85\n", + "adding: mem time78, current time 162, horizon 84\n", + "adding: mem time79, current time 162, horizon 83\n", + "adding: mem time80, current time 162, horizon 82\n", + "adding: mem time81, current time 162, horizon 81\n", + "adding: mem time82, current time 162, horizon 80\n", + "adding: mem time83, current time 162, horizon 79\n", + "adding: mem time84, current time 162, horizon 78\n", + "adding: mem time85, current time 162, horizon 77\n", + "adding: mem time86, current time 162, horizon 76\n", + "adding: mem time87, current time 162, horizon 75\n", + "adding: mem time88, current time 162, horizon 74\n", + "adding: mem time89, current time 162, horizon 73\n", + "adding: mem time90, current time 162, horizon 72\n", + "adding: mem time91, current time 162, horizon 71\n", + "adding: mem time92, current time 162, horizon 70\n", + "adding: mem time93, current time 162, horizon 69\n", + "adding: mem time94, current time 162, horizon 68\n", + "adding: mem time95, current time 162, horizon 67\n", + "adding: mem time96, current time 162, horizon 66\n", + "adding: mem time97, current time 162, horizon 65\n", + "adding: mem time98, current time 162, horizon 64\n", + "adding: mem time99, current time 162, horizon 63\n", + "adding: mem time100, current time 162, horizon 62\n", + "adding: mem time101, current time 162, horizon 61\n", + "adding: mem time102, current time 162, horizon 60\n", + "adding: mem time103, current time 162, horizon 59\n", + "adding: mem time104, current time 162, horizon 58\n", + "adding: mem time105, current time 162, horizon 57\n", + "adding: mem time106, current time 162, horizon 56\n", + "adding: mem time107, current time 162, horizon 55\n", + "adding: mem time108, current time 162, horizon 54\n", + "adding: mem time109, current time 162, horizon 53\n", + "adding: mem time110, current time 162, horizon 52\n", + "adding: mem time111, current time 162, horizon 51\n", + "adding: mem time112, current time 162, horizon 50\n", + "adding: mem time113, current time 162, horizon 49\n", + "adding: mem time114, current time 162, horizon 48\n", + "adding: mem time115, current time 162, horizon 47\n", + "adding: mem time116, current time 162, horizon 46\n", + "adding: mem time117, current time 162, horizon 45\n", + "adding: mem time118, current time 162, horizon 44\n", + "adding: mem time119, current time 162, horizon 43\n", + "adding: mem time120, current time 162, horizon 42\n", + "adding: mem time121, current time 162, horizon 41\n", + "adding: mem time122, current time 162, horizon 40\n", + "adding: mem time123, current time 162, horizon 39\n", + "adding: mem time124, current time 162, horizon 38\n", + "adding: mem time125, current time 162, horizon 37\n", + "adding: mem time126, current time 162, horizon 36\n", + "adding: mem time127, current time 162, horizon 35\n", + "adding: mem time128, current time 162, horizon 34\n", + "adding: mem time129, current time 162, horizon 33\n", + "adding: mem time130, current time 162, horizon 32\n", + "adding: mem time131, current time 162, horizon 31\n", + "adding: mem time132, current time 162, horizon 30\n", + "adding: mem time133, current time 162, horizon 29\n", + "adding: mem time134, current time 162, horizon 28\n", + "adding: mem time135, current time 162, horizon 27\n", + "adding: mem time136, current time 162, horizon 26\n", + "adding: mem time137, current time 162, horizon 25\n", + "adding: mem time138, current time 162, horizon 24\n", + "adding: mem time139, current time 162, horizon 23\n", + "adding: mem time140, current time 162, horizon 22\n", + "adding: mem time141, current time 162, horizon 21\n", + "adding: mem time142, current time 162, horizon 20\n", + "adding: mem time143, current time 162, horizon 19\n", + "adding: mem time144, current time 162, horizon 18\n", + "adding: mem time145, current time 162, horizon 17\n", + "adding: mem time146, current time 162, horizon 16\n", + "adding: mem time147, current time 162, horizon 15\n", + "adding: mem time148, current time 162, horizon 14\n", + "adding: mem time149, current time 162, horizon 13\n", + "adding: mem time150, current time 162, horizon 12\n", + "adding: mem time151, current time 162, horizon 11\n", + "adding: mem time152, current time 162, horizon 10\n", + "adding: mem time153, current time 162, horizon 9\n", + "adding: mem time154, current time 162, horizon 8\n", + "adding: mem time155, current time 162, horizon 7\n", + "adding: mem time156, current time 162, horizon 6\n", + "adding: mem time157, current time 162, horizon 5\n", + "adding: mem time158, current time 162, horizon 4\n", + "adding: mem time159, current time 162, horizon 3\n", + "adding: mem time160, current time 162, horizon 2\n", + "adding: mem time161, current time 162, horizon 1\n", + "adding: mem time0, current time 163, horizon 163\n", + "adding: mem time1, current time 163, horizon 162\n", + "adding: mem time2, current time 163, horizon 161\n", + "adding: mem time3, current time 163, horizon 160\n", + "adding: mem time4, current time 163, horizon 159\n", + "adding: mem time5, current time 163, horizon 158\n", + "adding: mem time6, current time 163, horizon 157\n", + "adding: mem time7, current time 163, horizon 156\n", + "adding: mem time8, current time 163, horizon 155\n", + "adding: mem time9, current time 163, horizon 154\n", + "adding: mem time10, current time 163, horizon 153\n", + "adding: mem time11, current time 163, horizon 152\n", + "adding: mem time12, current time 163, horizon 151\n", + "adding: mem time13, current time 163, horizon 150\n", + "adding: mem time14, current time 163, horizon 149\n", + "adding: mem time15, current time 163, horizon 148\n", + "adding: mem time16, current time 163, horizon 147\n", + "adding: mem time17, current time 163, horizon 146\n", + "adding: mem time18, current time 163, horizon 145\n", + "adding: mem time19, current time 163, horizon 144\n", + "adding: mem time20, current time 163, horizon 143\n", + "adding: mem time21, current time 163, horizon 142\n", + "adding: mem time22, current time 163, horizon 141\n", + "adding: mem time23, current time 163, horizon 140\n", + "adding: mem time24, current time 163, horizon 139\n", + "adding: mem time25, current time 163, horizon 138\n", + "adding: mem time26, current time 163, horizon 137\n", + "adding: mem time27, current time 163, horizon 136\n", + "adding: mem time28, current time 163, horizon 135\n", + "adding: mem time29, current time 163, horizon 134\n", + "adding: mem time30, current time 163, horizon 133\n", + "adding: mem time31, current time 163, horizon 132\n", + "adding: mem time32, current time 163, horizon 131\n", + "adding: mem time33, current time 163, horizon 130\n", + "adding: mem time34, current time 163, horizon 129\n", + "adding: mem time35, current time 163, horizon 128\n", + "adding: mem time36, current time 163, horizon 127\n", + "adding: mem time37, current time 163, horizon 126\n", + "adding: mem time38, current time 163, horizon 125\n", + "adding: mem time39, current time 163, horizon 124\n", + "adding: mem time40, current time 163, horizon 123\n", + "adding: mem time41, current time 163, horizon 122\n", + "adding: mem time42, current time 163, horizon 121\n", + "adding: mem time43, current time 163, horizon 120\n", + "adding: mem time44, current time 163, horizon 119\n", + "adding: mem time45, current time 163, horizon 118\n", + "adding: mem time46, current time 163, horizon 117\n", + "adding: mem time47, current time 163, horizon 116\n", + "adding: mem time48, current time 163, horizon 115\n", + "adding: mem time49, current time 163, horizon 114\n", + "adding: mem time50, current time 163, horizon 113\n", + "adding: mem time51, current time 163, horizon 112\n", + "adding: mem time52, current time 163, horizon 111\n", + "adding: mem time53, current time 163, horizon 110\n", + "adding: mem time54, current time 163, horizon 109\n", + "adding: mem time55, current time 163, horizon 108\n", + "adding: mem time56, current time 163, horizon 107\n", + "adding: mem time57, current time 163, horizon 106\n", + "adding: mem time58, current time 163, horizon 105\n", + "adding: mem time59, current time 163, horizon 104\n", + "adding: mem time60, current time 163, horizon 103\n", + "adding: mem time61, current time 163, horizon 102\n", + "adding: mem time62, current time 163, horizon 101\n", + "adding: mem time63, current time 163, horizon 100\n", + "adding: mem time64, current time 163, horizon 99\n", + "adding: mem time65, current time 163, horizon 98\n", + "adding: mem time66, current time 163, horizon 97\n", + "adding: mem time67, current time 163, horizon 96\n", + "adding: mem time68, current time 163, horizon 95\n", + "adding: mem time69, current time 163, horizon 94\n", + "adding: mem time70, current time 163, horizon 93\n", + "adding: mem time71, current time 163, horizon 92\n", + "adding: mem time72, current time 163, horizon 91\n", + "adding: mem time73, current time 163, horizon 90\n", + "adding: mem time74, current time 163, horizon 89\n", + "adding: mem time75, current time 163, horizon 88\n", + "adding: mem time76, current time 163, horizon 87\n", + "adding: mem time77, current time 163, horizon 86\n", + "adding: mem time78, current time 163, horizon 85\n", + "adding: mem time79, current time 163, horizon 84\n", + "adding: mem time80, current time 163, horizon 83\n", + "adding: mem time81, current time 163, horizon 82\n", + "adding: mem time82, current time 163, horizon 81\n", + "adding: mem time83, current time 163, horizon 80\n", + "adding: mem time84, current time 163, horizon 79\n", + "adding: mem time85, current time 163, horizon 78\n", + "adding: mem time86, current time 163, horizon 77\n", + "adding: mem time87, current time 163, horizon 76\n", + "adding: mem time88, current time 163, horizon 75\n", + "adding: mem time89, current time 163, horizon 74\n", + "adding: mem time90, current time 163, horizon 73\n", + "adding: mem time91, current time 163, horizon 72\n", + "adding: mem time92, current time 163, horizon 71\n", + "adding: mem time93, current time 163, horizon 70\n", + "adding: mem time94, current time 163, horizon 69\n", + "adding: mem time95, current time 163, horizon 68\n", + "adding: mem time96, current time 163, horizon 67\n", + "adding: mem time97, current time 163, horizon 66\n", + "adding: mem time98, current time 163, horizon 65\n", + "adding: mem time99, current time 163, horizon 64\n", + "adding: mem time100, current time 163, horizon 63\n", + "adding: mem time101, current time 163, horizon 62\n", + "adding: mem time102, current time 163, horizon 61\n", + "adding: mem time103, current time 163, horizon 60\n", + "adding: mem time104, current time 163, horizon 59\n", + "adding: mem time105, current time 163, horizon 58\n", + "adding: mem time106, current time 163, horizon 57\n", + "adding: mem time107, current time 163, horizon 56\n", + "adding: mem time108, current time 163, horizon 55\n", + "adding: mem time109, current time 163, horizon 54\n", + "adding: mem time110, current time 163, horizon 53\n", + "adding: mem time111, current time 163, horizon 52\n", + "adding: mem time112, current time 163, horizon 51\n", + "adding: mem time113, current time 163, horizon 50\n", + "adding: mem time114, current time 163, horizon 49\n", + "adding: mem time115, current time 163, horizon 48\n", + "adding: mem time116, current time 163, horizon 47\n", + "adding: mem time117, current time 163, horizon 46\n", + "adding: mem time118, current time 163, horizon 45\n", + "adding: mem time119, current time 163, horizon 44\n", + "adding: mem time120, current time 163, horizon 43\n", + "adding: mem time121, current time 163, horizon 42\n", + "adding: mem time122, current time 163, horizon 41\n", + "adding: mem time123, current time 163, horizon 40\n", + "adding: mem time124, current time 163, horizon 39\n", + "adding: mem time125, current time 163, horizon 38\n", + "adding: mem time126, current time 163, horizon 37\n", + "adding: mem time127, current time 163, horizon 36\n", + "adding: mem time128, current time 163, horizon 35\n", + "adding: mem time129, current time 163, horizon 34\n", + "adding: mem time130, current time 163, horizon 33\n", + "adding: mem time131, current time 163, horizon 32\n", + "adding: mem time132, current time 163, horizon 31\n", + "adding: mem time133, current time 163, horizon 30\n", + "adding: mem time134, current time 163, horizon 29\n", + "adding: mem time135, current time 163, horizon 28\n", + "adding: mem time136, current time 163, horizon 27\n", + "adding: mem time137, current time 163, horizon 26\n", + "adding: mem time138, current time 163, horizon 25\n", + "adding: mem time139, current time 163, horizon 24\n", + "adding: mem time140, current time 163, horizon 23\n", + "adding: mem time141, current time 163, horizon 22\n", + "adding: mem time142, current time 163, horizon 21\n", + "adding: mem time143, current time 163, horizon 20\n", + "adding: mem time144, current time 163, horizon 19\n", + "adding: mem time145, current time 163, horizon 18\n", + "adding: mem time146, current time 163, horizon 17\n", + "adding: mem time147, current time 163, horizon 16\n", + "adding: mem time148, current time 163, horizon 15\n", + "adding: mem time149, current time 163, horizon 14\n", + "adding: mem time150, current time 163, horizon 13\n", + "adding: mem time151, current time 163, horizon 12\n", + "adding: mem time152, current time 163, horizon 11\n", + "adding: mem time153, current time 163, horizon 10\n", + "adding: mem time154, current time 163, horizon 9\n", + "adding: mem time155, current time 163, horizon 8\n", + "adding: mem time156, current time 163, horizon 7\n", + "adding: mem time157, current time 163, horizon 6\n", + "adding: mem time158, current time 163, horizon 5\n", + "adding: mem time159, current time 163, horizon 4\n", + "adding: mem time160, current time 163, horizon 3\n", + "adding: mem time161, current time 163, horizon 2\n", + "adding: mem time162, current time 163, horizon 1\n", + "adding: mem time0, current time 164, horizon 164\n", + "adding: mem time1, current time 164, horizon 163\n", + "adding: mem time2, current time 164, horizon 162\n", + "adding: mem time3, current time 164, horizon 161\n", + "adding: mem time4, current time 164, horizon 160\n", + "adding: mem time5, current time 164, horizon 159\n", + "adding: mem time6, current time 164, horizon 158\n", + "adding: mem time7, current time 164, horizon 157\n", + "adding: mem time8, current time 164, horizon 156\n", + "adding: mem time9, current time 164, horizon 155\n", + "adding: mem time10, current time 164, horizon 154\n", + "adding: mem time11, current time 164, horizon 153\n", + "adding: mem time12, current time 164, horizon 152\n", + "adding: mem time13, current time 164, horizon 151\n", + "adding: mem time14, current time 164, horizon 150\n", + "adding: mem time15, current time 164, horizon 149\n", + "adding: mem time16, current time 164, horizon 148\n", + "adding: mem time17, current time 164, horizon 147\n", + "adding: mem time18, current time 164, horizon 146\n", + "adding: mem time19, current time 164, horizon 145\n", + "adding: mem time20, current time 164, horizon 144\n", + "adding: mem time21, current time 164, horizon 143\n", + "adding: mem time22, current time 164, horizon 142\n", + "adding: mem time23, current time 164, horizon 141\n", + "adding: mem time24, current time 164, horizon 140\n", + "adding: mem time25, current time 164, horizon 139\n", + "adding: mem time26, current time 164, horizon 138\n", + "adding: mem time27, current time 164, horizon 137\n", + "adding: mem time28, current time 164, horizon 136\n", + "adding: mem time29, current time 164, horizon 135\n", + "adding: mem time30, current time 164, horizon 134\n", + "adding: mem time31, current time 164, horizon 133\n", + "adding: mem time32, current time 164, horizon 132\n", + "adding: mem time33, current time 164, horizon 131\n", + "adding: mem time34, current time 164, horizon 130\n", + "adding: mem time35, current time 164, horizon 129\n", + "adding: mem time36, current time 164, horizon 128\n", + "adding: mem time37, current time 164, horizon 127\n", + "adding: mem time38, current time 164, horizon 126\n", + "adding: mem time39, current time 164, horizon 125\n", + "adding: mem time40, current time 164, horizon 124\n", + "adding: mem time41, current time 164, horizon 123\n", + "adding: mem time42, current time 164, horizon 122\n", + "adding: mem time43, current time 164, horizon 121\n", + "adding: mem time44, current time 164, horizon 120\n", + "adding: mem time45, current time 164, horizon 119\n", + "adding: mem time46, current time 164, horizon 118\n", + "adding: mem time47, current time 164, horizon 117\n", + "adding: mem time48, current time 164, horizon 116\n", + "adding: mem time49, current time 164, horizon 115\n", + "adding: mem time50, current time 164, horizon 114\n", + "adding: mem time51, current time 164, horizon 113\n", + "adding: mem time52, current time 164, horizon 112\n", + "adding: mem time53, current time 164, horizon 111\n", + "adding: mem time54, current time 164, horizon 110\n", + "adding: mem time55, current time 164, horizon 109\n", + "adding: mem time56, current time 164, horizon 108\n", + "adding: mem time57, current time 164, horizon 107\n", + "adding: mem time58, current time 164, horizon 106\n", + "adding: mem time59, current time 164, horizon 105\n", + "adding: mem time60, current time 164, horizon 104\n", + "adding: mem time61, current time 164, horizon 103\n", + "adding: mem time62, current time 164, horizon 102\n", + "adding: mem time63, current time 164, horizon 101\n", + "adding: mem time64, current time 164, horizon 100\n", + "adding: mem time65, current time 164, horizon 99\n", + "adding: mem time66, current time 164, horizon 98\n", + "adding: mem time67, current time 164, horizon 97\n", + "adding: mem time68, current time 164, horizon 96\n", + "adding: mem time69, current time 164, horizon 95\n", + "adding: mem time70, current time 164, horizon 94\n", + "adding: mem time71, current time 164, horizon 93\n", + "adding: mem time72, current time 164, horizon 92\n", + "adding: mem time73, current time 164, horizon 91\n", + "adding: mem time74, current time 164, horizon 90\n", + "adding: mem time75, current time 164, horizon 89\n", + "adding: mem time76, current time 164, horizon 88\n", + "adding: mem time77, current time 164, horizon 87\n", + "adding: mem time78, current time 164, horizon 86\n", + "adding: mem time79, current time 164, horizon 85\n", + "adding: mem time80, current time 164, horizon 84\n", + "adding: mem time81, current time 164, horizon 83\n", + "adding: mem time82, current time 164, horizon 82\n", + "adding: mem time83, current time 164, horizon 81\n", + "adding: mem time84, current time 164, horizon 80\n", + "adding: mem time85, current time 164, horizon 79\n", + "adding: mem time86, current time 164, horizon 78\n", + "adding: mem time87, current time 164, horizon 77\n", + "adding: mem time88, current time 164, horizon 76\n", + "adding: mem time89, current time 164, horizon 75\n", + "adding: mem time90, current time 164, horizon 74\n", + "adding: mem time91, current time 164, horizon 73\n", + "adding: mem time92, current time 164, horizon 72\n", + "adding: mem time93, current time 164, horizon 71\n", + "adding: mem time94, current time 164, horizon 70\n", + "adding: mem time95, current time 164, horizon 69\n", + "adding: mem time96, current time 164, horizon 68\n", + "adding: mem time97, current time 164, horizon 67\n", + "adding: mem time98, current time 164, horizon 66\n", + "adding: mem time99, current time 164, horizon 65\n", + "adding: mem time100, current time 164, horizon 64\n", + "adding: mem time101, current time 164, horizon 63\n", + "adding: mem time102, current time 164, horizon 62\n", + "adding: mem time103, current time 164, horizon 61\n", + "adding: mem time104, current time 164, horizon 60\n", + "adding: mem time105, current time 164, horizon 59\n", + "adding: mem time106, current time 164, horizon 58\n", + "adding: mem time107, current time 164, horizon 57\n", + "adding: mem time108, current time 164, horizon 56\n", + "adding: mem time109, current time 164, horizon 55\n", + "adding: mem time110, current time 164, horizon 54\n", + "adding: mem time111, current time 164, horizon 53\n", + "adding: mem time112, current time 164, horizon 52\n", + "adding: mem time113, current time 164, horizon 51\n", + "adding: mem time114, current time 164, horizon 50\n", + "adding: mem time115, current time 164, horizon 49\n", + "adding: mem time116, current time 164, horizon 48\n", + "adding: mem time117, current time 164, horizon 47\n", + "adding: mem time118, current time 164, horizon 46\n", + "adding: mem time119, current time 164, horizon 45\n", + "adding: mem time120, current time 164, horizon 44\n", + "adding: mem time121, current time 164, horizon 43\n", + "adding: mem time122, current time 164, horizon 42\n", + "adding: mem time123, current time 164, horizon 41\n", + "adding: mem time124, current time 164, horizon 40\n", + "adding: mem time125, current time 164, horizon 39\n", + "adding: mem time126, current time 164, horizon 38\n", + "adding: mem time127, current time 164, horizon 37\n", + "adding: mem time128, current time 164, horizon 36\n", + "adding: mem time129, current time 164, horizon 35\n", + "adding: mem time130, current time 164, horizon 34\n", + "adding: mem time131, current time 164, horizon 33\n", + "adding: mem time132, current time 164, horizon 32\n", + "adding: mem time133, current time 164, horizon 31\n", + "adding: mem time134, current time 164, horizon 30\n", + "adding: mem time135, current time 164, horizon 29\n", + "adding: mem time136, current time 164, horizon 28\n", + "adding: mem time137, current time 164, horizon 27\n", + "adding: mem time138, current time 164, horizon 26\n", + "adding: mem time139, current time 164, horizon 25\n", + "adding: mem time140, current time 164, horizon 24\n", + "adding: mem time141, current time 164, horizon 23\n", + "adding: mem time142, current time 164, horizon 22\n", + "adding: mem time143, current time 164, horizon 21\n", + "adding: mem time144, current time 164, horizon 20\n", + "adding: mem time145, current time 164, horizon 19\n", + "adding: mem time146, current time 164, horizon 18\n", + "adding: mem time147, current time 164, horizon 17\n", + "adding: mem time148, current time 164, horizon 16\n", + "adding: mem time149, current time 164, horizon 15\n", + "adding: mem time150, current time 164, horizon 14\n", + "adding: mem time151, current time 164, horizon 13\n", + "adding: mem time152, current time 164, horizon 12\n", + "adding: mem time153, current time 164, horizon 11\n", + "adding: mem time154, current time 164, horizon 10\n", + "adding: mem time155, current time 164, horizon 9\n", + "adding: mem time156, current time 164, horizon 8\n", + "adding: mem time157, current time 164, horizon 7\n", + "adding: mem time158, current time 164, horizon 6\n", + "adding: mem time159, current time 164, horizon 5\n", + "adding: mem time160, current time 164, horizon 4\n", + "adding: mem time161, current time 164, horizon 3\n", + "adding: mem time162, current time 164, horizon 2\n", + "adding: mem time163, current time 164, horizon 1\n", + "adding: mem time0, current time 165, horizon 165\n", + "adding: mem time1, current time 165, horizon 164\n", + "adding: mem time2, current time 165, horizon 163\n", + "adding: mem time3, current time 165, horizon 162\n", + "adding: mem time4, current time 165, horizon 161\n", + "adding: mem time5, current time 165, horizon 160\n", + "adding: mem time6, current time 165, horizon 159\n", + "adding: mem time7, current time 165, horizon 158\n", + "adding: mem time8, current time 165, horizon 157\n", + "adding: mem time9, current time 165, horizon 156\n", + "adding: mem time10, current time 165, horizon 155\n", + "adding: mem time11, current time 165, horizon 154\n", + "adding: mem time12, current time 165, horizon 153\n", + "adding: mem time13, current time 165, horizon 152\n", + "adding: mem time14, current time 165, horizon 151\n", + "adding: mem time15, current time 165, horizon 150\n", + "adding: mem time16, current time 165, horizon 149\n", + "adding: mem time17, current time 165, horizon 148\n", + "adding: mem time18, current time 165, horizon 147\n", + "adding: mem time19, current time 165, horizon 146\n", + "adding: mem time20, current time 165, horizon 145\n", + "adding: mem time21, current time 165, horizon 144\n", + "adding: mem time22, current time 165, horizon 143\n", + "adding: mem time23, current time 165, horizon 142\n", + "adding: mem time24, current time 165, horizon 141\n", + "adding: mem time25, current time 165, horizon 140\n", + "adding: mem time26, current time 165, horizon 139\n", + "adding: mem time27, current time 165, horizon 138\n", + "adding: mem time28, current time 165, horizon 137\n", + "adding: mem time29, current time 165, horizon 136\n", + "adding: mem time30, current time 165, horizon 135\n", + "adding: mem time31, current time 165, horizon 134\n", + "adding: mem time32, current time 165, horizon 133\n", + "adding: mem time33, current time 165, horizon 132\n", + "adding: mem time34, current time 165, horizon 131\n", + "adding: mem time35, current time 165, horizon 130\n", + "adding: mem time36, current time 165, horizon 129\n", + "adding: mem time37, current time 165, horizon 128\n", + "adding: mem time38, current time 165, horizon 127\n", + "adding: mem time39, current time 165, horizon 126\n", + "adding: mem time40, current time 165, horizon 125\n", + "adding: mem time41, current time 165, horizon 124\n", + "adding: mem time42, current time 165, horizon 123\n", + "adding: mem time43, current time 165, horizon 122\n", + "adding: mem time44, current time 165, horizon 121\n", + "adding: mem time45, current time 165, horizon 120\n", + "adding: mem time46, current time 165, horizon 119\n", + "adding: mem time47, current time 165, horizon 118\n", + "adding: mem time48, current time 165, horizon 117\n", + "adding: mem time49, current time 165, horizon 116\n", + "adding: mem time50, current time 165, horizon 115\n", + "adding: mem time51, current time 165, horizon 114\n", + "adding: mem time52, current time 165, horizon 113\n", + "adding: mem time53, current time 165, horizon 112\n", + "adding: mem time54, current time 165, horizon 111\n", + "adding: mem time55, current time 165, horizon 110\n", + "adding: mem time56, current time 165, horizon 109\n", + "adding: mem time57, current time 165, horizon 108\n", + "adding: mem time58, current time 165, horizon 107\n", + "adding: mem time59, current time 165, horizon 106\n", + "adding: mem time60, current time 165, horizon 105\n", + "adding: mem time61, current time 165, horizon 104\n", + "adding: mem time62, current time 165, horizon 103\n", + "adding: mem time63, current time 165, horizon 102\n", + "adding: mem time64, current time 165, horizon 101\n", + "adding: mem time65, current time 165, horizon 100\n", + "adding: mem time66, current time 165, horizon 99\n", + "adding: mem time67, current time 165, horizon 98\n", + "adding: mem time68, current time 165, horizon 97\n", + "adding: mem time69, current time 165, horizon 96\n", + "adding: mem time70, current time 165, horizon 95\n", + "adding: mem time71, current time 165, horizon 94\n", + "adding: mem time72, current time 165, horizon 93\n", + "adding: mem time73, current time 165, horizon 92\n", + "adding: mem time74, current time 165, horizon 91\n", + "adding: mem time75, current time 165, horizon 90\n", + "adding: mem time76, current time 165, horizon 89\n", + "adding: mem time77, current time 165, horizon 88\n", + "adding: mem time78, current time 165, horizon 87\n", + "adding: mem time79, current time 165, horizon 86\n", + "adding: mem time80, current time 165, horizon 85\n", + "adding: mem time81, current time 165, horizon 84\n", + "adding: mem time82, current time 165, horizon 83\n", + "adding: mem time83, current time 165, horizon 82\n", + "adding: mem time84, current time 165, horizon 81\n", + "adding: mem time85, current time 165, horizon 80\n", + "adding: mem time86, current time 165, horizon 79\n", + "adding: mem time87, current time 165, horizon 78\n", + "adding: mem time88, current time 165, horizon 77\n", + "adding: mem time89, current time 165, horizon 76\n", + "adding: mem time90, current time 165, horizon 75\n", + "adding: mem time91, current time 165, horizon 74\n", + "adding: mem time92, current time 165, horizon 73\n", + "adding: mem time93, current time 165, horizon 72\n", + "adding: mem time94, current time 165, horizon 71\n", + "adding: mem time95, current time 165, horizon 70\n", + "adding: mem time96, current time 165, horizon 69\n", + "adding: mem time97, current time 165, horizon 68\n", + "adding: mem time98, current time 165, horizon 67\n", + "adding: mem time99, current time 165, horizon 66\n", + "adding: mem time100, current time 165, horizon 65\n", + "adding: mem time101, current time 165, horizon 64\n", + "adding: mem time102, current time 165, horizon 63\n", + "adding: mem time103, current time 165, horizon 62\n", + "adding: mem time104, current time 165, horizon 61\n", + "adding: mem time105, current time 165, horizon 60\n", + "adding: mem time106, current time 165, horizon 59\n", + "adding: mem time107, current time 165, horizon 58\n", + "adding: mem time108, current time 165, horizon 57\n", + "adding: mem time109, current time 165, horizon 56\n", + "adding: mem time110, current time 165, horizon 55\n", + "adding: mem time111, current time 165, horizon 54\n", + "adding: mem time112, current time 165, horizon 53\n", + "adding: mem time113, current time 165, horizon 52\n", + "adding: mem time114, current time 165, horizon 51\n", + "adding: mem time115, current time 165, horizon 50\n", + "adding: mem time116, current time 165, horizon 49\n", + "adding: mem time117, current time 165, horizon 48\n", + "adding: mem time118, current time 165, horizon 47\n", + "adding: mem time119, current time 165, horizon 46\n", + "adding: mem time120, current time 165, horizon 45\n", + "adding: mem time121, current time 165, horizon 44\n", + "adding: mem time122, current time 165, horizon 43\n", + "adding: mem time123, current time 165, horizon 42\n", + "adding: mem time124, current time 165, horizon 41\n", + "adding: mem time125, current time 165, horizon 40\n", + "adding: mem time126, current time 165, horizon 39\n", + "adding: mem time127, current time 165, horizon 38\n", + "adding: mem time128, current time 165, horizon 37\n", + "adding: mem time129, current time 165, horizon 36\n", + "adding: mem time130, current time 165, horizon 35\n", + "adding: mem time131, current time 165, horizon 34\n", + "adding: mem time132, current time 165, horizon 33\n", + "adding: mem time133, current time 165, horizon 32\n", + "adding: mem time134, current time 165, horizon 31\n", + "adding: mem time135, current time 165, horizon 30\n", + "adding: mem time136, current time 165, horizon 29\n", + "adding: mem time137, current time 165, horizon 28\n", + "adding: mem time138, current time 165, horizon 27\n", + "adding: mem time139, current time 165, horizon 26\n", + "adding: mem time140, current time 165, horizon 25\n", + "adding: mem time141, current time 165, horizon 24\n", + "adding: mem time142, current time 165, horizon 23\n", + "adding: mem time143, current time 165, horizon 22\n", + "adding: mem time144, current time 165, horizon 21\n", + "adding: mem time145, current time 165, horizon 20\n", + "adding: mem time146, current time 165, horizon 19\n", + "adding: mem time147, current time 165, horizon 18\n", + "adding: mem time148, current time 165, horizon 17\n", + "adding: mem time149, current time 165, horizon 16\n", + "adding: mem time150, current time 165, horizon 15\n", + "adding: mem time151, current time 165, horizon 14\n", + "adding: mem time152, current time 165, horizon 13\n", + "adding: mem time153, current time 165, horizon 12\n", + "adding: mem time154, current time 165, horizon 11\n", + "adding: mem time155, current time 165, horizon 10\n", + "adding: mem time156, current time 165, horizon 9\n", + "adding: mem time157, current time 165, horizon 8\n", + "adding: mem time158, current time 165, horizon 7\n", + "adding: mem time159, current time 165, horizon 6\n", + "adding: mem time160, current time 165, horizon 5\n", + "adding: mem time161, current time 165, horizon 4\n", + "adding: mem time162, current time 165, horizon 3\n", + "adding: mem time163, current time 165, horizon 2\n", + "adding: mem time164, current time 165, horizon 1\n", + "adding: mem time0, current time 166, horizon 166\n", + "adding: mem time1, current time 166, horizon 165\n", + "adding: mem time2, current time 166, horizon 164\n", + "adding: mem time3, current time 166, horizon 163\n", + "adding: mem time4, current time 166, horizon 162\n", + "adding: mem time5, current time 166, horizon 161\n", + "adding: mem time6, current time 166, horizon 160\n", + "adding: mem time7, current time 166, horizon 159\n", + "adding: mem time8, current time 166, horizon 158\n", + "adding: mem time9, current time 166, horizon 157\n", + "adding: mem time10, current time 166, horizon 156\n", + "adding: mem time11, current time 166, horizon 155\n", + "adding: mem time12, current time 166, horizon 154\n", + "adding: mem time13, current time 166, horizon 153\n", + "adding: mem time14, current time 166, horizon 152\n", + "adding: mem time15, current time 166, horizon 151\n", + "adding: mem time16, current time 166, horizon 150\n", + "adding: mem time17, current time 166, horizon 149\n", + "adding: mem time18, current time 166, horizon 148\n", + "adding: mem time19, current time 166, horizon 147\n", + "adding: mem time20, current time 166, horizon 146\n", + "adding: mem time21, current time 166, horizon 145\n", + "adding: mem time22, current time 166, horizon 144\n", + "adding: mem time23, current time 166, horizon 143\n", + "adding: mem time24, current time 166, horizon 142\n", + "adding: mem time25, current time 166, horizon 141\n", + "adding: mem time26, current time 166, horizon 140\n", + "adding: mem time27, current time 166, horizon 139\n", + "adding: mem time28, current time 166, horizon 138\n", + "adding: mem time29, current time 166, horizon 137\n", + "adding: mem time30, current time 166, horizon 136\n", + "adding: mem time31, current time 166, horizon 135\n", + "adding: mem time32, current time 166, horizon 134\n", + "adding: mem time33, current time 166, horizon 133\n", + "adding: mem time34, current time 166, horizon 132\n", + "adding: mem time35, current time 166, horizon 131\n", + "adding: mem time36, current time 166, horizon 130\n", + "adding: mem time37, current time 166, horizon 129\n", + "adding: mem time38, current time 166, horizon 128\n", + "adding: mem time39, current time 166, horizon 127\n", + "adding: mem time40, current time 166, horizon 126\n", + "adding: mem time41, current time 166, horizon 125\n", + "adding: mem time42, current time 166, horizon 124\n", + "adding: mem time43, current time 166, horizon 123\n", + "adding: mem time44, current time 166, horizon 122\n", + "adding: mem time45, current time 166, horizon 121\n", + "adding: mem time46, current time 166, horizon 120\n", + "adding: mem time47, current time 166, horizon 119\n", + "adding: mem time48, current time 166, horizon 118\n", + "adding: mem time49, current time 166, horizon 117\n", + "adding: mem time50, current time 166, horizon 116\n", + "adding: mem time51, current time 166, horizon 115\n", + "adding: mem time52, current time 166, horizon 114\n", + "adding: mem time53, current time 166, horizon 113\n", + "adding: mem time54, current time 166, horizon 112\n", + "adding: mem time55, current time 166, horizon 111\n", + "adding: mem time56, current time 166, horizon 110\n", + "adding: mem time57, current time 166, horizon 109\n", + "adding: mem time58, current time 166, horizon 108\n", + "adding: mem time59, current time 166, horizon 107\n", + "adding: mem time60, current time 166, horizon 106\n", + "adding: mem time61, current time 166, horizon 105\n", + "adding: mem time62, current time 166, horizon 104\n", + "adding: mem time63, current time 166, horizon 103\n", + "adding: mem time64, current time 166, horizon 102\n", + "adding: mem time65, current time 166, horizon 101\n", + "adding: mem time66, current time 166, horizon 100\n", + "adding: mem time67, current time 166, horizon 99\n", + "adding: mem time68, current time 166, horizon 98\n", + "adding: mem time69, current time 166, horizon 97\n", + "adding: mem time70, current time 166, horizon 96\n", + "adding: mem time71, current time 166, horizon 95\n", + "adding: mem time72, current time 166, horizon 94\n", + "adding: mem time73, current time 166, horizon 93\n", + "adding: mem time74, current time 166, horizon 92\n", + "adding: mem time75, current time 166, horizon 91\n", + "adding: mem time76, current time 166, horizon 90\n", + "adding: mem time77, current time 166, horizon 89\n", + "adding: mem time78, current time 166, horizon 88\n", + "adding: mem time79, current time 166, horizon 87\n", + "adding: mem time80, current time 166, horizon 86\n", + "adding: mem time81, current time 166, horizon 85\n", + "adding: mem time82, current time 166, horizon 84\n", + "adding: mem time83, current time 166, horizon 83\n", + "adding: mem time84, current time 166, horizon 82\n", + "adding: mem time85, current time 166, horizon 81\n", + "adding: mem time86, current time 166, horizon 80\n", + "adding: mem time87, current time 166, horizon 79\n", + "adding: mem time88, current time 166, horizon 78\n", + "adding: mem time89, current time 166, horizon 77\n", + "adding: mem time90, current time 166, horizon 76\n", + "adding: mem time91, current time 166, horizon 75\n", + "adding: mem time92, current time 166, horizon 74\n", + "adding: mem time93, current time 166, horizon 73\n", + "adding: mem time94, current time 166, horizon 72\n", + "adding: mem time95, current time 166, horizon 71\n", + "adding: mem time96, current time 166, horizon 70\n", + "adding: mem time97, current time 166, horizon 69\n", + "adding: mem time98, current time 166, horizon 68\n", + "adding: mem time99, current time 166, horizon 67\n", + "adding: mem time100, current time 166, horizon 66\n", + "adding: mem time101, current time 166, horizon 65\n", + "adding: mem time102, current time 166, horizon 64\n", + "adding: mem time103, current time 166, horizon 63\n", + "adding: mem time104, current time 166, horizon 62\n", + "adding: mem time105, current time 166, horizon 61\n", + "adding: mem time106, current time 166, horizon 60\n", + "adding: mem time107, current time 166, horizon 59\n", + "adding: mem time108, current time 166, horizon 58\n", + "adding: mem time109, current time 166, horizon 57\n", + "adding: mem time110, current time 166, horizon 56\n", + "adding: mem time111, current time 166, horizon 55\n", + "adding: mem time112, current time 166, horizon 54\n", + "adding: mem time113, current time 166, horizon 53\n", + "adding: mem time114, current time 166, horizon 52\n", + "adding: mem time115, current time 166, horizon 51\n", + "adding: mem time116, current time 166, horizon 50\n", + "adding: mem time117, current time 166, horizon 49\n", + "adding: mem time118, current time 166, horizon 48\n", + "adding: mem time119, current time 166, horizon 47\n", + "adding: mem time120, current time 166, horizon 46\n", + "adding: mem time121, current time 166, horizon 45\n", + "adding: mem time122, current time 166, horizon 44\n", + "adding: mem time123, current time 166, horizon 43\n", + "adding: mem time124, current time 166, horizon 42\n", + "adding: mem time125, current time 166, horizon 41\n", + "adding: mem time126, current time 166, horizon 40\n", + "adding: mem time127, current time 166, horizon 39\n", + "adding: mem time128, current time 166, horizon 38\n", + "adding: mem time129, current time 166, horizon 37\n", + "adding: mem time130, current time 166, horizon 36\n", + "adding: mem time131, current time 166, horizon 35\n", + "adding: mem time132, current time 166, horizon 34\n", + "adding: mem time133, current time 166, horizon 33\n", + "adding: mem time134, current time 166, horizon 32\n", + "adding: mem time135, current time 166, horizon 31\n", + "adding: mem time136, current time 166, horizon 30\n", + "adding: mem time137, current time 166, horizon 29\n", + "adding: mem time138, current time 166, horizon 28\n", + "adding: mem time139, current time 166, horizon 27\n", + "adding: mem time140, current time 166, horizon 26\n", + "adding: mem time141, current time 166, horizon 25\n", + "adding: mem time142, current time 166, horizon 24\n", + "adding: mem time143, current time 166, horizon 23\n", + "adding: mem time144, current time 166, horizon 22\n", + "adding: mem time145, current time 166, horizon 21\n", + "adding: mem time146, current time 166, horizon 20\n", + "adding: mem time147, current time 166, horizon 19\n", + "adding: mem time148, current time 166, horizon 18\n", + "adding: mem time149, current time 166, horizon 17\n", + "adding: mem time150, current time 166, horizon 16\n", + "adding: mem time151, current time 166, horizon 15\n", + "adding: mem time152, current time 166, horizon 14\n", + "adding: mem time153, current time 166, horizon 13\n", + "adding: mem time154, current time 166, horizon 12\n", + "adding: mem time155, current time 166, horizon 11\n", + "adding: mem time156, current time 166, horizon 10\n", + "adding: mem time157, current time 166, horizon 9\n", + "adding: mem time158, current time 166, horizon 8\n", + "adding: mem time159, current time 166, horizon 7\n", + "adding: mem time160, current time 166, horizon 6\n", + "adding: mem time161, current time 166, horizon 5\n", + "adding: mem time162, current time 166, horizon 4\n", + "adding: mem time163, current time 166, horizon 3\n", + "adding: mem time164, current time 166, horizon 2\n", + "adding: mem time165, current time 166, horizon 1\n", + "adding: mem time0, current time 167, horizon 167\n", + "adding: mem time1, current time 167, horizon 166\n", + "adding: mem time2, current time 167, horizon 165\n", + "adding: mem time3, current time 167, horizon 164\n", + "adding: mem time4, current time 167, horizon 163\n", + "adding: mem time5, current time 167, horizon 162\n", + "adding: mem time6, current time 167, horizon 161\n", + "adding: mem time7, current time 167, horizon 160\n", + "adding: mem time8, current time 167, horizon 159\n", + "adding: mem time9, current time 167, horizon 158\n", + "adding: mem time10, current time 167, horizon 157\n", + "adding: mem time11, current time 167, horizon 156\n", + "adding: mem time12, current time 167, horizon 155\n", + "adding: mem time13, current time 167, horizon 154\n", + "adding: mem time14, current time 167, horizon 153\n", + "adding: mem time15, current time 167, horizon 152\n", + "adding: mem time16, current time 167, horizon 151\n", + "adding: mem time17, current time 167, horizon 150\n", + "adding: mem time18, current time 167, horizon 149\n", + "adding: mem time19, current time 167, horizon 148\n", + "adding: mem time20, current time 167, horizon 147\n", + "adding: mem time21, current time 167, horizon 146\n", + "adding: mem time22, current time 167, horizon 145\n", + "adding: mem time23, current time 167, horizon 144\n", + "adding: mem time24, current time 167, horizon 143\n", + "adding: mem time25, current time 167, horizon 142\n", + "adding: mem time26, current time 167, horizon 141\n", + "adding: mem time27, current time 167, horizon 140\n", + "adding: mem time28, current time 167, horizon 139\n", + "adding: mem time29, current time 167, horizon 138\n", + "adding: mem time30, current time 167, horizon 137\n", + "adding: mem time31, current time 167, horizon 136\n", + "adding: mem time32, current time 167, horizon 135\n", + "adding: mem time33, current time 167, horizon 134\n", + "adding: mem time34, current time 167, horizon 133\n", + "adding: mem time35, current time 167, horizon 132\n", + "adding: mem time36, current time 167, horizon 131\n", + "adding: mem time37, current time 167, horizon 130\n", + "adding: mem time38, current time 167, horizon 129\n", + "adding: mem time39, current time 167, horizon 128\n", + "adding: mem time40, current time 167, horizon 127\n", + "adding: mem time41, current time 167, horizon 126\n", + "adding: mem time42, current time 167, horizon 125\n", + "adding: mem time43, current time 167, horizon 124\n", + "adding: mem time44, current time 167, horizon 123\n", + "adding: mem time45, current time 167, horizon 122\n", + "adding: mem time46, current time 167, horizon 121\n", + "adding: mem time47, current time 167, horizon 120\n", + "adding: mem time48, current time 167, horizon 119\n", + "adding: mem time49, current time 167, horizon 118\n", + "adding: mem time50, current time 167, horizon 117\n", + "adding: mem time51, current time 167, horizon 116\n", + "adding: mem time52, current time 167, horizon 115\n", + "adding: mem time53, current time 167, horizon 114\n", + "adding: mem time54, current time 167, horizon 113\n", + "adding: mem time55, current time 167, horizon 112\n", + "adding: mem time56, current time 167, horizon 111\n", + "adding: mem time57, current time 167, horizon 110\n", + "adding: mem time58, current time 167, horizon 109\n", + "adding: mem time59, current time 167, horizon 108\n", + "adding: mem time60, current time 167, horizon 107\n", + "adding: mem time61, current time 167, horizon 106\n", + "adding: mem time62, current time 167, horizon 105\n", + "adding: mem time63, current time 167, horizon 104\n", + "adding: mem time64, current time 167, horizon 103\n", + "adding: mem time65, current time 167, horizon 102\n", + "adding: mem time66, current time 167, horizon 101\n", + "adding: mem time67, current time 167, horizon 100\n", + "adding: mem time68, current time 167, horizon 99\n", + "adding: mem time69, current time 167, horizon 98\n", + "adding: mem time70, current time 167, horizon 97\n", + "adding: mem time71, current time 167, horizon 96\n", + "adding: mem time72, current time 167, horizon 95\n", + "adding: mem time73, current time 167, horizon 94\n", + "adding: mem time74, current time 167, horizon 93\n", + "adding: mem time75, current time 167, horizon 92\n", + "adding: mem time76, current time 167, horizon 91\n", + "adding: mem time77, current time 167, horizon 90\n", + "adding: mem time78, current time 167, horizon 89\n", + "adding: mem time79, current time 167, horizon 88\n", + "adding: mem time80, current time 167, horizon 87\n", + "adding: mem time81, current time 167, horizon 86\n", + "adding: mem time82, current time 167, horizon 85\n", + "adding: mem time83, current time 167, horizon 84\n", + "adding: mem time84, current time 167, horizon 83\n", + "adding: mem time85, current time 167, horizon 82\n", + "adding: mem time86, current time 167, horizon 81\n", + "adding: mem time87, current time 167, horizon 80\n", + "adding: mem time88, current time 167, horizon 79\n", + "adding: mem time89, current time 167, horizon 78\n", + "adding: mem time90, current time 167, horizon 77\n", + "adding: mem time91, current time 167, horizon 76\n", + "adding: mem time92, current time 167, horizon 75\n", + "adding: mem time93, current time 167, horizon 74\n", + "adding: mem time94, current time 167, horizon 73\n", + "adding: mem time95, current time 167, horizon 72\n", + "adding: mem time96, current time 167, horizon 71\n", + "adding: mem time97, current time 167, horizon 70\n", + "adding: mem time98, current time 167, horizon 69\n", + "adding: mem time99, current time 167, horizon 68\n", + "adding: mem time100, current time 167, horizon 67\n", + "adding: mem time101, current time 167, horizon 66\n", + "adding: mem time102, current time 167, horizon 65\n", + "adding: mem time103, current time 167, horizon 64\n", + "adding: mem time104, current time 167, horizon 63\n", + "adding: mem time105, current time 167, horizon 62\n", + "adding: mem time106, current time 167, horizon 61\n", + "adding: mem time107, current time 167, horizon 60\n", + "adding: mem time108, current time 167, horizon 59\n", + "adding: mem time109, current time 167, horizon 58\n", + "adding: mem time110, current time 167, horizon 57\n", + "adding: mem time111, current time 167, horizon 56\n", + "adding: mem time112, current time 167, horizon 55\n", + "adding: mem time113, current time 167, horizon 54\n", + "adding: mem time114, current time 167, horizon 53\n", + "adding: mem time115, current time 167, horizon 52\n", + "adding: mem time116, current time 167, horizon 51\n", + "adding: mem time117, current time 167, horizon 50\n", + "adding: mem time118, current time 167, horizon 49\n", + "adding: mem time119, current time 167, horizon 48\n", + "adding: mem time120, current time 167, horizon 47\n", + "adding: mem time121, current time 167, horizon 46\n", + "adding: mem time122, current time 167, horizon 45\n", + "adding: mem time123, current time 167, horizon 44\n", + "adding: mem time124, current time 167, horizon 43\n", + "adding: mem time125, current time 167, horizon 42\n", + "adding: mem time126, current time 167, horizon 41\n", + "adding: mem time127, current time 167, horizon 40\n", + "adding: mem time128, current time 167, horizon 39\n", + "adding: mem time129, current time 167, horizon 38\n", + "adding: mem time130, current time 167, horizon 37\n", + "adding: mem time131, current time 167, horizon 36\n", + "adding: mem time132, current time 167, horizon 35\n", + "adding: mem time133, current time 167, horizon 34\n", + "adding: mem time134, current time 167, horizon 33\n", + "adding: mem time135, current time 167, horizon 32\n", + "adding: mem time136, current time 167, horizon 31\n", + "adding: mem time137, current time 167, horizon 30\n", + "adding: mem time138, current time 167, horizon 29\n", + "adding: mem time139, current time 167, horizon 28\n", + "adding: mem time140, current time 167, horizon 27\n", + "adding: mem time141, current time 167, horizon 26\n", + "adding: mem time142, current time 167, horizon 25\n", + "adding: mem time143, current time 167, horizon 24\n", + "adding: mem time144, current time 167, horizon 23\n", + "adding: mem time145, current time 167, horizon 22\n", + "adding: mem time146, current time 167, horizon 21\n", + "adding: mem time147, current time 167, horizon 20\n", + "adding: mem time148, current time 167, horizon 19\n", + "adding: mem time149, current time 167, horizon 18\n", + "adding: mem time150, current time 167, horizon 17\n", + "adding: mem time151, current time 167, horizon 16\n", + "adding: mem time152, current time 167, horizon 15\n", + "adding: mem time153, current time 167, horizon 14\n", + "adding: mem time154, current time 167, horizon 13\n", + "adding: mem time155, current time 167, horizon 12\n", + "adding: mem time156, current time 167, horizon 11\n", + "adding: mem time157, current time 167, horizon 10\n", + "adding: mem time158, current time 167, horizon 9\n", + "adding: mem time159, current time 167, horizon 8\n", + "adding: mem time160, current time 167, horizon 7\n", + "adding: mem time161, current time 167, horizon 6\n", + "adding: mem time162, current time 167, horizon 5\n", + "adding: mem time163, current time 167, horizon 4\n", + "adding: mem time164, current time 167, horizon 3\n", + "adding: mem time165, current time 167, horizon 2\n", + "adding: mem time166, current time 167, horizon 1\n", + "adding: mem time0, current time 168, horizon 168\n", + "adding: mem time1, current time 168, horizon 167\n", + "adding: mem time2, current time 168, horizon 166\n", + "adding: mem time3, current time 168, horizon 165\n", + "adding: mem time4, current time 168, horizon 164\n", + "adding: mem time5, current time 168, horizon 163\n", + "adding: mem time6, current time 168, horizon 162\n", + "adding: mem time7, current time 168, horizon 161\n", + "adding: mem time8, current time 168, horizon 160\n", + "adding: mem time9, current time 168, horizon 159\n", + "adding: mem time10, current time 168, horizon 158\n", + "adding: mem time11, current time 168, horizon 157\n", + "adding: mem time12, current time 168, horizon 156\n", + "adding: mem time13, current time 168, horizon 155\n", + "adding: mem time14, current time 168, horizon 154\n", + "adding: mem time15, current time 168, horizon 153\n", + "adding: mem time16, current time 168, horizon 152\n", + "adding: mem time17, current time 168, horizon 151\n", + "adding: mem time18, current time 168, horizon 150\n", + "adding: mem time19, current time 168, horizon 149\n", + "adding: mem time20, current time 168, horizon 148\n", + "adding: mem time21, current time 168, horizon 147\n", + "adding: mem time22, current time 168, horizon 146\n", + "adding: mem time23, current time 168, horizon 145\n", + "adding: mem time24, current time 168, horizon 144\n", + "adding: mem time25, current time 168, horizon 143\n", + "adding: mem time26, current time 168, horizon 142\n", + "adding: mem time27, current time 168, horizon 141\n", + "adding: mem time28, current time 168, horizon 140\n", + "adding: mem time29, current time 168, horizon 139\n", + "adding: mem time30, current time 168, horizon 138\n", + "adding: mem time31, current time 168, horizon 137\n", + "adding: mem time32, current time 168, horizon 136\n", + "adding: mem time33, current time 168, horizon 135\n", + "adding: mem time34, current time 168, horizon 134\n", + "adding: mem time35, current time 168, horizon 133\n", + "adding: mem time36, current time 168, horizon 132\n", + "adding: mem time37, current time 168, horizon 131\n", + "adding: mem time38, current time 168, horizon 130\n", + "adding: mem time39, current time 168, horizon 129\n", + "adding: mem time40, current time 168, horizon 128\n", + "adding: mem time41, current time 168, horizon 127\n", + "adding: mem time42, current time 168, horizon 126\n", + "adding: mem time43, current time 168, horizon 125\n", + "adding: mem time44, current time 168, horizon 124\n", + "adding: mem time45, current time 168, horizon 123\n", + "adding: mem time46, current time 168, horizon 122\n", + "adding: mem time47, current time 168, horizon 121\n", + "adding: mem time48, current time 168, horizon 120\n", + "adding: mem time49, current time 168, horizon 119\n", + "adding: mem time50, current time 168, horizon 118\n", + "adding: mem time51, current time 168, horizon 117\n", + "adding: mem time52, current time 168, horizon 116\n", + "adding: mem time53, current time 168, horizon 115\n", + "adding: mem time54, current time 168, horizon 114\n", + "adding: mem time55, current time 168, horizon 113\n", + "adding: mem time56, current time 168, horizon 112\n", + "adding: mem time57, current time 168, horizon 111\n", + "adding: mem time58, current time 168, horizon 110\n", + "adding: mem time59, current time 168, horizon 109\n", + "adding: mem time60, current time 168, horizon 108\n", + "adding: mem time61, current time 168, horizon 107\n", + "adding: mem time62, current time 168, horizon 106\n", + "adding: mem time63, current time 168, horizon 105\n", + "adding: mem time64, current time 168, horizon 104\n", + "adding: mem time65, current time 168, horizon 103\n", + "adding: mem time66, current time 168, horizon 102\n", + "adding: mem time67, current time 168, horizon 101\n", + "adding: mem time68, current time 168, horizon 100\n", + "adding: mem time69, current time 168, horizon 99\n", + "adding: mem time70, current time 168, horizon 98\n", + "adding: mem time71, current time 168, horizon 97\n", + "adding: mem time72, current time 168, horizon 96\n", + "adding: mem time73, current time 168, horizon 95\n", + "adding: mem time74, current time 168, horizon 94\n", + "adding: mem time75, current time 168, horizon 93\n", + "adding: mem time76, current time 168, horizon 92\n", + "adding: mem time77, current time 168, horizon 91\n", + "adding: mem time78, current time 168, horizon 90\n", + "adding: mem time79, current time 168, horizon 89\n", + "adding: mem time80, current time 168, horizon 88\n", + "adding: mem time81, current time 168, horizon 87\n", + "adding: mem time82, current time 168, horizon 86\n", + "adding: mem time83, current time 168, horizon 85\n", + "adding: mem time84, current time 168, horizon 84\n", + "adding: mem time85, current time 168, horizon 83\n", + "adding: mem time86, current time 168, horizon 82\n", + "adding: mem time87, current time 168, horizon 81\n", + "adding: mem time88, current time 168, horizon 80\n", + "adding: mem time89, current time 168, horizon 79\n", + "adding: mem time90, current time 168, horizon 78\n", + "adding: mem time91, current time 168, horizon 77\n", + "adding: mem time92, current time 168, horizon 76\n", + "adding: mem time93, current time 168, horizon 75\n", + "adding: mem time94, current time 168, horizon 74\n", + "adding: mem time95, current time 168, horizon 73\n", + "adding: mem time96, current time 168, horizon 72\n", + "adding: mem time97, current time 168, horizon 71\n", + "adding: mem time98, current time 168, horizon 70\n", + "adding: mem time99, current time 168, horizon 69\n", + "adding: mem time100, current time 168, horizon 68\n", + "adding: mem time101, current time 168, horizon 67\n", + "adding: mem time102, current time 168, horizon 66\n", + "adding: mem time103, current time 168, horizon 65\n", + "adding: mem time104, current time 168, horizon 64\n", + "adding: mem time105, current time 168, horizon 63\n", + "adding: mem time106, current time 168, horizon 62\n", + "adding: mem time107, current time 168, horizon 61\n", + "adding: mem time108, current time 168, horizon 60\n", + "adding: mem time109, current time 168, horizon 59\n", + "adding: mem time110, current time 168, horizon 58\n", + "adding: mem time111, current time 168, horizon 57\n", + "adding: mem time112, current time 168, horizon 56\n", + "adding: mem time113, current time 168, horizon 55\n", + "adding: mem time114, current time 168, horizon 54\n", + "adding: mem time115, current time 168, horizon 53\n", + "adding: mem time116, current time 168, horizon 52\n", + "adding: mem time117, current time 168, horizon 51\n", + "adding: mem time118, current time 168, horizon 50\n", + "adding: mem time119, current time 168, horizon 49\n", + "adding: mem time120, current time 168, horizon 48\n", + "adding: mem time121, current time 168, horizon 47\n", + "adding: mem time122, current time 168, horizon 46\n", + "adding: mem time123, current time 168, horizon 45\n", + "adding: mem time124, current time 168, horizon 44\n", + "adding: mem time125, current time 168, horizon 43\n", + "adding: mem time126, current time 168, horizon 42\n", + "adding: mem time127, current time 168, horizon 41\n", + "adding: mem time128, current time 168, horizon 40\n", + "adding: mem time129, current time 168, horizon 39\n", + "adding: mem time130, current time 168, horizon 38\n", + "adding: mem time131, current time 168, horizon 37\n", + "adding: mem time132, current time 168, horizon 36\n", + "adding: mem time133, current time 168, horizon 35\n", + "adding: mem time134, current time 168, horizon 34\n", + "adding: mem time135, current time 168, horizon 33\n", + "adding: mem time136, current time 168, horizon 32\n", + "adding: mem time137, current time 168, horizon 31\n", + "adding: mem time138, current time 168, horizon 30\n", + "adding: mem time139, current time 168, horizon 29\n", + "adding: mem time140, current time 168, horizon 28\n", + "adding: mem time141, current time 168, horizon 27\n", + "adding: mem time142, current time 168, horizon 26\n", + "adding: mem time143, current time 168, horizon 25\n", + "adding: mem time144, current time 168, horizon 24\n", + "adding: mem time145, current time 168, horizon 23\n", + "adding: mem time146, current time 168, horizon 22\n", + "adding: mem time147, current time 168, horizon 21\n", + "adding: mem time148, current time 168, horizon 20\n", + "adding: mem time149, current time 168, horizon 19\n", + "adding: mem time150, current time 168, horizon 18\n", + "adding: mem time151, current time 168, horizon 17\n", + "adding: mem time152, current time 168, horizon 16\n", + "adding: mem time153, current time 168, horizon 15\n", + "adding: mem time154, current time 168, horizon 14\n", + "adding: mem time155, current time 168, horizon 13\n", + "adding: mem time156, current time 168, horizon 12\n", + "adding: mem time157, current time 168, horizon 11\n", + "adding: mem time158, current time 168, horizon 10\n", + "adding: mem time159, current time 168, horizon 9\n", + "adding: mem time160, current time 168, horizon 8\n", + "adding: mem time161, current time 168, horizon 7\n", + "adding: mem time162, current time 168, horizon 6\n", + "adding: mem time163, current time 168, horizon 5\n", + "adding: mem time164, current time 168, horizon 4\n", + "adding: mem time165, current time 168, horizon 3\n", + "adding: mem time166, current time 168, horizon 2\n", + "adding: mem time167, current time 168, horizon 1\n", + "adding: mem time0, current time 169, horizon 169\n", + "adding: mem time1, current time 169, horizon 168\n", + "adding: mem time2, current time 169, horizon 167\n", + "adding: mem time3, current time 169, horizon 166\n", + "adding: mem time4, current time 169, horizon 165\n", + "adding: mem time5, current time 169, horizon 164\n", + "adding: mem time6, current time 169, horizon 163\n", + "adding: mem time7, current time 169, horizon 162\n", + "adding: mem time8, current time 169, horizon 161\n", + "adding: mem time9, current time 169, horizon 160\n", + "adding: mem time10, current time 169, horizon 159\n", + "adding: mem time11, current time 169, horizon 158\n", + "adding: mem time12, current time 169, horizon 157\n", + "adding: mem time13, current time 169, horizon 156\n", + "adding: mem time14, current time 169, horizon 155\n", + "adding: mem time15, current time 169, horizon 154\n", + "adding: mem time16, current time 169, horizon 153\n", + "adding: mem time17, current time 169, horizon 152\n", + "adding: mem time18, current time 169, horizon 151\n", + "adding: mem time19, current time 169, horizon 150\n", + "adding: mem time20, current time 169, horizon 149\n", + "adding: mem time21, current time 169, horizon 148\n", + "adding: mem time22, current time 169, horizon 147\n", + "adding: mem time23, current time 169, horizon 146\n", + "adding: mem time24, current time 169, horizon 145\n", + "adding: mem time25, current time 169, horizon 144\n", + "adding: mem time26, current time 169, horizon 143\n", + "adding: mem time27, current time 169, horizon 142\n", + "adding: mem time28, current time 169, horizon 141\n", + "adding: mem time29, current time 169, horizon 140\n", + "adding: mem time30, current time 169, horizon 139\n", + "adding: mem time31, current time 169, horizon 138\n", + "adding: mem time32, current time 169, horizon 137\n", + "adding: mem time33, current time 169, horizon 136\n", + "adding: mem time34, current time 169, horizon 135\n", + "adding: mem time35, current time 169, horizon 134\n", + "adding: mem time36, current time 169, horizon 133\n", + "adding: mem time37, current time 169, horizon 132\n", + "adding: mem time38, current time 169, horizon 131\n", + "adding: mem time39, current time 169, horizon 130\n", + "adding: mem time40, current time 169, horizon 129\n", + "adding: mem time41, current time 169, horizon 128\n", + "adding: mem time42, current time 169, horizon 127\n", + "adding: mem time43, current time 169, horizon 126\n", + "adding: mem time44, current time 169, horizon 125\n", + "adding: mem time45, current time 169, horizon 124\n", + "adding: mem time46, current time 169, horizon 123\n", + "adding: mem time47, current time 169, horizon 122\n", + "adding: mem time48, current time 169, horizon 121\n", + "adding: mem time49, current time 169, horizon 120\n", + "adding: mem time50, current time 169, horizon 119\n", + "adding: mem time51, current time 169, horizon 118\n", + "adding: mem time52, current time 169, horizon 117\n", + "adding: mem time53, current time 169, horizon 116\n", + "adding: mem time54, current time 169, horizon 115\n", + "adding: mem time55, current time 169, horizon 114\n", + "adding: mem time56, current time 169, horizon 113\n", + "adding: mem time57, current time 169, horizon 112\n", + "adding: mem time58, current time 169, horizon 111\n", + "adding: mem time59, current time 169, horizon 110\n", + "adding: mem time60, current time 169, horizon 109\n", + "adding: mem time61, current time 169, horizon 108\n", + "adding: mem time62, current time 169, horizon 107\n", + "adding: mem time63, current time 169, horizon 106\n", + "adding: mem time64, current time 169, horizon 105\n", + "adding: mem time65, current time 169, horizon 104\n", + "adding: mem time66, current time 169, horizon 103\n", + "adding: mem time67, current time 169, horizon 102\n", + "adding: mem time68, current time 169, horizon 101\n", + "adding: mem time69, current time 169, horizon 100\n", + "adding: mem time70, current time 169, horizon 99\n", + "adding: mem time71, current time 169, horizon 98\n", + "adding: mem time72, current time 169, horizon 97\n", + "adding: mem time73, current time 169, horizon 96\n", + "adding: mem time74, current time 169, horizon 95\n", + "adding: mem time75, current time 169, horizon 94\n", + "adding: mem time76, current time 169, horizon 93\n", + "adding: mem time77, current time 169, horizon 92\n", + "adding: mem time78, current time 169, horizon 91\n", + "adding: mem time79, current time 169, horizon 90\n", + "adding: mem time80, current time 169, horizon 89\n", + "adding: mem time81, current time 169, horizon 88\n", + "adding: mem time82, current time 169, horizon 87\n", + "adding: mem time83, current time 169, horizon 86\n", + "adding: mem time84, current time 169, horizon 85\n", + "adding: mem time85, current time 169, horizon 84\n", + "adding: mem time86, current time 169, horizon 83\n", + "adding: mem time87, current time 169, horizon 82\n", + "adding: mem time88, current time 169, horizon 81\n", + "adding: mem time89, current time 169, horizon 80\n", + "adding: mem time90, current time 169, horizon 79\n", + "adding: mem time91, current time 169, horizon 78\n", + "adding: mem time92, current time 169, horizon 77\n", + "adding: mem time93, current time 169, horizon 76\n", + "adding: mem time94, current time 169, horizon 75\n", + "adding: mem time95, current time 169, horizon 74\n", + "adding: mem time96, current time 169, horizon 73\n", + "adding: mem time97, current time 169, horizon 72\n", + "adding: mem time98, current time 169, horizon 71\n", + "adding: mem time99, current time 169, horizon 70\n", + "adding: mem time100, current time 169, horizon 69\n", + "adding: mem time101, current time 169, horizon 68\n", + "adding: mem time102, current time 169, horizon 67\n", + "adding: mem time103, current time 169, horizon 66\n", + "adding: mem time104, current time 169, horizon 65\n", + "adding: mem time105, current time 169, horizon 64\n", + "adding: mem time106, current time 169, horizon 63\n", + "adding: mem time107, current time 169, horizon 62\n", + "adding: mem time108, current time 169, horizon 61\n", + "adding: mem time109, current time 169, horizon 60\n", + "adding: mem time110, current time 169, horizon 59\n", + "adding: mem time111, current time 169, horizon 58\n", + "adding: mem time112, current time 169, horizon 57\n", + "adding: mem time113, current time 169, horizon 56\n", + "adding: mem time114, current time 169, horizon 55\n", + "adding: mem time115, current time 169, horizon 54\n", + "adding: mem time116, current time 169, horizon 53\n", + "adding: mem time117, current time 169, horizon 52\n", + "adding: mem time118, current time 169, horizon 51\n", + "adding: mem time119, current time 169, horizon 50\n", + "adding: mem time120, current time 169, horizon 49\n", + "adding: mem time121, current time 169, horizon 48\n", + "adding: mem time122, current time 169, horizon 47\n", + "adding: mem time123, current time 169, horizon 46\n", + "adding: mem time124, current time 169, horizon 45\n", + "adding: mem time125, current time 169, horizon 44\n", + "adding: mem time126, current time 169, horizon 43\n", + "adding: mem time127, current time 169, horizon 42\n", + "adding: mem time128, current time 169, horizon 41\n", + "adding: mem time129, current time 169, horizon 40\n", + "adding: mem time130, current time 169, horizon 39\n", + "adding: mem time131, current time 169, horizon 38\n", + "adding: mem time132, current time 169, horizon 37\n", + "adding: mem time133, current time 169, horizon 36\n", + "adding: mem time134, current time 169, horizon 35\n", + "adding: mem time135, current time 169, horizon 34\n", + "adding: mem time136, current time 169, horizon 33\n", + "adding: mem time137, current time 169, horizon 32\n", + "adding: mem time138, current time 169, horizon 31\n", + "adding: mem time139, current time 169, horizon 30\n", + "adding: mem time140, current time 169, horizon 29\n", + "adding: mem time141, current time 169, horizon 28\n", + "adding: mem time142, current time 169, horizon 27\n", + "adding: mem time143, current time 169, horizon 26\n", + "adding: mem time144, current time 169, horizon 25\n", + "adding: mem time145, current time 169, horizon 24\n", + "adding: mem time146, current time 169, horizon 23\n", + "adding: mem time147, current time 169, horizon 22\n", + "adding: mem time148, current time 169, horizon 21\n", + "adding: mem time149, current time 169, horizon 20\n", + "adding: mem time150, current time 169, horizon 19\n", + "adding: mem time151, current time 169, horizon 18\n", + "adding: mem time152, current time 169, horizon 17\n", + "adding: mem time153, current time 169, horizon 16\n", + "adding: mem time154, current time 169, horizon 15\n", + "adding: mem time155, current time 169, horizon 14\n", + "adding: mem time156, current time 169, horizon 13\n", + "adding: mem time157, current time 169, horizon 12\n", + "adding: mem time158, current time 169, horizon 11\n", + "adding: mem time159, current time 169, horizon 10\n", + "adding: mem time160, current time 169, horizon 9\n", + "adding: mem time161, current time 169, horizon 8\n", + "adding: mem time162, current time 169, horizon 7\n", + "adding: mem time163, current time 169, horizon 6\n", + "adding: mem time164, current time 169, horizon 5\n", + "adding: mem time165, current time 169, horizon 4\n", + "adding: mem time166, current time 169, horizon 3\n", + "adding: mem time167, current time 169, horizon 2\n", + "adding: mem time168, current time 169, horizon 1\n", + "adding: mem time0, current time 170, horizon 170\n", + "adding: mem time1, current time 170, horizon 169\n", + "adding: mem time2, current time 170, horizon 168\n", + "adding: mem time3, current time 170, horizon 167\n", + "adding: mem time4, current time 170, horizon 166\n", + "adding: mem time5, current time 170, horizon 165\n", + "adding: mem time6, current time 170, horizon 164\n", + "adding: mem time7, current time 170, horizon 163\n", + "adding: mem time8, current time 170, horizon 162\n", + "adding: mem time9, current time 170, horizon 161\n", + "adding: mem time10, current time 170, horizon 160\n", + "adding: mem time11, current time 170, horizon 159\n", + "adding: mem time12, current time 170, horizon 158\n", + "adding: mem time13, current time 170, horizon 157\n", + "adding: mem time14, current time 170, horizon 156\n", + "adding: mem time15, current time 170, horizon 155\n", + "adding: mem time16, current time 170, horizon 154\n", + "adding: mem time17, current time 170, horizon 153\n", + "adding: mem time18, current time 170, horizon 152\n", + "adding: mem time19, current time 170, horizon 151\n", + "adding: mem time20, current time 170, horizon 150\n", + "adding: mem time21, current time 170, horizon 149\n", + "adding: mem time22, current time 170, horizon 148\n", + "adding: mem time23, current time 170, horizon 147\n", + "adding: mem time24, current time 170, horizon 146\n", + "adding: mem time25, current time 170, horizon 145\n", + "adding: mem time26, current time 170, horizon 144\n", + "adding: mem time27, current time 170, horizon 143\n", + "adding: mem time28, current time 170, horizon 142\n", + "adding: mem time29, current time 170, horizon 141\n", + "adding: mem time30, current time 170, horizon 140\n", + "adding: mem time31, current time 170, horizon 139\n", + "adding: mem time32, current time 170, horizon 138\n", + "adding: mem time33, current time 170, horizon 137\n", + "adding: mem time34, current time 170, horizon 136\n", + "adding: mem time35, current time 170, horizon 135\n", + "adding: mem time36, current time 170, horizon 134\n", + "adding: mem time37, current time 170, horizon 133\n", + "adding: mem time38, current time 170, horizon 132\n", + "adding: mem time39, current time 170, horizon 131\n", + "adding: mem time40, current time 170, horizon 130\n", + "adding: mem time41, current time 170, horizon 129\n", + "adding: mem time42, current time 170, horizon 128\n", + "adding: mem time43, current time 170, horizon 127\n", + "adding: mem time44, current time 170, horizon 126\n", + "adding: mem time45, current time 170, horizon 125\n", + "adding: mem time46, current time 170, horizon 124\n", + "adding: mem time47, current time 170, horizon 123\n", + "adding: mem time48, current time 170, horizon 122\n", + "adding: mem time49, current time 170, horizon 121\n", + "adding: mem time50, current time 170, horizon 120\n", + "adding: mem time51, current time 170, horizon 119\n", + "adding: mem time52, current time 170, horizon 118\n", + "adding: mem time53, current time 170, horizon 117\n", + "adding: mem time54, current time 170, horizon 116\n", + "adding: mem time55, current time 170, horizon 115\n", + "adding: mem time56, current time 170, horizon 114\n", + "adding: mem time57, current time 170, horizon 113\n", + "adding: mem time58, current time 170, horizon 112\n", + "adding: mem time59, current time 170, horizon 111\n", + "adding: mem time60, current time 170, horizon 110\n", + "adding: mem time61, current time 170, horizon 109\n", + "adding: mem time62, current time 170, horizon 108\n", + "adding: mem time63, current time 170, horizon 107\n", + "adding: mem time64, current time 170, horizon 106\n", + "adding: mem time65, current time 170, horizon 105\n", + "adding: mem time66, current time 170, horizon 104\n", + "adding: mem time67, current time 170, horizon 103\n", + "adding: mem time68, current time 170, horizon 102\n", + "adding: mem time69, current time 170, horizon 101\n", + "adding: mem time70, current time 170, horizon 100\n", + "adding: mem time71, current time 170, horizon 99\n", + "adding: mem time72, current time 170, horizon 98\n", + "adding: mem time73, current time 170, horizon 97\n", + "adding: mem time74, current time 170, horizon 96\n", + "adding: mem time75, current time 170, horizon 95\n", + "adding: mem time76, current time 170, horizon 94\n", + "adding: mem time77, current time 170, horizon 93\n", + "adding: mem time78, current time 170, horizon 92\n", + "adding: mem time79, current time 170, horizon 91\n", + "adding: mem time80, current time 170, horizon 90\n", + "adding: mem time81, current time 170, horizon 89\n", + "adding: mem time82, current time 170, horizon 88\n", + "adding: mem time83, current time 170, horizon 87\n", + "adding: mem time84, current time 170, horizon 86\n", + "adding: mem time85, current time 170, horizon 85\n", + "adding: mem time86, current time 170, horizon 84\n", + "adding: mem time87, current time 170, horizon 83\n", + "adding: mem time88, current time 170, horizon 82\n", + "adding: mem time89, current time 170, horizon 81\n", + "adding: mem time90, current time 170, horizon 80\n", + "adding: mem time91, current time 170, horizon 79\n", + "adding: mem time92, current time 170, horizon 78\n", + "adding: mem time93, current time 170, horizon 77\n", + "adding: mem time94, current time 170, horizon 76\n", + "adding: mem time95, current time 170, horizon 75\n", + "adding: mem time96, current time 170, horizon 74\n", + "adding: mem time97, current time 170, horizon 73\n", + "adding: mem time98, current time 170, horizon 72\n", + "adding: mem time99, current time 170, horizon 71\n", + "adding: mem time100, current time 170, horizon 70\n", + "adding: mem time101, current time 170, horizon 69\n", + "adding: mem time102, current time 170, horizon 68\n", + "adding: mem time103, current time 170, horizon 67\n", + "adding: mem time104, current time 170, horizon 66\n", + "adding: mem time105, current time 170, horizon 65\n", + "adding: mem time106, current time 170, horizon 64\n", + "adding: mem time107, current time 170, horizon 63\n", + "adding: mem time108, current time 170, horizon 62\n", + "adding: mem time109, current time 170, horizon 61\n", + "adding: mem time110, current time 170, horizon 60\n", + "adding: mem time111, current time 170, horizon 59\n", + "adding: mem time112, current time 170, horizon 58\n", + "adding: mem time113, current time 170, horizon 57\n", + "adding: mem time114, current time 170, horizon 56\n", + "adding: mem time115, current time 170, horizon 55\n", + "adding: mem time116, current time 170, horizon 54\n", + "adding: mem time117, current time 170, horizon 53\n", + "adding: mem time118, current time 170, horizon 52\n", + "adding: mem time119, current time 170, horizon 51\n", + "adding: mem time120, current time 170, horizon 50\n", + "adding: mem time121, current time 170, horizon 49\n", + "adding: mem time122, current time 170, horizon 48\n", + "adding: mem time123, current time 170, horizon 47\n", + "adding: mem time124, current time 170, horizon 46\n", + "adding: mem time125, current time 170, horizon 45\n", + "adding: mem time126, current time 170, horizon 44\n", + "adding: mem time127, current time 170, horizon 43\n", + "adding: mem time128, current time 170, horizon 42\n", + "adding: mem time129, current time 170, horizon 41\n", + "adding: mem time130, current time 170, horizon 40\n", + "adding: mem time131, current time 170, horizon 39\n", + "adding: mem time132, current time 170, horizon 38\n", + "adding: mem time133, current time 170, horizon 37\n", + "adding: mem time134, current time 170, horizon 36\n", + "adding: mem time135, current time 170, horizon 35\n", + "adding: mem time136, current time 170, horizon 34\n", + "adding: mem time137, current time 170, horizon 33\n", + "adding: mem time138, current time 170, horizon 32\n", + "adding: mem time139, current time 170, horizon 31\n", + "adding: mem time140, current time 170, horizon 30\n", + "adding: mem time141, current time 170, horizon 29\n", + "adding: mem time142, current time 170, horizon 28\n", + "adding: mem time143, current time 170, horizon 27\n", + "adding: mem time144, current time 170, horizon 26\n", + "adding: mem time145, current time 170, horizon 25\n", + "adding: mem time146, current time 170, horizon 24\n", + "adding: mem time147, current time 170, horizon 23\n", + "adding: mem time148, current time 170, horizon 22\n", + "adding: mem time149, current time 170, horizon 21\n", + "adding: mem time150, current time 170, horizon 20\n", + "adding: mem time151, current time 170, horizon 19\n", + "adding: mem time152, current time 170, horizon 18\n", + "adding: mem time153, current time 170, horizon 17\n", + "adding: mem time154, current time 170, horizon 16\n", + "adding: mem time155, current time 170, horizon 15\n", + "adding: mem time156, current time 170, horizon 14\n", + "adding: mem time157, current time 170, horizon 13\n", + "adding: mem time158, current time 170, horizon 12\n", + "adding: mem time159, current time 170, horizon 11\n", + "adding: mem time160, current time 170, horizon 10\n", + "adding: mem time161, current time 170, horizon 9\n", + "adding: mem time162, current time 170, horizon 8\n", + "adding: mem time163, current time 170, horizon 7\n", + "adding: mem time164, current time 170, horizon 6\n", + "adding: mem time165, current time 170, horizon 5\n", + "adding: mem time166, current time 170, horizon 4\n", + "adding: mem time167, current time 170, horizon 3\n", + "adding: mem time168, current time 170, horizon 2\n", + "adding: mem time169, current time 170, horizon 1\n", + "adding: mem time0, current time 171, horizon 171\n", + "adding: mem time1, current time 171, horizon 170\n", + "adding: mem time2, current time 171, horizon 169\n", + "adding: mem time3, current time 171, horizon 168\n", + "adding: mem time4, current time 171, horizon 167\n", + "adding: mem time5, current time 171, horizon 166\n", + "adding: mem time6, current time 171, horizon 165\n", + "adding: mem time7, current time 171, horizon 164\n", + "adding: mem time8, current time 171, horizon 163\n", + "adding: mem time9, current time 171, horizon 162\n", + "adding: mem time10, current time 171, horizon 161\n", + "adding: mem time11, current time 171, horizon 160\n", + "adding: mem time12, current time 171, horizon 159\n", + "adding: mem time13, current time 171, horizon 158\n", + "adding: mem time14, current time 171, horizon 157\n", + "adding: mem time15, current time 171, horizon 156\n", + "adding: mem time16, current time 171, horizon 155\n", + "adding: mem time17, current time 171, horizon 154\n", + "adding: mem time18, current time 171, horizon 153\n", + "adding: mem time19, current time 171, horizon 152\n", + "adding: mem time20, current time 171, horizon 151\n", + "adding: mem time21, current time 171, horizon 150\n", + "adding: mem time22, current time 171, horizon 149\n", + "adding: mem time23, current time 171, horizon 148\n", + "adding: mem time24, current time 171, horizon 147\n", + "adding: mem time25, current time 171, horizon 146\n", + "adding: mem time26, current time 171, horizon 145\n", + "adding: mem time27, current time 171, horizon 144\n", + "adding: mem time28, current time 171, horizon 143\n", + "adding: mem time29, current time 171, horizon 142\n", + "adding: mem time30, current time 171, horizon 141\n", + "adding: mem time31, current time 171, horizon 140\n", + "adding: mem time32, current time 171, horizon 139\n", + "adding: mem time33, current time 171, horizon 138\n", + "adding: mem time34, current time 171, horizon 137\n", + "adding: mem time35, current time 171, horizon 136\n", + "adding: mem time36, current time 171, horizon 135\n", + "adding: mem time37, current time 171, horizon 134\n", + "adding: mem time38, current time 171, horizon 133\n", + "adding: mem time39, current time 171, horizon 132\n", + "adding: mem time40, current time 171, horizon 131\n", + "adding: mem time41, current time 171, horizon 130\n", + "adding: mem time42, current time 171, horizon 129\n", + "adding: mem time43, current time 171, horizon 128\n", + "adding: mem time44, current time 171, horizon 127\n", + "adding: mem time45, current time 171, horizon 126\n", + "adding: mem time46, current time 171, horizon 125\n", + "adding: mem time47, current time 171, horizon 124\n", + "adding: mem time48, current time 171, horizon 123\n", + "adding: mem time49, current time 171, horizon 122\n", + "adding: mem time50, current time 171, horizon 121\n", + "adding: mem time51, current time 171, horizon 120\n", + "adding: mem time52, current time 171, horizon 119\n", + "adding: mem time53, current time 171, horizon 118\n", + "adding: mem time54, current time 171, horizon 117\n", + "adding: mem time55, current time 171, horizon 116\n", + "adding: mem time56, current time 171, horizon 115\n", + "adding: mem time57, current time 171, horizon 114\n", + "adding: mem time58, current time 171, horizon 113\n", + "adding: mem time59, current time 171, horizon 112\n", + "adding: mem time60, current time 171, horizon 111\n", + "adding: mem time61, current time 171, horizon 110\n", + "adding: mem time62, current time 171, horizon 109\n", + "adding: mem time63, current time 171, horizon 108\n", + "adding: mem time64, current time 171, horizon 107\n", + "adding: mem time65, current time 171, horizon 106\n", + "adding: mem time66, current time 171, horizon 105\n", + "adding: mem time67, current time 171, horizon 104\n", + "adding: mem time68, current time 171, horizon 103\n", + "adding: mem time69, current time 171, horizon 102\n", + "adding: mem time70, current time 171, horizon 101\n", + "adding: mem time71, current time 171, horizon 100\n", + "adding: mem time72, current time 171, horizon 99\n", + "adding: mem time73, current time 171, horizon 98\n", + "adding: mem time74, current time 171, horizon 97\n", + "adding: mem time75, current time 171, horizon 96\n", + "adding: mem time76, current time 171, horizon 95\n", + "adding: mem time77, current time 171, horizon 94\n", + "adding: mem time78, current time 171, horizon 93\n", + "adding: mem time79, current time 171, horizon 92\n", + "adding: mem time80, current time 171, horizon 91\n", + "adding: mem time81, current time 171, horizon 90\n", + "adding: mem time82, current time 171, horizon 89\n", + "adding: mem time83, current time 171, horizon 88\n", + "adding: mem time84, current time 171, horizon 87\n", + "adding: mem time85, current time 171, horizon 86\n", + "adding: mem time86, current time 171, horizon 85\n", + "adding: mem time87, current time 171, horizon 84\n", + "adding: mem time88, current time 171, horizon 83\n", + "adding: mem time89, current time 171, horizon 82\n", + "adding: mem time90, current time 171, horizon 81\n", + "adding: mem time91, current time 171, horizon 80\n", + "adding: mem time92, current time 171, horizon 79\n", + "adding: mem time93, current time 171, horizon 78\n", + "adding: mem time94, current time 171, horizon 77\n", + "adding: mem time95, current time 171, horizon 76\n", + "adding: mem time96, current time 171, horizon 75\n", + "adding: mem time97, current time 171, horizon 74\n", + "adding: mem time98, current time 171, horizon 73\n", + "adding: mem time99, current time 171, horizon 72\n", + "adding: mem time100, current time 171, horizon 71\n", + "adding: mem time101, current time 171, horizon 70\n", + "adding: mem time102, current time 171, horizon 69\n", + "adding: mem time103, current time 171, horizon 68\n", + "adding: mem time104, current time 171, horizon 67\n", + "adding: mem time105, current time 171, horizon 66\n", + "adding: mem time106, current time 171, horizon 65\n", + "adding: mem time107, current time 171, horizon 64\n", + "adding: mem time108, current time 171, horizon 63\n", + "adding: mem time109, current time 171, horizon 62\n", + "adding: mem time110, current time 171, horizon 61\n", + "adding: mem time111, current time 171, horizon 60\n", + "adding: mem time112, current time 171, horizon 59\n", + "adding: mem time113, current time 171, horizon 58\n", + "adding: mem time114, current time 171, horizon 57\n", + "adding: mem time115, current time 171, horizon 56\n", + "adding: mem time116, current time 171, horizon 55\n", + "adding: mem time117, current time 171, horizon 54\n", + "adding: mem time118, current time 171, horizon 53\n", + "adding: mem time119, current time 171, horizon 52\n", + "adding: mem time120, current time 171, horizon 51\n", + "adding: mem time121, current time 171, horizon 50\n", + "adding: mem time122, current time 171, horizon 49\n", + "adding: mem time123, current time 171, horizon 48\n", + "adding: mem time124, current time 171, horizon 47\n", + "adding: mem time125, current time 171, horizon 46\n", + "adding: mem time126, current time 171, horizon 45\n", + "adding: mem time127, current time 171, horizon 44\n", + "adding: mem time128, current time 171, horizon 43\n", + "adding: mem time129, current time 171, horizon 42\n", + "adding: mem time130, current time 171, horizon 41\n", + "adding: mem time131, current time 171, horizon 40\n", + "adding: mem time132, current time 171, horizon 39\n", + "adding: mem time133, current time 171, horizon 38\n", + "adding: mem time134, current time 171, horizon 37\n", + "adding: mem time135, current time 171, horizon 36\n", + "adding: mem time136, current time 171, horizon 35\n", + "adding: mem time137, current time 171, horizon 34\n", + "adding: mem time138, current time 171, horizon 33\n", + "adding: mem time139, current time 171, horizon 32\n", + "adding: mem time140, current time 171, horizon 31\n", + "adding: mem time141, current time 171, horizon 30\n", + "adding: mem time142, current time 171, horizon 29\n", + "adding: mem time143, current time 171, horizon 28\n", + "adding: mem time144, current time 171, horizon 27\n", + "adding: mem time145, current time 171, horizon 26\n", + "adding: mem time146, current time 171, horizon 25\n", + "adding: mem time147, current time 171, horizon 24\n", + "adding: mem time148, current time 171, horizon 23\n", + "adding: mem time149, current time 171, horizon 22\n", + "adding: mem time150, current time 171, horizon 21\n", + "adding: mem time151, current time 171, horizon 20\n", + "adding: mem time152, current time 171, horizon 19\n", + "adding: mem time153, current time 171, horizon 18\n", + "adding: mem time154, current time 171, horizon 17\n", + "adding: mem time155, current time 171, horizon 16\n", + "adding: mem time156, current time 171, horizon 15\n", + "adding: mem time157, current time 171, horizon 14\n", + "adding: mem time158, current time 171, horizon 13\n", + "adding: mem time159, current time 171, horizon 12\n", + "adding: mem time160, current time 171, horizon 11\n", + "adding: mem time161, current time 171, horizon 10\n", + "adding: mem time162, current time 171, horizon 9\n", + "adding: mem time163, current time 171, horizon 8\n", + "adding: mem time164, current time 171, horizon 7\n", + "adding: mem time165, current time 171, horizon 6\n", + "adding: mem time166, current time 171, horizon 5\n", + "adding: mem time167, current time 171, horizon 4\n", + "adding: mem time168, current time 171, horizon 3\n", + "adding: mem time169, current time 171, horizon 2\n", + "adding: mem time170, current time 171, horizon 1\n", + "adding: mem time0, current time 172, horizon 172\n", + "adding: mem time1, current time 172, horizon 171\n", + "adding: mem time2, current time 172, horizon 170\n", + "adding: mem time3, current time 172, horizon 169\n", + "adding: mem time4, current time 172, horizon 168\n", + "adding: mem time5, current time 172, horizon 167\n", + "adding: mem time6, current time 172, horizon 166\n", + "adding: mem time7, current time 172, horizon 165\n", + "adding: mem time8, current time 172, horizon 164\n", + "adding: mem time9, current time 172, horizon 163\n", + "adding: mem time10, current time 172, horizon 162\n", + "adding: mem time11, current time 172, horizon 161\n", + "adding: mem time12, current time 172, horizon 160\n", + "adding: mem time13, current time 172, horizon 159\n", + "adding: mem time14, current time 172, horizon 158\n", + "adding: mem time15, current time 172, horizon 157\n", + "adding: mem time16, current time 172, horizon 156\n", + "adding: mem time17, current time 172, horizon 155\n", + "adding: mem time18, current time 172, horizon 154\n", + "adding: mem time19, current time 172, horizon 153\n", + "adding: mem time20, current time 172, horizon 152\n", + "adding: mem time21, current time 172, horizon 151\n", + "adding: mem time22, current time 172, horizon 150\n", + "adding: mem time23, current time 172, horizon 149\n", + "adding: mem time24, current time 172, horizon 148\n", + "adding: mem time25, current time 172, horizon 147\n", + "adding: mem time26, current time 172, horizon 146\n", + "adding: mem time27, current time 172, horizon 145\n", + "adding: mem time28, current time 172, horizon 144\n", + "adding: mem time29, current time 172, horizon 143\n", + "adding: mem time30, current time 172, horizon 142\n", + "adding: mem time31, current time 172, horizon 141\n", + "adding: mem time32, current time 172, horizon 140\n", + "adding: mem time33, current time 172, horizon 139\n", + "adding: mem time34, current time 172, horizon 138\n", + "adding: mem time35, current time 172, horizon 137\n", + "adding: mem time36, current time 172, horizon 136\n", + "adding: mem time37, current time 172, horizon 135\n", + "adding: mem time38, current time 172, horizon 134\n", + "adding: mem time39, current time 172, horizon 133\n", + "adding: mem time40, current time 172, horizon 132\n", + "adding: mem time41, current time 172, horizon 131\n", + "adding: mem time42, current time 172, horizon 130\n", + "adding: mem time43, current time 172, horizon 129\n", + "adding: mem time44, current time 172, horizon 128\n", + "adding: mem time45, current time 172, horizon 127\n", + "adding: mem time46, current time 172, horizon 126\n", + "adding: mem time47, current time 172, horizon 125\n", + "adding: mem time48, current time 172, horizon 124\n", + "adding: mem time49, current time 172, horizon 123\n", + "adding: mem time50, current time 172, horizon 122\n", + "adding: mem time51, current time 172, horizon 121\n", + "adding: mem time52, current time 172, horizon 120\n", + "adding: mem time53, current time 172, horizon 119\n", + "adding: mem time54, current time 172, horizon 118\n", + "adding: mem time55, current time 172, horizon 117\n", + "adding: mem time56, current time 172, horizon 116\n", + "adding: mem time57, current time 172, horizon 115\n", + "adding: mem time58, current time 172, horizon 114\n", + "adding: mem time59, current time 172, horizon 113\n", + "adding: mem time60, current time 172, horizon 112\n", + "adding: mem time61, current time 172, horizon 111\n", + "adding: mem time62, current time 172, horizon 110\n", + "adding: mem time63, current time 172, horizon 109\n", + "adding: mem time64, current time 172, horizon 108\n", + "adding: mem time65, current time 172, horizon 107\n", + "adding: mem time66, current time 172, horizon 106\n", + "adding: mem time67, current time 172, horizon 105\n", + "adding: mem time68, current time 172, horizon 104\n", + "adding: mem time69, current time 172, horizon 103\n", + "adding: mem time70, current time 172, horizon 102\n", + "adding: mem time71, current time 172, horizon 101\n", + "adding: mem time72, current time 172, horizon 100\n", + "adding: mem time73, current time 172, horizon 99\n", + "adding: mem time74, current time 172, horizon 98\n", + "adding: mem time75, current time 172, horizon 97\n", + "adding: mem time76, current time 172, horizon 96\n", + "adding: mem time77, current time 172, horizon 95\n", + "adding: mem time78, current time 172, horizon 94\n", + "adding: mem time79, current time 172, horizon 93\n", + "adding: mem time80, current time 172, horizon 92\n", + "adding: mem time81, current time 172, horizon 91\n", + "adding: mem time82, current time 172, horizon 90\n", + "adding: mem time83, current time 172, horizon 89\n", + "adding: mem time84, current time 172, horizon 88\n", + "adding: mem time85, current time 172, horizon 87\n", + "adding: mem time86, current time 172, horizon 86\n", + "adding: mem time87, current time 172, horizon 85\n", + "adding: mem time88, current time 172, horizon 84\n", + "adding: mem time89, current time 172, horizon 83\n", + "adding: mem time90, current time 172, horizon 82\n", + "adding: mem time91, current time 172, horizon 81\n", + "adding: mem time92, current time 172, horizon 80\n", + "adding: mem time93, current time 172, horizon 79\n", + "adding: mem time94, current time 172, horizon 78\n", + "adding: mem time95, current time 172, horizon 77\n", + "adding: mem time96, current time 172, horizon 76\n", + "adding: mem time97, current time 172, horizon 75\n", + "adding: mem time98, current time 172, horizon 74\n", + "adding: mem time99, current time 172, horizon 73\n", + "adding: mem time100, current time 172, horizon 72\n", + "adding: mem time101, current time 172, horizon 71\n", + "adding: mem time102, current time 172, horizon 70\n", + "adding: mem time103, current time 172, horizon 69\n", + "adding: mem time104, current time 172, horizon 68\n", + "adding: mem time105, current time 172, horizon 67\n", + "adding: mem time106, current time 172, horizon 66\n", + "adding: mem time107, current time 172, horizon 65\n", + "adding: mem time108, current time 172, horizon 64\n", + "adding: mem time109, current time 172, horizon 63\n", + "adding: mem time110, current time 172, horizon 62\n", + "adding: mem time111, current time 172, horizon 61\n", + "adding: mem time112, current time 172, horizon 60\n", + "adding: mem time113, current time 172, horizon 59\n", + "adding: mem time114, current time 172, horizon 58\n", + "adding: mem time115, current time 172, horizon 57\n", + "adding: mem time116, current time 172, horizon 56\n", + "adding: mem time117, current time 172, horizon 55\n", + "adding: mem time118, current time 172, horizon 54\n", + "adding: mem time119, current time 172, horizon 53\n", + "adding: mem time120, current time 172, horizon 52\n", + "adding: mem time121, current time 172, horizon 51\n", + "adding: mem time122, current time 172, horizon 50\n", + "adding: mem time123, current time 172, horizon 49\n", + "adding: mem time124, current time 172, horizon 48\n", + "adding: mem time125, current time 172, horizon 47\n", + "adding: mem time126, current time 172, horizon 46\n", + "adding: mem time127, current time 172, horizon 45\n", + "adding: mem time128, current time 172, horizon 44\n", + "adding: mem time129, current time 172, horizon 43\n", + "adding: mem time130, current time 172, horizon 42\n", + "adding: mem time131, current time 172, horizon 41\n", + "adding: mem time132, current time 172, horizon 40\n", + "adding: mem time133, current time 172, horizon 39\n", + "adding: mem time134, current time 172, horizon 38\n", + "adding: mem time135, current time 172, horizon 37\n", + "adding: mem time136, current time 172, horizon 36\n", + "adding: mem time137, current time 172, horizon 35\n", + "adding: mem time138, current time 172, horizon 34\n", + "adding: mem time139, current time 172, horizon 33\n", + "adding: mem time140, current time 172, horizon 32\n", + "adding: mem time141, current time 172, horizon 31\n", + "adding: mem time142, current time 172, horizon 30\n", + "adding: mem time143, current time 172, horizon 29\n", + "adding: mem time144, current time 172, horizon 28\n", + "adding: mem time145, current time 172, horizon 27\n", + "adding: mem time146, current time 172, horizon 26\n", + "adding: mem time147, current time 172, horizon 25\n", + "adding: mem time148, current time 172, horizon 24\n", + "adding: mem time149, current time 172, horizon 23\n", + "adding: mem time150, current time 172, horizon 22\n", + "adding: mem time151, current time 172, horizon 21\n", + "adding: mem time152, current time 172, horizon 20\n", + "adding: mem time153, current time 172, horizon 19\n", + "adding: mem time154, current time 172, horizon 18\n", + "adding: mem time155, current time 172, horizon 17\n", + "adding: mem time156, current time 172, horizon 16\n", + "adding: mem time157, current time 172, horizon 15\n", + "adding: mem time158, current time 172, horizon 14\n", + "adding: mem time159, current time 172, horizon 13\n", + "adding: mem time160, current time 172, horizon 12\n", + "adding: mem time161, current time 172, horizon 11\n", + "adding: mem time162, current time 172, horizon 10\n", + "adding: mem time163, current time 172, horizon 9\n", + "adding: mem time164, current time 172, horizon 8\n", + "adding: mem time165, current time 172, horizon 7\n", + "adding: mem time166, current time 172, horizon 6\n", + "adding: mem time167, current time 172, horizon 5\n", + "adding: mem time168, current time 172, horizon 4\n", + "adding: mem time169, current time 172, horizon 3\n", + "adding: mem time170, current time 172, horizon 2\n", + "adding: mem time171, current time 172, horizon 1\n", + "adding: mem time0, current time 173, horizon 173\n", + "adding: mem time1, current time 173, horizon 172\n", + "adding: mem time2, current time 173, horizon 171\n", + "adding: mem time3, current time 173, horizon 170\n", + "adding: mem time4, current time 173, horizon 169\n", + "adding: mem time5, current time 173, horizon 168\n", + "adding: mem time6, current time 173, horizon 167\n", + "adding: mem time7, current time 173, horizon 166\n", + "adding: mem time8, current time 173, horizon 165\n", + "adding: mem time9, current time 173, horizon 164\n", + "adding: mem time10, current time 173, horizon 163\n", + "adding: mem time11, current time 173, horizon 162\n", + "adding: mem time12, current time 173, horizon 161\n", + "adding: mem time13, current time 173, horizon 160\n", + "adding: mem time14, current time 173, horizon 159\n", + "adding: mem time15, current time 173, horizon 158\n", + "adding: mem time16, current time 173, horizon 157\n", + "adding: mem time17, current time 173, horizon 156\n", + "adding: mem time18, current time 173, horizon 155\n", + "adding: mem time19, current time 173, horizon 154\n", + "adding: mem time20, current time 173, horizon 153\n", + "adding: mem time21, current time 173, horizon 152\n", + "adding: mem time22, current time 173, horizon 151\n", + "adding: mem time23, current time 173, horizon 150\n", + "adding: mem time24, current time 173, horizon 149\n", + "adding: mem time25, current time 173, horizon 148\n", + "adding: mem time26, current time 173, horizon 147\n", + "adding: mem time27, current time 173, horizon 146\n", + "adding: mem time28, current time 173, horizon 145\n", + "adding: mem time29, current time 173, horizon 144\n", + "adding: mem time30, current time 173, horizon 143\n", + "adding: mem time31, current time 173, horizon 142\n", + "adding: mem time32, current time 173, horizon 141\n", + "adding: mem time33, current time 173, horizon 140\n", + "adding: mem time34, current time 173, horizon 139\n", + "adding: mem time35, current time 173, horizon 138\n", + "adding: mem time36, current time 173, horizon 137\n", + "adding: mem time37, current time 173, horizon 136\n", + "adding: mem time38, current time 173, horizon 135\n", + "adding: mem time39, current time 173, horizon 134\n", + "adding: mem time40, current time 173, horizon 133\n", + "adding: mem time41, current time 173, horizon 132\n", + "adding: mem time42, current time 173, horizon 131\n", + "adding: mem time43, current time 173, horizon 130\n", + "adding: mem time44, current time 173, horizon 129\n", + "adding: mem time45, current time 173, horizon 128\n", + "adding: mem time46, current time 173, horizon 127\n", + "adding: mem time47, current time 173, horizon 126\n", + "adding: mem time48, current time 173, horizon 125\n", + "adding: mem time49, current time 173, horizon 124\n", + "adding: mem time50, current time 173, horizon 123\n", + "adding: mem time51, current time 173, horizon 122\n", + "adding: mem time52, current time 173, horizon 121\n", + "adding: mem time53, current time 173, horizon 120\n", + "adding: mem time54, current time 173, horizon 119\n", + "adding: mem time55, current time 173, horizon 118\n", + "adding: mem time56, current time 173, horizon 117\n", + "adding: mem time57, current time 173, horizon 116\n", + "adding: mem time58, current time 173, horizon 115\n", + "adding: mem time59, current time 173, horizon 114\n", + "adding: mem time60, current time 173, horizon 113\n", + "adding: mem time61, current time 173, horizon 112\n", + "adding: mem time62, current time 173, horizon 111\n", + "adding: mem time63, current time 173, horizon 110\n", + "adding: mem time64, current time 173, horizon 109\n", + "adding: mem time65, current time 173, horizon 108\n", + "adding: mem time66, current time 173, horizon 107\n", + "adding: mem time67, current time 173, horizon 106\n", + "adding: mem time68, current time 173, horizon 105\n", + "adding: mem time69, current time 173, horizon 104\n", + "adding: mem time70, current time 173, horizon 103\n", + "adding: mem time71, current time 173, horizon 102\n", + "adding: mem time72, current time 173, horizon 101\n", + "adding: mem time73, current time 173, horizon 100\n", + "adding: mem time74, current time 173, horizon 99\n", + "adding: mem time75, current time 173, horizon 98\n", + "adding: mem time76, current time 173, horizon 97\n", + "adding: mem time77, current time 173, horizon 96\n", + "adding: mem time78, current time 173, horizon 95\n", + "adding: mem time79, current time 173, horizon 94\n", + "adding: mem time80, current time 173, horizon 93\n", + "adding: mem time81, current time 173, horizon 92\n", + "adding: mem time82, current time 173, horizon 91\n", + "adding: mem time83, current time 173, horizon 90\n", + "adding: mem time84, current time 173, horizon 89\n", + "adding: mem time85, current time 173, horizon 88\n", + "adding: mem time86, current time 173, horizon 87\n", + "adding: mem time87, current time 173, horizon 86\n", + "adding: mem time88, current time 173, horizon 85\n", + "adding: mem time89, current time 173, horizon 84\n", + "adding: mem time90, current time 173, horizon 83\n", + "adding: mem time91, current time 173, horizon 82\n", + "adding: mem time92, current time 173, horizon 81\n", + "adding: mem time93, current time 173, horizon 80\n", + "adding: mem time94, current time 173, horizon 79\n", + "adding: mem time95, current time 173, horizon 78\n", + "adding: mem time96, current time 173, horizon 77\n", + "adding: mem time97, current time 173, horizon 76\n", + "adding: mem time98, current time 173, horizon 75\n", + "adding: mem time99, current time 173, horizon 74\n", + "adding: mem time100, current time 173, horizon 73\n", + "adding: mem time101, current time 173, horizon 72\n", + "adding: mem time102, current time 173, horizon 71\n", + "adding: mem time103, current time 173, horizon 70\n", + "adding: mem time104, current time 173, horizon 69\n", + "adding: mem time105, current time 173, horizon 68\n", + "adding: mem time106, current time 173, horizon 67\n", + "adding: mem time107, current time 173, horizon 66\n", + "adding: mem time108, current time 173, horizon 65\n", + "adding: mem time109, current time 173, horizon 64\n", + "adding: mem time110, current time 173, horizon 63\n", + "adding: mem time111, current time 173, horizon 62\n", + "adding: mem time112, current time 173, horizon 61\n", + "adding: mem time113, current time 173, horizon 60\n", + "adding: mem time114, current time 173, horizon 59\n", + "adding: mem time115, current time 173, horizon 58\n", + "adding: mem time116, current time 173, horizon 57\n", + "adding: mem time117, current time 173, horizon 56\n", + "adding: mem time118, current time 173, horizon 55\n", + "adding: mem time119, current time 173, horizon 54\n", + "adding: mem time120, current time 173, horizon 53\n", + "adding: mem time121, current time 173, horizon 52\n", + "adding: mem time122, current time 173, horizon 51\n", + "adding: mem time123, current time 173, horizon 50\n", + "adding: mem time124, current time 173, horizon 49\n", + "adding: mem time125, current time 173, horizon 48\n", + "adding: mem time126, current time 173, horizon 47\n", + "adding: mem time127, current time 173, horizon 46\n", + "adding: mem time128, current time 173, horizon 45\n", + "adding: mem time129, current time 173, horizon 44\n", + "adding: mem time130, current time 173, horizon 43\n", + "adding: mem time131, current time 173, horizon 42\n", + "adding: mem time132, current time 173, horizon 41\n", + "adding: mem time133, current time 173, horizon 40\n", + "adding: mem time134, current time 173, horizon 39\n", + "adding: mem time135, current time 173, horizon 38\n", + "adding: mem time136, current time 173, horizon 37\n", + "adding: mem time137, current time 173, horizon 36\n", + "adding: mem time138, current time 173, horizon 35\n", + "adding: mem time139, current time 173, horizon 34\n", + "adding: mem time140, current time 173, horizon 33\n", + "adding: mem time141, current time 173, horizon 32\n", + "adding: mem time142, current time 173, horizon 31\n", + "adding: mem time143, current time 173, horizon 30\n", + "adding: mem time144, current time 173, horizon 29\n", + "adding: mem time145, current time 173, horizon 28\n", + "adding: mem time146, current time 173, horizon 27\n", + "adding: mem time147, current time 173, horizon 26\n", + "adding: mem time148, current time 173, horizon 25\n", + "adding: mem time149, current time 173, horizon 24\n", + "adding: mem time150, current time 173, horizon 23\n", + "adding: mem time151, current time 173, horizon 22\n", + "adding: mem time152, current time 173, horizon 21\n", + "adding: mem time153, current time 173, horizon 20\n", + "adding: mem time154, current time 173, horizon 19\n", + "adding: mem time155, current time 173, horizon 18\n", + "adding: mem time156, current time 173, horizon 17\n", + "adding: mem time157, current time 173, horizon 16\n", + "adding: mem time158, current time 173, horizon 15\n", + "adding: mem time159, current time 173, horizon 14\n", + "adding: mem time160, current time 173, horizon 13\n", + "adding: mem time161, current time 173, horizon 12\n", + "adding: mem time162, current time 173, horizon 11\n", + "adding: mem time163, current time 173, horizon 10\n", + "adding: mem time164, current time 173, horizon 9\n", + "adding: mem time165, current time 173, horizon 8\n", + "adding: mem time166, current time 173, horizon 7\n", + "adding: mem time167, current time 173, horizon 6\n", + "adding: mem time168, current time 173, horizon 5\n", + "adding: mem time169, current time 173, horizon 4\n", + "adding: mem time170, current time 173, horizon 3\n", + "adding: mem time171, current time 173, horizon 2\n", + "adding: mem time172, current time 173, horizon 1\n", + "adding: mem time0, current time 174, horizon 174\n", + "adding: mem time1, current time 174, horizon 173\n", + "adding: mem time2, current time 174, horizon 172\n", + "adding: mem time3, current time 174, horizon 171\n", + "adding: mem time4, current time 174, horizon 170\n", + "adding: mem time5, current time 174, horizon 169\n", + "adding: mem time6, current time 174, horizon 168\n", + "adding: mem time7, current time 174, horizon 167\n", + "adding: mem time8, current time 174, horizon 166\n", + "adding: mem time9, current time 174, horizon 165\n", + "adding: mem time10, current time 174, horizon 164\n", + "adding: mem time11, current time 174, horizon 163\n", + "adding: mem time12, current time 174, horizon 162\n", + "adding: mem time13, current time 174, horizon 161\n", + "adding: mem time14, current time 174, horizon 160\n", + "adding: mem time15, current time 174, horizon 159\n", + "adding: mem time16, current time 174, horizon 158\n", + "adding: mem time17, current time 174, horizon 157\n", + "adding: mem time18, current time 174, horizon 156\n", + "adding: mem time19, current time 174, horizon 155\n", + "adding: mem time20, current time 174, horizon 154\n", + "adding: mem time21, current time 174, horizon 153\n", + "adding: mem time22, current time 174, horizon 152\n", + "adding: mem time23, current time 174, horizon 151\n", + "adding: mem time24, current time 174, horizon 150\n", + "adding: mem time25, current time 174, horizon 149\n", + "adding: mem time26, current time 174, horizon 148\n", + "adding: mem time27, current time 174, horizon 147\n", + "adding: mem time28, current time 174, horizon 146\n", + "adding: mem time29, current time 174, horizon 145\n", + "adding: mem time30, current time 174, horizon 144\n", + "adding: mem time31, current time 174, horizon 143\n", + "adding: mem time32, current time 174, horizon 142\n", + "adding: mem time33, current time 174, horizon 141\n", + "adding: mem time34, current time 174, horizon 140\n", + "adding: mem time35, current time 174, horizon 139\n", + "adding: mem time36, current time 174, horizon 138\n", + "adding: mem time37, current time 174, horizon 137\n", + "adding: mem time38, current time 174, horizon 136\n", + "adding: mem time39, current time 174, horizon 135\n", + "adding: mem time40, current time 174, horizon 134\n", + "adding: mem time41, current time 174, horizon 133\n", + "adding: mem time42, current time 174, horizon 132\n", + "adding: mem time43, current time 174, horizon 131\n", + "adding: mem time44, current time 174, horizon 130\n", + "adding: mem time45, current time 174, horizon 129\n", + "adding: mem time46, current time 174, horizon 128\n", + "adding: mem time47, current time 174, horizon 127\n", + "adding: mem time48, current time 174, horizon 126\n", + "adding: mem time49, current time 174, horizon 125\n", + "adding: mem time50, current time 174, horizon 124\n", + "adding: mem time51, current time 174, horizon 123\n", + "adding: mem time52, current time 174, horizon 122\n", + "adding: mem time53, current time 174, horizon 121\n", + "adding: mem time54, current time 174, horizon 120\n", + "adding: mem time55, current time 174, horizon 119\n", + "adding: mem time56, current time 174, horizon 118\n", + "adding: mem time57, current time 174, horizon 117\n", + "adding: mem time58, current time 174, horizon 116\n", + "adding: mem time59, current time 174, horizon 115\n", + "adding: mem time60, current time 174, horizon 114\n", + "adding: mem time61, current time 174, horizon 113\n", + "adding: mem time62, current time 174, horizon 112\n", + "adding: mem time63, current time 174, horizon 111\n", + "adding: mem time64, current time 174, horizon 110\n", + "adding: mem time65, current time 174, horizon 109\n", + "adding: mem time66, current time 174, horizon 108\n", + "adding: mem time67, current time 174, horizon 107\n", + "adding: mem time68, current time 174, horizon 106\n", + "adding: mem time69, current time 174, horizon 105\n", + "adding: mem time70, current time 174, horizon 104\n", + "adding: mem time71, current time 174, horizon 103\n", + "adding: mem time72, current time 174, horizon 102\n", + "adding: mem time73, current time 174, horizon 101\n", + "adding: mem time74, current time 174, horizon 100\n", + "adding: mem time75, current time 174, horizon 99\n", + "adding: mem time76, current time 174, horizon 98\n", + "adding: mem time77, current time 174, horizon 97\n", + "adding: mem time78, current time 174, horizon 96\n", + "adding: mem time79, current time 174, horizon 95\n", + "adding: mem time80, current time 174, horizon 94\n", + "adding: mem time81, current time 174, horizon 93\n", + "adding: mem time82, current time 174, horizon 92\n", + "adding: mem time83, current time 174, horizon 91\n", + "adding: mem time84, current time 174, horizon 90\n", + "adding: mem time85, current time 174, horizon 89\n", + "adding: mem time86, current time 174, horizon 88\n", + "adding: mem time87, current time 174, horizon 87\n", + "adding: mem time88, current time 174, horizon 86\n", + "adding: mem time89, current time 174, horizon 85\n", + "adding: mem time90, current time 174, horizon 84\n", + "adding: mem time91, current time 174, horizon 83\n", + "adding: mem time92, current time 174, horizon 82\n", + "adding: mem time93, current time 174, horizon 81\n", + "adding: mem time94, current time 174, horizon 80\n", + "adding: mem time95, current time 174, horizon 79\n", + "adding: mem time96, current time 174, horizon 78\n", + "adding: mem time97, current time 174, horizon 77\n", + "adding: mem time98, current time 174, horizon 76\n", + "adding: mem time99, current time 174, horizon 75\n", + "adding: mem time100, current time 174, horizon 74\n", + "adding: mem time101, current time 174, horizon 73\n", + "adding: mem time102, current time 174, horizon 72\n", + "adding: mem time103, current time 174, horizon 71\n", + "adding: mem time104, current time 174, horizon 70\n", + "adding: mem time105, current time 174, horizon 69\n", + "adding: mem time106, current time 174, horizon 68\n", + "adding: mem time107, current time 174, horizon 67\n", + "adding: mem time108, current time 174, horizon 66\n", + "adding: mem time109, current time 174, horizon 65\n", + "adding: mem time110, current time 174, horizon 64\n", + "adding: mem time111, current time 174, horizon 63\n", + "adding: mem time112, current time 174, horizon 62\n", + "adding: mem time113, current time 174, horizon 61\n", + "adding: mem time114, current time 174, horizon 60\n", + "adding: mem time115, current time 174, horizon 59\n", + "adding: mem time116, current time 174, horizon 58\n", + "adding: mem time117, current time 174, horizon 57\n", + "adding: mem time118, current time 174, horizon 56\n", + "adding: mem time119, current time 174, horizon 55\n", + "adding: mem time120, current time 174, horizon 54\n", + "adding: mem time121, current time 174, horizon 53\n", + "adding: mem time122, current time 174, horizon 52\n", + "adding: mem time123, current time 174, horizon 51\n", + "adding: mem time124, current time 174, horizon 50\n", + "adding: mem time125, current time 174, horizon 49\n", + "adding: mem time126, current time 174, horizon 48\n", + "adding: mem time127, current time 174, horizon 47\n", + "adding: mem time128, current time 174, horizon 46\n", + "adding: mem time129, current time 174, horizon 45\n", + "adding: mem time130, current time 174, horizon 44\n", + "adding: mem time131, current time 174, horizon 43\n", + "adding: mem time132, current time 174, horizon 42\n", + "adding: mem time133, current time 174, horizon 41\n", + "adding: mem time134, current time 174, horizon 40\n", + "adding: mem time135, current time 174, horizon 39\n", + "adding: mem time136, current time 174, horizon 38\n", + "adding: mem time137, current time 174, horizon 37\n", + "adding: mem time138, current time 174, horizon 36\n", + "adding: mem time139, current time 174, horizon 35\n", + "adding: mem time140, current time 174, horizon 34\n", + "adding: mem time141, current time 174, horizon 33\n", + "adding: mem time142, current time 174, horizon 32\n", + "adding: mem time143, current time 174, horizon 31\n", + "adding: mem time144, current time 174, horizon 30\n", + "adding: mem time145, current time 174, horizon 29\n", + "adding: mem time146, current time 174, horizon 28\n", + "adding: mem time147, current time 174, horizon 27\n", + "adding: mem time148, current time 174, horizon 26\n", + "adding: mem time149, current time 174, horizon 25\n", + "adding: mem time150, current time 174, horizon 24\n", + "adding: mem time151, current time 174, horizon 23\n", + "adding: mem time152, current time 174, horizon 22\n", + "adding: mem time153, current time 174, horizon 21\n", + "adding: mem time154, current time 174, horizon 20\n", + "adding: mem time155, current time 174, horizon 19\n", + "adding: mem time156, current time 174, horizon 18\n", + "adding: mem time157, current time 174, horizon 17\n", + "adding: mem time158, current time 174, horizon 16\n", + "adding: mem time159, current time 174, horizon 15\n", + "adding: mem time160, current time 174, horizon 14\n", + "adding: mem time161, current time 174, horizon 13\n", + "adding: mem time162, current time 174, horizon 12\n", + "adding: mem time163, current time 174, horizon 11\n", + "adding: mem time164, current time 174, horizon 10\n", + "adding: mem time165, current time 174, horizon 9\n", + "adding: mem time166, current time 174, horizon 8\n", + "adding: mem time167, current time 174, horizon 7\n", + "adding: mem time168, current time 174, horizon 6\n", + "adding: mem time169, current time 174, horizon 5\n", + "adding: mem time170, current time 174, horizon 4\n", + "adding: mem time171, current time 174, horizon 3\n", + "adding: mem time172, current time 174, horizon 2\n", + "adding: mem time173, current time 174, horizon 1\n", + "adding: mem time0, current time 175, horizon 175\n", + "adding: mem time1, current time 175, horizon 174\n", + "adding: mem time2, current time 175, horizon 173\n", + "adding: mem time3, current time 175, horizon 172\n", + "adding: mem time4, current time 175, horizon 171\n", + "adding: mem time5, current time 175, horizon 170\n", + "adding: mem time6, current time 175, horizon 169\n", + "adding: mem time7, current time 175, horizon 168\n", + "adding: mem time8, current time 175, horizon 167\n", + "adding: mem time9, current time 175, horizon 166\n", + "adding: mem time10, current time 175, horizon 165\n", + "adding: mem time11, current time 175, horizon 164\n", + "adding: mem time12, current time 175, horizon 163\n", + "adding: mem time13, current time 175, horizon 162\n", + "adding: mem time14, current time 175, horizon 161\n", + "adding: mem time15, current time 175, horizon 160\n", + "adding: mem time16, current time 175, horizon 159\n", + "adding: mem time17, current time 175, horizon 158\n", + "adding: mem time18, current time 175, horizon 157\n", + "adding: mem time19, current time 175, horizon 156\n", + "adding: mem time20, current time 175, horizon 155\n", + "adding: mem time21, current time 175, horizon 154\n", + "adding: mem time22, current time 175, horizon 153\n", + "adding: mem time23, current time 175, horizon 152\n", + "adding: mem time24, current time 175, horizon 151\n", + "adding: mem time25, current time 175, horizon 150\n", + "adding: mem time26, current time 175, horizon 149\n", + "adding: mem time27, current time 175, horizon 148\n", + "adding: mem time28, current time 175, horizon 147\n", + "adding: mem time29, current time 175, horizon 146\n", + "adding: mem time30, current time 175, horizon 145\n", + "adding: mem time31, current time 175, horizon 144\n", + "adding: mem time32, current time 175, horizon 143\n", + "adding: mem time33, current time 175, horizon 142\n", + "adding: mem time34, current time 175, horizon 141\n", + "adding: mem time35, current time 175, horizon 140\n", + "adding: mem time36, current time 175, horizon 139\n", + "adding: mem time37, current time 175, horizon 138\n", + "adding: mem time38, current time 175, horizon 137\n", + "adding: mem time39, current time 175, horizon 136\n", + "adding: mem time40, current time 175, horizon 135\n", + "adding: mem time41, current time 175, horizon 134\n", + "adding: mem time42, current time 175, horizon 133\n", + "adding: mem time43, current time 175, horizon 132\n", + "adding: mem time44, current time 175, horizon 131\n", + "adding: mem time45, current time 175, horizon 130\n", + "adding: mem time46, current time 175, horizon 129\n", + "adding: mem time47, current time 175, horizon 128\n", + "adding: mem time48, current time 175, horizon 127\n", + "adding: mem time49, current time 175, horizon 126\n", + "adding: mem time50, current time 175, horizon 125\n", + "adding: mem time51, current time 175, horizon 124\n", + "adding: mem time52, current time 175, horizon 123\n", + "adding: mem time53, current time 175, horizon 122\n", + "adding: mem time54, current time 175, horizon 121\n", + "adding: mem time55, current time 175, horizon 120\n", + "adding: mem time56, current time 175, horizon 119\n", + "adding: mem time57, current time 175, horizon 118\n", + "adding: mem time58, current time 175, horizon 117\n", + "adding: mem time59, current time 175, horizon 116\n", + "adding: mem time60, current time 175, horizon 115\n", + "adding: mem time61, current time 175, horizon 114\n", + "adding: mem time62, current time 175, horizon 113\n", + "adding: mem time63, current time 175, horizon 112\n", + "adding: mem time64, current time 175, horizon 111\n", + "adding: mem time65, current time 175, horizon 110\n", + "adding: mem time66, current time 175, horizon 109\n", + "adding: mem time67, current time 175, horizon 108\n", + "adding: mem time68, current time 175, horizon 107\n", + "adding: mem time69, current time 175, horizon 106\n", + "adding: mem time70, current time 175, horizon 105\n", + "adding: mem time71, current time 175, horizon 104\n", + "adding: mem time72, current time 175, horizon 103\n", + "adding: mem time73, current time 175, horizon 102\n", + "adding: mem time74, current time 175, horizon 101\n", + "adding: mem time75, current time 175, horizon 100\n", + "adding: mem time76, current time 175, horizon 99\n", + "adding: mem time77, current time 175, horizon 98\n", + "adding: mem time78, current time 175, horizon 97\n", + "adding: mem time79, current time 175, horizon 96\n", + "adding: mem time80, current time 175, horizon 95\n", + "adding: mem time81, current time 175, horizon 94\n", + "adding: mem time82, current time 175, horizon 93\n", + "adding: mem time83, current time 175, horizon 92\n", + "adding: mem time84, current time 175, horizon 91\n", + "adding: mem time85, current time 175, horizon 90\n", + "adding: mem time86, current time 175, horizon 89\n", + "adding: mem time87, current time 175, horizon 88\n", + "adding: mem time88, current time 175, horizon 87\n", + "adding: mem time89, current time 175, horizon 86\n", + "adding: mem time90, current time 175, horizon 85\n", + "adding: mem time91, current time 175, horizon 84\n", + "adding: mem time92, current time 175, horizon 83\n", + "adding: mem time93, current time 175, horizon 82\n", + "adding: mem time94, current time 175, horizon 81\n", + "adding: mem time95, current time 175, horizon 80\n", + "adding: mem time96, current time 175, horizon 79\n", + "adding: mem time97, current time 175, horizon 78\n", + "adding: mem time98, current time 175, horizon 77\n", + "adding: mem time99, current time 175, horizon 76\n", + "adding: mem time100, current time 175, horizon 75\n", + "adding: mem time101, current time 175, horizon 74\n", + "adding: mem time102, current time 175, horizon 73\n", + "adding: mem time103, current time 175, horizon 72\n", + "adding: mem time104, current time 175, horizon 71\n", + "adding: mem time105, current time 175, horizon 70\n", + "adding: mem time106, current time 175, horizon 69\n", + "adding: mem time107, current time 175, horizon 68\n", + "adding: mem time108, current time 175, horizon 67\n", + "adding: mem time109, current time 175, horizon 66\n", + "adding: mem time110, current time 175, horizon 65\n", + "adding: mem time111, current time 175, horizon 64\n", + "adding: mem time112, current time 175, horizon 63\n", + "adding: mem time113, current time 175, horizon 62\n", + "adding: mem time114, current time 175, horizon 61\n", + "adding: mem time115, current time 175, horizon 60\n", + "adding: mem time116, current time 175, horizon 59\n", + "adding: mem time117, current time 175, horizon 58\n", + "adding: mem time118, current time 175, horizon 57\n", + "adding: mem time119, current time 175, horizon 56\n", + "adding: mem time120, current time 175, horizon 55\n", + "adding: mem time121, current time 175, horizon 54\n", + "adding: mem time122, current time 175, horizon 53\n", + "adding: mem time123, current time 175, horizon 52\n", + "adding: mem time124, current time 175, horizon 51\n", + "adding: mem time125, current time 175, horizon 50\n", + "adding: mem time126, current time 175, horizon 49\n", + "adding: mem time127, current time 175, horizon 48\n", + "adding: mem time128, current time 175, horizon 47\n", + "adding: mem time129, current time 175, horizon 46\n", + "adding: mem time130, current time 175, horizon 45\n", + "adding: mem time131, current time 175, horizon 44\n", + "adding: mem time132, current time 175, horizon 43\n", + "adding: mem time133, current time 175, horizon 42\n", + "adding: mem time134, current time 175, horizon 41\n", + "adding: mem time135, current time 175, horizon 40\n", + "adding: mem time136, current time 175, horizon 39\n", + "adding: mem time137, current time 175, horizon 38\n", + "adding: mem time138, current time 175, horizon 37\n", + "adding: mem time139, current time 175, horizon 36\n", + "adding: mem time140, current time 175, horizon 35\n", + "adding: mem time141, current time 175, horizon 34\n", + "adding: mem time142, current time 175, horizon 33\n", + "adding: mem time143, current time 175, horizon 32\n", + "adding: mem time144, current time 175, horizon 31\n", + "adding: mem time145, current time 175, horizon 30\n", + "adding: mem time146, current time 175, horizon 29\n", + "adding: mem time147, current time 175, horizon 28\n", + "adding: mem time148, current time 175, horizon 27\n", + "adding: mem time149, current time 175, horizon 26\n", + "adding: mem time150, current time 175, horizon 25\n", + "adding: mem time151, current time 175, horizon 24\n", + "adding: mem time152, current time 175, horizon 23\n", + "adding: mem time153, current time 175, horizon 22\n", + "adding: mem time154, current time 175, horizon 21\n", + "adding: mem time155, current time 175, horizon 20\n", + "adding: mem time156, current time 175, horizon 19\n", + "adding: mem time157, current time 175, horizon 18\n", + "adding: mem time158, current time 175, horizon 17\n", + "adding: mem time159, current time 175, horizon 16\n", + "adding: mem time160, current time 175, horizon 15\n", + "adding: mem time161, current time 175, horizon 14\n", + "adding: mem time162, current time 175, horizon 13\n", + "adding: mem time163, current time 175, horizon 12\n", + "adding: mem time164, current time 175, horizon 11\n", + "adding: mem time165, current time 175, horizon 10\n", + "adding: mem time166, current time 175, horizon 9\n", + "adding: mem time167, current time 175, horizon 8\n", + "adding: mem time168, current time 175, horizon 7\n", + "adding: mem time169, current time 175, horizon 6\n", + "adding: mem time170, current time 175, horizon 5\n", + "adding: mem time171, current time 175, horizon 4\n", + "adding: mem time172, current time 175, horizon 3\n", + "adding: mem time173, current time 175, horizon 2\n", + "adding: mem time174, current time 175, horizon 1\n", + "adding: mem time0, current time 176, horizon 176\n", + "adding: mem time1, current time 176, horizon 175\n", + "adding: mem time2, current time 176, horizon 174\n", + "adding: mem time3, current time 176, horizon 173\n", + "adding: mem time4, current time 176, horizon 172\n", + "adding: mem time5, current time 176, horizon 171\n", + "adding: mem time6, current time 176, horizon 170\n", + "adding: mem time7, current time 176, horizon 169\n", + "adding: mem time8, current time 176, horizon 168\n", + "adding: mem time9, current time 176, horizon 167\n", + "adding: mem time10, current time 176, horizon 166\n", + "adding: mem time11, current time 176, horizon 165\n", + "adding: mem time12, current time 176, horizon 164\n", + "adding: mem time13, current time 176, horizon 163\n", + "adding: mem time14, current time 176, horizon 162\n", + "adding: mem time15, current time 176, horizon 161\n", + "adding: mem time16, current time 176, horizon 160\n", + "adding: mem time17, current time 176, horizon 159\n", + "adding: mem time18, current time 176, horizon 158\n", + "adding: mem time19, current time 176, horizon 157\n", + "adding: mem time20, current time 176, horizon 156\n", + "adding: mem time21, current time 176, horizon 155\n", + "adding: mem time22, current time 176, horizon 154\n", + "adding: mem time23, current time 176, horizon 153\n", + "adding: mem time24, current time 176, horizon 152\n", + "adding: mem time25, current time 176, horizon 151\n", + "adding: mem time26, current time 176, horizon 150\n", + "adding: mem time27, current time 176, horizon 149\n", + "adding: mem time28, current time 176, horizon 148\n", + "adding: mem time29, current time 176, horizon 147\n", + "adding: mem time30, current time 176, horizon 146\n", + "adding: mem time31, current time 176, horizon 145\n", + "adding: mem time32, current time 176, horizon 144\n", + "adding: mem time33, current time 176, horizon 143\n", + "adding: mem time34, current time 176, horizon 142\n", + "adding: mem time35, current time 176, horizon 141\n", + "adding: mem time36, current time 176, horizon 140\n", + "adding: mem time37, current time 176, horizon 139\n", + "adding: mem time38, current time 176, horizon 138\n", + "adding: mem time39, current time 176, horizon 137\n", + "adding: mem time40, current time 176, horizon 136\n", + "adding: mem time41, current time 176, horizon 135\n", + "adding: mem time42, current time 176, horizon 134\n", + "adding: mem time43, current time 176, horizon 133\n", + "adding: mem time44, current time 176, horizon 132\n", + "adding: mem time45, current time 176, horizon 131\n", + "adding: mem time46, current time 176, horizon 130\n", + "adding: mem time47, current time 176, horizon 129\n", + "adding: mem time48, current time 176, horizon 128\n", + "adding: mem time49, current time 176, horizon 127\n", + "adding: mem time50, current time 176, horizon 126\n", + "adding: mem time51, current time 176, horizon 125\n", + "adding: mem time52, current time 176, horizon 124\n", + "adding: mem time53, current time 176, horizon 123\n", + "adding: mem time54, current time 176, horizon 122\n", + "adding: mem time55, current time 176, horizon 121\n", + "adding: mem time56, current time 176, horizon 120\n", + "adding: mem time57, current time 176, horizon 119\n", + "adding: mem time58, current time 176, horizon 118\n", + "adding: mem time59, current time 176, horizon 117\n", + "adding: mem time60, current time 176, horizon 116\n", + "adding: mem time61, current time 176, horizon 115\n", + "adding: mem time62, current time 176, horizon 114\n", + "adding: mem time63, current time 176, horizon 113\n", + "adding: mem time64, current time 176, horizon 112\n", + "adding: mem time65, current time 176, horizon 111\n", + "adding: mem time66, current time 176, horizon 110\n", + "adding: mem time67, current time 176, horizon 109\n", + "adding: mem time68, current time 176, horizon 108\n", + "adding: mem time69, current time 176, horizon 107\n", + "adding: mem time70, current time 176, horizon 106\n", + "adding: mem time71, current time 176, horizon 105\n", + "adding: mem time72, current time 176, horizon 104\n", + "adding: mem time73, current time 176, horizon 103\n", + "adding: mem time74, current time 176, horizon 102\n", + "adding: mem time75, current time 176, horizon 101\n", + "adding: mem time76, current time 176, horizon 100\n", + "adding: mem time77, current time 176, horizon 99\n", + "adding: mem time78, current time 176, horizon 98\n", + "adding: mem time79, current time 176, horizon 97\n", + "adding: mem time80, current time 176, horizon 96\n", + "adding: mem time81, current time 176, horizon 95\n", + "adding: mem time82, current time 176, horizon 94\n", + "adding: mem time83, current time 176, horizon 93\n", + "adding: mem time84, current time 176, horizon 92\n", + "adding: mem time85, current time 176, horizon 91\n", + "adding: mem time86, current time 176, horizon 90\n", + "adding: mem time87, current time 176, horizon 89\n", + "adding: mem time88, current time 176, horizon 88\n", + "adding: mem time89, current time 176, horizon 87\n", + "adding: mem time90, current time 176, horizon 86\n", + "adding: mem time91, current time 176, horizon 85\n", + "adding: mem time92, current time 176, horizon 84\n", + "adding: mem time93, current time 176, horizon 83\n", + "adding: mem time94, current time 176, horizon 82\n", + "adding: mem time95, current time 176, horizon 81\n", + "adding: mem time96, current time 176, horizon 80\n", + "adding: mem time97, current time 176, horizon 79\n", + "adding: mem time98, current time 176, horizon 78\n", + "adding: mem time99, current time 176, horizon 77\n", + "adding: mem time100, current time 176, horizon 76\n", + "adding: mem time101, current time 176, horizon 75\n", + "adding: mem time102, current time 176, horizon 74\n", + "adding: mem time103, current time 176, horizon 73\n", + "adding: mem time104, current time 176, horizon 72\n", + "adding: mem time105, current time 176, horizon 71\n", + "adding: mem time106, current time 176, horizon 70\n", + "adding: mem time107, current time 176, horizon 69\n", + "adding: mem time108, current time 176, horizon 68\n", + "adding: mem time109, current time 176, horizon 67\n", + "adding: mem time110, current time 176, horizon 66\n", + "adding: mem time111, current time 176, horizon 65\n", + "adding: mem time112, current time 176, horizon 64\n", + "adding: mem time113, current time 176, horizon 63\n", + "adding: mem time114, current time 176, horizon 62\n", + "adding: mem time115, current time 176, horizon 61\n", + "adding: mem time116, current time 176, horizon 60\n", + "adding: mem time117, current time 176, horizon 59\n", + "adding: mem time118, current time 176, horizon 58\n", + "adding: mem time119, current time 176, horizon 57\n", + "adding: mem time120, current time 176, horizon 56\n", + "adding: mem time121, current time 176, horizon 55\n", + "adding: mem time122, current time 176, horizon 54\n", + "adding: mem time123, current time 176, horizon 53\n", + "adding: mem time124, current time 176, horizon 52\n", + "adding: mem time125, current time 176, horizon 51\n", + "adding: mem time126, current time 176, horizon 50\n", + "adding: mem time127, current time 176, horizon 49\n", + "adding: mem time128, current time 176, horizon 48\n", + "adding: mem time129, current time 176, horizon 47\n", + "adding: mem time130, current time 176, horizon 46\n", + "adding: mem time131, current time 176, horizon 45\n", + "adding: mem time132, current time 176, horizon 44\n", + "adding: mem time133, current time 176, horizon 43\n", + "adding: mem time134, current time 176, horizon 42\n", + "adding: mem time135, current time 176, horizon 41\n", + "adding: mem time136, current time 176, horizon 40\n", + "adding: mem time137, current time 176, horizon 39\n", + "adding: mem time138, current time 176, horizon 38\n", + "adding: mem time139, current time 176, horizon 37\n", + "adding: mem time140, current time 176, horizon 36\n", + "adding: mem time141, current time 176, horizon 35\n", + "adding: mem time142, current time 176, horizon 34\n", + "adding: mem time143, current time 176, horizon 33\n", + "adding: mem time144, current time 176, horizon 32\n", + "adding: mem time145, current time 176, horizon 31\n", + "adding: mem time146, current time 176, horizon 30\n", + "adding: mem time147, current time 176, horizon 29\n", + "adding: mem time148, current time 176, horizon 28\n", + "adding: mem time149, current time 176, horizon 27\n", + "adding: mem time150, current time 176, horizon 26\n", + "adding: mem time151, current time 176, horizon 25\n", + "adding: mem time152, current time 176, horizon 24\n", + "adding: mem time153, current time 176, horizon 23\n", + "adding: mem time154, current time 176, horizon 22\n", + "adding: mem time155, current time 176, horizon 21\n", + "adding: mem time156, current time 176, horizon 20\n", + "adding: mem time157, current time 176, horizon 19\n", + "adding: mem time158, current time 176, horizon 18\n", + "adding: mem time159, current time 176, horizon 17\n", + "adding: mem time160, current time 176, horizon 16\n", + "adding: mem time161, current time 176, horizon 15\n", + "adding: mem time162, current time 176, horizon 14\n", + "adding: mem time163, current time 176, horizon 13\n", + "adding: mem time164, current time 176, horizon 12\n", + "adding: mem time165, current time 176, horizon 11\n", + "adding: mem time166, current time 176, horizon 10\n", + "adding: mem time167, current time 176, horizon 9\n", + "adding: mem time168, current time 176, horizon 8\n", + "adding: mem time169, current time 176, horizon 7\n", + "adding: mem time170, current time 176, horizon 6\n", + "adding: mem time171, current time 176, horizon 5\n", + "adding: mem time172, current time 176, horizon 4\n", + "adding: mem time173, current time 176, horizon 3\n", + "adding: mem time174, current time 176, horizon 2\n", + "adding: mem time175, current time 176, horizon 1\n", + "adding: mem time0, current time 177, horizon 177\n", + "adding: mem time1, current time 177, horizon 176\n", + "adding: mem time2, current time 177, horizon 175\n", + "adding: mem time3, current time 177, horizon 174\n", + "adding: mem time4, current time 177, horizon 173\n", + "adding: mem time5, current time 177, horizon 172\n", + "adding: mem time6, current time 177, horizon 171\n", + "adding: mem time7, current time 177, horizon 170\n", + "adding: mem time8, current time 177, horizon 169\n", + "adding: mem time9, current time 177, horizon 168\n", + "adding: mem time10, current time 177, horizon 167\n", + "adding: mem time11, current time 177, horizon 166\n", + "adding: mem time12, current time 177, horizon 165\n", + "adding: mem time13, current time 177, horizon 164\n", + "adding: mem time14, current time 177, horizon 163\n", + "adding: mem time15, current time 177, horizon 162\n", + "adding: mem time16, current time 177, horizon 161\n", + "adding: mem time17, current time 177, horizon 160\n", + "adding: mem time18, current time 177, horizon 159\n", + "adding: mem time19, current time 177, horizon 158\n", + "adding: mem time20, current time 177, horizon 157\n", + "adding: mem time21, current time 177, horizon 156\n", + "adding: mem time22, current time 177, horizon 155\n", + "adding: mem time23, current time 177, horizon 154\n", + "adding: mem time24, current time 177, horizon 153\n", + "adding: mem time25, current time 177, horizon 152\n", + "adding: mem time26, current time 177, horizon 151\n", + "adding: mem time27, current time 177, horizon 150\n", + "adding: mem time28, current time 177, horizon 149\n", + "adding: mem time29, current time 177, horizon 148\n", + "adding: mem time30, current time 177, horizon 147\n", + "adding: mem time31, current time 177, horizon 146\n", + "adding: mem time32, current time 177, horizon 145\n", + "adding: mem time33, current time 177, horizon 144\n", + "adding: mem time34, current time 177, horizon 143\n", + "adding: mem time35, current time 177, horizon 142\n", + "adding: mem time36, current time 177, horizon 141\n", + "adding: mem time37, current time 177, horizon 140\n", + "adding: mem time38, current time 177, horizon 139\n", + "adding: mem time39, current time 177, horizon 138\n", + "adding: mem time40, current time 177, horizon 137\n", + "adding: mem time41, current time 177, horizon 136\n", + "adding: mem time42, current time 177, horizon 135\n", + "adding: mem time43, current time 177, horizon 134\n", + "adding: mem time44, current time 177, horizon 133\n", + "adding: mem time45, current time 177, horizon 132\n", + "adding: mem time46, current time 177, horizon 131\n", + "adding: mem time47, current time 177, horizon 130\n", + "adding: mem time48, current time 177, horizon 129\n", + "adding: mem time49, current time 177, horizon 128\n", + "adding: mem time50, current time 177, horizon 127\n", + "adding: mem time51, current time 177, horizon 126\n", + "adding: mem time52, current time 177, horizon 125\n", + "adding: mem time53, current time 177, horizon 124\n", + "adding: mem time54, current time 177, horizon 123\n", + "adding: mem time55, current time 177, horizon 122\n", + "adding: mem time56, current time 177, horizon 121\n", + "adding: mem time57, current time 177, horizon 120\n", + "adding: mem time58, current time 177, horizon 119\n", + "adding: mem time59, current time 177, horizon 118\n", + "adding: mem time60, current time 177, horizon 117\n", + "adding: mem time61, current time 177, horizon 116\n", + "adding: mem time62, current time 177, horizon 115\n", + "adding: mem time63, current time 177, horizon 114\n", + "adding: mem time64, current time 177, horizon 113\n", + "adding: mem time65, current time 177, horizon 112\n", + "adding: mem time66, current time 177, horizon 111\n", + "adding: mem time67, current time 177, horizon 110\n", + "adding: mem time68, current time 177, horizon 109\n", + "adding: mem time69, current time 177, horizon 108\n", + "adding: mem time70, current time 177, horizon 107\n", + "adding: mem time71, current time 177, horizon 106\n", + "adding: mem time72, current time 177, horizon 105\n", + "adding: mem time73, current time 177, horizon 104\n", + "adding: mem time74, current time 177, horizon 103\n", + "adding: mem time75, current time 177, horizon 102\n", + "adding: mem time76, current time 177, horizon 101\n", + "adding: mem time77, current time 177, horizon 100\n", + "adding: mem time78, current time 177, horizon 99\n", + "adding: mem time79, current time 177, horizon 98\n", + "adding: mem time80, current time 177, horizon 97\n", + "adding: mem time81, current time 177, horizon 96\n", + "adding: mem time82, current time 177, horizon 95\n", + "adding: mem time83, current time 177, horizon 94\n", + "adding: mem time84, current time 177, horizon 93\n", + "adding: mem time85, current time 177, horizon 92\n", + "adding: mem time86, current time 177, horizon 91\n", + "adding: mem time87, current time 177, horizon 90\n", + "adding: mem time88, current time 177, horizon 89\n", + "adding: mem time89, current time 177, horizon 88\n", + "adding: mem time90, current time 177, horizon 87\n", + "adding: mem time91, current time 177, horizon 86\n", + "adding: mem time92, current time 177, horizon 85\n", + "adding: mem time93, current time 177, horizon 84\n", + "adding: mem time94, current time 177, horizon 83\n", + "adding: mem time95, current time 177, horizon 82\n", + "adding: mem time96, current time 177, horizon 81\n", + "adding: mem time97, current time 177, horizon 80\n", + "adding: mem time98, current time 177, horizon 79\n", + "adding: mem time99, current time 177, horizon 78\n", + "adding: mem time100, current time 177, horizon 77\n", + "adding: mem time101, current time 177, horizon 76\n", + "adding: mem time102, current time 177, horizon 75\n", + "adding: mem time103, current time 177, horizon 74\n", + "adding: mem time104, current time 177, horizon 73\n", + "adding: mem time105, current time 177, horizon 72\n", + "adding: mem time106, current time 177, horizon 71\n", + "adding: mem time107, current time 177, horizon 70\n", + "adding: mem time108, current time 177, horizon 69\n", + "adding: mem time109, current time 177, horizon 68\n", + "adding: mem time110, current time 177, horizon 67\n", + "adding: mem time111, current time 177, horizon 66\n", + "adding: mem time112, current time 177, horizon 65\n", + "adding: mem time113, current time 177, horizon 64\n", + "adding: mem time114, current time 177, horizon 63\n", + "adding: mem time115, current time 177, horizon 62\n", + "adding: mem time116, current time 177, horizon 61\n", + "adding: mem time117, current time 177, horizon 60\n", + "adding: mem time118, current time 177, horizon 59\n", + "adding: mem time119, current time 177, horizon 58\n", + "adding: mem time120, current time 177, horizon 57\n", + "adding: mem time121, current time 177, horizon 56\n", + "adding: mem time122, current time 177, horizon 55\n", + "adding: mem time123, current time 177, horizon 54\n", + "adding: mem time124, current time 177, horizon 53\n", + "adding: mem time125, current time 177, horizon 52\n", + "adding: mem time126, current time 177, horizon 51\n", + "adding: mem time127, current time 177, horizon 50\n", + "adding: mem time128, current time 177, horizon 49\n", + "adding: mem time129, current time 177, horizon 48\n", + "adding: mem time130, current time 177, horizon 47\n", + "adding: mem time131, current time 177, horizon 46\n", + "adding: mem time132, current time 177, horizon 45\n", + "adding: mem time133, current time 177, horizon 44\n", + "adding: mem time134, current time 177, horizon 43\n", + "adding: mem time135, current time 177, horizon 42\n", + "adding: mem time136, current time 177, horizon 41\n", + "adding: mem time137, current time 177, horizon 40\n", + "adding: mem time138, current time 177, horizon 39\n", + "adding: mem time139, current time 177, horizon 38\n", + "adding: mem time140, current time 177, horizon 37\n", + "adding: mem time141, current time 177, horizon 36\n", + "adding: mem time142, current time 177, horizon 35\n", + "adding: mem time143, current time 177, horizon 34\n", + "adding: mem time144, current time 177, horizon 33\n", + "adding: mem time145, current time 177, horizon 32\n", + "adding: mem time146, current time 177, horizon 31\n", + "adding: mem time147, current time 177, horizon 30\n", + "adding: mem time148, current time 177, horizon 29\n", + "adding: mem time149, current time 177, horizon 28\n", + "adding: mem time150, current time 177, horizon 27\n", + "adding: mem time151, current time 177, horizon 26\n", + "adding: mem time152, current time 177, horizon 25\n", + "adding: mem time153, current time 177, horizon 24\n", + "adding: mem time154, current time 177, horizon 23\n", + "adding: mem time155, current time 177, horizon 22\n", + "adding: mem time156, current time 177, horizon 21\n", + "adding: mem time157, current time 177, horizon 20\n", + "adding: mem time158, current time 177, horizon 19\n", + "adding: mem time159, current time 177, horizon 18\n", + "adding: mem time160, current time 177, horizon 17\n", + "adding: mem time161, current time 177, horizon 16\n", + "adding: mem time162, current time 177, horizon 15\n", + "adding: mem time163, current time 177, horizon 14\n", + "adding: mem time164, current time 177, horizon 13\n", + "adding: mem time165, current time 177, horizon 12\n", + "adding: mem time166, current time 177, horizon 11\n", + "adding: mem time167, current time 177, horizon 10\n", + "adding: mem time168, current time 177, horizon 9\n", + "adding: mem time169, current time 177, horizon 8\n", + "adding: mem time170, current time 177, horizon 7\n", + "adding: mem time171, current time 177, horizon 6\n", + "adding: mem time172, current time 177, horizon 5\n", + "adding: mem time173, current time 177, horizon 4\n", + "adding: mem time174, current time 177, horizon 3\n", + "adding: mem time175, current time 177, horizon 2\n", + "adding: mem time176, current time 177, horizon 1\n", + "adding: mem time0, current time 178, horizon 178\n", + "adding: mem time1, current time 178, horizon 177\n", + "adding: mem time2, current time 178, horizon 176\n", + "adding: mem time3, current time 178, horizon 175\n", + "adding: mem time4, current time 178, horizon 174\n", + "adding: mem time5, current time 178, horizon 173\n", + "adding: mem time6, current time 178, horizon 172\n", + "adding: mem time7, current time 178, horizon 171\n", + "adding: mem time8, current time 178, horizon 170\n", + "adding: mem time9, current time 178, horizon 169\n", + "adding: mem time10, current time 178, horizon 168\n", + "adding: mem time11, current time 178, horizon 167\n", + "adding: mem time12, current time 178, horizon 166\n", + "adding: mem time13, current time 178, horizon 165\n", + "adding: mem time14, current time 178, horizon 164\n", + "adding: mem time15, current time 178, horizon 163\n", + "adding: mem time16, current time 178, horizon 162\n", + "adding: mem time17, current time 178, horizon 161\n", + "adding: mem time18, current time 178, horizon 160\n", + "adding: mem time19, current time 178, horizon 159\n", + "adding: mem time20, current time 178, horizon 158\n", + "adding: mem time21, current time 178, horizon 157\n", + "adding: mem time22, current time 178, horizon 156\n", + "adding: mem time23, current time 178, horizon 155\n", + "adding: mem time24, current time 178, horizon 154\n", + "adding: mem time25, current time 178, horizon 153\n", + "adding: mem time26, current time 178, horizon 152\n", + "adding: mem time27, current time 178, horizon 151\n", + "adding: mem time28, current time 178, horizon 150\n", + "adding: mem time29, current time 178, horizon 149\n", + "adding: mem time30, current time 178, horizon 148\n", + "adding: mem time31, current time 178, horizon 147\n", + "adding: mem time32, current time 178, horizon 146\n", + "adding: mem time33, current time 178, horizon 145\n", + "adding: mem time34, current time 178, horizon 144\n", + "adding: mem time35, current time 178, horizon 143\n", + "adding: mem time36, current time 178, horizon 142\n", + "adding: mem time37, current time 178, horizon 141\n", + "adding: mem time38, current time 178, horizon 140\n", + "adding: mem time39, current time 178, horizon 139\n", + "adding: mem time40, current time 178, horizon 138\n", + "adding: mem time41, current time 178, horizon 137\n", + "adding: mem time42, current time 178, horizon 136\n", + "adding: mem time43, current time 178, horizon 135\n", + "adding: mem time44, current time 178, horizon 134\n", + "adding: mem time45, current time 178, horizon 133\n", + "adding: mem time46, current time 178, horizon 132\n", + "adding: mem time47, current time 178, horizon 131\n", + "adding: mem time48, current time 178, horizon 130\n", + "adding: mem time49, current time 178, horizon 129\n", + "adding: mem time50, current time 178, horizon 128\n", + "adding: mem time51, current time 178, horizon 127\n", + "adding: mem time52, current time 178, horizon 126\n", + "adding: mem time53, current time 178, horizon 125\n", + "adding: mem time54, current time 178, horizon 124\n", + "adding: mem time55, current time 178, horizon 123\n", + "adding: mem time56, current time 178, horizon 122\n", + "adding: mem time57, current time 178, horizon 121\n", + "adding: mem time58, current time 178, horizon 120\n", + "adding: mem time59, current time 178, horizon 119\n", + "adding: mem time60, current time 178, horizon 118\n", + "adding: mem time61, current time 178, horizon 117\n", + "adding: mem time62, current time 178, horizon 116\n", + "adding: mem time63, current time 178, horizon 115\n", + "adding: mem time64, current time 178, horizon 114\n", + "adding: mem time65, current time 178, horizon 113\n", + "adding: mem time66, current time 178, horizon 112\n", + "adding: mem time67, current time 178, horizon 111\n", + "adding: mem time68, current time 178, horizon 110\n", + "adding: mem time69, current time 178, horizon 109\n", + "adding: mem time70, current time 178, horizon 108\n", + "adding: mem time71, current time 178, horizon 107\n", + "adding: mem time72, current time 178, horizon 106\n", + "adding: mem time73, current time 178, horizon 105\n", + "adding: mem time74, current time 178, horizon 104\n", + "adding: mem time75, current time 178, horizon 103\n", + "adding: mem time76, current time 178, horizon 102\n", + "adding: mem time77, current time 178, horizon 101\n", + "adding: mem time78, current time 178, horizon 100\n", + "adding: mem time79, current time 178, horizon 99\n", + "adding: mem time80, current time 178, horizon 98\n", + "adding: mem time81, current time 178, horizon 97\n", + "adding: mem time82, current time 178, horizon 96\n", + "adding: mem time83, current time 178, horizon 95\n", + "adding: mem time84, current time 178, horizon 94\n", + "adding: mem time85, current time 178, horizon 93\n", + "adding: mem time86, current time 178, horizon 92\n", + "adding: mem time87, current time 178, horizon 91\n", + "adding: mem time88, current time 178, horizon 90\n", + "adding: mem time89, current time 178, horizon 89\n", + "adding: mem time90, current time 178, horizon 88\n", + "adding: mem time91, current time 178, horizon 87\n", + "adding: mem time92, current time 178, horizon 86\n", + "adding: mem time93, current time 178, horizon 85\n", + "adding: mem time94, current time 178, horizon 84\n", + "adding: mem time95, current time 178, horizon 83\n", + "adding: mem time96, current time 178, horizon 82\n", + "adding: mem time97, current time 178, horizon 81\n", + "adding: mem time98, current time 178, horizon 80\n", + "adding: mem time99, current time 178, horizon 79\n", + "adding: mem time100, current time 178, horizon 78\n", + "adding: mem time101, current time 178, horizon 77\n", + "adding: mem time102, current time 178, horizon 76\n", + "adding: mem time103, current time 178, horizon 75\n", + "adding: mem time104, current time 178, horizon 74\n", + "adding: mem time105, current time 178, horizon 73\n", + "adding: mem time106, current time 178, horizon 72\n", + "adding: mem time107, current time 178, horizon 71\n", + "adding: mem time108, current time 178, horizon 70\n", + "adding: mem time109, current time 178, horizon 69\n", + "adding: mem time110, current time 178, horizon 68\n", + "adding: mem time111, current time 178, horizon 67\n", + "adding: mem time112, current time 178, horizon 66\n", + "adding: mem time113, current time 178, horizon 65\n", + "adding: mem time114, current time 178, horizon 64\n", + "adding: mem time115, current time 178, horizon 63\n", + "adding: mem time116, current time 178, horizon 62\n", + "adding: mem time117, current time 178, horizon 61\n", + "adding: mem time118, current time 178, horizon 60\n", + "adding: mem time119, current time 178, horizon 59\n", + "adding: mem time120, current time 178, horizon 58\n", + "adding: mem time121, current time 178, horizon 57\n", + "adding: mem time122, current time 178, horizon 56\n", + "adding: mem time123, current time 178, horizon 55\n", + "adding: mem time124, current time 178, horizon 54\n", + "adding: mem time125, current time 178, horizon 53\n", + "adding: mem time126, current time 178, horizon 52\n", + "adding: mem time127, current time 178, horizon 51\n", + "adding: mem time128, current time 178, horizon 50\n", + "adding: mem time129, current time 178, horizon 49\n", + "adding: mem time130, current time 178, horizon 48\n", + "adding: mem time131, current time 178, horizon 47\n", + "adding: mem time132, current time 178, horizon 46\n", + "adding: mem time133, current time 178, horizon 45\n", + "adding: mem time134, current time 178, horizon 44\n", + "adding: mem time135, current time 178, horizon 43\n", + "adding: mem time136, current time 178, horizon 42\n", + "adding: mem time137, current time 178, horizon 41\n", + "adding: mem time138, current time 178, horizon 40\n", + "adding: mem time139, current time 178, horizon 39\n", + "adding: mem time140, current time 178, horizon 38\n", + "adding: mem time141, current time 178, horizon 37\n", + "adding: mem time142, current time 178, horizon 36\n", + "adding: mem time143, current time 178, horizon 35\n", + "adding: mem time144, current time 178, horizon 34\n", + "adding: mem time145, current time 178, horizon 33\n", + "adding: mem time146, current time 178, horizon 32\n", + "adding: mem time147, current time 178, horizon 31\n", + "adding: mem time148, current time 178, horizon 30\n", + "adding: mem time149, current time 178, horizon 29\n", + "adding: mem time150, current time 178, horizon 28\n", + "adding: mem time151, current time 178, horizon 27\n", + "adding: mem time152, current time 178, horizon 26\n", + "adding: mem time153, current time 178, horizon 25\n", + "adding: mem time154, current time 178, horizon 24\n", + "adding: mem time155, current time 178, horizon 23\n", + "adding: mem time156, current time 178, horizon 22\n", + "adding: mem time157, current time 178, horizon 21\n", + "adding: mem time158, current time 178, horizon 20\n", + "adding: mem time159, current time 178, horizon 19\n", + "adding: mem time160, current time 178, horizon 18\n", + "adding: mem time161, current time 178, horizon 17\n", + "adding: mem time162, current time 178, horizon 16\n", + "adding: mem time163, current time 178, horizon 15\n", + "adding: mem time164, current time 178, horizon 14\n", + "adding: mem time165, current time 178, horizon 13\n", + "adding: mem time166, current time 178, horizon 12\n", + "adding: mem time167, current time 178, horizon 11\n", + "adding: mem time168, current time 178, horizon 10\n", + "adding: mem time169, current time 178, horizon 9\n", + "adding: mem time170, current time 178, horizon 8\n", + "adding: mem time171, current time 178, horizon 7\n", + "adding: mem time172, current time 178, horizon 6\n", + "adding: mem time173, current time 178, horizon 5\n", + "adding: mem time174, current time 178, horizon 4\n", + "adding: mem time175, current time 178, horizon 3\n", + "adding: mem time176, current time 178, horizon 2\n", + "adding: mem time177, current time 178, horizon 1\n", + "adding: mem time0, current time 179, horizon 179\n", + "adding: mem time1, current time 179, horizon 178\n", + "adding: mem time2, current time 179, horizon 177\n", + "adding: mem time3, current time 179, horizon 176\n", + "adding: mem time4, current time 179, horizon 175\n", + "adding: mem time5, current time 179, horizon 174\n", + "adding: mem time6, current time 179, horizon 173\n", + "adding: mem time7, current time 179, horizon 172\n", + "adding: mem time8, current time 179, horizon 171\n", + "adding: mem time9, current time 179, horizon 170\n", + "adding: mem time10, current time 179, horizon 169\n", + "adding: mem time11, current time 179, horizon 168\n", + "adding: mem time12, current time 179, horizon 167\n", + "adding: mem time13, current time 179, horizon 166\n", + "adding: mem time14, current time 179, horizon 165\n", + "adding: mem time15, current time 179, horizon 164\n", + "adding: mem time16, current time 179, horizon 163\n", + "adding: mem time17, current time 179, horizon 162\n", + "adding: mem time18, current time 179, horizon 161\n", + "adding: mem time19, current time 179, horizon 160\n", + "adding: mem time20, current time 179, horizon 159\n", + "adding: mem time21, current time 179, horizon 158\n", + "adding: mem time22, current time 179, horizon 157\n", + "adding: mem time23, current time 179, horizon 156\n", + "adding: mem time24, current time 179, horizon 155\n", + "adding: mem time25, current time 179, horizon 154\n", + "adding: mem time26, current time 179, horizon 153\n", + "adding: mem time27, current time 179, horizon 152\n", + "adding: mem time28, current time 179, horizon 151\n", + "adding: mem time29, current time 179, horizon 150\n", + "adding: mem time30, current time 179, horizon 149\n", + "adding: mem time31, current time 179, horizon 148\n", + "adding: mem time32, current time 179, horizon 147\n", + "adding: mem time33, current time 179, horizon 146\n", + "adding: mem time34, current time 179, horizon 145\n", + "adding: mem time35, current time 179, horizon 144\n", + "adding: mem time36, current time 179, horizon 143\n", + "adding: mem time37, current time 179, horizon 142\n", + "adding: mem time38, current time 179, horizon 141\n", + "adding: mem time39, current time 179, horizon 140\n", + "adding: mem time40, current time 179, horizon 139\n", + "adding: mem time41, current time 179, horizon 138\n", + "adding: mem time42, current time 179, horizon 137\n", + "adding: mem time43, current time 179, horizon 136\n", + "adding: mem time44, current time 179, horizon 135\n", + "adding: mem time45, current time 179, horizon 134\n", + "adding: mem time46, current time 179, horizon 133\n", + "adding: mem time47, current time 179, horizon 132\n", + "adding: mem time48, current time 179, horizon 131\n", + "adding: mem time49, current time 179, horizon 130\n", + "adding: mem time50, current time 179, horizon 129\n", + "adding: mem time51, current time 179, horizon 128\n", + "adding: mem time52, current time 179, horizon 127\n", + "adding: mem time53, current time 179, horizon 126\n", + "adding: mem time54, current time 179, horizon 125\n", + "adding: mem time55, current time 179, horizon 124\n", + "adding: mem time56, current time 179, horizon 123\n", + "adding: mem time57, current time 179, horizon 122\n", + "adding: mem time58, current time 179, horizon 121\n", + "adding: mem time59, current time 179, horizon 120\n", + "adding: mem time60, current time 179, horizon 119\n", + "adding: mem time61, current time 179, horizon 118\n", + "adding: mem time62, current time 179, horizon 117\n", + "adding: mem time63, current time 179, horizon 116\n", + "adding: mem time64, current time 179, horizon 115\n", + "adding: mem time65, current time 179, horizon 114\n", + "adding: mem time66, current time 179, horizon 113\n", + "adding: mem time67, current time 179, horizon 112\n", + "adding: mem time68, current time 179, horizon 111\n", + "adding: mem time69, current time 179, horizon 110\n", + "adding: mem time70, current time 179, horizon 109\n", + "adding: mem time71, current time 179, horizon 108\n", + "adding: mem time72, current time 179, horizon 107\n", + "adding: mem time73, current time 179, horizon 106\n", + "adding: mem time74, current time 179, horizon 105\n", + "adding: mem time75, current time 179, horizon 104\n", + "adding: mem time76, current time 179, horizon 103\n", + "adding: mem time77, current time 179, horizon 102\n", + "adding: mem time78, current time 179, horizon 101\n", + "adding: mem time79, current time 179, horizon 100\n", + "adding: mem time80, current time 179, horizon 99\n", + "adding: mem time81, current time 179, horizon 98\n", + "adding: mem time82, current time 179, horizon 97\n", + "adding: mem time83, current time 179, horizon 96\n", + "adding: mem time84, current time 179, horizon 95\n", + "adding: mem time85, current time 179, horizon 94\n", + "adding: mem time86, current time 179, horizon 93\n", + "adding: mem time87, current time 179, horizon 92\n", + "adding: mem time88, current time 179, horizon 91\n", + "adding: mem time89, current time 179, horizon 90\n", + "adding: mem time90, current time 179, horizon 89\n", + "adding: mem time91, current time 179, horizon 88\n", + "adding: mem time92, current time 179, horizon 87\n", + "adding: mem time93, current time 179, horizon 86\n", + "adding: mem time94, current time 179, horizon 85\n", + "adding: mem time95, current time 179, horizon 84\n", + "adding: mem time96, current time 179, horizon 83\n", + "adding: mem time97, current time 179, horizon 82\n", + "adding: mem time98, current time 179, horizon 81\n", + "adding: mem time99, current time 179, horizon 80\n", + "adding: mem time100, current time 179, horizon 79\n", + "adding: mem time101, current time 179, horizon 78\n", + "adding: mem time102, current time 179, horizon 77\n", + "adding: mem time103, current time 179, horizon 76\n", + "adding: mem time104, current time 179, horizon 75\n", + "adding: mem time105, current time 179, horizon 74\n", + "adding: mem time106, current time 179, horizon 73\n", + "adding: mem time107, current time 179, horizon 72\n", + "adding: mem time108, current time 179, horizon 71\n", + "adding: mem time109, current time 179, horizon 70\n", + "adding: mem time110, current time 179, horizon 69\n", + "adding: mem time111, current time 179, horizon 68\n", + "adding: mem time112, current time 179, horizon 67\n", + "adding: mem time113, current time 179, horizon 66\n", + "adding: mem time114, current time 179, horizon 65\n", + "adding: mem time115, current time 179, horizon 64\n", + "adding: mem time116, current time 179, horizon 63\n", + "adding: mem time117, current time 179, horizon 62\n", + "adding: mem time118, current time 179, horizon 61\n", + "adding: mem time119, current time 179, horizon 60\n", + "adding: mem time120, current time 179, horizon 59\n", + "adding: mem time121, current time 179, horizon 58\n", + "adding: mem time122, current time 179, horizon 57\n", + "adding: mem time123, current time 179, horizon 56\n", + "adding: mem time124, current time 179, horizon 55\n", + "adding: mem time125, current time 179, horizon 54\n", + "adding: mem time126, current time 179, horizon 53\n", + "adding: mem time127, current time 179, horizon 52\n", + "adding: mem time128, current time 179, horizon 51\n", + "adding: mem time129, current time 179, horizon 50\n", + "adding: mem time130, current time 179, horizon 49\n", + "adding: mem time131, current time 179, horizon 48\n", + "adding: mem time132, current time 179, horizon 47\n", + "adding: mem time133, current time 179, horizon 46\n", + "adding: mem time134, current time 179, horizon 45\n", + "adding: mem time135, current time 179, horizon 44\n", + "adding: mem time136, current time 179, horizon 43\n", + "adding: mem time137, current time 179, horizon 42\n", + "adding: mem time138, current time 179, horizon 41\n", + "adding: mem time139, current time 179, horizon 40\n", + "adding: mem time140, current time 179, horizon 39\n", + "adding: mem time141, current time 179, horizon 38\n", + "adding: mem time142, current time 179, horizon 37\n", + "adding: mem time143, current time 179, horizon 36\n", + "adding: mem time144, current time 179, horizon 35\n", + "adding: mem time145, current time 179, horizon 34\n", + "adding: mem time146, current time 179, horizon 33\n", + "adding: mem time147, current time 179, horizon 32\n", + "adding: mem time148, current time 179, horizon 31\n", + "adding: mem time149, current time 179, horizon 30\n", + "adding: mem time150, current time 179, horizon 29\n", + "adding: mem time151, current time 179, horizon 28\n", + "adding: mem time152, current time 179, horizon 27\n", + "adding: mem time153, current time 179, horizon 26\n", + "adding: mem time154, current time 179, horizon 25\n", + "adding: mem time155, current time 179, horizon 24\n", + "adding: mem time156, current time 179, horizon 23\n", + "adding: mem time157, current time 179, horizon 22\n", + "adding: mem time158, current time 179, horizon 21\n", + "adding: mem time159, current time 179, horizon 20\n", + "adding: mem time160, current time 179, horizon 19\n", + "adding: mem time161, current time 179, horizon 18\n", + "adding: mem time162, current time 179, horizon 17\n", + "adding: mem time163, current time 179, horizon 16\n", + "adding: mem time164, current time 179, horizon 15\n", + "adding: mem time165, current time 179, horizon 14\n", + "adding: mem time166, current time 179, horizon 13\n", + "adding: mem time167, current time 179, horizon 12\n", + "adding: mem time168, current time 179, horizon 11\n", + "adding: mem time169, current time 179, horizon 10\n", + "adding: mem time170, current time 179, horizon 9\n", + "adding: mem time171, current time 179, horizon 8\n", + "adding: mem time172, current time 179, horizon 7\n", + "adding: mem time173, current time 179, horizon 6\n", + "adding: mem time174, current time 179, horizon 5\n", + "adding: mem time175, current time 179, horizon 4\n", + "adding: mem time176, current time 179, horizon 3\n", + "adding: mem time177, current time 179, horizon 2\n", + "adding: mem time178, current time 179, horizon 1\n", + "adding: mem time0, current time 180, horizon 180\n", + "adding: mem time1, current time 180, horizon 179\n", + "adding: mem time2, current time 180, horizon 178\n", + "adding: mem time3, current time 180, horizon 177\n", + "adding: mem time4, current time 180, horizon 176\n", + "adding: mem time5, current time 180, horizon 175\n", + "adding: mem time6, current time 180, horizon 174\n", + "adding: mem time7, current time 180, horizon 173\n", + "adding: mem time8, current time 180, horizon 172\n", + "adding: mem time9, current time 180, horizon 171\n", + "adding: mem time10, current time 180, horizon 170\n", + "adding: mem time11, current time 180, horizon 169\n", + "adding: mem time12, current time 180, horizon 168\n", + "adding: mem time13, current time 180, horizon 167\n", + "adding: mem time14, current time 180, horizon 166\n", + "adding: mem time15, current time 180, horizon 165\n", + "adding: mem time16, current time 180, horizon 164\n", + "adding: mem time17, current time 180, horizon 163\n", + "adding: mem time18, current time 180, horizon 162\n", + "adding: mem time19, current time 180, horizon 161\n", + "adding: mem time20, current time 180, horizon 160\n", + "adding: mem time21, current time 180, horizon 159\n", + "adding: mem time22, current time 180, horizon 158\n", + "adding: mem time23, current time 180, horizon 157\n", + "adding: mem time24, current time 180, horizon 156\n", + "adding: mem time25, current time 180, horizon 155\n", + "adding: mem time26, current time 180, horizon 154\n", + "adding: mem time27, current time 180, horizon 153\n", + "adding: mem time28, current time 180, horizon 152\n", + "adding: mem time29, current time 180, horizon 151\n", + "adding: mem time30, current time 180, horizon 150\n", + "adding: mem time31, current time 180, horizon 149\n", + "adding: mem time32, current time 180, horizon 148\n", + "adding: mem time33, current time 180, horizon 147\n", + "adding: mem time34, current time 180, horizon 146\n", + "adding: mem time35, current time 180, horizon 145\n", + "adding: mem time36, current time 180, horizon 144\n", + "adding: mem time37, current time 180, horizon 143\n", + "adding: mem time38, current time 180, horizon 142\n", + "adding: mem time39, current time 180, horizon 141\n", + "adding: mem time40, current time 180, horizon 140\n", + "adding: mem time41, current time 180, horizon 139\n", + "adding: mem time42, current time 180, horizon 138\n", + "adding: mem time43, current time 180, horizon 137\n", + "adding: mem time44, current time 180, horizon 136\n", + "adding: mem time45, current time 180, horizon 135\n", + "adding: mem time46, current time 180, horizon 134\n", + "adding: mem time47, current time 180, horizon 133\n", + "adding: mem time48, current time 180, horizon 132\n", + "adding: mem time49, current time 180, horizon 131\n", + "adding: mem time50, current time 180, horizon 130\n", + "adding: mem time51, current time 180, horizon 129\n", + "adding: mem time52, current time 180, horizon 128\n", + "adding: mem time53, current time 180, horizon 127\n", + "adding: mem time54, current time 180, horizon 126\n", + "adding: mem time55, current time 180, horizon 125\n", + "adding: mem time56, current time 180, horizon 124\n", + "adding: mem time57, current time 180, horizon 123\n", + "adding: mem time58, current time 180, horizon 122\n", + "adding: mem time59, current time 180, horizon 121\n", + "adding: mem time60, current time 180, horizon 120\n", + "adding: mem time61, current time 180, horizon 119\n", + "adding: mem time62, current time 180, horizon 118\n", + "adding: mem time63, current time 180, horizon 117\n", + "adding: mem time64, current time 180, horizon 116\n", + "adding: mem time65, current time 180, horizon 115\n", + "adding: mem time66, current time 180, horizon 114\n", + "adding: mem time67, current time 180, horizon 113\n", + "adding: mem time68, current time 180, horizon 112\n", + "adding: mem time69, current time 180, horizon 111\n", + "adding: mem time70, current time 180, horizon 110\n", + "adding: mem time71, current time 180, horizon 109\n", + "adding: mem time72, current time 180, horizon 108\n", + "adding: mem time73, current time 180, horizon 107\n", + "adding: mem time74, current time 180, horizon 106\n", + "adding: mem time75, current time 180, horizon 105\n", + "adding: mem time76, current time 180, horizon 104\n", + "adding: mem time77, current time 180, horizon 103\n", + "adding: mem time78, current time 180, horizon 102\n", + "adding: mem time79, current time 180, horizon 101\n", + "adding: mem time80, current time 180, horizon 100\n", + "adding: mem time81, current time 180, horizon 99\n", + "adding: mem time82, current time 180, horizon 98\n", + "adding: mem time83, current time 180, horizon 97\n", + "adding: mem time84, current time 180, horizon 96\n", + "adding: mem time85, current time 180, horizon 95\n", + "adding: mem time86, current time 180, horizon 94\n", + "adding: mem time87, current time 180, horizon 93\n", + "adding: mem time88, current time 180, horizon 92\n", + "adding: mem time89, current time 180, horizon 91\n", + "adding: mem time90, current time 180, horizon 90\n", + "adding: mem time91, current time 180, horizon 89\n", + "adding: mem time92, current time 180, horizon 88\n", + "adding: mem time93, current time 180, horizon 87\n", + "adding: mem time94, current time 180, horizon 86\n", + "adding: mem time95, current time 180, horizon 85\n", + "adding: mem time96, current time 180, horizon 84\n", + "adding: mem time97, current time 180, horizon 83\n", + "adding: mem time98, current time 180, horizon 82\n", + "adding: mem time99, current time 180, horizon 81\n", + "adding: mem time100, current time 180, horizon 80\n", + "adding: mem time101, current time 180, horizon 79\n", + "adding: mem time102, current time 180, horizon 78\n", + "adding: mem time103, current time 180, horizon 77\n", + "adding: mem time104, current time 180, horizon 76\n", + "adding: mem time105, current time 180, horizon 75\n", + "adding: mem time106, current time 180, horizon 74\n", + "adding: mem time107, current time 180, horizon 73\n", + "adding: mem time108, current time 180, horizon 72\n", + "adding: mem time109, current time 180, horizon 71\n", + "adding: mem time110, current time 180, horizon 70\n", + "adding: mem time111, current time 180, horizon 69\n", + "adding: mem time112, current time 180, horizon 68\n", + "adding: mem time113, current time 180, horizon 67\n", + "adding: mem time114, current time 180, horizon 66\n", + "adding: mem time115, current time 180, horizon 65\n", + "adding: mem time116, current time 180, horizon 64\n", + "adding: mem time117, current time 180, horizon 63\n", + "adding: mem time118, current time 180, horizon 62\n", + "adding: mem time119, current time 180, horizon 61\n", + "adding: mem time120, current time 180, horizon 60\n", + "adding: mem time121, current time 180, horizon 59\n", + "adding: mem time122, current time 180, horizon 58\n", + "adding: mem time123, current time 180, horizon 57\n", + "adding: mem time124, current time 180, horizon 56\n", + "adding: mem time125, current time 180, horizon 55\n", + "adding: mem time126, current time 180, horizon 54\n", + "adding: mem time127, current time 180, horizon 53\n", + "adding: mem time128, current time 180, horizon 52\n", + "adding: mem time129, current time 180, horizon 51\n", + "adding: mem time130, current time 180, horizon 50\n", + "adding: mem time131, current time 180, horizon 49\n", + "adding: mem time132, current time 180, horizon 48\n", + "adding: mem time133, current time 180, horizon 47\n", + "adding: mem time134, current time 180, horizon 46\n", + "adding: mem time135, current time 180, horizon 45\n", + "adding: mem time136, current time 180, horizon 44\n", + "adding: mem time137, current time 180, horizon 43\n", + "adding: mem time138, current time 180, horizon 42\n", + "adding: mem time139, current time 180, horizon 41\n", + "adding: mem time140, current time 180, horizon 40\n", + "adding: mem time141, current time 180, horizon 39\n", + "adding: mem time142, current time 180, horizon 38\n", + "adding: mem time143, current time 180, horizon 37\n", + "adding: mem time144, current time 180, horizon 36\n", + "adding: mem time145, current time 180, horizon 35\n", + "adding: mem time146, current time 180, horizon 34\n", + "adding: mem time147, current time 180, horizon 33\n", + "adding: mem time148, current time 180, horizon 32\n", + "adding: mem time149, current time 180, horizon 31\n", + "adding: mem time150, current time 180, horizon 30\n", + "adding: mem time151, current time 180, horizon 29\n", + "adding: mem time152, current time 180, horizon 28\n", + "adding: mem time153, current time 180, horizon 27\n", + "adding: mem time154, current time 180, horizon 26\n", + "adding: mem time155, current time 180, horizon 25\n", + "adding: mem time156, current time 180, horizon 24\n", + "adding: mem time157, current time 180, horizon 23\n", + "adding: mem time158, current time 180, horizon 22\n", + "adding: mem time159, current time 180, horizon 21\n", + "adding: mem time160, current time 180, horizon 20\n", + "adding: mem time161, current time 180, horizon 19\n", + "adding: mem time162, current time 180, horizon 18\n", + "adding: mem time163, current time 180, horizon 17\n", + "adding: mem time164, current time 180, horizon 16\n", + "adding: mem time165, current time 180, horizon 15\n", + "adding: mem time166, current time 180, horizon 14\n", + "adding: mem time167, current time 180, horizon 13\n", + "adding: mem time168, current time 180, horizon 12\n", + "adding: mem time169, current time 180, horizon 11\n", + "adding: mem time170, current time 180, horizon 10\n", + "adding: mem time171, current time 180, horizon 9\n", + "adding: mem time172, current time 180, horizon 8\n", + "adding: mem time173, current time 180, horizon 7\n", + "adding: mem time174, current time 180, horizon 6\n", + "adding: mem time175, current time 180, horizon 5\n", + "adding: mem time176, current time 180, horizon 4\n", + "adding: mem time177, current time 180, horizon 3\n", + "adding: mem time178, current time 180, horizon 2\n", + "adding: mem time179, current time 180, horizon 1\n", + "adding: mem time0, current time 181, horizon 181\n", + "adding: mem time1, current time 181, horizon 180\n", + "adding: mem time2, current time 181, horizon 179\n", + "adding: mem time3, current time 181, horizon 178\n", + "adding: mem time4, current time 181, horizon 177\n", + "adding: mem time5, current time 181, horizon 176\n", + "adding: mem time6, current time 181, horizon 175\n", + "adding: mem time7, current time 181, horizon 174\n", + "adding: mem time8, current time 181, horizon 173\n", + "adding: mem time9, current time 181, horizon 172\n", + "adding: mem time10, current time 181, horizon 171\n", + "adding: mem time11, current time 181, horizon 170\n", + "adding: mem time12, current time 181, horizon 169\n", + "adding: mem time13, current time 181, horizon 168\n", + "adding: mem time14, current time 181, horizon 167\n", + "adding: mem time15, current time 181, horizon 166\n", + "adding: mem time16, current time 181, horizon 165\n", + "adding: mem time17, current time 181, horizon 164\n", + "adding: mem time18, current time 181, horizon 163\n", + "adding: mem time19, current time 181, horizon 162\n", + "adding: mem time20, current time 181, horizon 161\n", + "adding: mem time21, current time 181, horizon 160\n", + "adding: mem time22, current time 181, horizon 159\n", + "adding: mem time23, current time 181, horizon 158\n", + "adding: mem time24, current time 181, horizon 157\n", + "adding: mem time25, current time 181, horizon 156\n", + "adding: mem time26, current time 181, horizon 155\n", + "adding: mem time27, current time 181, horizon 154\n", + "adding: mem time28, current time 181, horizon 153\n", + "adding: mem time29, current time 181, horizon 152\n", + "adding: mem time30, current time 181, horizon 151\n", + "adding: mem time31, current time 181, horizon 150\n", + "adding: mem time32, current time 181, horizon 149\n", + "adding: mem time33, current time 181, horizon 148\n", + "adding: mem time34, current time 181, horizon 147\n", + "adding: mem time35, current time 181, horizon 146\n", + "adding: mem time36, current time 181, horizon 145\n", + "adding: mem time37, current time 181, horizon 144\n", + "adding: mem time38, current time 181, horizon 143\n", + "adding: mem time39, current time 181, horizon 142\n", + "adding: mem time40, current time 181, horizon 141\n", + "adding: mem time41, current time 181, horizon 140\n", + "adding: mem time42, current time 181, horizon 139\n", + "adding: mem time43, current time 181, horizon 138\n", + "adding: mem time44, current time 181, horizon 137\n", + "adding: mem time45, current time 181, horizon 136\n", + "adding: mem time46, current time 181, horizon 135\n", + "adding: mem time47, current time 181, horizon 134\n", + "adding: mem time48, current time 181, horizon 133\n", + "adding: mem time49, current time 181, horizon 132\n", + "adding: mem time50, current time 181, horizon 131\n", + "adding: mem time51, current time 181, horizon 130\n", + "adding: mem time52, current time 181, horizon 129\n", + "adding: mem time53, current time 181, horizon 128\n", + "adding: mem time54, current time 181, horizon 127\n", + "adding: mem time55, current time 181, horizon 126\n", + "adding: mem time56, current time 181, horizon 125\n", + "adding: mem time57, current time 181, horizon 124\n", + "adding: mem time58, current time 181, horizon 123\n", + "adding: mem time59, current time 181, horizon 122\n", + "adding: mem time60, current time 181, horizon 121\n", + "adding: mem time61, current time 181, horizon 120\n", + "adding: mem time62, current time 181, horizon 119\n", + "adding: mem time63, current time 181, horizon 118\n", + "adding: mem time64, current time 181, horizon 117\n", + "adding: mem time65, current time 181, horizon 116\n", + "adding: mem time66, current time 181, horizon 115\n", + "adding: mem time67, current time 181, horizon 114\n", + "adding: mem time68, current time 181, horizon 113\n", + "adding: mem time69, current time 181, horizon 112\n", + "adding: mem time70, current time 181, horizon 111\n", + "adding: mem time71, current time 181, horizon 110\n", + "adding: mem time72, current time 181, horizon 109\n", + "adding: mem time73, current time 181, horizon 108\n", + "adding: mem time74, current time 181, horizon 107\n", + "adding: mem time75, current time 181, horizon 106\n", + "adding: mem time76, current time 181, horizon 105\n", + "adding: mem time77, current time 181, horizon 104\n", + "adding: mem time78, current time 181, horizon 103\n", + "adding: mem time79, current time 181, horizon 102\n", + "adding: mem time80, current time 181, horizon 101\n", + "adding: mem time81, current time 181, horizon 100\n", + "adding: mem time82, current time 181, horizon 99\n", + "adding: mem time83, current time 181, horizon 98\n", + "adding: mem time84, current time 181, horizon 97\n", + "adding: mem time85, current time 181, horizon 96\n", + "adding: mem time86, current time 181, horizon 95\n", + "adding: mem time87, current time 181, horizon 94\n", + "adding: mem time88, current time 181, horizon 93\n", + "adding: mem time89, current time 181, horizon 92\n", + "adding: mem time90, current time 181, horizon 91\n", + "adding: mem time91, current time 181, horizon 90\n", + "adding: mem time92, current time 181, horizon 89\n", + "adding: mem time93, current time 181, horizon 88\n", + "adding: mem time94, current time 181, horizon 87\n", + "adding: mem time95, current time 181, horizon 86\n", + "adding: mem time96, current time 181, horizon 85\n", + "adding: mem time97, current time 181, horizon 84\n", + "adding: mem time98, current time 181, horizon 83\n", + "adding: mem time99, current time 181, horizon 82\n", + "adding: mem time100, current time 181, horizon 81\n", + "adding: mem time101, current time 181, horizon 80\n", + "adding: mem time102, current time 181, horizon 79\n", + "adding: mem time103, current time 181, horizon 78\n", + "adding: mem time104, current time 181, horizon 77\n", + "adding: mem time105, current time 181, horizon 76\n", + "adding: mem time106, current time 181, horizon 75\n", + "adding: mem time107, current time 181, horizon 74\n", + "adding: mem time108, current time 181, horizon 73\n", + "adding: mem time109, current time 181, horizon 72\n", + "adding: mem time110, current time 181, horizon 71\n", + "adding: mem time111, current time 181, horizon 70\n", + "adding: mem time112, current time 181, horizon 69\n", + "adding: mem time113, current time 181, horizon 68\n", + "adding: mem time114, current time 181, horizon 67\n", + "adding: mem time115, current time 181, horizon 66\n", + "adding: mem time116, current time 181, horizon 65\n", + "adding: mem time117, current time 181, horizon 64\n", + "adding: mem time118, current time 181, horizon 63\n", + "adding: mem time119, current time 181, horizon 62\n", + "adding: mem time120, current time 181, horizon 61\n", + "adding: mem time121, current time 181, horizon 60\n", + "adding: mem time122, current time 181, horizon 59\n", + "adding: mem time123, current time 181, horizon 58\n", + "adding: mem time124, current time 181, horizon 57\n", + "adding: mem time125, current time 181, horizon 56\n", + "adding: mem time126, current time 181, horizon 55\n", + "adding: mem time127, current time 181, horizon 54\n", + "adding: mem time128, current time 181, horizon 53\n", + "adding: mem time129, current time 181, horizon 52\n", + "adding: mem time130, current time 181, horizon 51\n", + "adding: mem time131, current time 181, horizon 50\n", + "adding: mem time132, current time 181, horizon 49\n", + "adding: mem time133, current time 181, horizon 48\n", + "adding: mem time134, current time 181, horizon 47\n", + "adding: mem time135, current time 181, horizon 46\n", + "adding: mem time136, current time 181, horizon 45\n", + "adding: mem time137, current time 181, horizon 44\n", + "adding: mem time138, current time 181, horizon 43\n", + "adding: mem time139, current time 181, horizon 42\n", + "adding: mem time140, current time 181, horizon 41\n", + "adding: mem time141, current time 181, horizon 40\n", + "adding: mem time142, current time 181, horizon 39\n", + "adding: mem time143, current time 181, horizon 38\n", + "adding: mem time144, current time 181, horizon 37\n", + "adding: mem time145, current time 181, horizon 36\n", + "adding: mem time146, current time 181, horizon 35\n", + "adding: mem time147, current time 181, horizon 34\n", + "adding: mem time148, current time 181, horizon 33\n", + "adding: mem time149, current time 181, horizon 32\n", + "adding: mem time150, current time 181, horizon 31\n", + "adding: mem time151, current time 181, horizon 30\n", + "adding: mem time152, current time 181, horizon 29\n", + "adding: mem time153, current time 181, horizon 28\n", + "adding: mem time154, current time 181, horizon 27\n", + "adding: mem time155, current time 181, horizon 26\n", + "adding: mem time156, current time 181, horizon 25\n", + "adding: mem time157, current time 181, horizon 24\n", + "adding: mem time158, current time 181, horizon 23\n", + "adding: mem time159, current time 181, horizon 22\n", + "adding: mem time160, current time 181, horizon 21\n", + "adding: mem time161, current time 181, horizon 20\n", + "adding: mem time162, current time 181, horizon 19\n", + "adding: mem time163, current time 181, horizon 18\n", + "adding: mem time164, current time 181, horizon 17\n", + "adding: mem time165, current time 181, horizon 16\n", + "adding: mem time166, current time 181, horizon 15\n", + "adding: mem time167, current time 181, horizon 14\n", + "adding: mem time168, current time 181, horizon 13\n", + "adding: mem time169, current time 181, horizon 12\n", + "adding: mem time170, current time 181, horizon 11\n", + "adding: mem time171, current time 181, horizon 10\n", + "adding: mem time172, current time 181, horizon 9\n", + "adding: mem time173, current time 181, horizon 8\n", + "adding: mem time174, current time 181, horizon 7\n", + "adding: mem time175, current time 181, horizon 6\n", + "adding: mem time176, current time 181, horizon 5\n", + "adding: mem time177, current time 181, horizon 4\n", + "adding: mem time178, current time 181, horizon 3\n", + "adding: mem time179, current time 181, horizon 2\n", + "adding: mem time180, current time 181, horizon 1\n", + "adding: mem time0, current time 182, horizon 182\n", + "adding: mem time1, current time 182, horizon 181\n", + "adding: mem time2, current time 182, horizon 180\n", + "adding: mem time3, current time 182, horizon 179\n", + "adding: mem time4, current time 182, horizon 178\n", + "adding: mem time5, current time 182, horizon 177\n", + "adding: mem time6, current time 182, horizon 176\n", + "adding: mem time7, current time 182, horizon 175\n", + "adding: mem time8, current time 182, horizon 174\n", + "adding: mem time9, current time 182, horizon 173\n", + "adding: mem time10, current time 182, horizon 172\n", + "adding: mem time11, current time 182, horizon 171\n", + "adding: mem time12, current time 182, horizon 170\n", + "adding: mem time13, current time 182, horizon 169\n", + "adding: mem time14, current time 182, horizon 168\n", + "adding: mem time15, current time 182, horizon 167\n", + "adding: mem time16, current time 182, horizon 166\n", + "adding: mem time17, current time 182, horizon 165\n", + "adding: mem time18, current time 182, horizon 164\n", + "adding: mem time19, current time 182, horizon 163\n", + "adding: mem time20, current time 182, horizon 162\n", + "adding: mem time21, current time 182, horizon 161\n", + "adding: mem time22, current time 182, horizon 160\n", + "adding: mem time23, current time 182, horizon 159\n", + "adding: mem time24, current time 182, horizon 158\n", + "adding: mem time25, current time 182, horizon 157\n", + "adding: mem time26, current time 182, horizon 156\n", + "adding: mem time27, current time 182, horizon 155\n", + "adding: mem time28, current time 182, horizon 154\n", + "adding: mem time29, current time 182, horizon 153\n", + "adding: mem time30, current time 182, horizon 152\n", + "adding: mem time31, current time 182, horizon 151\n", + "adding: mem time32, current time 182, horizon 150\n", + "adding: mem time33, current time 182, horizon 149\n", + "adding: mem time34, current time 182, horizon 148\n", + "adding: mem time35, current time 182, horizon 147\n", + "adding: mem time36, current time 182, horizon 146\n", + "adding: mem time37, current time 182, horizon 145\n", + "adding: mem time38, current time 182, horizon 144\n", + "adding: mem time39, current time 182, horizon 143\n", + "adding: mem time40, current time 182, horizon 142\n", + "adding: mem time41, current time 182, horizon 141\n", + "adding: mem time42, current time 182, horizon 140\n", + "adding: mem time43, current time 182, horizon 139\n", + "adding: mem time44, current time 182, horizon 138\n", + "adding: mem time45, current time 182, horizon 137\n", + "adding: mem time46, current time 182, horizon 136\n", + "adding: mem time47, current time 182, horizon 135\n", + "adding: mem time48, current time 182, horizon 134\n", + "adding: mem time49, current time 182, horizon 133\n", + "adding: mem time50, current time 182, horizon 132\n", + "adding: mem time51, current time 182, horizon 131\n", + "adding: mem time52, current time 182, horizon 130\n", + "adding: mem time53, current time 182, horizon 129\n", + "adding: mem time54, current time 182, horizon 128\n", + "adding: mem time55, current time 182, horizon 127\n", + "adding: mem time56, current time 182, horizon 126\n", + "adding: mem time57, current time 182, horizon 125\n", + "adding: mem time58, current time 182, horizon 124\n", + "adding: mem time59, current time 182, horizon 123\n", + "adding: mem time60, current time 182, horizon 122\n", + "adding: mem time61, current time 182, horizon 121\n", + "adding: mem time62, current time 182, horizon 120\n", + "adding: mem time63, current time 182, horizon 119\n", + "adding: mem time64, current time 182, horizon 118\n", + "adding: mem time65, current time 182, horizon 117\n", + "adding: mem time66, current time 182, horizon 116\n", + "adding: mem time67, current time 182, horizon 115\n", + "adding: mem time68, current time 182, horizon 114\n", + "adding: mem time69, current time 182, horizon 113\n", + "adding: mem time70, current time 182, horizon 112\n", + "adding: mem time71, current time 182, horizon 111\n", + "adding: mem time72, current time 182, horizon 110\n", + "adding: mem time73, current time 182, horizon 109\n", + "adding: mem time74, current time 182, horizon 108\n", + "adding: mem time75, current time 182, horizon 107\n", + "adding: mem time76, current time 182, horizon 106\n", + "adding: mem time77, current time 182, horizon 105\n", + "adding: mem time78, current time 182, horizon 104\n", + "adding: mem time79, current time 182, horizon 103\n", + "adding: mem time80, current time 182, horizon 102\n", + "adding: mem time81, current time 182, horizon 101\n", + "adding: mem time82, current time 182, horizon 100\n", + "adding: mem time83, current time 182, horizon 99\n", + "adding: mem time84, current time 182, horizon 98\n", + "adding: mem time85, current time 182, horizon 97\n", + "adding: mem time86, current time 182, horizon 96\n", + "adding: mem time87, current time 182, horizon 95\n", + "adding: mem time88, current time 182, horizon 94\n", + "adding: mem time89, current time 182, horizon 93\n", + "adding: mem time90, current time 182, horizon 92\n", + "adding: mem time91, current time 182, horizon 91\n", + "adding: mem time92, current time 182, horizon 90\n", + "adding: mem time93, current time 182, horizon 89\n", + "adding: mem time94, current time 182, horizon 88\n", + "adding: mem time95, current time 182, horizon 87\n", + "adding: mem time96, current time 182, horizon 86\n", + "adding: mem time97, current time 182, horizon 85\n", + "adding: mem time98, current time 182, horizon 84\n", + "adding: mem time99, current time 182, horizon 83\n", + "adding: mem time100, current time 182, horizon 82\n", + "adding: mem time101, current time 182, horizon 81\n", + "adding: mem time102, current time 182, horizon 80\n", + "adding: mem time103, current time 182, horizon 79\n", + "adding: mem time104, current time 182, horizon 78\n", + "adding: mem time105, current time 182, horizon 77\n", + "adding: mem time106, current time 182, horizon 76\n", + "adding: mem time107, current time 182, horizon 75\n", + "adding: mem time108, current time 182, horizon 74\n", + "adding: mem time109, current time 182, horizon 73\n", + "adding: mem time110, current time 182, horizon 72\n", + "adding: mem time111, current time 182, horizon 71\n", + "adding: mem time112, current time 182, horizon 70\n", + "adding: mem time113, current time 182, horizon 69\n", + "adding: mem time114, current time 182, horizon 68\n", + "adding: mem time115, current time 182, horizon 67\n", + "adding: mem time116, current time 182, horizon 66\n", + "adding: mem time117, current time 182, horizon 65\n", + "adding: mem time118, current time 182, horizon 64\n", + "adding: mem time119, current time 182, horizon 63\n", + "adding: mem time120, current time 182, horizon 62\n", + "adding: mem time121, current time 182, horizon 61\n", + "adding: mem time122, current time 182, horizon 60\n", + "adding: mem time123, current time 182, horizon 59\n", + "adding: mem time124, current time 182, horizon 58\n", + "adding: mem time125, current time 182, horizon 57\n", + "adding: mem time126, current time 182, horizon 56\n", + "adding: mem time127, current time 182, horizon 55\n", + "adding: mem time128, current time 182, horizon 54\n", + "adding: mem time129, current time 182, horizon 53\n", + "adding: mem time130, current time 182, horizon 52\n", + "adding: mem time131, current time 182, horizon 51\n", + "adding: mem time132, current time 182, horizon 50\n", + "adding: mem time133, current time 182, horizon 49\n", + "adding: mem time134, current time 182, horizon 48\n", + "adding: mem time135, current time 182, horizon 47\n", + "adding: mem time136, current time 182, horizon 46\n", + "adding: mem time137, current time 182, horizon 45\n", + "adding: mem time138, current time 182, horizon 44\n", + "adding: mem time139, current time 182, horizon 43\n", + "adding: mem time140, current time 182, horizon 42\n", + "adding: mem time141, current time 182, horizon 41\n", + "adding: mem time142, current time 182, horizon 40\n", + "adding: mem time143, current time 182, horizon 39\n", + "adding: mem time144, current time 182, horizon 38\n", + "adding: mem time145, current time 182, horizon 37\n", + "adding: mem time146, current time 182, horizon 36\n", + "adding: mem time147, current time 182, horizon 35\n", + "adding: mem time148, current time 182, horizon 34\n", + "adding: mem time149, current time 182, horizon 33\n", + "adding: mem time150, current time 182, horizon 32\n", + "adding: mem time151, current time 182, horizon 31\n", + "adding: mem time152, current time 182, horizon 30\n", + "adding: mem time153, current time 182, horizon 29\n", + "adding: mem time154, current time 182, horizon 28\n", + "adding: mem time155, current time 182, horizon 27\n", + "adding: mem time156, current time 182, horizon 26\n", + "adding: mem time157, current time 182, horizon 25\n", + "adding: mem time158, current time 182, horizon 24\n", + "adding: mem time159, current time 182, horizon 23\n", + "adding: mem time160, current time 182, horizon 22\n", + "adding: mem time161, current time 182, horizon 21\n", + "adding: mem time162, current time 182, horizon 20\n", + "adding: mem time163, current time 182, horizon 19\n", + "adding: mem time164, current time 182, horizon 18\n", + "adding: mem time165, current time 182, horizon 17\n", + "adding: mem time166, current time 182, horizon 16\n", + "adding: mem time167, current time 182, horizon 15\n", + "adding: mem time168, current time 182, horizon 14\n", + "adding: mem time169, current time 182, horizon 13\n", + "adding: mem time170, current time 182, horizon 12\n", + "adding: mem time171, current time 182, horizon 11\n", + "adding: mem time172, current time 182, horizon 10\n", + "adding: mem time173, current time 182, horizon 9\n", + "adding: mem time174, current time 182, horizon 8\n", + "adding: mem time175, current time 182, horizon 7\n", + "adding: mem time176, current time 182, horizon 6\n", + "adding: mem time177, current time 182, horizon 5\n", + "adding: mem time178, current time 182, horizon 4\n", + "adding: mem time179, current time 182, horizon 3\n", + "adding: mem time180, current time 182, horizon 2\n", + "adding: mem time181, current time 182, horizon 1\n", + "adding: mem time0, current time 183, horizon 183\n", + "adding: mem time1, current time 183, horizon 182\n", + "adding: mem time2, current time 183, horizon 181\n", + "adding: mem time3, current time 183, horizon 180\n", + "adding: mem time4, current time 183, horizon 179\n", + "adding: mem time5, current time 183, horizon 178\n", + "adding: mem time6, current time 183, horizon 177\n", + "adding: mem time7, current time 183, horizon 176\n", + "adding: mem time8, current time 183, horizon 175\n", + "adding: mem time9, current time 183, horizon 174\n", + "adding: mem time10, current time 183, horizon 173\n", + "adding: mem time11, current time 183, horizon 172\n", + "adding: mem time12, current time 183, horizon 171\n", + "adding: mem time13, current time 183, horizon 170\n", + "adding: mem time14, current time 183, horizon 169\n", + "adding: mem time15, current time 183, horizon 168\n", + "adding: mem time16, current time 183, horizon 167\n", + "adding: mem time17, current time 183, horizon 166\n", + "adding: mem time18, current time 183, horizon 165\n", + "adding: mem time19, current time 183, horizon 164\n", + "adding: mem time20, current time 183, horizon 163\n", + "adding: mem time21, current time 183, horizon 162\n", + "adding: mem time22, current time 183, horizon 161\n", + "adding: mem time23, current time 183, horizon 160\n", + "adding: mem time24, current time 183, horizon 159\n", + "adding: mem time25, current time 183, horizon 158\n", + "adding: mem time26, current time 183, horizon 157\n", + "adding: mem time27, current time 183, horizon 156\n", + "adding: mem time28, current time 183, horizon 155\n", + "adding: mem time29, current time 183, horizon 154\n", + "adding: mem time30, current time 183, horizon 153\n", + "adding: mem time31, current time 183, horizon 152\n", + "adding: mem time32, current time 183, horizon 151\n", + "adding: mem time33, current time 183, horizon 150\n", + "adding: mem time34, current time 183, horizon 149\n", + "adding: mem time35, current time 183, horizon 148\n", + "adding: mem time36, current time 183, horizon 147\n", + "adding: mem time37, current time 183, horizon 146\n", + "adding: mem time38, current time 183, horizon 145\n", + "adding: mem time39, current time 183, horizon 144\n", + "adding: mem time40, current time 183, horizon 143\n", + "adding: mem time41, current time 183, horizon 142\n", + "adding: mem time42, current time 183, horizon 141\n", + "adding: mem time43, current time 183, horizon 140\n", + "adding: mem time44, current time 183, horizon 139\n", + "adding: mem time45, current time 183, horizon 138\n", + "adding: mem time46, current time 183, horizon 137\n", + "adding: mem time47, current time 183, horizon 136\n", + "adding: mem time48, current time 183, horizon 135\n", + "adding: mem time49, current time 183, horizon 134\n", + "adding: mem time50, current time 183, horizon 133\n", + "adding: mem time51, current time 183, horizon 132\n", + "adding: mem time52, current time 183, horizon 131\n", + "adding: mem time53, current time 183, horizon 130\n", + "adding: mem time54, current time 183, horizon 129\n", + "adding: mem time55, current time 183, horizon 128\n", + "adding: mem time56, current time 183, horizon 127\n", + "adding: mem time57, current time 183, horizon 126\n", + "adding: mem time58, current time 183, horizon 125\n", + "adding: mem time59, current time 183, horizon 124\n", + "adding: mem time60, current time 183, horizon 123\n", + "adding: mem time61, current time 183, horizon 122\n", + "adding: mem time62, current time 183, horizon 121\n", + "adding: mem time63, current time 183, horizon 120\n", + "adding: mem time64, current time 183, horizon 119\n", + "adding: mem time65, current time 183, horizon 118\n", + "adding: mem time66, current time 183, horizon 117\n", + "adding: mem time67, current time 183, horizon 116\n", + "adding: mem time68, current time 183, horizon 115\n", + "adding: mem time69, current time 183, horizon 114\n", + "adding: mem time70, current time 183, horizon 113\n", + "adding: mem time71, current time 183, horizon 112\n", + "adding: mem time72, current time 183, horizon 111\n", + "adding: mem time73, current time 183, horizon 110\n", + "adding: mem time74, current time 183, horizon 109\n", + "adding: mem time75, current time 183, horizon 108\n", + "adding: mem time76, current time 183, horizon 107\n", + "adding: mem time77, current time 183, horizon 106\n", + "adding: mem time78, current time 183, horizon 105\n", + "adding: mem time79, current time 183, horizon 104\n", + "adding: mem time80, current time 183, horizon 103\n", + "adding: mem time81, current time 183, horizon 102\n", + "adding: mem time82, current time 183, horizon 101\n", + "adding: mem time83, current time 183, horizon 100\n", + "adding: mem time84, current time 183, horizon 99\n", + "adding: mem time85, current time 183, horizon 98\n", + "adding: mem time86, current time 183, horizon 97\n", + "adding: mem time87, current time 183, horizon 96\n", + "adding: mem time88, current time 183, horizon 95\n", + "adding: mem time89, current time 183, horizon 94\n", + "adding: mem time90, current time 183, horizon 93\n", + "adding: mem time91, current time 183, horizon 92\n", + "adding: mem time92, current time 183, horizon 91\n", + "adding: mem time93, current time 183, horizon 90\n", + "adding: mem time94, current time 183, horizon 89\n", + "adding: mem time95, current time 183, horizon 88\n", + "adding: mem time96, current time 183, horizon 87\n", + "adding: mem time97, current time 183, horizon 86\n", + "adding: mem time98, current time 183, horizon 85\n", + "adding: mem time99, current time 183, horizon 84\n", + "adding: mem time100, current time 183, horizon 83\n", + "adding: mem time101, current time 183, horizon 82\n", + "adding: mem time102, current time 183, horizon 81\n", + "adding: mem time103, current time 183, horizon 80\n", + "adding: mem time104, current time 183, horizon 79\n", + "adding: mem time105, current time 183, horizon 78\n", + "adding: mem time106, current time 183, horizon 77\n", + "adding: mem time107, current time 183, horizon 76\n", + "adding: mem time108, current time 183, horizon 75\n", + "adding: mem time109, current time 183, horizon 74\n", + "adding: mem time110, current time 183, horizon 73\n", + "adding: mem time111, current time 183, horizon 72\n", + "adding: mem time112, current time 183, horizon 71\n", + "adding: mem time113, current time 183, horizon 70\n", + "adding: mem time114, current time 183, horizon 69\n", + "adding: mem time115, current time 183, horizon 68\n", + "adding: mem time116, current time 183, horizon 67\n", + "adding: mem time117, current time 183, horizon 66\n", + "adding: mem time118, current time 183, horizon 65\n", + "adding: mem time119, current time 183, horizon 64\n", + "adding: mem time120, current time 183, horizon 63\n", + "adding: mem time121, current time 183, horizon 62\n", + "adding: mem time122, current time 183, horizon 61\n", + "adding: mem time123, current time 183, horizon 60\n", + "adding: mem time124, current time 183, horizon 59\n", + "adding: mem time125, current time 183, horizon 58\n", + "adding: mem time126, current time 183, horizon 57\n", + "adding: mem time127, current time 183, horizon 56\n", + "adding: mem time128, current time 183, horizon 55\n", + "adding: mem time129, current time 183, horizon 54\n", + "adding: mem time130, current time 183, horizon 53\n", + "adding: mem time131, current time 183, horizon 52\n", + "adding: mem time132, current time 183, horizon 51\n", + "adding: mem time133, current time 183, horizon 50\n", + "adding: mem time134, current time 183, horizon 49\n", + "adding: mem time135, current time 183, horizon 48\n", + "adding: mem time136, current time 183, horizon 47\n", + "adding: mem time137, current time 183, horizon 46\n", + "adding: mem time138, current time 183, horizon 45\n", + "adding: mem time139, current time 183, horizon 44\n", + "adding: mem time140, current time 183, horizon 43\n", + "adding: mem time141, current time 183, horizon 42\n", + "adding: mem time142, current time 183, horizon 41\n", + "adding: mem time143, current time 183, horizon 40\n", + "adding: mem time144, current time 183, horizon 39\n", + "adding: mem time145, current time 183, horizon 38\n", + "adding: mem time146, current time 183, horizon 37\n", + "adding: mem time147, current time 183, horizon 36\n", + "adding: mem time148, current time 183, horizon 35\n", + "adding: mem time149, current time 183, horizon 34\n", + "adding: mem time150, current time 183, horizon 33\n", + "adding: mem time151, current time 183, horizon 32\n", + "adding: mem time152, current time 183, horizon 31\n", + "adding: mem time153, current time 183, horizon 30\n", + "adding: mem time154, current time 183, horizon 29\n", + "adding: mem time155, current time 183, horizon 28\n", + "adding: mem time156, current time 183, horizon 27\n", + "adding: mem time157, current time 183, horizon 26\n", + "adding: mem time158, current time 183, horizon 25\n", + "adding: mem time159, current time 183, horizon 24\n", + "adding: mem time160, current time 183, horizon 23\n", + "adding: mem time161, current time 183, horizon 22\n", + "adding: mem time162, current time 183, horizon 21\n", + "adding: mem time163, current time 183, horizon 20\n", + "adding: mem time164, current time 183, horizon 19\n", + "adding: mem time165, current time 183, horizon 18\n", + "adding: mem time166, current time 183, horizon 17\n", + "adding: mem time167, current time 183, horizon 16\n", + "adding: mem time168, current time 183, horizon 15\n", + "adding: mem time169, current time 183, horizon 14\n", + "adding: mem time170, current time 183, horizon 13\n", + "adding: mem time171, current time 183, horizon 12\n", + "adding: mem time172, current time 183, horizon 11\n", + "adding: mem time173, current time 183, horizon 10\n", + "adding: mem time174, current time 183, horizon 9\n", + "adding: mem time175, current time 183, horizon 8\n", + "adding: mem time176, current time 183, horizon 7\n", + "adding: mem time177, current time 183, horizon 6\n", + "adding: mem time178, current time 183, horizon 5\n", + "adding: mem time179, current time 183, horizon 4\n", + "adding: mem time180, current time 183, horizon 3\n", + "adding: mem time181, current time 183, horizon 2\n", + "adding: mem time182, current time 183, horizon 1\n", + "adding: mem time0, current time 184, horizon 184\n", + "adding: mem time1, current time 184, horizon 183\n", + "adding: mem time2, current time 184, horizon 182\n", + "adding: mem time3, current time 184, horizon 181\n", + "adding: mem time4, current time 184, horizon 180\n", + "adding: mem time5, current time 184, horizon 179\n", + "adding: mem time6, current time 184, horizon 178\n", + "adding: mem time7, current time 184, horizon 177\n", + "adding: mem time8, current time 184, horizon 176\n", + "adding: mem time9, current time 184, horizon 175\n", + "adding: mem time10, current time 184, horizon 174\n", + "adding: mem time11, current time 184, horizon 173\n", + "adding: mem time12, current time 184, horizon 172\n", + "adding: mem time13, current time 184, horizon 171\n", + "adding: mem time14, current time 184, horizon 170\n", + "adding: mem time15, current time 184, horizon 169\n", + "adding: mem time16, current time 184, horizon 168\n", + "adding: mem time17, current time 184, horizon 167\n", + "adding: mem time18, current time 184, horizon 166\n", + "adding: mem time19, current time 184, horizon 165\n", + "adding: mem time20, current time 184, horizon 164\n", + "adding: mem time21, current time 184, horizon 163\n", + "adding: mem time22, current time 184, horizon 162\n", + "adding: mem time23, current time 184, horizon 161\n", + "adding: mem time24, current time 184, horizon 160\n", + "adding: mem time25, current time 184, horizon 159\n", + "adding: mem time26, current time 184, horizon 158\n", + "adding: mem time27, current time 184, horizon 157\n", + "adding: mem time28, current time 184, horizon 156\n", + "adding: mem time29, current time 184, horizon 155\n", + "adding: mem time30, current time 184, horizon 154\n", + "adding: mem time31, current time 184, horizon 153\n", + "adding: mem time32, current time 184, horizon 152\n", + "adding: mem time33, current time 184, horizon 151\n", + "adding: mem time34, current time 184, horizon 150\n", + "adding: mem time35, current time 184, horizon 149\n", + "adding: mem time36, current time 184, horizon 148\n", + "adding: mem time37, current time 184, horizon 147\n", + "adding: mem time38, current time 184, horizon 146\n", + "adding: mem time39, current time 184, horizon 145\n", + "adding: mem time40, current time 184, horizon 144\n", + "adding: mem time41, current time 184, horizon 143\n", + "adding: mem time42, current time 184, horizon 142\n", + "adding: mem time43, current time 184, horizon 141\n", + "adding: mem time44, current time 184, horizon 140\n", + "adding: mem time45, current time 184, horizon 139\n", + "adding: mem time46, current time 184, horizon 138\n", + "adding: mem time47, current time 184, horizon 137\n", + "adding: mem time48, current time 184, horizon 136\n", + "adding: mem time49, current time 184, horizon 135\n", + "adding: mem time50, current time 184, horizon 134\n", + "adding: mem time51, current time 184, horizon 133\n", + "adding: mem time52, current time 184, horizon 132\n", + "adding: mem time53, current time 184, horizon 131\n", + "adding: mem time54, current time 184, horizon 130\n", + "adding: mem time55, current time 184, horizon 129\n", + "adding: mem time56, current time 184, horizon 128\n", + "adding: mem time57, current time 184, horizon 127\n", + "adding: mem time58, current time 184, horizon 126\n", + "adding: mem time59, current time 184, horizon 125\n", + "adding: mem time60, current time 184, horizon 124\n", + "adding: mem time61, current time 184, horizon 123\n", + "adding: mem time62, current time 184, horizon 122\n", + "adding: mem time63, current time 184, horizon 121\n", + "adding: mem time64, current time 184, horizon 120\n", + "adding: mem time65, current time 184, horizon 119\n", + "adding: mem time66, current time 184, horizon 118\n", + "adding: mem time67, current time 184, horizon 117\n", + "adding: mem time68, current time 184, horizon 116\n", + "adding: mem time69, current time 184, horizon 115\n", + "adding: mem time70, current time 184, horizon 114\n", + "adding: mem time71, current time 184, horizon 113\n", + "adding: mem time72, current time 184, horizon 112\n", + "adding: mem time73, current time 184, horizon 111\n", + "adding: mem time74, current time 184, horizon 110\n", + "adding: mem time75, current time 184, horizon 109\n", + "adding: mem time76, current time 184, horizon 108\n", + "adding: mem time77, current time 184, horizon 107\n", + "adding: mem time78, current time 184, horizon 106\n", + "adding: mem time79, current time 184, horizon 105\n", + "adding: mem time80, current time 184, horizon 104\n", + "adding: mem time81, current time 184, horizon 103\n", + "adding: mem time82, current time 184, horizon 102\n", + "adding: mem time83, current time 184, horizon 101\n", + "adding: mem time84, current time 184, horizon 100\n", + "adding: mem time85, current time 184, horizon 99\n", + "adding: mem time86, current time 184, horizon 98\n", + "adding: mem time87, current time 184, horizon 97\n", + "adding: mem time88, current time 184, horizon 96\n", + "adding: mem time89, current time 184, horizon 95\n", + "adding: mem time90, current time 184, horizon 94\n", + "adding: mem time91, current time 184, horizon 93\n", + "adding: mem time92, current time 184, horizon 92\n", + "adding: mem time93, current time 184, horizon 91\n", + "adding: mem time94, current time 184, horizon 90\n", + "adding: mem time95, current time 184, horizon 89\n", + "adding: mem time96, current time 184, horizon 88\n", + "adding: mem time97, current time 184, horizon 87\n", + "adding: mem time98, current time 184, horizon 86\n", + "adding: mem time99, current time 184, horizon 85\n", + "adding: mem time100, current time 184, horizon 84\n", + "adding: mem time101, current time 184, horizon 83\n", + "adding: mem time102, current time 184, horizon 82\n", + "adding: mem time103, current time 184, horizon 81\n", + "adding: mem time104, current time 184, horizon 80\n", + "adding: mem time105, current time 184, horizon 79\n", + "adding: mem time106, current time 184, horizon 78\n", + "adding: mem time107, current time 184, horizon 77\n", + "adding: mem time108, current time 184, horizon 76\n", + "adding: mem time109, current time 184, horizon 75\n", + "adding: mem time110, current time 184, horizon 74\n", + "adding: mem time111, current time 184, horizon 73\n", + "adding: mem time112, current time 184, horizon 72\n", + "adding: mem time113, current time 184, horizon 71\n", + "adding: mem time114, current time 184, horizon 70\n", + "adding: mem time115, current time 184, horizon 69\n", + "adding: mem time116, current time 184, horizon 68\n", + "adding: mem time117, current time 184, horizon 67\n", + "adding: mem time118, current time 184, horizon 66\n", + "adding: mem time119, current time 184, horizon 65\n", + "adding: mem time120, current time 184, horizon 64\n", + "adding: mem time121, current time 184, horizon 63\n", + "adding: mem time122, current time 184, horizon 62\n", + "adding: mem time123, current time 184, horizon 61\n", + "adding: mem time124, current time 184, horizon 60\n", + "adding: mem time125, current time 184, horizon 59\n", + "adding: mem time126, current time 184, horizon 58\n", + "adding: mem time127, current time 184, horizon 57\n", + "adding: mem time128, current time 184, horizon 56\n", + "adding: mem time129, current time 184, horizon 55\n", + "adding: mem time130, current time 184, horizon 54\n", + "adding: mem time131, current time 184, horizon 53\n", + "adding: mem time132, current time 184, horizon 52\n", + "adding: mem time133, current time 184, horizon 51\n", + "adding: mem time134, current time 184, horizon 50\n", + "adding: mem time135, current time 184, horizon 49\n", + "adding: mem time136, current time 184, horizon 48\n", + "adding: mem time137, current time 184, horizon 47\n", + "adding: mem time138, current time 184, horizon 46\n", + "adding: mem time139, current time 184, horizon 45\n", + "adding: mem time140, current time 184, horizon 44\n", + "adding: mem time141, current time 184, horizon 43\n", + "adding: mem time142, current time 184, horizon 42\n", + "adding: mem time143, current time 184, horizon 41\n", + "adding: mem time144, current time 184, horizon 40\n", + "adding: mem time145, current time 184, horizon 39\n", + "adding: mem time146, current time 184, horizon 38\n", + "adding: mem time147, current time 184, horizon 37\n", + "adding: mem time148, current time 184, horizon 36\n", + "adding: mem time149, current time 184, horizon 35\n", + "adding: mem time150, current time 184, horizon 34\n", + "adding: mem time151, current time 184, horizon 33\n", + "adding: mem time152, current time 184, horizon 32\n", + "adding: mem time153, current time 184, horizon 31\n", + "adding: mem time154, current time 184, horizon 30\n", + "adding: mem time155, current time 184, horizon 29\n", + "adding: mem time156, current time 184, horizon 28\n", + "adding: mem time157, current time 184, horizon 27\n", + "adding: mem time158, current time 184, horizon 26\n", + "adding: mem time159, current time 184, horizon 25\n", + "adding: mem time160, current time 184, horizon 24\n", + "adding: mem time161, current time 184, horizon 23\n", + "adding: mem time162, current time 184, horizon 22\n", + "adding: mem time163, current time 184, horizon 21\n", + "adding: mem time164, current time 184, horizon 20\n", + "adding: mem time165, current time 184, horizon 19\n", + "adding: mem time166, current time 184, horizon 18\n", + "adding: mem time167, current time 184, horizon 17\n", + "adding: mem time168, current time 184, horizon 16\n", + "adding: mem time169, current time 184, horizon 15\n", + "adding: mem time170, current time 184, horizon 14\n", + "adding: mem time171, current time 184, horizon 13\n", + "adding: mem time172, current time 184, horizon 12\n", + "adding: mem time173, current time 184, horizon 11\n", + "adding: mem time174, current time 184, horizon 10\n", + "adding: mem time175, current time 184, horizon 9\n", + "adding: mem time176, current time 184, horizon 8\n", + "adding: mem time177, current time 184, horizon 7\n", + "adding: mem time178, current time 184, horizon 6\n", + "adding: mem time179, current time 184, horizon 5\n", + "adding: mem time180, current time 184, horizon 4\n", + "adding: mem time181, current time 184, horizon 3\n", + "adding: mem time182, current time 184, horizon 2\n", + "adding: mem time183, current time 184, horizon 1\n", + "adding: mem time0, current time 185, horizon 185\n", + "adding: mem time1, current time 185, horizon 184\n", + "adding: mem time2, current time 185, horizon 183\n", + "adding: mem time3, current time 185, horizon 182\n", + "adding: mem time4, current time 185, horizon 181\n", + "adding: mem time5, current time 185, horizon 180\n", + "adding: mem time6, current time 185, horizon 179\n", + "adding: mem time7, current time 185, horizon 178\n", + "adding: mem time8, current time 185, horizon 177\n", + "adding: mem time9, current time 185, horizon 176\n", + "adding: mem time10, current time 185, horizon 175\n", + "adding: mem time11, current time 185, horizon 174\n", + "adding: mem time12, current time 185, horizon 173\n", + "adding: mem time13, current time 185, horizon 172\n", + "adding: mem time14, current time 185, horizon 171\n", + "adding: mem time15, current time 185, horizon 170\n", + "adding: mem time16, current time 185, horizon 169\n", + "adding: mem time17, current time 185, horizon 168\n", + "adding: mem time18, current time 185, horizon 167\n", + "adding: mem time19, current time 185, horizon 166\n", + "adding: mem time20, current time 185, horizon 165\n", + "adding: mem time21, current time 185, horizon 164\n", + "adding: mem time22, current time 185, horizon 163\n", + "adding: mem time23, current time 185, horizon 162\n", + "adding: mem time24, current time 185, horizon 161\n", + "adding: mem time25, current time 185, horizon 160\n", + "adding: mem time26, current time 185, horizon 159\n", + "adding: mem time27, current time 185, horizon 158\n", + "adding: mem time28, current time 185, horizon 157\n", + "adding: mem time29, current time 185, horizon 156\n", + "adding: mem time30, current time 185, horizon 155\n", + "adding: mem time31, current time 185, horizon 154\n", + "adding: mem time32, current time 185, horizon 153\n", + "adding: mem time33, current time 185, horizon 152\n", + "adding: mem time34, current time 185, horizon 151\n", + "adding: mem time35, current time 185, horizon 150\n", + "adding: mem time36, current time 185, horizon 149\n", + "adding: mem time37, current time 185, horizon 148\n", + "adding: mem time38, current time 185, horizon 147\n", + "adding: mem time39, current time 185, horizon 146\n", + "adding: mem time40, current time 185, horizon 145\n", + "adding: mem time41, current time 185, horizon 144\n", + "adding: mem time42, current time 185, horizon 143\n", + "adding: mem time43, current time 185, horizon 142\n", + "adding: mem time44, current time 185, horizon 141\n", + "adding: mem time45, current time 185, horizon 140\n", + "adding: mem time46, current time 185, horizon 139\n", + "adding: mem time47, current time 185, horizon 138\n", + "adding: mem time48, current time 185, horizon 137\n", + "adding: mem time49, current time 185, horizon 136\n", + "adding: mem time50, current time 185, horizon 135\n", + "adding: mem time51, current time 185, horizon 134\n", + "adding: mem time52, current time 185, horizon 133\n", + "adding: mem time53, current time 185, horizon 132\n", + "adding: mem time54, current time 185, horizon 131\n", + "adding: mem time55, current time 185, horizon 130\n", + "adding: mem time56, current time 185, horizon 129\n", + "adding: mem time57, current time 185, horizon 128\n", + "adding: mem time58, current time 185, horizon 127\n", + "adding: mem time59, current time 185, horizon 126\n", + "adding: mem time60, current time 185, horizon 125\n", + "adding: mem time61, current time 185, horizon 124\n", + "adding: mem time62, current time 185, horizon 123\n", + "adding: mem time63, current time 185, horizon 122\n", + "adding: mem time64, current time 185, horizon 121\n", + "adding: mem time65, current time 185, horizon 120\n", + "adding: mem time66, current time 185, horizon 119\n", + "adding: mem time67, current time 185, horizon 118\n", + "adding: mem time68, current time 185, horizon 117\n", + "adding: mem time69, current time 185, horizon 116\n", + "adding: mem time70, current time 185, horizon 115\n", + "adding: mem time71, current time 185, horizon 114\n", + "adding: mem time72, current time 185, horizon 113\n", + "adding: mem time73, current time 185, horizon 112\n", + "adding: mem time74, current time 185, horizon 111\n", + "adding: mem time75, current time 185, horizon 110\n", + "adding: mem time76, current time 185, horizon 109\n", + "adding: mem time77, current time 185, horizon 108\n", + "adding: mem time78, current time 185, horizon 107\n", + "adding: mem time79, current time 185, horizon 106\n", + "adding: mem time80, current time 185, horizon 105\n", + "adding: mem time81, current time 185, horizon 104\n", + "adding: mem time82, current time 185, horizon 103\n", + "adding: mem time83, current time 185, horizon 102\n", + "adding: mem time84, current time 185, horizon 101\n", + "adding: mem time85, current time 185, horizon 100\n", + "adding: mem time86, current time 185, horizon 99\n", + "adding: mem time87, current time 185, horizon 98\n", + "adding: mem time88, current time 185, horizon 97\n", + "adding: mem time89, current time 185, horizon 96\n", + "adding: mem time90, current time 185, horizon 95\n", + "adding: mem time91, current time 185, horizon 94\n", + "adding: mem time92, current time 185, horizon 93\n", + "adding: mem time93, current time 185, horizon 92\n", + "adding: mem time94, current time 185, horizon 91\n", + "adding: mem time95, current time 185, horizon 90\n", + "adding: mem time96, current time 185, horizon 89\n", + "adding: mem time97, current time 185, horizon 88\n", + "adding: mem time98, current time 185, horizon 87\n", + "adding: mem time99, current time 185, horizon 86\n", + "adding: mem time100, current time 185, horizon 85\n", + "adding: mem time101, current time 185, horizon 84\n", + "adding: mem time102, current time 185, horizon 83\n", + "adding: mem time103, current time 185, horizon 82\n", + "adding: mem time104, current time 185, horizon 81\n", + "adding: mem time105, current time 185, horizon 80\n", + "adding: mem time106, current time 185, horizon 79\n", + "adding: mem time107, current time 185, horizon 78\n", + "adding: mem time108, current time 185, horizon 77\n", + "adding: mem time109, current time 185, horizon 76\n", + "adding: mem time110, current time 185, horizon 75\n", + "adding: mem time111, current time 185, horizon 74\n", + "adding: mem time112, current time 185, horizon 73\n", + "adding: mem time113, current time 185, horizon 72\n", + "adding: mem time114, current time 185, horizon 71\n", + "adding: mem time115, current time 185, horizon 70\n", + "adding: mem time116, current time 185, horizon 69\n", + "adding: mem time117, current time 185, horizon 68\n", + "adding: mem time118, current time 185, horizon 67\n", + "adding: mem time119, current time 185, horizon 66\n", + "adding: mem time120, current time 185, horizon 65\n", + "adding: mem time121, current time 185, horizon 64\n", + "adding: mem time122, current time 185, horizon 63\n", + "adding: mem time123, current time 185, horizon 62\n", + "adding: mem time124, current time 185, horizon 61\n", + "adding: mem time125, current time 185, horizon 60\n", + "adding: mem time126, current time 185, horizon 59\n", + "adding: mem time127, current time 185, horizon 58\n", + "adding: mem time128, current time 185, horizon 57\n", + "adding: mem time129, current time 185, horizon 56\n", + "adding: mem time130, current time 185, horizon 55\n", + "adding: mem time131, current time 185, horizon 54\n", + "adding: mem time132, current time 185, horizon 53\n", + "adding: mem time133, current time 185, horizon 52\n", + "adding: mem time134, current time 185, horizon 51\n", + "adding: mem time135, current time 185, horizon 50\n", + "adding: mem time136, current time 185, horizon 49\n", + "adding: mem time137, current time 185, horizon 48\n", + "adding: mem time138, current time 185, horizon 47\n", + "adding: mem time139, current time 185, horizon 46\n", + "adding: mem time140, current time 185, horizon 45\n", + "adding: mem time141, current time 185, horizon 44\n", + "adding: mem time142, current time 185, horizon 43\n", + "adding: mem time143, current time 185, horizon 42\n", + "adding: mem time144, current time 185, horizon 41\n", + "adding: mem time145, current time 185, horizon 40\n", + "adding: mem time146, current time 185, horizon 39\n", + "adding: mem time147, current time 185, horizon 38\n", + "adding: mem time148, current time 185, horizon 37\n", + "adding: mem time149, current time 185, horizon 36\n", + "adding: mem time150, current time 185, horizon 35\n", + "adding: mem time151, current time 185, horizon 34\n", + "adding: mem time152, current time 185, horizon 33\n", + "adding: mem time153, current time 185, horizon 32\n", + "adding: mem time154, current time 185, horizon 31\n", + "adding: mem time155, current time 185, horizon 30\n", + "adding: mem time156, current time 185, horizon 29\n", + "adding: mem time157, current time 185, horizon 28\n", + "adding: mem time158, current time 185, horizon 27\n", + "adding: mem time159, current time 185, horizon 26\n", + "adding: mem time160, current time 185, horizon 25\n", + "adding: mem time161, current time 185, horizon 24\n", + "adding: mem time162, current time 185, horizon 23\n", + "adding: mem time163, current time 185, horizon 22\n", + "adding: mem time164, current time 185, horizon 21\n", + "adding: mem time165, current time 185, horizon 20\n", + "adding: mem time166, current time 185, horizon 19\n", + "adding: mem time167, current time 185, horizon 18\n", + "adding: mem time168, current time 185, horizon 17\n", + "adding: mem time169, current time 185, horizon 16\n", + "adding: mem time170, current time 185, horizon 15\n", + "adding: mem time171, current time 185, horizon 14\n", + "adding: mem time172, current time 185, horizon 13\n", + "adding: mem time173, current time 185, horizon 12\n", + "adding: mem time174, current time 185, horizon 11\n", + "adding: mem time175, current time 185, horizon 10\n", + "adding: mem time176, current time 185, horizon 9\n", + "adding: mem time177, current time 185, horizon 8\n", + "adding: mem time178, current time 185, horizon 7\n", + "adding: mem time179, current time 185, horizon 6\n", + "adding: mem time180, current time 185, horizon 5\n", + "adding: mem time181, current time 185, horizon 4\n", + "adding: mem time182, current time 185, horizon 3\n", + "adding: mem time183, current time 185, horizon 2\n", + "adding: mem time184, current time 185, horizon 1\n", + "adding: mem time0, current time 186, horizon 186\n", + "adding: mem time1, current time 186, horizon 185\n", + "adding: mem time2, current time 186, horizon 184\n", + "adding: mem time3, current time 186, horizon 183\n", + "adding: mem time4, current time 186, horizon 182\n", + "adding: mem time5, current time 186, horizon 181\n", + "adding: mem time6, current time 186, horizon 180\n", + "adding: mem time7, current time 186, horizon 179\n", + "adding: mem time8, current time 186, horizon 178\n", + "adding: mem time9, current time 186, horizon 177\n", + "adding: mem time10, current time 186, horizon 176\n", + "adding: mem time11, current time 186, horizon 175\n", + "adding: mem time12, current time 186, horizon 174\n", + "adding: mem time13, current time 186, horizon 173\n", + "adding: mem time14, current time 186, horizon 172\n", + "adding: mem time15, current time 186, horizon 171\n", + "adding: mem time16, current time 186, horizon 170\n", + "adding: mem time17, current time 186, horizon 169\n", + "adding: mem time18, current time 186, horizon 168\n", + "adding: mem time19, current time 186, horizon 167\n", + "adding: mem time20, current time 186, horizon 166\n", + "adding: mem time21, current time 186, horizon 165\n", + "adding: mem time22, current time 186, horizon 164\n", + "adding: mem time23, current time 186, horizon 163\n", + "adding: mem time24, current time 186, horizon 162\n", + "adding: mem time25, current time 186, horizon 161\n", + "adding: mem time26, current time 186, horizon 160\n", + "adding: mem time27, current time 186, horizon 159\n", + "adding: mem time28, current time 186, horizon 158\n", + "adding: mem time29, current time 186, horizon 157\n", + "adding: mem time30, current time 186, horizon 156\n", + "adding: mem time31, current time 186, horizon 155\n", + "adding: mem time32, current time 186, horizon 154\n", + "adding: mem time33, current time 186, horizon 153\n", + "adding: mem time34, current time 186, horizon 152\n", + "adding: mem time35, current time 186, horizon 151\n", + "adding: mem time36, current time 186, horizon 150\n", + "adding: mem time37, current time 186, horizon 149\n", + "adding: mem time38, current time 186, horizon 148\n", + "adding: mem time39, current time 186, horizon 147\n", + "adding: mem time40, current time 186, horizon 146\n", + "adding: mem time41, current time 186, horizon 145\n", + "adding: mem time42, current time 186, horizon 144\n", + "adding: mem time43, current time 186, horizon 143\n", + "adding: mem time44, current time 186, horizon 142\n", + "adding: mem time45, current time 186, horizon 141\n", + "adding: mem time46, current time 186, horizon 140\n", + "adding: mem time47, current time 186, horizon 139\n", + "adding: mem time48, current time 186, horizon 138\n", + "adding: mem time49, current time 186, horizon 137\n", + "adding: mem time50, current time 186, horizon 136\n", + "adding: mem time51, current time 186, horizon 135\n", + "adding: mem time52, current time 186, horizon 134\n", + "adding: mem time53, current time 186, horizon 133\n", + "adding: mem time54, current time 186, horizon 132\n", + "adding: mem time55, current time 186, horizon 131\n", + "adding: mem time56, current time 186, horizon 130\n", + "adding: mem time57, current time 186, horizon 129\n", + "adding: mem time58, current time 186, horizon 128\n", + "adding: mem time59, current time 186, horizon 127\n", + "adding: mem time60, current time 186, horizon 126\n", + "adding: mem time61, current time 186, horizon 125\n", + "adding: mem time62, current time 186, horizon 124\n", + "adding: mem time63, current time 186, horizon 123\n", + "adding: mem time64, current time 186, horizon 122\n", + "adding: mem time65, current time 186, horizon 121\n", + "adding: mem time66, current time 186, horizon 120\n", + "adding: mem time67, current time 186, horizon 119\n", + "adding: mem time68, current time 186, horizon 118\n", + "adding: mem time69, current time 186, horizon 117\n", + "adding: mem time70, current time 186, horizon 116\n", + "adding: mem time71, current time 186, horizon 115\n", + "adding: mem time72, current time 186, horizon 114\n", + "adding: mem time73, current time 186, horizon 113\n", + "adding: mem time74, current time 186, horizon 112\n", + "adding: mem time75, current time 186, horizon 111\n", + "adding: mem time76, current time 186, horizon 110\n", + "adding: mem time77, current time 186, horizon 109\n", + "adding: mem time78, current time 186, horizon 108\n", + "adding: mem time79, current time 186, horizon 107\n", + "adding: mem time80, current time 186, horizon 106\n", + "adding: mem time81, current time 186, horizon 105\n", + "adding: mem time82, current time 186, horizon 104\n", + "adding: mem time83, current time 186, horizon 103\n", + "adding: mem time84, current time 186, horizon 102\n", + "adding: mem time85, current time 186, horizon 101\n", + "adding: mem time86, current time 186, horizon 100\n", + "adding: mem time87, current time 186, horizon 99\n", + "adding: mem time88, current time 186, horizon 98\n", + "adding: mem time89, current time 186, horizon 97\n", + "adding: mem time90, current time 186, horizon 96\n", + "adding: mem time91, current time 186, horizon 95\n", + "adding: mem time92, current time 186, horizon 94\n", + "adding: mem time93, current time 186, horizon 93\n", + "adding: mem time94, current time 186, horizon 92\n", + "adding: mem time95, current time 186, horizon 91\n", + "adding: mem time96, current time 186, horizon 90\n", + "adding: mem time97, current time 186, horizon 89\n", + "adding: mem time98, current time 186, horizon 88\n", + "adding: mem time99, current time 186, horizon 87\n", + "adding: mem time100, current time 186, horizon 86\n", + "adding: mem time101, current time 186, horizon 85\n", + "adding: mem time102, current time 186, horizon 84\n", + "adding: mem time103, current time 186, horizon 83\n", + "adding: mem time104, current time 186, horizon 82\n", + "adding: mem time105, current time 186, horizon 81\n", + "adding: mem time106, current time 186, horizon 80\n", + "adding: mem time107, current time 186, horizon 79\n", + "adding: mem time108, current time 186, horizon 78\n", + "adding: mem time109, current time 186, horizon 77\n", + "adding: mem time110, current time 186, horizon 76\n", + "adding: mem time111, current time 186, horizon 75\n", + "adding: mem time112, current time 186, horizon 74\n", + "adding: mem time113, current time 186, horizon 73\n", + "adding: mem time114, current time 186, horizon 72\n", + "adding: mem time115, current time 186, horizon 71\n", + "adding: mem time116, current time 186, horizon 70\n", + "adding: mem time117, current time 186, horizon 69\n", + "adding: mem time118, current time 186, horizon 68\n", + "adding: mem time119, current time 186, horizon 67\n", + "adding: mem time120, current time 186, horizon 66\n", + "adding: mem time121, current time 186, horizon 65\n", + "adding: mem time122, current time 186, horizon 64\n", + "adding: mem time123, current time 186, horizon 63\n", + "adding: mem time124, current time 186, horizon 62\n", + "adding: mem time125, current time 186, horizon 61\n", + "adding: mem time126, current time 186, horizon 60\n", + "adding: mem time127, current time 186, horizon 59\n", + "adding: mem time128, current time 186, horizon 58\n", + "adding: mem time129, current time 186, horizon 57\n", + "adding: mem time130, current time 186, horizon 56\n", + "adding: mem time131, current time 186, horizon 55\n", + "adding: mem time132, current time 186, horizon 54\n", + "adding: mem time133, current time 186, horizon 53\n", + "adding: mem time134, current time 186, horizon 52\n", + "adding: mem time135, current time 186, horizon 51\n", + "adding: mem time136, current time 186, horizon 50\n", + "adding: mem time137, current time 186, horizon 49\n", + "adding: mem time138, current time 186, horizon 48\n", + "adding: mem time139, current time 186, horizon 47\n", + "adding: mem time140, current time 186, horizon 46\n", + "adding: mem time141, current time 186, horizon 45\n", + "adding: mem time142, current time 186, horizon 44\n", + "adding: mem time143, current time 186, horizon 43\n", + "adding: mem time144, current time 186, horizon 42\n", + "adding: mem time145, current time 186, horizon 41\n", + "adding: mem time146, current time 186, horizon 40\n", + "adding: mem time147, current time 186, horizon 39\n", + "adding: mem time148, current time 186, horizon 38\n", + "adding: mem time149, current time 186, horizon 37\n", + "adding: mem time150, current time 186, horizon 36\n", + "adding: mem time151, current time 186, horizon 35\n", + "adding: mem time152, current time 186, horizon 34\n", + "adding: mem time153, current time 186, horizon 33\n", + "adding: mem time154, current time 186, horizon 32\n", + "adding: mem time155, current time 186, horizon 31\n", + "adding: mem time156, current time 186, horizon 30\n", + "adding: mem time157, current time 186, horizon 29\n", + "adding: mem time158, current time 186, horizon 28\n", + "adding: mem time159, current time 186, horizon 27\n", + "adding: mem time160, current time 186, horizon 26\n", + "adding: mem time161, current time 186, horizon 25\n", + "adding: mem time162, current time 186, horizon 24\n", + "adding: mem time163, current time 186, horizon 23\n", + "adding: mem time164, current time 186, horizon 22\n", + "adding: mem time165, current time 186, horizon 21\n", + "adding: mem time166, current time 186, horizon 20\n", + "adding: mem time167, current time 186, horizon 19\n", + "adding: mem time168, current time 186, horizon 18\n", + "adding: mem time169, current time 186, horizon 17\n", + "adding: mem time170, current time 186, horizon 16\n", + "adding: mem time171, current time 186, horizon 15\n", + "adding: mem time172, current time 186, horizon 14\n", + "adding: mem time173, current time 186, horizon 13\n", + "adding: mem time174, current time 186, horizon 12\n", + "adding: mem time175, current time 186, horizon 11\n", + "adding: mem time176, current time 186, horizon 10\n", + "adding: mem time177, current time 186, horizon 9\n", + "adding: mem time178, current time 186, horizon 8\n", + "adding: mem time179, current time 186, horizon 7\n", + "adding: mem time180, current time 186, horizon 6\n", + "adding: mem time181, current time 186, horizon 5\n", + "adding: mem time182, current time 186, horizon 4\n", + "adding: mem time183, current time 186, horizon 3\n", + "adding: mem time184, current time 186, horizon 2\n", + "adding: mem time185, current time 186, horizon 1\n", + "adding: mem time0, current time 187, horizon 187\n", + "adding: mem time1, current time 187, horizon 186\n", + "adding: mem time2, current time 187, horizon 185\n", + "adding: mem time3, current time 187, horizon 184\n", + "adding: mem time4, current time 187, horizon 183\n", + "adding: mem time5, current time 187, horizon 182\n", + "adding: mem time6, current time 187, horizon 181\n", + "adding: mem time7, current time 187, horizon 180\n", + "adding: mem time8, current time 187, horizon 179\n", + "adding: mem time9, current time 187, horizon 178\n", + "adding: mem time10, current time 187, horizon 177\n", + "adding: mem time11, current time 187, horizon 176\n", + "adding: mem time12, current time 187, horizon 175\n", + "adding: mem time13, current time 187, horizon 174\n", + "adding: mem time14, current time 187, horizon 173\n", + "adding: mem time15, current time 187, horizon 172\n", + "adding: mem time16, current time 187, horizon 171\n", + "adding: mem time17, current time 187, horizon 170\n", + "adding: mem time18, current time 187, horizon 169\n", + "adding: mem time19, current time 187, horizon 168\n", + "adding: mem time20, current time 187, horizon 167\n", + "adding: mem time21, current time 187, horizon 166\n", + "adding: mem time22, current time 187, horizon 165\n", + "adding: mem time23, current time 187, horizon 164\n", + "adding: mem time24, current time 187, horizon 163\n", + "adding: mem time25, current time 187, horizon 162\n", + "adding: mem time26, current time 187, horizon 161\n", + "adding: mem time27, current time 187, horizon 160\n", + "adding: mem time28, current time 187, horizon 159\n", + "adding: mem time29, current time 187, horizon 158\n", + "adding: mem time30, current time 187, horizon 157\n", + "adding: mem time31, current time 187, horizon 156\n", + "adding: mem time32, current time 187, horizon 155\n", + "adding: mem time33, current time 187, horizon 154\n", + "adding: mem time34, current time 187, horizon 153\n", + "adding: mem time35, current time 187, horizon 152\n", + "adding: mem time36, current time 187, horizon 151\n", + "adding: mem time37, current time 187, horizon 150\n", + "adding: mem time38, current time 187, horizon 149\n", + "adding: mem time39, current time 187, horizon 148\n", + "adding: mem time40, current time 187, horizon 147\n", + "adding: mem time41, current time 187, horizon 146\n", + "adding: mem time42, current time 187, horizon 145\n", + "adding: mem time43, current time 187, horizon 144\n", + "adding: mem time44, current time 187, horizon 143\n", + "adding: mem time45, current time 187, horizon 142\n", + "adding: mem time46, current time 187, horizon 141\n", + "adding: mem time47, current time 187, horizon 140\n", + "adding: mem time48, current time 187, horizon 139\n", + "adding: mem time49, current time 187, horizon 138\n", + "adding: mem time50, current time 187, horizon 137\n", + "adding: mem time51, current time 187, horizon 136\n", + "adding: mem time52, current time 187, horizon 135\n", + "adding: mem time53, current time 187, horizon 134\n", + "adding: mem time54, current time 187, horizon 133\n", + "adding: mem time55, current time 187, horizon 132\n", + "adding: mem time56, current time 187, horizon 131\n", + "adding: mem time57, current time 187, horizon 130\n", + "adding: mem time58, current time 187, horizon 129\n", + "adding: mem time59, current time 187, horizon 128\n", + "adding: mem time60, current time 187, horizon 127\n", + "adding: mem time61, current time 187, horizon 126\n", + "adding: mem time62, current time 187, horizon 125\n", + "adding: mem time63, current time 187, horizon 124\n", + "adding: mem time64, current time 187, horizon 123\n", + "adding: mem time65, current time 187, horizon 122\n", + "adding: mem time66, current time 187, horizon 121\n", + "adding: mem time67, current time 187, horizon 120\n", + "adding: mem time68, current time 187, horizon 119\n", + "adding: mem time69, current time 187, horizon 118\n", + "adding: mem time70, current time 187, horizon 117\n", + "adding: mem time71, current time 187, horizon 116\n", + "adding: mem time72, current time 187, horizon 115\n", + "adding: mem time73, current time 187, horizon 114\n", + "adding: mem time74, current time 187, horizon 113\n", + "adding: mem time75, current time 187, horizon 112\n", + "adding: mem time76, current time 187, horizon 111\n", + "adding: mem time77, current time 187, horizon 110\n", + "adding: mem time78, current time 187, horizon 109\n", + "adding: mem time79, current time 187, horizon 108\n", + "adding: mem time80, current time 187, horizon 107\n", + "adding: mem time81, current time 187, horizon 106\n", + "adding: mem time82, current time 187, horizon 105\n", + "adding: mem time83, current time 187, horizon 104\n", + "adding: mem time84, current time 187, horizon 103\n", + "adding: mem time85, current time 187, horizon 102\n", + "adding: mem time86, current time 187, horizon 101\n", + "adding: mem time87, current time 187, horizon 100\n", + "adding: mem time88, current time 187, horizon 99\n", + "adding: mem time89, current time 187, horizon 98\n", + "adding: mem time90, current time 187, horizon 97\n", + "adding: mem time91, current time 187, horizon 96\n", + "adding: mem time92, current time 187, horizon 95\n", + "adding: mem time93, current time 187, horizon 94\n", + "adding: mem time94, current time 187, horizon 93\n", + "adding: mem time95, current time 187, horizon 92\n", + "adding: mem time96, current time 187, horizon 91\n", + "adding: mem time97, current time 187, horizon 90\n", + "adding: mem time98, current time 187, horizon 89\n", + "adding: mem time99, current time 187, horizon 88\n", + "adding: mem time100, current time 187, horizon 87\n", + "adding: mem time101, current time 187, horizon 86\n", + "adding: mem time102, current time 187, horizon 85\n", + "adding: mem time103, current time 187, horizon 84\n", + "adding: mem time104, current time 187, horizon 83\n", + "adding: mem time105, current time 187, horizon 82\n", + "adding: mem time106, current time 187, horizon 81\n", + "adding: mem time107, current time 187, horizon 80\n", + "adding: mem time108, current time 187, horizon 79\n", + "adding: mem time109, current time 187, horizon 78\n", + "adding: mem time110, current time 187, horizon 77\n", + "adding: mem time111, current time 187, horizon 76\n", + "adding: mem time112, current time 187, horizon 75\n", + "adding: mem time113, current time 187, horizon 74\n", + "adding: mem time114, current time 187, horizon 73\n", + "adding: mem time115, current time 187, horizon 72\n", + "adding: mem time116, current time 187, horizon 71\n", + "adding: mem time117, current time 187, horizon 70\n", + "adding: mem time118, current time 187, horizon 69\n", + "adding: mem time119, current time 187, horizon 68\n", + "adding: mem time120, current time 187, horizon 67\n", + "adding: mem time121, current time 187, horizon 66\n", + "adding: mem time122, current time 187, horizon 65\n", + "adding: mem time123, current time 187, horizon 64\n", + "adding: mem time124, current time 187, horizon 63\n", + "adding: mem time125, current time 187, horizon 62\n", + "adding: mem time126, current time 187, horizon 61\n", + "adding: mem time127, current time 187, horizon 60\n", + "adding: mem time128, current time 187, horizon 59\n", + "adding: mem time129, current time 187, horizon 58\n", + "adding: mem time130, current time 187, horizon 57\n", + "adding: mem time131, current time 187, horizon 56\n", + "adding: mem time132, current time 187, horizon 55\n", + "adding: mem time133, current time 187, horizon 54\n", + "adding: mem time134, current time 187, horizon 53\n", + "adding: mem time135, current time 187, horizon 52\n", + "adding: mem time136, current time 187, horizon 51\n", + "adding: mem time137, current time 187, horizon 50\n", + "adding: mem time138, current time 187, horizon 49\n", + "adding: mem time139, current time 187, horizon 48\n", + "adding: mem time140, current time 187, horizon 47\n", + "adding: mem time141, current time 187, horizon 46\n", + "adding: mem time142, current time 187, horizon 45\n", + "adding: mem time143, current time 187, horizon 44\n", + "adding: mem time144, current time 187, horizon 43\n", + "adding: mem time145, current time 187, horizon 42\n", + "adding: mem time146, current time 187, horizon 41\n", + "adding: mem time147, current time 187, horizon 40\n", + "adding: mem time148, current time 187, horizon 39\n", + "adding: mem time149, current time 187, horizon 38\n", + "adding: mem time150, current time 187, horizon 37\n", + "adding: mem time151, current time 187, horizon 36\n", + "adding: mem time152, current time 187, horizon 35\n", + "adding: mem time153, current time 187, horizon 34\n", + "adding: mem time154, current time 187, horizon 33\n", + "adding: mem time155, current time 187, horizon 32\n", + "adding: mem time156, current time 187, horizon 31\n", + "adding: mem time157, current time 187, horizon 30\n", + "adding: mem time158, current time 187, horizon 29\n", + "adding: mem time159, current time 187, horizon 28\n", + "adding: mem time160, current time 187, horizon 27\n", + "adding: mem time161, current time 187, horizon 26\n", + "adding: mem time162, current time 187, horizon 25\n", + "adding: mem time163, current time 187, horizon 24\n", + "adding: mem time164, current time 187, horizon 23\n", + "adding: mem time165, current time 187, horizon 22\n", + "adding: mem time166, current time 187, horizon 21\n", + "adding: mem time167, current time 187, horizon 20\n", + "adding: mem time168, current time 187, horizon 19\n", + "adding: mem time169, current time 187, horizon 18\n", + "adding: mem time170, current time 187, horizon 17\n", + "adding: mem time171, current time 187, horizon 16\n", + "adding: mem time172, current time 187, horizon 15\n", + "adding: mem time173, current time 187, horizon 14\n", + "adding: mem time174, current time 187, horizon 13\n", + "adding: mem time175, current time 187, horizon 12\n", + "adding: mem time176, current time 187, horizon 11\n", + "adding: mem time177, current time 187, horizon 10\n", + "adding: mem time178, current time 187, horizon 9\n", + "adding: mem time179, current time 187, horizon 8\n", + "adding: mem time180, current time 187, horizon 7\n", + "adding: mem time181, current time 187, horizon 6\n", + "adding: mem time182, current time 187, horizon 5\n", + "adding: mem time183, current time 187, horizon 4\n", + "adding: mem time184, current time 187, horizon 3\n", + "adding: mem time185, current time 187, horizon 2\n", + "adding: mem time186, current time 187, horizon 1\n", + "adding: mem time0, current time 188, horizon 188\n", + "adding: mem time1, current time 188, horizon 187\n", + "adding: mem time2, current time 188, horizon 186\n", + "adding: mem time3, current time 188, horizon 185\n", + "adding: mem time4, current time 188, horizon 184\n", + "adding: mem time5, current time 188, horizon 183\n", + "adding: mem time6, current time 188, horizon 182\n", + "adding: mem time7, current time 188, horizon 181\n", + "adding: mem time8, current time 188, horizon 180\n", + "adding: mem time9, current time 188, horizon 179\n", + "adding: mem time10, current time 188, horizon 178\n", + "adding: mem time11, current time 188, horizon 177\n", + "adding: mem time12, current time 188, horizon 176\n", + "adding: mem time13, current time 188, horizon 175\n", + "adding: mem time14, current time 188, horizon 174\n", + "adding: mem time15, current time 188, horizon 173\n", + "adding: mem time16, current time 188, horizon 172\n", + "adding: mem time17, current time 188, horizon 171\n", + "adding: mem time18, current time 188, horizon 170\n", + "adding: mem time19, current time 188, horizon 169\n", + "adding: mem time20, current time 188, horizon 168\n", + "adding: mem time21, current time 188, horizon 167\n", + "adding: mem time22, current time 188, horizon 166\n", + "adding: mem time23, current time 188, horizon 165\n", + "adding: mem time24, current time 188, horizon 164\n", + "adding: mem time25, current time 188, horizon 163\n", + "adding: mem time26, current time 188, horizon 162\n", + "adding: mem time27, current time 188, horizon 161\n", + "adding: mem time28, current time 188, horizon 160\n", + "adding: mem time29, current time 188, horizon 159\n", + "adding: mem time30, current time 188, horizon 158\n", + "adding: mem time31, current time 188, horizon 157\n", + "adding: mem time32, current time 188, horizon 156\n", + "adding: mem time33, current time 188, horizon 155\n", + "adding: mem time34, current time 188, horizon 154\n", + "adding: mem time35, current time 188, horizon 153\n", + "adding: mem time36, current time 188, horizon 152\n", + "adding: mem time37, current time 188, horizon 151\n", + "adding: mem time38, current time 188, horizon 150\n", + "adding: mem time39, current time 188, horizon 149\n", + "adding: mem time40, current time 188, horizon 148\n", + "adding: mem time41, current time 188, horizon 147\n", + "adding: mem time42, current time 188, horizon 146\n", + "adding: mem time43, current time 188, horizon 145\n", + "adding: mem time44, current time 188, horizon 144\n", + "adding: mem time45, current time 188, horizon 143\n", + "adding: mem time46, current time 188, horizon 142\n", + "adding: mem time47, current time 188, horizon 141\n", + "adding: mem time48, current time 188, horizon 140\n", + "adding: mem time49, current time 188, horizon 139\n", + "adding: mem time50, current time 188, horizon 138\n", + "adding: mem time51, current time 188, horizon 137\n", + "adding: mem time52, current time 188, horizon 136\n", + "adding: mem time53, current time 188, horizon 135\n", + "adding: mem time54, current time 188, horizon 134\n", + "adding: mem time55, current time 188, horizon 133\n", + "adding: mem time56, current time 188, horizon 132\n", + "adding: mem time57, current time 188, horizon 131\n", + "adding: mem time58, current time 188, horizon 130\n", + "adding: mem time59, current time 188, horizon 129\n", + "adding: mem time60, current time 188, horizon 128\n", + "adding: mem time61, current time 188, horizon 127\n", + "adding: mem time62, current time 188, horizon 126\n", + "adding: mem time63, current time 188, horizon 125\n", + "adding: mem time64, current time 188, horizon 124\n", + "adding: mem time65, current time 188, horizon 123\n", + "adding: mem time66, current time 188, horizon 122\n", + "adding: mem time67, current time 188, horizon 121\n", + "adding: mem time68, current time 188, horizon 120\n", + "adding: mem time69, current time 188, horizon 119\n", + "adding: mem time70, current time 188, horizon 118\n", + "adding: mem time71, current time 188, horizon 117\n", + "adding: mem time72, current time 188, horizon 116\n", + "adding: mem time73, current time 188, horizon 115\n", + "adding: mem time74, current time 188, horizon 114\n", + "adding: mem time75, current time 188, horizon 113\n", + "adding: mem time76, current time 188, horizon 112\n", + "adding: mem time77, current time 188, horizon 111\n", + "adding: mem time78, current time 188, horizon 110\n", + "adding: mem time79, current time 188, horizon 109\n", + "adding: mem time80, current time 188, horizon 108\n", + "adding: mem time81, current time 188, horizon 107\n", + "adding: mem time82, current time 188, horizon 106\n", + "adding: mem time83, current time 188, horizon 105\n", + "adding: mem time84, current time 188, horizon 104\n", + "adding: mem time85, current time 188, horizon 103\n", + "adding: mem time86, current time 188, horizon 102\n", + "adding: mem time87, current time 188, horizon 101\n", + "adding: mem time88, current time 188, horizon 100\n", + "adding: mem time89, current time 188, horizon 99\n", + "adding: mem time90, current time 188, horizon 98\n", + "adding: mem time91, current time 188, horizon 97\n", + "adding: mem time92, current time 188, horizon 96\n", + "adding: mem time93, current time 188, horizon 95\n", + "adding: mem time94, current time 188, horizon 94\n", + "adding: mem time95, current time 188, horizon 93\n", + "adding: mem time96, current time 188, horizon 92\n", + "adding: mem time97, current time 188, horizon 91\n", + "adding: mem time98, current time 188, horizon 90\n", + "adding: mem time99, current time 188, horizon 89\n", + "adding: mem time100, current time 188, horizon 88\n", + "adding: mem time101, current time 188, horizon 87\n", + "adding: mem time102, current time 188, horizon 86\n", + "adding: mem time103, current time 188, horizon 85\n", + "adding: mem time104, current time 188, horizon 84\n", + "adding: mem time105, current time 188, horizon 83\n", + "adding: mem time106, current time 188, horizon 82\n", + "adding: mem time107, current time 188, horizon 81\n", + "adding: mem time108, current time 188, horizon 80\n", + "adding: mem time109, current time 188, horizon 79\n", + "adding: mem time110, current time 188, horizon 78\n", + "adding: mem time111, current time 188, horizon 77\n", + "adding: mem time112, current time 188, horizon 76\n", + "adding: mem time113, current time 188, horizon 75\n", + "adding: mem time114, current time 188, horizon 74\n", + "adding: mem time115, current time 188, horizon 73\n", + "adding: mem time116, current time 188, horizon 72\n", + "adding: mem time117, current time 188, horizon 71\n", + "adding: mem time118, current time 188, horizon 70\n", + "adding: mem time119, current time 188, horizon 69\n", + "adding: mem time120, current time 188, horizon 68\n", + "adding: mem time121, current time 188, horizon 67\n", + "adding: mem time122, current time 188, horizon 66\n", + "adding: mem time123, current time 188, horizon 65\n", + "adding: mem time124, current time 188, horizon 64\n", + "adding: mem time125, current time 188, horizon 63\n", + "adding: mem time126, current time 188, horizon 62\n", + "adding: mem time127, current time 188, horizon 61\n", + "adding: mem time128, current time 188, horizon 60\n", + "adding: mem time129, current time 188, horizon 59\n", + "adding: mem time130, current time 188, horizon 58\n", + "adding: mem time131, current time 188, horizon 57\n", + "adding: mem time132, current time 188, horizon 56\n", + "adding: mem time133, current time 188, horizon 55\n", + "adding: mem time134, current time 188, horizon 54\n", + "adding: mem time135, current time 188, horizon 53\n", + "adding: mem time136, current time 188, horizon 52\n", + "adding: mem time137, current time 188, horizon 51\n", + "adding: mem time138, current time 188, horizon 50\n", + "adding: mem time139, current time 188, horizon 49\n", + "adding: mem time140, current time 188, horizon 48\n", + "adding: mem time141, current time 188, horizon 47\n", + "adding: mem time142, current time 188, horizon 46\n", + "adding: mem time143, current time 188, horizon 45\n", + "adding: mem time144, current time 188, horizon 44\n", + "adding: mem time145, current time 188, horizon 43\n", + "adding: mem time146, current time 188, horizon 42\n", + "adding: mem time147, current time 188, horizon 41\n", + "adding: mem time148, current time 188, horizon 40\n", + "adding: mem time149, current time 188, horizon 39\n", + "adding: mem time150, current time 188, horizon 38\n", + "adding: mem time151, current time 188, horizon 37\n", + "adding: mem time152, current time 188, horizon 36\n", + "adding: mem time153, current time 188, horizon 35\n", + "adding: mem time154, current time 188, horizon 34\n", + "adding: mem time155, current time 188, horizon 33\n", + "adding: mem time156, current time 188, horizon 32\n", + "adding: mem time157, current time 188, horizon 31\n", + "adding: mem time158, current time 188, horizon 30\n", + "adding: mem time159, current time 188, horizon 29\n", + "adding: mem time160, current time 188, horizon 28\n", + "adding: mem time161, current time 188, horizon 27\n", + "adding: mem time162, current time 188, horizon 26\n", + "adding: mem time163, current time 188, horizon 25\n", + "adding: mem time164, current time 188, horizon 24\n", + "adding: mem time165, current time 188, horizon 23\n", + "adding: mem time166, current time 188, horizon 22\n", + "adding: mem time167, current time 188, horizon 21\n", + "adding: mem time168, current time 188, horizon 20\n", + "adding: mem time169, current time 188, horizon 19\n", + "adding: mem time170, current time 188, horizon 18\n", + "adding: mem time171, current time 188, horizon 17\n", + "adding: mem time172, current time 188, horizon 16\n", + "adding: mem time173, current time 188, horizon 15\n", + "adding: mem time174, current time 188, horizon 14\n", + "adding: mem time175, current time 188, horizon 13\n", + "adding: mem time176, current time 188, horizon 12\n", + "adding: mem time177, current time 188, horizon 11\n", + "adding: mem time178, current time 188, horizon 10\n", + "adding: mem time179, current time 188, horizon 9\n", + "adding: mem time180, current time 188, horizon 8\n", + "adding: mem time181, current time 188, horizon 7\n", + "adding: mem time182, current time 188, horizon 6\n", + "adding: mem time183, current time 188, horizon 5\n", + "adding: mem time184, current time 188, horizon 4\n", + "adding: mem time185, current time 188, horizon 3\n", + "adding: mem time186, current time 188, horizon 2\n", + "adding: mem time187, current time 188, horizon 1\n", + "adding: mem time0, current time 189, horizon 189\n", + "adding: mem time1, current time 189, horizon 188\n", + "adding: mem time2, current time 189, horizon 187\n", + "adding: mem time3, current time 189, horizon 186\n", + "adding: mem time4, current time 189, horizon 185\n", + "adding: mem time5, current time 189, horizon 184\n", + "adding: mem time6, current time 189, horizon 183\n", + "adding: mem time7, current time 189, horizon 182\n", + "adding: mem time8, current time 189, horizon 181\n", + "adding: mem time9, current time 189, horizon 180\n", + "adding: mem time10, current time 189, horizon 179\n", + "adding: mem time11, current time 189, horizon 178\n", + "adding: mem time12, current time 189, horizon 177\n", + "adding: mem time13, current time 189, horizon 176\n", + "adding: mem time14, current time 189, horizon 175\n", + "adding: mem time15, current time 189, horizon 174\n", + "adding: mem time16, current time 189, horizon 173\n", + "adding: mem time17, current time 189, horizon 172\n", + "adding: mem time18, current time 189, horizon 171\n", + "adding: mem time19, current time 189, horizon 170\n", + "adding: mem time20, current time 189, horizon 169\n", + "adding: mem time21, current time 189, horizon 168\n", + "adding: mem time22, current time 189, horizon 167\n", + "adding: mem time23, current time 189, horizon 166\n", + "adding: mem time24, current time 189, horizon 165\n", + "adding: mem time25, current time 189, horizon 164\n", + "adding: mem time26, current time 189, horizon 163\n", + "adding: mem time27, current time 189, horizon 162\n", + "adding: mem time28, current time 189, horizon 161\n", + "adding: mem time29, current time 189, horizon 160\n", + "adding: mem time30, current time 189, horizon 159\n", + "adding: mem time31, current time 189, horizon 158\n", + "adding: mem time32, current time 189, horizon 157\n", + "adding: mem time33, current time 189, horizon 156\n", + "adding: mem time34, current time 189, horizon 155\n", + "adding: mem time35, current time 189, horizon 154\n", + "adding: mem time36, current time 189, horizon 153\n", + "adding: mem time37, current time 189, horizon 152\n", + "adding: mem time38, current time 189, horizon 151\n", + "adding: mem time39, current time 189, horizon 150\n", + "adding: mem time40, current time 189, horizon 149\n", + "adding: mem time41, current time 189, horizon 148\n", + "adding: mem time42, current time 189, horizon 147\n", + "adding: mem time43, current time 189, horizon 146\n", + "adding: mem time44, current time 189, horizon 145\n", + "adding: mem time45, current time 189, horizon 144\n", + "adding: mem time46, current time 189, horizon 143\n", + "adding: mem time47, current time 189, horizon 142\n", + "adding: mem time48, current time 189, horizon 141\n", + "adding: mem time49, current time 189, horizon 140\n", + "adding: mem time50, current time 189, horizon 139\n", + "adding: mem time51, current time 189, horizon 138\n", + "adding: mem time52, current time 189, horizon 137\n", + "adding: mem time53, current time 189, horizon 136\n", + "adding: mem time54, current time 189, horizon 135\n", + "adding: mem time55, current time 189, horizon 134\n", + "adding: mem time56, current time 189, horizon 133\n", + "adding: mem time57, current time 189, horizon 132\n", + "adding: mem time58, current time 189, horizon 131\n", + "adding: mem time59, current time 189, horizon 130\n", + "adding: mem time60, current time 189, horizon 129\n", + "adding: mem time61, current time 189, horizon 128\n", + "adding: mem time62, current time 189, horizon 127\n", + "adding: mem time63, current time 189, horizon 126\n", + "adding: mem time64, current time 189, horizon 125\n", + "adding: mem time65, current time 189, horizon 124\n", + "adding: mem time66, current time 189, horizon 123\n", + "adding: mem time67, current time 189, horizon 122\n", + "adding: mem time68, current time 189, horizon 121\n", + "adding: mem time69, current time 189, horizon 120\n", + "adding: mem time70, current time 189, horizon 119\n", + "adding: mem time71, current time 189, horizon 118\n", + "adding: mem time72, current time 189, horizon 117\n", + "adding: mem time73, current time 189, horizon 116\n", + "adding: mem time74, current time 189, horizon 115\n", + "adding: mem time75, current time 189, horizon 114\n", + "adding: mem time76, current time 189, horizon 113\n", + "adding: mem time77, current time 189, horizon 112\n", + "adding: mem time78, current time 189, horizon 111\n", + "adding: mem time79, current time 189, horizon 110\n", + "adding: mem time80, current time 189, horizon 109\n", + "adding: mem time81, current time 189, horizon 108\n", + "adding: mem time82, current time 189, horizon 107\n", + "adding: mem time83, current time 189, horizon 106\n", + "adding: mem time84, current time 189, horizon 105\n", + "adding: mem time85, current time 189, horizon 104\n", + "adding: mem time86, current time 189, horizon 103\n", + "adding: mem time87, current time 189, horizon 102\n", + "adding: mem time88, current time 189, horizon 101\n", + "adding: mem time89, current time 189, horizon 100\n", + "adding: mem time90, current time 189, horizon 99\n", + "adding: mem time91, current time 189, horizon 98\n", + "adding: mem time92, current time 189, horizon 97\n", + "adding: mem time93, current time 189, horizon 96\n", + "adding: mem time94, current time 189, horizon 95\n", + "adding: mem time95, current time 189, horizon 94\n", + "adding: mem time96, current time 189, horizon 93\n", + "adding: mem time97, current time 189, horizon 92\n", + "adding: mem time98, current time 189, horizon 91\n", + "adding: mem time99, current time 189, horizon 90\n", + "adding: mem time100, current time 189, horizon 89\n", + "adding: mem time101, current time 189, horizon 88\n", + "adding: mem time102, current time 189, horizon 87\n", + "adding: mem time103, current time 189, horizon 86\n", + "adding: mem time104, current time 189, horizon 85\n", + "adding: mem time105, current time 189, horizon 84\n", + "adding: mem time106, current time 189, horizon 83\n", + "adding: mem time107, current time 189, horizon 82\n", + "adding: mem time108, current time 189, horizon 81\n", + "adding: mem time109, current time 189, horizon 80\n", + "adding: mem time110, current time 189, horizon 79\n", + "adding: mem time111, current time 189, horizon 78\n", + "adding: mem time112, current time 189, horizon 77\n", + "adding: mem time113, current time 189, horizon 76\n", + "adding: mem time114, current time 189, horizon 75\n", + "adding: mem time115, current time 189, horizon 74\n", + "adding: mem time116, current time 189, horizon 73\n", + "adding: mem time117, current time 189, horizon 72\n", + "adding: mem time118, current time 189, horizon 71\n", + "adding: mem time119, current time 189, horizon 70\n", + "adding: mem time120, current time 189, horizon 69\n", + "adding: mem time121, current time 189, horizon 68\n", + "adding: mem time122, current time 189, horizon 67\n", + "adding: mem time123, current time 189, horizon 66\n", + "adding: mem time124, current time 189, horizon 65\n", + "adding: mem time125, current time 189, horizon 64\n", + "adding: mem time126, current time 189, horizon 63\n", + "adding: mem time127, current time 189, horizon 62\n", + "adding: mem time128, current time 189, horizon 61\n", + "adding: mem time129, current time 189, horizon 60\n", + "adding: mem time130, current time 189, horizon 59\n", + "adding: mem time131, current time 189, horizon 58\n", + "adding: mem time132, current time 189, horizon 57\n", + "adding: mem time133, current time 189, horizon 56\n", + "adding: mem time134, current time 189, horizon 55\n", + "adding: mem time135, current time 189, horizon 54\n", + "adding: mem time136, current time 189, horizon 53\n", + "adding: mem time137, current time 189, horizon 52\n", + "adding: mem time138, current time 189, horizon 51\n", + "adding: mem time139, current time 189, horizon 50\n", + "adding: mem time140, current time 189, horizon 49\n", + "adding: mem time141, current time 189, horizon 48\n", + "adding: mem time142, current time 189, horizon 47\n", + "adding: mem time143, current time 189, horizon 46\n", + "adding: mem time144, current time 189, horizon 45\n", + "adding: mem time145, current time 189, horizon 44\n", + "adding: mem time146, current time 189, horizon 43\n", + "adding: mem time147, current time 189, horizon 42\n", + "adding: mem time148, current time 189, horizon 41\n", + "adding: mem time149, current time 189, horizon 40\n", + "adding: mem time150, current time 189, horizon 39\n", + "adding: mem time151, current time 189, horizon 38\n", + "adding: mem time152, current time 189, horizon 37\n", + "adding: mem time153, current time 189, horizon 36\n", + "adding: mem time154, current time 189, horizon 35\n", + "adding: mem time155, current time 189, horizon 34\n", + "adding: mem time156, current time 189, horizon 33\n", + "adding: mem time157, current time 189, horizon 32\n", + "adding: mem time158, current time 189, horizon 31\n", + "adding: mem time159, current time 189, horizon 30\n", + "adding: mem time160, current time 189, horizon 29\n", + "adding: mem time161, current time 189, horizon 28\n", + "adding: mem time162, current time 189, horizon 27\n", + "adding: mem time163, current time 189, horizon 26\n", + "adding: mem time164, current time 189, horizon 25\n", + "adding: mem time165, current time 189, horizon 24\n", + "adding: mem time166, current time 189, horizon 23\n", + "adding: mem time167, current time 189, horizon 22\n", + "adding: mem time168, current time 189, horizon 21\n", + "adding: mem time169, current time 189, horizon 20\n", + "adding: mem time170, current time 189, horizon 19\n", + "adding: mem time171, current time 189, horizon 18\n", + "adding: mem time172, current time 189, horizon 17\n", + "adding: mem time173, current time 189, horizon 16\n", + "adding: mem time174, current time 189, horizon 15\n", + "adding: mem time175, current time 189, horizon 14\n", + "adding: mem time176, current time 189, horizon 13\n", + "adding: mem time177, current time 189, horizon 12\n", + "adding: mem time178, current time 189, horizon 11\n", + "adding: mem time179, current time 189, horizon 10\n", + "adding: mem time180, current time 189, horizon 9\n", + "adding: mem time181, current time 189, horizon 8\n", + "adding: mem time182, current time 189, horizon 7\n", + "adding: mem time183, current time 189, horizon 6\n", + "adding: mem time184, current time 189, horizon 5\n", + "adding: mem time185, current time 189, horizon 4\n", + "adding: mem time186, current time 189, horizon 3\n", + "adding: mem time187, current time 189, horizon 2\n", + "adding: mem time188, current time 189, horizon 1\n", + "adding: mem time0, current time 190, horizon 190\n", + "adding: mem time1, current time 190, horizon 189\n", + "adding: mem time2, current time 190, horizon 188\n", + "adding: mem time3, current time 190, horizon 187\n", + "adding: mem time4, current time 190, horizon 186\n", + "adding: mem time5, current time 190, horizon 185\n", + "adding: mem time6, current time 190, horizon 184\n", + "adding: mem time7, current time 190, horizon 183\n", + "adding: mem time8, current time 190, horizon 182\n", + "adding: mem time9, current time 190, horizon 181\n", + "adding: mem time10, current time 190, horizon 180\n", + "adding: mem time11, current time 190, horizon 179\n", + "adding: mem time12, current time 190, horizon 178\n", + "adding: mem time13, current time 190, horizon 177\n", + "adding: mem time14, current time 190, horizon 176\n", + "adding: mem time15, current time 190, horizon 175\n", + "adding: mem time16, current time 190, horizon 174\n", + "adding: mem time17, current time 190, horizon 173\n", + "adding: mem time18, current time 190, horizon 172\n", + "adding: mem time19, current time 190, horizon 171\n", + "adding: mem time20, current time 190, horizon 170\n", + "adding: mem time21, current time 190, horizon 169\n", + "adding: mem time22, current time 190, horizon 168\n", + "adding: mem time23, current time 190, horizon 167\n", + "adding: mem time24, current time 190, horizon 166\n", + "adding: mem time25, current time 190, horizon 165\n", + "adding: mem time26, current time 190, horizon 164\n", + "adding: mem time27, current time 190, horizon 163\n", + "adding: mem time28, current time 190, horizon 162\n", + "adding: mem time29, current time 190, horizon 161\n", + "adding: mem time30, current time 190, horizon 160\n", + "adding: mem time31, current time 190, horizon 159\n", + "adding: mem time32, current time 190, horizon 158\n", + "adding: mem time33, current time 190, horizon 157\n", + "adding: mem time34, current time 190, horizon 156\n", + "adding: mem time35, current time 190, horizon 155\n", + "adding: mem time36, current time 190, horizon 154\n", + "adding: mem time37, current time 190, horizon 153\n", + "adding: mem time38, current time 190, horizon 152\n", + "adding: mem time39, current time 190, horizon 151\n", + "adding: mem time40, current time 190, horizon 150\n", + "adding: mem time41, current time 190, horizon 149\n", + "adding: mem time42, current time 190, horizon 148\n", + "adding: mem time43, current time 190, horizon 147\n", + "adding: mem time44, current time 190, horizon 146\n", + "adding: mem time45, current time 190, horizon 145\n", + "adding: mem time46, current time 190, horizon 144\n", + "adding: mem time47, current time 190, horizon 143\n", + "adding: mem time48, current time 190, horizon 142\n", + "adding: mem time49, current time 190, horizon 141\n", + "adding: mem time50, current time 190, horizon 140\n", + "adding: mem time51, current time 190, horizon 139\n", + "adding: mem time52, current time 190, horizon 138\n", + "adding: mem time53, current time 190, horizon 137\n", + "adding: mem time54, current time 190, horizon 136\n", + "adding: mem time55, current time 190, horizon 135\n", + "adding: mem time56, current time 190, horizon 134\n", + "adding: mem time57, current time 190, horizon 133\n", + "adding: mem time58, current time 190, horizon 132\n", + "adding: mem time59, current time 190, horizon 131\n", + "adding: mem time60, current time 190, horizon 130\n", + "adding: mem time61, current time 190, horizon 129\n", + "adding: mem time62, current time 190, horizon 128\n", + "adding: mem time63, current time 190, horizon 127\n", + "adding: mem time64, current time 190, horizon 126\n", + "adding: mem time65, current time 190, horizon 125\n", + "adding: mem time66, current time 190, horizon 124\n", + "adding: mem time67, current time 190, horizon 123\n", + "adding: mem time68, current time 190, horizon 122\n", + "adding: mem time69, current time 190, horizon 121\n", + "adding: mem time70, current time 190, horizon 120\n", + "adding: mem time71, current time 190, horizon 119\n", + "adding: mem time72, current time 190, horizon 118\n", + "adding: mem time73, current time 190, horizon 117\n", + "adding: mem time74, current time 190, horizon 116\n", + "adding: mem time75, current time 190, horizon 115\n", + "adding: mem time76, current time 190, horizon 114\n", + "adding: mem time77, current time 190, horizon 113\n", + "adding: mem time78, current time 190, horizon 112\n", + "adding: mem time79, current time 190, horizon 111\n", + "adding: mem time80, current time 190, horizon 110\n", + "adding: mem time81, current time 190, horizon 109\n", + "adding: mem time82, current time 190, horizon 108\n", + "adding: mem time83, current time 190, horizon 107\n", + "adding: mem time84, current time 190, horizon 106\n", + "adding: mem time85, current time 190, horizon 105\n", + "adding: mem time86, current time 190, horizon 104\n", + "adding: mem time87, current time 190, horizon 103\n", + "adding: mem time88, current time 190, horizon 102\n", + "adding: mem time89, current time 190, horizon 101\n", + "adding: mem time90, current time 190, horizon 100\n", + "adding: mem time91, current time 190, horizon 99\n", + "adding: mem time92, current time 190, horizon 98\n", + "adding: mem time93, current time 190, horizon 97\n", + "adding: mem time94, current time 190, horizon 96\n", + "adding: mem time95, current time 190, horizon 95\n", + "adding: mem time96, current time 190, horizon 94\n", + "adding: mem time97, current time 190, horizon 93\n", + "adding: mem time98, current time 190, horizon 92\n", + "adding: mem time99, current time 190, horizon 91\n", + "adding: mem time100, current time 190, horizon 90\n", + "adding: mem time101, current time 190, horizon 89\n", + "adding: mem time102, current time 190, horizon 88\n", + "adding: mem time103, current time 190, horizon 87\n", + "adding: mem time104, current time 190, horizon 86\n", + "adding: mem time105, current time 190, horizon 85\n", + "adding: mem time106, current time 190, horizon 84\n", + "adding: mem time107, current time 190, horizon 83\n", + "adding: mem time108, current time 190, horizon 82\n", + "adding: mem time109, current time 190, horizon 81\n", + "adding: mem time110, current time 190, horizon 80\n", + "adding: mem time111, current time 190, horizon 79\n", + "adding: mem time112, current time 190, horizon 78\n", + "adding: mem time113, current time 190, horizon 77\n", + "adding: mem time114, current time 190, horizon 76\n", + "adding: mem time115, current time 190, horizon 75\n", + "adding: mem time116, current time 190, horizon 74\n", + "adding: mem time117, current time 190, horizon 73\n", + "adding: mem time118, current time 190, horizon 72\n", + "adding: mem time119, current time 190, horizon 71\n", + "adding: mem time120, current time 190, horizon 70\n", + "adding: mem time121, current time 190, horizon 69\n", + "adding: mem time122, current time 190, horizon 68\n", + "adding: mem time123, current time 190, horizon 67\n", + "adding: mem time124, current time 190, horizon 66\n", + "adding: mem time125, current time 190, horizon 65\n", + "adding: mem time126, current time 190, horizon 64\n", + "adding: mem time127, current time 190, horizon 63\n", + "adding: mem time128, current time 190, horizon 62\n", + "adding: mem time129, current time 190, horizon 61\n", + "adding: mem time130, current time 190, horizon 60\n", + "adding: mem time131, current time 190, horizon 59\n", + "adding: mem time132, current time 190, horizon 58\n", + "adding: mem time133, current time 190, horizon 57\n", + "adding: mem time134, current time 190, horizon 56\n", + "adding: mem time135, current time 190, horizon 55\n", + "adding: mem time136, current time 190, horizon 54\n", + "adding: mem time137, current time 190, horizon 53\n", + "adding: mem time138, current time 190, horizon 52\n", + "adding: mem time139, current time 190, horizon 51\n", + "adding: mem time140, current time 190, horizon 50\n", + "adding: mem time141, current time 190, horizon 49\n", + "adding: mem time142, current time 190, horizon 48\n", + "adding: mem time143, current time 190, horizon 47\n", + "adding: mem time144, current time 190, horizon 46\n", + "adding: mem time145, current time 190, horizon 45\n", + "adding: mem time146, current time 190, horizon 44\n", + "adding: mem time147, current time 190, horizon 43\n", + "adding: mem time148, current time 190, horizon 42\n", + "adding: mem time149, current time 190, horizon 41\n", + "adding: mem time150, current time 190, horizon 40\n", + "adding: mem time151, current time 190, horizon 39\n", + "adding: mem time152, current time 190, horizon 38\n", + "adding: mem time153, current time 190, horizon 37\n", + "adding: mem time154, current time 190, horizon 36\n", + "adding: mem time155, current time 190, horizon 35\n", + "adding: mem time156, current time 190, horizon 34\n", + "adding: mem time157, current time 190, horizon 33\n", + "adding: mem time158, current time 190, horizon 32\n", + "adding: mem time159, current time 190, horizon 31\n", + "adding: mem time160, current time 190, horizon 30\n", + "adding: mem time161, current time 190, horizon 29\n", + "adding: mem time162, current time 190, horizon 28\n", + "adding: mem time163, current time 190, horizon 27\n", + "adding: mem time164, current time 190, horizon 26\n", + "adding: mem time165, current time 190, horizon 25\n", + "adding: mem time166, current time 190, horizon 24\n", + "adding: mem time167, current time 190, horizon 23\n", + "adding: mem time168, current time 190, horizon 22\n", + "adding: mem time169, current time 190, horizon 21\n", + "adding: mem time170, current time 190, horizon 20\n", + "adding: mem time171, current time 190, horizon 19\n", + "adding: mem time172, current time 190, horizon 18\n", + "adding: mem time173, current time 190, horizon 17\n", + "adding: mem time174, current time 190, horizon 16\n", + "adding: mem time175, current time 190, horizon 15\n", + "adding: mem time176, current time 190, horizon 14\n", + "adding: mem time177, current time 190, horizon 13\n", + "adding: mem time178, current time 190, horizon 12\n", + "adding: mem time179, current time 190, horizon 11\n", + "adding: mem time180, current time 190, horizon 10\n", + "adding: mem time181, current time 190, horizon 9\n", + "adding: mem time182, current time 190, horizon 8\n", + "adding: mem time183, current time 190, horizon 7\n", + "adding: mem time184, current time 190, horizon 6\n", + "adding: mem time185, current time 190, horizon 5\n", + "adding: mem time186, current time 190, horizon 4\n", + "adding: mem time187, current time 190, horizon 3\n", + "adding: mem time188, current time 190, horizon 2\n", + "adding: mem time189, current time 190, horizon 1\n", + "adding: mem time0, current time 191, horizon 191\n", + "adding: mem time1, current time 191, horizon 190\n", + "adding: mem time2, current time 191, horizon 189\n", + "adding: mem time3, current time 191, horizon 188\n", + "adding: mem time4, current time 191, horizon 187\n", + "adding: mem time5, current time 191, horizon 186\n", + "adding: mem time6, current time 191, horizon 185\n", + "adding: mem time7, current time 191, horizon 184\n", + "adding: mem time8, current time 191, horizon 183\n", + "adding: mem time9, current time 191, horizon 182\n", + "adding: mem time10, current time 191, horizon 181\n", + "adding: mem time11, current time 191, horizon 180\n", + "adding: mem time12, current time 191, horizon 179\n", + "adding: mem time13, current time 191, horizon 178\n", + "adding: mem time14, current time 191, horizon 177\n", + "adding: mem time15, current time 191, horizon 176\n", + "adding: mem time16, current time 191, horizon 175\n", + "adding: mem time17, current time 191, horizon 174\n", + "adding: mem time18, current time 191, horizon 173\n", + "adding: mem time19, current time 191, horizon 172\n", + "adding: mem time20, current time 191, horizon 171\n", + "adding: mem time21, current time 191, horizon 170\n", + "adding: mem time22, current time 191, horizon 169\n", + "adding: mem time23, current time 191, horizon 168\n", + "adding: mem time24, current time 191, horizon 167\n", + "adding: mem time25, current time 191, horizon 166\n", + "adding: mem time26, current time 191, horizon 165\n", + "adding: mem time27, current time 191, horizon 164\n", + "adding: mem time28, current time 191, horizon 163\n", + "adding: mem time29, current time 191, horizon 162\n", + "adding: mem time30, current time 191, horizon 161\n", + "adding: mem time31, current time 191, horizon 160\n", + "adding: mem time32, current time 191, horizon 159\n", + "adding: mem time33, current time 191, horizon 158\n", + "adding: mem time34, current time 191, horizon 157\n", + "adding: mem time35, current time 191, horizon 156\n", + "adding: mem time36, current time 191, horizon 155\n", + "adding: mem time37, current time 191, horizon 154\n", + "adding: mem time38, current time 191, horizon 153\n", + "adding: mem time39, current time 191, horizon 152\n", + "adding: mem time40, current time 191, horizon 151\n", + "adding: mem time41, current time 191, horizon 150\n", + "adding: mem time42, current time 191, horizon 149\n", + "adding: mem time43, current time 191, horizon 148\n", + "adding: mem time44, current time 191, horizon 147\n", + "adding: mem time45, current time 191, horizon 146\n", + "adding: mem time46, current time 191, horizon 145\n", + "adding: mem time47, current time 191, horizon 144\n", + "adding: mem time48, current time 191, horizon 143\n", + "adding: mem time49, current time 191, horizon 142\n", + "adding: mem time50, current time 191, horizon 141\n", + "adding: mem time51, current time 191, horizon 140\n", + "adding: mem time52, current time 191, horizon 139\n", + "adding: mem time53, current time 191, horizon 138\n", + "adding: mem time54, current time 191, horizon 137\n", + "adding: mem time55, current time 191, horizon 136\n", + "adding: mem time56, current time 191, horizon 135\n", + "adding: mem time57, current time 191, horizon 134\n", + "adding: mem time58, current time 191, horizon 133\n", + "adding: mem time59, current time 191, horizon 132\n", + "adding: mem time60, current time 191, horizon 131\n", + "adding: mem time61, current time 191, horizon 130\n", + "adding: mem time62, current time 191, horizon 129\n", + "adding: mem time63, current time 191, horizon 128\n", + "adding: mem time64, current time 191, horizon 127\n", + "adding: mem time65, current time 191, horizon 126\n", + "adding: mem time66, current time 191, horizon 125\n", + "adding: mem time67, current time 191, horizon 124\n", + "adding: mem time68, current time 191, horizon 123\n", + "adding: mem time69, current time 191, horizon 122\n", + "adding: mem time70, current time 191, horizon 121\n", + "adding: mem time71, current time 191, horizon 120\n", + "adding: mem time72, current time 191, horizon 119\n", + "adding: mem time73, current time 191, horizon 118\n", + "adding: mem time74, current time 191, horizon 117\n", + "adding: mem time75, current time 191, horizon 116\n", + "adding: mem time76, current time 191, horizon 115\n", + "adding: mem time77, current time 191, horizon 114\n", + "adding: mem time78, current time 191, horizon 113\n", + "adding: mem time79, current time 191, horizon 112\n", + "adding: mem time80, current time 191, horizon 111\n", + "adding: mem time81, current time 191, horizon 110\n", + "adding: mem time82, current time 191, horizon 109\n", + "adding: mem time83, current time 191, horizon 108\n", + "adding: mem time84, current time 191, horizon 107\n", + "adding: mem time85, current time 191, horizon 106\n", + "adding: mem time86, current time 191, horizon 105\n", + "adding: mem time87, current time 191, horizon 104\n", + "adding: mem time88, current time 191, horizon 103\n", + "adding: mem time89, current time 191, horizon 102\n", + "adding: mem time90, current time 191, horizon 101\n", + "adding: mem time91, current time 191, horizon 100\n", + "adding: mem time92, current time 191, horizon 99\n", + "adding: mem time93, current time 191, horizon 98\n", + "adding: mem time94, current time 191, horizon 97\n", + "adding: mem time95, current time 191, horizon 96\n", + "adding: mem time96, current time 191, horizon 95\n", + "adding: mem time97, current time 191, horizon 94\n", + "adding: mem time98, current time 191, horizon 93\n", + "adding: mem time99, current time 191, horizon 92\n", + "adding: mem time100, current time 191, horizon 91\n", + "adding: mem time101, current time 191, horizon 90\n", + "adding: mem time102, current time 191, horizon 89\n", + "adding: mem time103, current time 191, horizon 88\n", + "adding: mem time104, current time 191, horizon 87\n", + "adding: mem time105, current time 191, horizon 86\n", + "adding: mem time106, current time 191, horizon 85\n", + "adding: mem time107, current time 191, horizon 84\n", + "adding: mem time108, current time 191, horizon 83\n", + "adding: mem time109, current time 191, horizon 82\n", + "adding: mem time110, current time 191, horizon 81\n", + "adding: mem time111, current time 191, horizon 80\n", + "adding: mem time112, current time 191, horizon 79\n", + "adding: mem time113, current time 191, horizon 78\n", + "adding: mem time114, current time 191, horizon 77\n", + "adding: mem time115, current time 191, horizon 76\n", + "adding: mem time116, current time 191, horizon 75\n", + "adding: mem time117, current time 191, horizon 74\n", + "adding: mem time118, current time 191, horizon 73\n", + "adding: mem time119, current time 191, horizon 72\n", + "adding: mem time120, current time 191, horizon 71\n", + "adding: mem time121, current time 191, horizon 70\n", + "adding: mem time122, current time 191, horizon 69\n", + "adding: mem time123, current time 191, horizon 68\n", + "adding: mem time124, current time 191, horizon 67\n", + "adding: mem time125, current time 191, horizon 66\n", + "adding: mem time126, current time 191, horizon 65\n", + "adding: mem time127, current time 191, horizon 64\n", + "adding: mem time128, current time 191, horizon 63\n", + "adding: mem time129, current time 191, horizon 62\n", + "adding: mem time130, current time 191, horizon 61\n", + "adding: mem time131, current time 191, horizon 60\n", + "adding: mem time132, current time 191, horizon 59\n", + "adding: mem time133, current time 191, horizon 58\n", + "adding: mem time134, current time 191, horizon 57\n", + "adding: mem time135, current time 191, horizon 56\n", + "adding: mem time136, current time 191, horizon 55\n", + "adding: mem time137, current time 191, horizon 54\n", + "adding: mem time138, current time 191, horizon 53\n", + "adding: mem time139, current time 191, horizon 52\n", + "adding: mem time140, current time 191, horizon 51\n", + "adding: mem time141, current time 191, horizon 50\n", + "adding: mem time142, current time 191, horizon 49\n", + "adding: mem time143, current time 191, horizon 48\n", + "adding: mem time144, current time 191, horizon 47\n", + "adding: mem time145, current time 191, horizon 46\n", + "adding: mem time146, current time 191, horizon 45\n", + "adding: mem time147, current time 191, horizon 44\n", + "adding: mem time148, current time 191, horizon 43\n", + "adding: mem time149, current time 191, horizon 42\n", + "adding: mem time150, current time 191, horizon 41\n", + "adding: mem time151, current time 191, horizon 40\n", + "adding: mem time152, current time 191, horizon 39\n", + "adding: mem time153, current time 191, horizon 38\n", + "adding: mem time154, current time 191, horizon 37\n", + "adding: mem time155, current time 191, horizon 36\n", + "adding: mem time156, current time 191, horizon 35\n", + "adding: mem time157, current time 191, horizon 34\n", + "adding: mem time158, current time 191, horizon 33\n", + "adding: mem time159, current time 191, horizon 32\n", + "adding: mem time160, current time 191, horizon 31\n", + "adding: mem time161, current time 191, horizon 30\n", + "adding: mem time162, current time 191, horizon 29\n", + "adding: mem time163, current time 191, horizon 28\n", + "adding: mem time164, current time 191, horizon 27\n", + "adding: mem time165, current time 191, horizon 26\n", + "adding: mem time166, current time 191, horizon 25\n", + "adding: mem time167, current time 191, horizon 24\n", + "adding: mem time168, current time 191, horizon 23\n", + "adding: mem time169, current time 191, horizon 22\n", + "adding: mem time170, current time 191, horizon 21\n", + "adding: mem time171, current time 191, horizon 20\n", + "adding: mem time172, current time 191, horizon 19\n", + "adding: mem time173, current time 191, horizon 18\n", + "adding: mem time174, current time 191, horizon 17\n", + "adding: mem time175, current time 191, horizon 16\n", + "adding: mem time176, current time 191, horizon 15\n", + "adding: mem time177, current time 191, horizon 14\n", + "adding: mem time178, current time 191, horizon 13\n", + "adding: mem time179, current time 191, horizon 12\n", + "adding: mem time180, current time 191, horizon 11\n", + "adding: mem time181, current time 191, horizon 10\n", + "adding: mem time182, current time 191, horizon 9\n", + "adding: mem time183, current time 191, horizon 8\n", + "adding: mem time184, current time 191, horizon 7\n", + "adding: mem time185, current time 191, horizon 6\n", + "adding: mem time186, current time 191, horizon 5\n", + "adding: mem time187, current time 191, horizon 4\n", + "adding: mem time188, current time 191, horizon 3\n", + "adding: mem time189, current time 191, horizon 2\n", + "adding: mem time190, current time 191, horizon 1\n", + "adding: mem time0, current time 192, horizon 192\n", + "adding: mem time1, current time 192, horizon 191\n", + "adding: mem time2, current time 192, horizon 190\n", + "adding: mem time3, current time 192, horizon 189\n", + "adding: mem time4, current time 192, horizon 188\n", + "adding: mem time5, current time 192, horizon 187\n", + "adding: mem time6, current time 192, horizon 186\n", + "adding: mem time7, current time 192, horizon 185\n", + "adding: mem time8, current time 192, horizon 184\n", + "adding: mem time9, current time 192, horizon 183\n", + "adding: mem time10, current time 192, horizon 182\n", + "adding: mem time11, current time 192, horizon 181\n", + "adding: mem time12, current time 192, horizon 180\n", + "adding: mem time13, current time 192, horizon 179\n", + "adding: mem time14, current time 192, horizon 178\n", + "adding: mem time15, current time 192, horizon 177\n", + "adding: mem time16, current time 192, horizon 176\n", + "adding: mem time17, current time 192, horizon 175\n", + "adding: mem time18, current time 192, horizon 174\n", + "adding: mem time19, current time 192, horizon 173\n", + "adding: mem time20, current time 192, horizon 172\n", + "adding: mem time21, current time 192, horizon 171\n", + "adding: mem time22, current time 192, horizon 170\n", + "adding: mem time23, current time 192, horizon 169\n", + "adding: mem time24, current time 192, horizon 168\n", + "adding: mem time25, current time 192, horizon 167\n", + "adding: mem time26, current time 192, horizon 166\n", + "adding: mem time27, current time 192, horizon 165\n", + "adding: mem time28, current time 192, horizon 164\n", + "adding: mem time29, current time 192, horizon 163\n", + "adding: mem time30, current time 192, horizon 162\n", + "adding: mem time31, current time 192, horizon 161\n", + "adding: mem time32, current time 192, horizon 160\n", + "adding: mem time33, current time 192, horizon 159\n", + "adding: mem time34, current time 192, horizon 158\n", + "adding: mem time35, current time 192, horizon 157\n", + "adding: mem time36, current time 192, horizon 156\n", + "adding: mem time37, current time 192, horizon 155\n", + "adding: mem time38, current time 192, horizon 154\n", + "adding: mem time39, current time 192, horizon 153\n", + "adding: mem time40, current time 192, horizon 152\n", + "adding: mem time41, current time 192, horizon 151\n", + "adding: mem time42, current time 192, horizon 150\n", + "adding: mem time43, current time 192, horizon 149\n", + "adding: mem time44, current time 192, horizon 148\n", + "adding: mem time45, current time 192, horizon 147\n", + "adding: mem time46, current time 192, horizon 146\n", + "adding: mem time47, current time 192, horizon 145\n", + "adding: mem time48, current time 192, horizon 144\n", + "adding: mem time49, current time 192, horizon 143\n", + "adding: mem time50, current time 192, horizon 142\n", + "adding: mem time51, current time 192, horizon 141\n", + "adding: mem time52, current time 192, horizon 140\n", + "adding: mem time53, current time 192, horizon 139\n", + "adding: mem time54, current time 192, horizon 138\n", + "adding: mem time55, current time 192, horizon 137\n", + "adding: mem time56, current time 192, horizon 136\n", + "adding: mem time57, current time 192, horizon 135\n", + "adding: mem time58, current time 192, horizon 134\n", + "adding: mem time59, current time 192, horizon 133\n", + "adding: mem time60, current time 192, horizon 132\n", + "adding: mem time61, current time 192, horizon 131\n", + "adding: mem time62, current time 192, horizon 130\n", + "adding: mem time63, current time 192, horizon 129\n", + "adding: mem time64, current time 192, horizon 128\n", + "adding: mem time65, current time 192, horizon 127\n", + "adding: mem time66, current time 192, horizon 126\n", + "adding: mem time67, current time 192, horizon 125\n", + "adding: mem time68, current time 192, horizon 124\n", + "adding: mem time69, current time 192, horizon 123\n", + "adding: mem time70, current time 192, horizon 122\n", + "adding: mem time71, current time 192, horizon 121\n", + "adding: mem time72, current time 192, horizon 120\n", + "adding: mem time73, current time 192, horizon 119\n", + "adding: mem time74, current time 192, horizon 118\n", + "adding: mem time75, current time 192, horizon 117\n", + "adding: mem time76, current time 192, horizon 116\n", + "adding: mem time77, current time 192, horizon 115\n", + "adding: mem time78, current time 192, horizon 114\n", + "adding: mem time79, current time 192, horizon 113\n", + "adding: mem time80, current time 192, horizon 112\n", + "adding: mem time81, current time 192, horizon 111\n", + "adding: mem time82, current time 192, horizon 110\n", + "adding: mem time83, current time 192, horizon 109\n", + "adding: mem time84, current time 192, horizon 108\n", + "adding: mem time85, current time 192, horizon 107\n", + "adding: mem time86, current time 192, horizon 106\n", + "adding: mem time87, current time 192, horizon 105\n", + "adding: mem time88, current time 192, horizon 104\n", + "adding: mem time89, current time 192, horizon 103\n", + "adding: mem time90, current time 192, horizon 102\n", + "adding: mem time91, current time 192, horizon 101\n", + "adding: mem time92, current time 192, horizon 100\n", + "adding: mem time93, current time 192, horizon 99\n", + "adding: mem time94, current time 192, horizon 98\n", + "adding: mem time95, current time 192, horizon 97\n", + "adding: mem time96, current time 192, horizon 96\n", + "adding: mem time97, current time 192, horizon 95\n", + "adding: mem time98, current time 192, horizon 94\n", + "adding: mem time99, current time 192, horizon 93\n", + "adding: mem time100, current time 192, horizon 92\n", + "adding: mem time101, current time 192, horizon 91\n", + "adding: mem time102, current time 192, horizon 90\n", + "adding: mem time103, current time 192, horizon 89\n", + "adding: mem time104, current time 192, horizon 88\n", + "adding: mem time105, current time 192, horizon 87\n", + "adding: mem time106, current time 192, horizon 86\n", + "adding: mem time107, current time 192, horizon 85\n", + "adding: mem time108, current time 192, horizon 84\n", + "adding: mem time109, current time 192, horizon 83\n", + "adding: mem time110, current time 192, horizon 82\n", + "adding: mem time111, current time 192, horizon 81\n", + "adding: mem time112, current time 192, horizon 80\n", + "adding: mem time113, current time 192, horizon 79\n", + "adding: mem time114, current time 192, horizon 78\n", + "adding: mem time115, current time 192, horizon 77\n", + "adding: mem time116, current time 192, horizon 76\n", + "adding: mem time117, current time 192, horizon 75\n", + "adding: mem time118, current time 192, horizon 74\n", + "adding: mem time119, current time 192, horizon 73\n", + "adding: mem time120, current time 192, horizon 72\n", + "adding: mem time121, current time 192, horizon 71\n", + "adding: mem time122, current time 192, horizon 70\n", + "adding: mem time123, current time 192, horizon 69\n", + "adding: mem time124, current time 192, horizon 68\n", + "adding: mem time125, current time 192, horizon 67\n", + "adding: mem time126, current time 192, horizon 66\n", + "adding: mem time127, current time 192, horizon 65\n", + "adding: mem time128, current time 192, horizon 64\n", + "adding: mem time129, current time 192, horizon 63\n", + "adding: mem time130, current time 192, horizon 62\n", + "adding: mem time131, current time 192, horizon 61\n", + "adding: mem time132, current time 192, horizon 60\n", + "adding: mem time133, current time 192, horizon 59\n", + "adding: mem time134, current time 192, horizon 58\n", + "adding: mem time135, current time 192, horizon 57\n", + "adding: mem time136, current time 192, horizon 56\n", + "adding: mem time137, current time 192, horizon 55\n", + "adding: mem time138, current time 192, horizon 54\n", + "adding: mem time139, current time 192, horizon 53\n", + "adding: mem time140, current time 192, horizon 52\n", + "adding: mem time141, current time 192, horizon 51\n", + "adding: mem time142, current time 192, horizon 50\n", + "adding: mem time143, current time 192, horizon 49\n", + "adding: mem time144, current time 192, horizon 48\n", + "adding: mem time145, current time 192, horizon 47\n", + "adding: mem time146, current time 192, horizon 46\n", + "adding: mem time147, current time 192, horizon 45\n", + "adding: mem time148, current time 192, horizon 44\n", + "adding: mem time149, current time 192, horizon 43\n", + "adding: mem time150, current time 192, horizon 42\n", + "adding: mem time151, current time 192, horizon 41\n", + "adding: mem time152, current time 192, horizon 40\n", + "adding: mem time153, current time 192, horizon 39\n", + "adding: mem time154, current time 192, horizon 38\n", + "adding: mem time155, current time 192, horizon 37\n", + "adding: mem time156, current time 192, horizon 36\n", + "adding: mem time157, current time 192, horizon 35\n", + "adding: mem time158, current time 192, horizon 34\n", + "adding: mem time159, current time 192, horizon 33\n", + "adding: mem time160, current time 192, horizon 32\n", + "adding: mem time161, current time 192, horizon 31\n", + "adding: mem time162, current time 192, horizon 30\n", + "adding: mem time163, current time 192, horizon 29\n", + "adding: mem time164, current time 192, horizon 28\n", + "adding: mem time165, current time 192, horizon 27\n", + "adding: mem time166, current time 192, horizon 26\n", + "adding: mem time167, current time 192, horizon 25\n", + "adding: mem time168, current time 192, horizon 24\n", + "adding: mem time169, current time 192, horizon 23\n", + "adding: mem time170, current time 192, horizon 22\n", + "adding: mem time171, current time 192, horizon 21\n", + "adding: mem time172, current time 192, horizon 20\n", + "adding: mem time173, current time 192, horizon 19\n", + "adding: mem time174, current time 192, horizon 18\n", + "adding: mem time175, current time 192, horizon 17\n", + "adding: mem time176, current time 192, horizon 16\n", + "adding: mem time177, current time 192, horizon 15\n", + "adding: mem time178, current time 192, horizon 14\n", + "adding: mem time179, current time 192, horizon 13\n", + "adding: mem time180, current time 192, horizon 12\n", + "adding: mem time181, current time 192, horizon 11\n", + "adding: mem time182, current time 192, horizon 10\n", + "adding: mem time183, current time 192, horizon 9\n", + "adding: mem time184, current time 192, horizon 8\n", + "adding: mem time185, current time 192, horizon 7\n", + "adding: mem time186, current time 192, horizon 6\n", + "adding: mem time187, current time 192, horizon 5\n", + "adding: mem time188, current time 192, horizon 4\n", + "adding: mem time189, current time 192, horizon 3\n", + "adding: mem time190, current time 192, horizon 2\n", + "adding: mem time191, current time 192, horizon 1\n", + "adding: mem time0, current time 193, horizon 193\n", + "adding: mem time1, current time 193, horizon 192\n", + "adding: mem time2, current time 193, horizon 191\n", + "adding: mem time3, current time 193, horizon 190\n", + "adding: mem time4, current time 193, horizon 189\n", + "adding: mem time5, current time 193, horizon 188\n", + "adding: mem time6, current time 193, horizon 187\n", + "adding: mem time7, current time 193, horizon 186\n", + "adding: mem time8, current time 193, horizon 185\n", + "adding: mem time9, current time 193, horizon 184\n", + "adding: mem time10, current time 193, horizon 183\n", + "adding: mem time11, current time 193, horizon 182\n", + "adding: mem time12, current time 193, horizon 181\n", + "adding: mem time13, current time 193, horizon 180\n", + "adding: mem time14, current time 193, horizon 179\n", + "adding: mem time15, current time 193, horizon 178\n", + "adding: mem time16, current time 193, horizon 177\n", + "adding: mem time17, current time 193, horizon 176\n", + "adding: mem time18, current time 193, horizon 175\n", + "adding: mem time19, current time 193, horizon 174\n", + "adding: mem time20, current time 193, horizon 173\n", + "adding: mem time21, current time 193, horizon 172\n", + "adding: mem time22, current time 193, horizon 171\n", + "adding: mem time23, current time 193, horizon 170\n", + "adding: mem time24, current time 193, horizon 169\n", + "adding: mem time25, current time 193, horizon 168\n", + "adding: mem time26, current time 193, horizon 167\n", + "adding: mem time27, current time 193, horizon 166\n", + "adding: mem time28, current time 193, horizon 165\n", + "adding: mem time29, current time 193, horizon 164\n", + "adding: mem time30, current time 193, horizon 163\n", + "adding: mem time31, current time 193, horizon 162\n", + "adding: mem time32, current time 193, horizon 161\n", + "adding: mem time33, current time 193, horizon 160\n", + "adding: mem time34, current time 193, horizon 159\n", + "adding: mem time35, current time 193, horizon 158\n", + "adding: mem time36, current time 193, horizon 157\n", + "adding: mem time37, current time 193, horizon 156\n", + "adding: mem time38, current time 193, horizon 155\n", + "adding: mem time39, current time 193, horizon 154\n", + "adding: mem time40, current time 193, horizon 153\n", + "adding: mem time41, current time 193, horizon 152\n", + "adding: mem time42, current time 193, horizon 151\n", + "adding: mem time43, current time 193, horizon 150\n", + "adding: mem time44, current time 193, horizon 149\n", + "adding: mem time45, current time 193, horizon 148\n", + "adding: mem time46, current time 193, horizon 147\n", + "adding: mem time47, current time 193, horizon 146\n", + "adding: mem time48, current time 193, horizon 145\n", + "adding: mem time49, current time 193, horizon 144\n", + "adding: mem time50, current time 193, horizon 143\n", + "adding: mem time51, current time 193, horizon 142\n", + "adding: mem time52, current time 193, horizon 141\n", + "adding: mem time53, current time 193, horizon 140\n", + "adding: mem time54, current time 193, horizon 139\n", + "adding: mem time55, current time 193, horizon 138\n", + "adding: mem time56, current time 193, horizon 137\n", + "adding: mem time57, current time 193, horizon 136\n", + "adding: mem time58, current time 193, horizon 135\n", + "adding: mem time59, current time 193, horizon 134\n", + "adding: mem time60, current time 193, horizon 133\n", + "adding: mem time61, current time 193, horizon 132\n", + "adding: mem time62, current time 193, horizon 131\n", + "adding: mem time63, current time 193, horizon 130\n", + "adding: mem time64, current time 193, horizon 129\n", + "adding: mem time65, current time 193, horizon 128\n", + "adding: mem time66, current time 193, horizon 127\n", + "adding: mem time67, current time 193, horizon 126\n", + "adding: mem time68, current time 193, horizon 125\n", + "adding: mem time69, current time 193, horizon 124\n", + "adding: mem time70, current time 193, horizon 123\n", + "adding: mem time71, current time 193, horizon 122\n", + "adding: mem time72, current time 193, horizon 121\n", + "adding: mem time73, current time 193, horizon 120\n", + "adding: mem time74, current time 193, horizon 119\n", + "adding: mem time75, current time 193, horizon 118\n", + "adding: mem time76, current time 193, horizon 117\n", + "adding: mem time77, current time 193, horizon 116\n", + "adding: mem time78, current time 193, horizon 115\n", + "adding: mem time79, current time 193, horizon 114\n", + "adding: mem time80, current time 193, horizon 113\n", + "adding: mem time81, current time 193, horizon 112\n", + "adding: mem time82, current time 193, horizon 111\n", + "adding: mem time83, current time 193, horizon 110\n", + "adding: mem time84, current time 193, horizon 109\n", + "adding: mem time85, current time 193, horizon 108\n", + "adding: mem time86, current time 193, horizon 107\n", + "adding: mem time87, current time 193, horizon 106\n", + "adding: mem time88, current time 193, horizon 105\n", + "adding: mem time89, current time 193, horizon 104\n", + "adding: mem time90, current time 193, horizon 103\n", + "adding: mem time91, current time 193, horizon 102\n", + "adding: mem time92, current time 193, horizon 101\n", + "adding: mem time93, current time 193, horizon 100\n", + "adding: mem time94, current time 193, horizon 99\n", + "adding: mem time95, current time 193, horizon 98\n", + "adding: mem time96, current time 193, horizon 97\n", + "adding: mem time97, current time 193, horizon 96\n", + "adding: mem time98, current time 193, horizon 95\n", + "adding: mem time99, current time 193, horizon 94\n", + "adding: mem time100, current time 193, horizon 93\n", + "adding: mem time101, current time 193, horizon 92\n", + "adding: mem time102, current time 193, horizon 91\n", + "adding: mem time103, current time 193, horizon 90\n", + "adding: mem time104, current time 193, horizon 89\n", + "adding: mem time105, current time 193, horizon 88\n", + "adding: mem time106, current time 193, horizon 87\n", + "adding: mem time107, current time 193, horizon 86\n", + "adding: mem time108, current time 193, horizon 85\n", + "adding: mem time109, current time 193, horizon 84\n", + "adding: mem time110, current time 193, horizon 83\n", + "adding: mem time111, current time 193, horizon 82\n", + "adding: mem time112, current time 193, horizon 81\n", + "adding: mem time113, current time 193, horizon 80\n", + "adding: mem time114, current time 193, horizon 79\n", + "adding: mem time115, current time 193, horizon 78\n", + "adding: mem time116, current time 193, horizon 77\n", + "adding: mem time117, current time 193, horizon 76\n", + "adding: mem time118, current time 193, horizon 75\n", + "adding: mem time119, current time 193, horizon 74\n", + "adding: mem time120, current time 193, horizon 73\n", + "adding: mem time121, current time 193, horizon 72\n", + "adding: mem time122, current time 193, horizon 71\n", + "adding: mem time123, current time 193, horizon 70\n", + "adding: mem time124, current time 193, horizon 69\n", + "adding: mem time125, current time 193, horizon 68\n", + "adding: mem time126, current time 193, horizon 67\n", + "adding: mem time127, current time 193, horizon 66\n", + "adding: mem time128, current time 193, horizon 65\n", + "adding: mem time129, current time 193, horizon 64\n", + "adding: mem time130, current time 193, horizon 63\n", + "adding: mem time131, current time 193, horizon 62\n", + "adding: mem time132, current time 193, horizon 61\n", + "adding: mem time133, current time 193, horizon 60\n", + "adding: mem time134, current time 193, horizon 59\n", + "adding: mem time135, current time 193, horizon 58\n", + "adding: mem time136, current time 193, horizon 57\n", + "adding: mem time137, current time 193, horizon 56\n", + "adding: mem time138, current time 193, horizon 55\n", + "adding: mem time139, current time 193, horizon 54\n", + "adding: mem time140, current time 193, horizon 53\n", + "adding: mem time141, current time 193, horizon 52\n", + "adding: mem time142, current time 193, horizon 51\n", + "adding: mem time143, current time 193, horizon 50\n", + "adding: mem time144, current time 193, horizon 49\n", + "adding: mem time145, current time 193, horizon 48\n", + "adding: mem time146, current time 193, horizon 47\n", + "adding: mem time147, current time 193, horizon 46\n", + "adding: mem time148, current time 193, horizon 45\n", + "adding: mem time149, current time 193, horizon 44\n", + "adding: mem time150, current time 193, horizon 43\n", + "adding: mem time151, current time 193, horizon 42\n", + "adding: mem time152, current time 193, horizon 41\n", + "adding: mem time153, current time 193, horizon 40\n", + "adding: mem time154, current time 193, horizon 39\n", + "adding: mem time155, current time 193, horizon 38\n", + "adding: mem time156, current time 193, horizon 37\n", + "adding: mem time157, current time 193, horizon 36\n", + "adding: mem time158, current time 193, horizon 35\n", + "adding: mem time159, current time 193, horizon 34\n", + "adding: mem time160, current time 193, horizon 33\n", + "adding: mem time161, current time 193, horizon 32\n", + "adding: mem time162, current time 193, horizon 31\n", + "adding: mem time163, current time 193, horizon 30\n", + "adding: mem time164, current time 193, horizon 29\n", + "adding: mem time165, current time 193, horizon 28\n", + "adding: mem time166, current time 193, horizon 27\n", + "adding: mem time167, current time 193, horizon 26\n", + "adding: mem time168, current time 193, horizon 25\n", + "adding: mem time169, current time 193, horizon 24\n", + "adding: mem time170, current time 193, horizon 23\n", + "adding: mem time171, current time 193, horizon 22\n", + "adding: mem time172, current time 193, horizon 21\n", + "adding: mem time173, current time 193, horizon 20\n", + "adding: mem time174, current time 193, horizon 19\n", + "adding: mem time175, current time 193, horizon 18\n", + "adding: mem time176, current time 193, horizon 17\n", + "adding: mem time177, current time 193, horizon 16\n", + "adding: mem time178, current time 193, horizon 15\n", + "adding: mem time179, current time 193, horizon 14\n", + "adding: mem time180, current time 193, horizon 13\n", + "adding: mem time181, current time 193, horizon 12\n", + "adding: mem time182, current time 193, horizon 11\n", + "adding: mem time183, current time 193, horizon 10\n", + "adding: mem time184, current time 193, horizon 9\n", + "adding: mem time185, current time 193, horizon 8\n", + "adding: mem time186, current time 193, horizon 7\n", + "adding: mem time187, current time 193, horizon 6\n", + "adding: mem time188, current time 193, horizon 5\n", + "adding: mem time189, current time 193, horizon 4\n", + "adding: mem time190, current time 193, horizon 3\n", + "adding: mem time191, current time 193, horizon 2\n", + "adding: mem time192, current time 193, horizon 1\n", + "adding: mem time0, current time 194, horizon 194\n", + "adding: mem time1, current time 194, horizon 193\n", + "adding: mem time2, current time 194, horizon 192\n", + "adding: mem time3, current time 194, horizon 191\n", + "adding: mem time4, current time 194, horizon 190\n", + "adding: mem time5, current time 194, horizon 189\n", + "adding: mem time6, current time 194, horizon 188\n", + "adding: mem time7, current time 194, horizon 187\n", + "adding: mem time8, current time 194, horizon 186\n", + "adding: mem time9, current time 194, horizon 185\n", + "adding: mem time10, current time 194, horizon 184\n", + "adding: mem time11, current time 194, horizon 183\n", + "adding: mem time12, current time 194, horizon 182\n", + "adding: mem time13, current time 194, horizon 181\n", + "adding: mem time14, current time 194, horizon 180\n", + "adding: mem time15, current time 194, horizon 179\n", + "adding: mem time16, current time 194, horizon 178\n", + "adding: mem time17, current time 194, horizon 177\n", + "adding: mem time18, current time 194, horizon 176\n", + "adding: mem time19, current time 194, horizon 175\n", + "adding: mem time20, current time 194, horizon 174\n", + "adding: mem time21, current time 194, horizon 173\n", + "adding: mem time22, current time 194, horizon 172\n", + "adding: mem time23, current time 194, horizon 171\n", + "adding: mem time24, current time 194, horizon 170\n", + "adding: mem time25, current time 194, horizon 169\n", + "adding: mem time26, current time 194, horizon 168\n", + "adding: mem time27, current time 194, horizon 167\n", + "adding: mem time28, current time 194, horizon 166\n", + "adding: mem time29, current time 194, horizon 165\n", + "adding: mem time30, current time 194, horizon 164\n", + "adding: mem time31, current time 194, horizon 163\n", + "adding: mem time32, current time 194, horizon 162\n", + "adding: mem time33, current time 194, horizon 161\n", + "adding: mem time34, current time 194, horizon 160\n", + "adding: mem time35, current time 194, horizon 159\n", + "adding: mem time36, current time 194, horizon 158\n", + "adding: mem time37, current time 194, horizon 157\n", + "adding: mem time38, current time 194, horizon 156\n", + "adding: mem time39, current time 194, horizon 155\n", + "adding: mem time40, current time 194, horizon 154\n", + "adding: mem time41, current time 194, horizon 153\n", + "adding: mem time42, current time 194, horizon 152\n", + "adding: mem time43, current time 194, horizon 151\n", + "adding: mem time44, current time 194, horizon 150\n", + "adding: mem time45, current time 194, horizon 149\n", + "adding: mem time46, current time 194, horizon 148\n", + "adding: mem time47, current time 194, horizon 147\n", + "adding: mem time48, current time 194, horizon 146\n", + "adding: mem time49, current time 194, horizon 145\n", + "adding: mem time50, current time 194, horizon 144\n", + "adding: mem time51, current time 194, horizon 143\n", + "adding: mem time52, current time 194, horizon 142\n", + "adding: mem time53, current time 194, horizon 141\n", + "adding: mem time54, current time 194, horizon 140\n", + "adding: mem time55, current time 194, horizon 139\n", + "adding: mem time56, current time 194, horizon 138\n", + "adding: mem time57, current time 194, horizon 137\n", + "adding: mem time58, current time 194, horizon 136\n", + "adding: mem time59, current time 194, horizon 135\n", + "adding: mem time60, current time 194, horizon 134\n", + "adding: mem time61, current time 194, horizon 133\n", + "adding: mem time62, current time 194, horizon 132\n", + "adding: mem time63, current time 194, horizon 131\n", + "adding: mem time64, current time 194, horizon 130\n", + "adding: mem time65, current time 194, horizon 129\n", + "adding: mem time66, current time 194, horizon 128\n", + "adding: mem time67, current time 194, horizon 127\n", + "adding: mem time68, current time 194, horizon 126\n", + "adding: mem time69, current time 194, horizon 125\n", + "adding: mem time70, current time 194, horizon 124\n", + "adding: mem time71, current time 194, horizon 123\n", + "adding: mem time72, current time 194, horizon 122\n", + "adding: mem time73, current time 194, horizon 121\n", + "adding: mem time74, current time 194, horizon 120\n", + "adding: mem time75, current time 194, horizon 119\n", + "adding: mem time76, current time 194, horizon 118\n", + "adding: mem time77, current time 194, horizon 117\n", + "adding: mem time78, current time 194, horizon 116\n", + "adding: mem time79, current time 194, horizon 115\n", + "adding: mem time80, current time 194, horizon 114\n", + "adding: mem time81, current time 194, horizon 113\n", + "adding: mem time82, current time 194, horizon 112\n", + "adding: mem time83, current time 194, horizon 111\n", + "adding: mem time84, current time 194, horizon 110\n", + "adding: mem time85, current time 194, horizon 109\n", + "adding: mem time86, current time 194, horizon 108\n", + "adding: mem time87, current time 194, horizon 107\n", + "adding: mem time88, current time 194, horizon 106\n", + "adding: mem time89, current time 194, horizon 105\n", + "adding: mem time90, current time 194, horizon 104\n", + "adding: mem time91, current time 194, horizon 103\n", + "adding: mem time92, current time 194, horizon 102\n", + "adding: mem time93, current time 194, horizon 101\n", + "adding: mem time94, current time 194, horizon 100\n", + "adding: mem time95, current time 194, horizon 99\n", + "adding: mem time96, current time 194, horizon 98\n", + "adding: mem time97, current time 194, horizon 97\n", + "adding: mem time98, current time 194, horizon 96\n", + "adding: mem time99, current time 194, horizon 95\n", + "adding: mem time100, current time 194, horizon 94\n", + "adding: mem time101, current time 194, horizon 93\n", + "adding: mem time102, current time 194, horizon 92\n", + "adding: mem time103, current time 194, horizon 91\n", + "adding: mem time104, current time 194, horizon 90\n", + "adding: mem time105, current time 194, horizon 89\n", + "adding: mem time106, current time 194, horizon 88\n", + "adding: mem time107, current time 194, horizon 87\n", + "adding: mem time108, current time 194, horizon 86\n", + "adding: mem time109, current time 194, horizon 85\n", + "adding: mem time110, current time 194, horizon 84\n", + "adding: mem time111, current time 194, horizon 83\n", + "adding: mem time112, current time 194, horizon 82\n", + "adding: mem time113, current time 194, horizon 81\n", + "adding: mem time114, current time 194, horizon 80\n", + "adding: mem time115, current time 194, horizon 79\n", + "adding: mem time116, current time 194, horizon 78\n", + "adding: mem time117, current time 194, horizon 77\n", + "adding: mem time118, current time 194, horizon 76\n", + "adding: mem time119, current time 194, horizon 75\n", + "adding: mem time120, current time 194, horizon 74\n", + "adding: mem time121, current time 194, horizon 73\n", + "adding: mem time122, current time 194, horizon 72\n", + "adding: mem time123, current time 194, horizon 71\n", + "adding: mem time124, current time 194, horizon 70\n", + "adding: mem time125, current time 194, horizon 69\n", + "adding: mem time126, current time 194, horizon 68\n", + "adding: mem time127, current time 194, horizon 67\n", + "adding: mem time128, current time 194, horizon 66\n", + "adding: mem time129, current time 194, horizon 65\n", + "adding: mem time130, current time 194, horizon 64\n", + "adding: mem time131, current time 194, horizon 63\n", + "adding: mem time132, current time 194, horizon 62\n", + "adding: mem time133, current time 194, horizon 61\n", + "adding: mem time134, current time 194, horizon 60\n", + "adding: mem time135, current time 194, horizon 59\n", + "adding: mem time136, current time 194, horizon 58\n", + "adding: mem time137, current time 194, horizon 57\n", + "adding: mem time138, current time 194, horizon 56\n", + "adding: mem time139, current time 194, horizon 55\n", + "adding: mem time140, current time 194, horizon 54\n", + "adding: mem time141, current time 194, horizon 53\n", + "adding: mem time142, current time 194, horizon 52\n", + "adding: mem time143, current time 194, horizon 51\n", + "adding: mem time144, current time 194, horizon 50\n", + "adding: mem time145, current time 194, horizon 49\n", + "adding: mem time146, current time 194, horizon 48\n", + "adding: mem time147, current time 194, horizon 47\n", + "adding: mem time148, current time 194, horizon 46\n", + "adding: mem time149, current time 194, horizon 45\n", + "adding: mem time150, current time 194, horizon 44\n", + "adding: mem time151, current time 194, horizon 43\n", + "adding: mem time152, current time 194, horizon 42\n", + "adding: mem time153, current time 194, horizon 41\n", + "adding: mem time154, current time 194, horizon 40\n", + "adding: mem time155, current time 194, horizon 39\n", + "adding: mem time156, current time 194, horizon 38\n", + "adding: mem time157, current time 194, horizon 37\n", + "adding: mem time158, current time 194, horizon 36\n", + "adding: mem time159, current time 194, horizon 35\n", + "adding: mem time160, current time 194, horizon 34\n", + "adding: mem time161, current time 194, horizon 33\n", + "adding: mem time162, current time 194, horizon 32\n", + "adding: mem time163, current time 194, horizon 31\n", + "adding: mem time164, current time 194, horizon 30\n", + "adding: mem time165, current time 194, horizon 29\n", + "adding: mem time166, current time 194, horizon 28\n", + "adding: mem time167, current time 194, horizon 27\n", + "adding: mem time168, current time 194, horizon 26\n", + "adding: mem time169, current time 194, horizon 25\n", + "adding: mem time170, current time 194, horizon 24\n", + "adding: mem time171, current time 194, horizon 23\n", + "adding: mem time172, current time 194, horizon 22\n", + "adding: mem time173, current time 194, horizon 21\n", + "adding: mem time174, current time 194, horizon 20\n", + "adding: mem time175, current time 194, horizon 19\n", + "adding: mem time176, current time 194, horizon 18\n", + "adding: mem time177, current time 194, horizon 17\n", + "adding: mem time178, current time 194, horizon 16\n", + "adding: mem time179, current time 194, horizon 15\n", + "adding: mem time180, current time 194, horizon 14\n", + "adding: mem time181, current time 194, horizon 13\n", + "adding: mem time182, current time 194, horizon 12\n", + "adding: mem time183, current time 194, horizon 11\n", + "adding: mem time184, current time 194, horizon 10\n", + "adding: mem time185, current time 194, horizon 9\n", + "adding: mem time186, current time 194, horizon 8\n", + "adding: mem time187, current time 194, horizon 7\n", + "adding: mem time188, current time 194, horizon 6\n", + "adding: mem time189, current time 194, horizon 5\n", + "adding: mem time190, current time 194, horizon 4\n", + "adding: mem time191, current time 194, horizon 3\n", + "adding: mem time192, current time 194, horizon 2\n", + "adding: mem time193, current time 194, horizon 1\n", + "adding: mem time0, current time 195, horizon 195\n", + "adding: mem time1, current time 195, horizon 194\n", + "adding: mem time2, current time 195, horizon 193\n", + "adding: mem time3, current time 195, horizon 192\n", + "adding: mem time4, current time 195, horizon 191\n", + "adding: mem time5, current time 195, horizon 190\n", + "adding: mem time6, current time 195, horizon 189\n", + "adding: mem time7, current time 195, horizon 188\n", + "adding: mem time8, current time 195, horizon 187\n", + "adding: mem time9, current time 195, horizon 186\n", + "adding: mem time10, current time 195, horizon 185\n", + "adding: mem time11, current time 195, horizon 184\n", + "adding: mem time12, current time 195, horizon 183\n", + "adding: mem time13, current time 195, horizon 182\n", + "adding: mem time14, current time 195, horizon 181\n", + "adding: mem time15, current time 195, horizon 180\n", + "adding: mem time16, current time 195, horizon 179\n", + "adding: mem time17, current time 195, horizon 178\n", + "adding: mem time18, current time 195, horizon 177\n", + "adding: mem time19, current time 195, horizon 176\n", + "adding: mem time20, current time 195, horizon 175\n", + "adding: mem time21, current time 195, horizon 174\n", + "adding: mem time22, current time 195, horizon 173\n", + "adding: mem time23, current time 195, horizon 172\n", + "adding: mem time24, current time 195, horizon 171\n", + "adding: mem time25, current time 195, horizon 170\n", + "adding: mem time26, current time 195, horizon 169\n", + "adding: mem time27, current time 195, horizon 168\n", + "adding: mem time28, current time 195, horizon 167\n", + "adding: mem time29, current time 195, horizon 166\n", + "adding: mem time30, current time 195, horizon 165\n", + "adding: mem time31, current time 195, horizon 164\n", + "adding: mem time32, current time 195, horizon 163\n", + "adding: mem time33, current time 195, horizon 162\n", + "adding: mem time34, current time 195, horizon 161\n", + "adding: mem time35, current time 195, horizon 160\n", + "adding: mem time36, current time 195, horizon 159\n", + "adding: mem time37, current time 195, horizon 158\n", + "adding: mem time38, current time 195, horizon 157\n", + "adding: mem time39, current time 195, horizon 156\n", + "adding: mem time40, current time 195, horizon 155\n", + "adding: mem time41, current time 195, horizon 154\n", + "adding: mem time42, current time 195, horizon 153\n", + "adding: mem time43, current time 195, horizon 152\n", + "adding: mem time44, current time 195, horizon 151\n", + "adding: mem time45, current time 195, horizon 150\n", + "adding: mem time46, current time 195, horizon 149\n", + "adding: mem time47, current time 195, horizon 148\n", + "adding: mem time48, current time 195, horizon 147\n", + "adding: mem time49, current time 195, horizon 146\n", + "adding: mem time50, current time 195, horizon 145\n", + "adding: mem time51, current time 195, horizon 144\n", + "adding: mem time52, current time 195, horizon 143\n", + "adding: mem time53, current time 195, horizon 142\n", + "adding: mem time54, current time 195, horizon 141\n", + "adding: mem time55, current time 195, horizon 140\n", + "adding: mem time56, current time 195, horizon 139\n", + "adding: mem time57, current time 195, horizon 138\n", + "adding: mem time58, current time 195, horizon 137\n", + "adding: mem time59, current time 195, horizon 136\n", + "adding: mem time60, current time 195, horizon 135\n", + "adding: mem time61, current time 195, horizon 134\n", + "adding: mem time62, current time 195, horizon 133\n", + "adding: mem time63, current time 195, horizon 132\n", + "adding: mem time64, current time 195, horizon 131\n", + "adding: mem time65, current time 195, horizon 130\n", + "adding: mem time66, current time 195, horizon 129\n", + "adding: mem time67, current time 195, horizon 128\n", + "adding: mem time68, current time 195, horizon 127\n", + "adding: mem time69, current time 195, horizon 126\n", + "adding: mem time70, current time 195, horizon 125\n", + "adding: mem time71, current time 195, horizon 124\n", + "adding: mem time72, current time 195, horizon 123\n", + "adding: mem time73, current time 195, horizon 122\n", + "adding: mem time74, current time 195, horizon 121\n", + "adding: mem time75, current time 195, horizon 120\n", + "adding: mem time76, current time 195, horizon 119\n", + "adding: mem time77, current time 195, horizon 118\n", + "adding: mem time78, current time 195, horizon 117\n", + "adding: mem time79, current time 195, horizon 116\n", + "adding: mem time80, current time 195, horizon 115\n", + "adding: mem time81, current time 195, horizon 114\n", + "adding: mem time82, current time 195, horizon 113\n", + "adding: mem time83, current time 195, horizon 112\n", + "adding: mem time84, current time 195, horizon 111\n", + "adding: mem time85, current time 195, horizon 110\n", + "adding: mem time86, current time 195, horizon 109\n", + "adding: mem time87, current time 195, horizon 108\n", + "adding: mem time88, current time 195, horizon 107\n", + "adding: mem time89, current time 195, horizon 106\n", + "adding: mem time90, current time 195, horizon 105\n", + "adding: mem time91, current time 195, horizon 104\n", + "adding: mem time92, current time 195, horizon 103\n", + "adding: mem time93, current time 195, horizon 102\n", + "adding: mem time94, current time 195, horizon 101\n", + "adding: mem time95, current time 195, horizon 100\n", + "adding: mem time96, current time 195, horizon 99\n", + "adding: mem time97, current time 195, horizon 98\n", + "adding: mem time98, current time 195, horizon 97\n", + "adding: mem time99, current time 195, horizon 96\n", + "adding: mem time100, current time 195, horizon 95\n", + "adding: mem time101, current time 195, horizon 94\n", + "adding: mem time102, current time 195, horizon 93\n", + "adding: mem time103, current time 195, horizon 92\n", + "adding: mem time104, current time 195, horizon 91\n", + "adding: mem time105, current time 195, horizon 90\n", + "adding: mem time106, current time 195, horizon 89\n", + "adding: mem time107, current time 195, horizon 88\n", + "adding: mem time108, current time 195, horizon 87\n", + "adding: mem time109, current time 195, horizon 86\n", + "adding: mem time110, current time 195, horizon 85\n", + "adding: mem time111, current time 195, horizon 84\n", + "adding: mem time112, current time 195, horizon 83\n", + "adding: mem time113, current time 195, horizon 82\n", + "adding: mem time114, current time 195, horizon 81\n", + "adding: mem time115, current time 195, horizon 80\n", + "adding: mem time116, current time 195, horizon 79\n", + "adding: mem time117, current time 195, horizon 78\n", + "adding: mem time118, current time 195, horizon 77\n", + "adding: mem time119, current time 195, horizon 76\n", + "adding: mem time120, current time 195, horizon 75\n", + "adding: mem time121, current time 195, horizon 74\n", + "adding: mem time122, current time 195, horizon 73\n", + "adding: mem time123, current time 195, horizon 72\n", + "adding: mem time124, current time 195, horizon 71\n", + "adding: mem time125, current time 195, horizon 70\n", + "adding: mem time126, current time 195, horizon 69\n", + "adding: mem time127, current time 195, horizon 68\n", + "adding: mem time128, current time 195, horizon 67\n", + "adding: mem time129, current time 195, horizon 66\n", + "adding: mem time130, current time 195, horizon 65\n", + "adding: mem time131, current time 195, horizon 64\n", + "adding: mem time132, current time 195, horizon 63\n", + "adding: mem time133, current time 195, horizon 62\n", + "adding: mem time134, current time 195, horizon 61\n", + "adding: mem time135, current time 195, horizon 60\n", + "adding: mem time136, current time 195, horizon 59\n", + "adding: mem time137, current time 195, horizon 58\n", + "adding: mem time138, current time 195, horizon 57\n", + "adding: mem time139, current time 195, horizon 56\n", + "adding: mem time140, current time 195, horizon 55\n", + "adding: mem time141, current time 195, horizon 54\n", + "adding: mem time142, current time 195, horizon 53\n", + "adding: mem time143, current time 195, horizon 52\n", + "adding: mem time144, current time 195, horizon 51\n", + "adding: mem time145, current time 195, horizon 50\n", + "adding: mem time146, current time 195, horizon 49\n", + "adding: mem time147, current time 195, horizon 48\n", + "adding: mem time148, current time 195, horizon 47\n", + "adding: mem time149, current time 195, horizon 46\n", + "adding: mem time150, current time 195, horizon 45\n", + "adding: mem time151, current time 195, horizon 44\n", + "adding: mem time152, current time 195, horizon 43\n", + "adding: mem time153, current time 195, horizon 42\n", + "adding: mem time154, current time 195, horizon 41\n", + "adding: mem time155, current time 195, horizon 40\n", + "adding: mem time156, current time 195, horizon 39\n", + "adding: mem time157, current time 195, horizon 38\n", + "adding: mem time158, current time 195, horizon 37\n", + "adding: mem time159, current time 195, horizon 36\n", + "adding: mem time160, current time 195, horizon 35\n", + "adding: mem time161, current time 195, horizon 34\n", + "adding: mem time162, current time 195, horizon 33\n", + "adding: mem time163, current time 195, horizon 32\n", + "adding: mem time164, current time 195, horizon 31\n", + "adding: mem time165, current time 195, horizon 30\n", + "adding: mem time166, current time 195, horizon 29\n", + "adding: mem time167, current time 195, horizon 28\n", + "adding: mem time168, current time 195, horizon 27\n", + "adding: mem time169, current time 195, horizon 26\n", + "adding: mem time170, current time 195, horizon 25\n", + "adding: mem time171, current time 195, horizon 24\n", + "adding: mem time172, current time 195, horizon 23\n", + "adding: mem time173, current time 195, horizon 22\n", + "adding: mem time174, current time 195, horizon 21\n", + "adding: mem time175, current time 195, horizon 20\n", + "adding: mem time176, current time 195, horizon 19\n", + "adding: mem time177, current time 195, horizon 18\n", + "adding: mem time178, current time 195, horizon 17\n", + "adding: mem time179, current time 195, horizon 16\n", + "adding: mem time180, current time 195, horizon 15\n", + "adding: mem time181, current time 195, horizon 14\n", + "adding: mem time182, current time 195, horizon 13\n", + "adding: mem time183, current time 195, horizon 12\n", + "adding: mem time184, current time 195, horizon 11\n", + "adding: mem time185, current time 195, horizon 10\n", + "adding: mem time186, current time 195, horizon 9\n", + "adding: mem time187, current time 195, horizon 8\n", + "adding: mem time188, current time 195, horizon 7\n", + "adding: mem time189, current time 195, horizon 6\n", + "adding: mem time190, current time 195, horizon 5\n", + "adding: mem time191, current time 195, horizon 4\n", + "adding: mem time192, current time 195, horizon 3\n", + "adding: mem time193, current time 195, horizon 2\n", + "adding: mem time194, current time 195, horizon 1\n", + "adding: mem time0, current time 196, horizon 196\n", + "adding: mem time1, current time 196, horizon 195\n", + "adding: mem time2, current time 196, horizon 194\n", + "adding: mem time3, current time 196, horizon 193\n", + "adding: mem time4, current time 196, horizon 192\n", + "adding: mem time5, current time 196, horizon 191\n", + "adding: mem time6, current time 196, horizon 190\n", + "adding: mem time7, current time 196, horizon 189\n", + "adding: mem time8, current time 196, horizon 188\n", + "adding: mem time9, current time 196, horizon 187\n", + "adding: mem time10, current time 196, horizon 186\n", + "adding: mem time11, current time 196, horizon 185\n", + "adding: mem time12, current time 196, horizon 184\n", + "adding: mem time13, current time 196, horizon 183\n", + "adding: mem time14, current time 196, horizon 182\n", + "adding: mem time15, current time 196, horizon 181\n", + "adding: mem time16, current time 196, horizon 180\n", + "adding: mem time17, current time 196, horizon 179\n", + "adding: mem time18, current time 196, horizon 178\n", + "adding: mem time19, current time 196, horizon 177\n", + "adding: mem time20, current time 196, horizon 176\n", + "adding: mem time21, current time 196, horizon 175\n", + "adding: mem time22, current time 196, horizon 174\n", + "adding: mem time23, current time 196, horizon 173\n", + "adding: mem time24, current time 196, horizon 172\n", + "adding: mem time25, current time 196, horizon 171\n", + "adding: mem time26, current time 196, horizon 170\n", + "adding: mem time27, current time 196, horizon 169\n", + "adding: mem time28, current time 196, horizon 168\n", + "adding: mem time29, current time 196, horizon 167\n", + "adding: mem time30, current time 196, horizon 166\n", + "adding: mem time31, current time 196, horizon 165\n", + "adding: mem time32, current time 196, horizon 164\n", + "adding: mem time33, current time 196, horizon 163\n", + "adding: mem time34, current time 196, horizon 162\n", + "adding: mem time35, current time 196, horizon 161\n", + "adding: mem time36, current time 196, horizon 160\n", + "adding: mem time37, current time 196, horizon 159\n", + "adding: mem time38, current time 196, horizon 158\n", + "adding: mem time39, current time 196, horizon 157\n", + "adding: mem time40, current time 196, horizon 156\n", + "adding: mem time41, current time 196, horizon 155\n", + "adding: mem time42, current time 196, horizon 154\n", + "adding: mem time43, current time 196, horizon 153\n", + "adding: mem time44, current time 196, horizon 152\n", + "adding: mem time45, current time 196, horizon 151\n", + "adding: mem time46, current time 196, horizon 150\n", + "adding: mem time47, current time 196, horizon 149\n", + "adding: mem time48, current time 196, horizon 148\n", + "adding: mem time49, current time 196, horizon 147\n", + "adding: mem time50, current time 196, horizon 146\n", + "adding: mem time51, current time 196, horizon 145\n", + "adding: mem time52, current time 196, horizon 144\n", + "adding: mem time53, current time 196, horizon 143\n", + "adding: mem time54, current time 196, horizon 142\n", + "adding: mem time55, current time 196, horizon 141\n", + "adding: mem time56, current time 196, horizon 140\n", + "adding: mem time57, current time 196, horizon 139\n", + "adding: mem time58, current time 196, horizon 138\n", + "adding: mem time59, current time 196, horizon 137\n", + "adding: mem time60, current time 196, horizon 136\n", + "adding: mem time61, current time 196, horizon 135\n", + "adding: mem time62, current time 196, horizon 134\n", + "adding: mem time63, current time 196, horizon 133\n", + "adding: mem time64, current time 196, horizon 132\n", + "adding: mem time65, current time 196, horizon 131\n", + "adding: mem time66, current time 196, horizon 130\n", + "adding: mem time67, current time 196, horizon 129\n", + "adding: mem time68, current time 196, horizon 128\n", + "adding: mem time69, current time 196, horizon 127\n", + "adding: mem time70, current time 196, horizon 126\n", + "adding: mem time71, current time 196, horizon 125\n", + "adding: mem time72, current time 196, horizon 124\n", + "adding: mem time73, current time 196, horizon 123\n", + "adding: mem time74, current time 196, horizon 122\n", + "adding: mem time75, current time 196, horizon 121\n", + "adding: mem time76, current time 196, horizon 120\n", + "adding: mem time77, current time 196, horizon 119\n", + "adding: mem time78, current time 196, horizon 118\n", + "adding: mem time79, current time 196, horizon 117\n", + "adding: mem time80, current time 196, horizon 116\n", + "adding: mem time81, current time 196, horizon 115\n", + "adding: mem time82, current time 196, horizon 114\n", + "adding: mem time83, current time 196, horizon 113\n", + "adding: mem time84, current time 196, horizon 112\n", + "adding: mem time85, current time 196, horizon 111\n", + "adding: mem time86, current time 196, horizon 110\n", + "adding: mem time87, current time 196, horizon 109\n", + "adding: mem time88, current time 196, horizon 108\n", + "adding: mem time89, current time 196, horizon 107\n", + "adding: mem time90, current time 196, horizon 106\n", + "adding: mem time91, current time 196, horizon 105\n", + "adding: mem time92, current time 196, horizon 104\n", + "adding: mem time93, current time 196, horizon 103\n", + "adding: mem time94, current time 196, horizon 102\n", + "adding: mem time95, current time 196, horizon 101\n", + "adding: mem time96, current time 196, horizon 100\n", + "adding: mem time97, current time 196, horizon 99\n", + "adding: mem time98, current time 196, horizon 98\n", + "adding: mem time99, current time 196, horizon 97\n", + "adding: mem time100, current time 196, horizon 96\n", + "adding: mem time101, current time 196, horizon 95\n", + "adding: mem time102, current time 196, horizon 94\n", + "adding: mem time103, current time 196, horizon 93\n", + "adding: mem time104, current time 196, horizon 92\n", + "adding: mem time105, current time 196, horizon 91\n", + "adding: mem time106, current time 196, horizon 90\n", + "adding: mem time107, current time 196, horizon 89\n", + "adding: mem time108, current time 196, horizon 88\n", + "adding: mem time109, current time 196, horizon 87\n", + "adding: mem time110, current time 196, horizon 86\n", + "adding: mem time111, current time 196, horizon 85\n", + "adding: mem time112, current time 196, horizon 84\n", + "adding: mem time113, current time 196, horizon 83\n", + "adding: mem time114, current time 196, horizon 82\n", + "adding: mem time115, current time 196, horizon 81\n", + "adding: mem time116, current time 196, horizon 80\n", + "adding: mem time117, current time 196, horizon 79\n", + "adding: mem time118, current time 196, horizon 78\n", + "adding: mem time119, current time 196, horizon 77\n", + "adding: mem time120, current time 196, horizon 76\n", + "adding: mem time121, current time 196, horizon 75\n", + "adding: mem time122, current time 196, horizon 74\n", + "adding: mem time123, current time 196, horizon 73\n", + "adding: mem time124, current time 196, horizon 72\n", + "adding: mem time125, current time 196, horizon 71\n", + "adding: mem time126, current time 196, horizon 70\n", + "adding: mem time127, current time 196, horizon 69\n", + "adding: mem time128, current time 196, horizon 68\n", + "adding: mem time129, current time 196, horizon 67\n", + "adding: mem time130, current time 196, horizon 66\n", + "adding: mem time131, current time 196, horizon 65\n", + "adding: mem time132, current time 196, horizon 64\n", + "adding: mem time133, current time 196, horizon 63\n", + "adding: mem time134, current time 196, horizon 62\n", + "adding: mem time135, current time 196, horizon 61\n", + "adding: mem time136, current time 196, horizon 60\n", + "adding: mem time137, current time 196, horizon 59\n", + "adding: mem time138, current time 196, horizon 58\n", + "adding: mem time139, current time 196, horizon 57\n", + "adding: mem time140, current time 196, horizon 56\n", + "adding: mem time141, current time 196, horizon 55\n", + "adding: mem time142, current time 196, horizon 54\n", + "adding: mem time143, current time 196, horizon 53\n", + "adding: mem time144, current time 196, horizon 52\n", + "adding: mem time145, current time 196, horizon 51\n", + "adding: mem time146, current time 196, horizon 50\n", + "adding: mem time147, current time 196, horizon 49\n", + "adding: mem time148, current time 196, horizon 48\n", + "adding: mem time149, current time 196, horizon 47\n", + "adding: mem time150, current time 196, horizon 46\n", + "adding: mem time151, current time 196, horizon 45\n", + "adding: mem time152, current time 196, horizon 44\n", + "adding: mem time153, current time 196, horizon 43\n", + "adding: mem time154, current time 196, horizon 42\n", + "adding: mem time155, current time 196, horizon 41\n", + "adding: mem time156, current time 196, horizon 40\n", + "adding: mem time157, current time 196, horizon 39\n", + "adding: mem time158, current time 196, horizon 38\n", + "adding: mem time159, current time 196, horizon 37\n", + "adding: mem time160, current time 196, horizon 36\n", + "adding: mem time161, current time 196, horizon 35\n", + "adding: mem time162, current time 196, horizon 34\n", + "adding: mem time163, current time 196, horizon 33\n", + "adding: mem time164, current time 196, horizon 32\n", + "adding: mem time165, current time 196, horizon 31\n", + "adding: mem time166, current time 196, horizon 30\n", + "adding: mem time167, current time 196, horizon 29\n", + "adding: mem time168, current time 196, horizon 28\n", + "adding: mem time169, current time 196, horizon 27\n", + "adding: mem time170, current time 196, horizon 26\n", + "adding: mem time171, current time 196, horizon 25\n", + "adding: mem time172, current time 196, horizon 24\n", + "adding: mem time173, current time 196, horizon 23\n", + "adding: mem time174, current time 196, horizon 22\n", + "adding: mem time175, current time 196, horizon 21\n", + "adding: mem time176, current time 196, horizon 20\n", + "adding: mem time177, current time 196, horizon 19\n", + "adding: mem time178, current time 196, horizon 18\n", + "adding: mem time179, current time 196, horizon 17\n", + "adding: mem time180, current time 196, horizon 16\n", + "adding: mem time181, current time 196, horizon 15\n", + "adding: mem time182, current time 196, horizon 14\n", + "adding: mem time183, current time 196, horizon 13\n", + "adding: mem time184, current time 196, horizon 12\n", + "adding: mem time185, current time 196, horizon 11\n", + "adding: mem time186, current time 196, horizon 10\n", + "adding: mem time187, current time 196, horizon 9\n", + "adding: mem time188, current time 196, horizon 8\n", + "adding: mem time189, current time 196, horizon 7\n", + "adding: mem time190, current time 196, horizon 6\n", + "adding: mem time191, current time 196, horizon 5\n", + "adding: mem time192, current time 196, horizon 4\n", + "adding: mem time193, current time 196, horizon 3\n", + "adding: mem time194, current time 196, horizon 2\n", + "adding: mem time195, current time 196, horizon 1\n", + "adding: mem time0, current time 197, horizon 197\n", + "adding: mem time1, current time 197, horizon 196\n", + "adding: mem time2, current time 197, horizon 195\n", + "adding: mem time3, current time 197, horizon 194\n", + "adding: mem time4, current time 197, horizon 193\n", + "adding: mem time5, current time 197, horizon 192\n", + "adding: mem time6, current time 197, horizon 191\n", + "adding: mem time7, current time 197, horizon 190\n", + "adding: mem time8, current time 197, horizon 189\n", + "adding: mem time9, current time 197, horizon 188\n", + "adding: mem time10, current time 197, horizon 187\n", + "adding: mem time11, current time 197, horizon 186\n", + "adding: mem time12, current time 197, horizon 185\n", + "adding: mem time13, current time 197, horizon 184\n", + "adding: mem time14, current time 197, horizon 183\n", + "adding: mem time15, current time 197, horizon 182\n", + "adding: mem time16, current time 197, horizon 181\n", + "adding: mem time17, current time 197, horizon 180\n", + "adding: mem time18, current time 197, horizon 179\n", + "adding: mem time19, current time 197, horizon 178\n", + "adding: mem time20, current time 197, horizon 177\n", + "adding: mem time21, current time 197, horizon 176\n", + "adding: mem time22, current time 197, horizon 175\n", + "adding: mem time23, current time 197, horizon 174\n", + "adding: mem time24, current time 197, horizon 173\n", + "adding: mem time25, current time 197, horizon 172\n", + "adding: mem time26, current time 197, horizon 171\n", + "adding: mem time27, current time 197, horizon 170\n", + "adding: mem time28, current time 197, horizon 169\n", + "adding: mem time29, current time 197, horizon 168\n", + "adding: mem time30, current time 197, horizon 167\n", + "adding: mem time31, current time 197, horizon 166\n", + "adding: mem time32, current time 197, horizon 165\n", + "adding: mem time33, current time 197, horizon 164\n", + "adding: mem time34, current time 197, horizon 163\n", + "adding: mem time35, current time 197, horizon 162\n", + "adding: mem time36, current time 197, horizon 161\n", + "adding: mem time37, current time 197, horizon 160\n", + "adding: mem time38, current time 197, horizon 159\n", + "adding: mem time39, current time 197, horizon 158\n", + "adding: mem time40, current time 197, horizon 157\n", + "adding: mem time41, current time 197, horizon 156\n", + "adding: mem time42, current time 197, horizon 155\n", + "adding: mem time43, current time 197, horizon 154\n", + "adding: mem time44, current time 197, horizon 153\n", + "adding: mem time45, current time 197, horizon 152\n", + "adding: mem time46, current time 197, horizon 151\n", + "adding: mem time47, current time 197, horizon 150\n", + "adding: mem time48, current time 197, horizon 149\n", + "adding: mem time49, current time 197, horizon 148\n", + "adding: mem time50, current time 197, horizon 147\n", + "adding: mem time51, current time 197, horizon 146\n", + "adding: mem time52, current time 197, horizon 145\n", + "adding: mem time53, current time 197, horizon 144\n", + "adding: mem time54, current time 197, horizon 143\n", + "adding: mem time55, current time 197, horizon 142\n", + "adding: mem time56, current time 197, horizon 141\n", + "adding: mem time57, current time 197, horizon 140\n", + "adding: mem time58, current time 197, horizon 139\n", + "adding: mem time59, current time 197, horizon 138\n", + "adding: mem time60, current time 197, horizon 137\n", + "adding: mem time61, current time 197, horizon 136\n", + "adding: mem time62, current time 197, horizon 135\n", + "adding: mem time63, current time 197, horizon 134\n", + "adding: mem time64, current time 197, horizon 133\n", + "adding: mem time65, current time 197, horizon 132\n", + "adding: mem time66, current time 197, horizon 131\n", + "adding: mem time67, current time 197, horizon 130\n", + "adding: mem time68, current time 197, horizon 129\n", + "adding: mem time69, current time 197, horizon 128\n", + "adding: mem time70, current time 197, horizon 127\n", + "adding: mem time71, current time 197, horizon 126\n", + "adding: mem time72, current time 197, horizon 125\n", + "adding: mem time73, current time 197, horizon 124\n", + "adding: mem time74, current time 197, horizon 123\n", + "adding: mem time75, current time 197, horizon 122\n", + "adding: mem time76, current time 197, horizon 121\n", + "adding: mem time77, current time 197, horizon 120\n", + "adding: mem time78, current time 197, horizon 119\n", + "adding: mem time79, current time 197, horizon 118\n", + "adding: mem time80, current time 197, horizon 117\n", + "adding: mem time81, current time 197, horizon 116\n", + "adding: mem time82, current time 197, horizon 115\n", + "adding: mem time83, current time 197, horizon 114\n", + "adding: mem time84, current time 197, horizon 113\n", + "adding: mem time85, current time 197, horizon 112\n", + "adding: mem time86, current time 197, horizon 111\n", + "adding: mem time87, current time 197, horizon 110\n", + "adding: mem time88, current time 197, horizon 109\n", + "adding: mem time89, current time 197, horizon 108\n", + "adding: mem time90, current time 197, horizon 107\n", + "adding: mem time91, current time 197, horizon 106\n", + "adding: mem time92, current time 197, horizon 105\n", + "adding: mem time93, current time 197, horizon 104\n", + "adding: mem time94, current time 197, horizon 103\n", + "adding: mem time95, current time 197, horizon 102\n", + "adding: mem time96, current time 197, horizon 101\n", + "adding: mem time97, current time 197, horizon 100\n", + "adding: mem time98, current time 197, horizon 99\n", + "adding: mem time99, current time 197, horizon 98\n", + "adding: mem time100, current time 197, horizon 97\n", + "adding: mem time101, current time 197, horizon 96\n", + "adding: mem time102, current time 197, horizon 95\n", + "adding: mem time103, current time 197, horizon 94\n", + "adding: mem time104, current time 197, horizon 93\n", + "adding: mem time105, current time 197, horizon 92\n", + "adding: mem time106, current time 197, horizon 91\n", + "adding: mem time107, current time 197, horizon 90\n", + "adding: mem time108, current time 197, horizon 89\n", + "adding: mem time109, current time 197, horizon 88\n", + "adding: mem time110, current time 197, horizon 87\n", + "adding: mem time111, current time 197, horizon 86\n", + "adding: mem time112, current time 197, horizon 85\n", + "adding: mem time113, current time 197, horizon 84\n", + "adding: mem time114, current time 197, horizon 83\n", + "adding: mem time115, current time 197, horizon 82\n", + "adding: mem time116, current time 197, horizon 81\n", + "adding: mem time117, current time 197, horizon 80\n", + "adding: mem time118, current time 197, horizon 79\n", + "adding: mem time119, current time 197, horizon 78\n", + "adding: mem time120, current time 197, horizon 77\n", + "adding: mem time121, current time 197, horizon 76\n", + "adding: mem time122, current time 197, horizon 75\n", + "adding: mem time123, current time 197, horizon 74\n", + "adding: mem time124, current time 197, horizon 73\n", + "adding: mem time125, current time 197, horizon 72\n", + "adding: mem time126, current time 197, horizon 71\n", + "adding: mem time127, current time 197, horizon 70\n", + "adding: mem time128, current time 197, horizon 69\n", + "adding: mem time129, current time 197, horizon 68\n", + "adding: mem time130, current time 197, horizon 67\n", + "adding: mem time131, current time 197, horizon 66\n", + "adding: mem time132, current time 197, horizon 65\n", + "adding: mem time133, current time 197, horizon 64\n", + "adding: mem time134, current time 197, horizon 63\n", + "adding: mem time135, current time 197, horizon 62\n", + "adding: mem time136, current time 197, horizon 61\n", + "adding: mem time137, current time 197, horizon 60\n", + "adding: mem time138, current time 197, horizon 59\n", + "adding: mem time139, current time 197, horizon 58\n", + "adding: mem time140, current time 197, horizon 57\n", + "adding: mem time141, current time 197, horizon 56\n", + "adding: mem time142, current time 197, horizon 55\n", + "adding: mem time143, current time 197, horizon 54\n", + "adding: mem time144, current time 197, horizon 53\n", + "adding: mem time145, current time 197, horizon 52\n", + "adding: mem time146, current time 197, horizon 51\n", + "adding: mem time147, current time 197, horizon 50\n", + "adding: mem time148, current time 197, horizon 49\n", + "adding: mem time149, current time 197, horizon 48\n", + "adding: mem time150, current time 197, horizon 47\n", + "adding: mem time151, current time 197, horizon 46\n", + "adding: mem time152, current time 197, horizon 45\n", + "adding: mem time153, current time 197, horizon 44\n", + "adding: mem time154, current time 197, horizon 43\n", + "adding: mem time155, current time 197, horizon 42\n", + "adding: mem time156, current time 197, horizon 41\n", + "adding: mem time157, current time 197, horizon 40\n", + "adding: mem time158, current time 197, horizon 39\n", + "adding: mem time159, current time 197, horizon 38\n", + "adding: mem time160, current time 197, horizon 37\n", + "adding: mem time161, current time 197, horizon 36\n", + "adding: mem time162, current time 197, horizon 35\n", + "adding: mem time163, current time 197, horizon 34\n", + "adding: mem time164, current time 197, horizon 33\n", + "adding: mem time165, current time 197, horizon 32\n", + "adding: mem time166, current time 197, horizon 31\n", + "adding: mem time167, current time 197, horizon 30\n", + "adding: mem time168, current time 197, horizon 29\n", + "adding: mem time169, current time 197, horizon 28\n", + "adding: mem time170, current time 197, horizon 27\n", + "adding: mem time171, current time 197, horizon 26\n", + "adding: mem time172, current time 197, horizon 25\n", + "adding: mem time173, current time 197, horizon 24\n", + "adding: mem time174, current time 197, horizon 23\n", + "adding: mem time175, current time 197, horizon 22\n", + "adding: mem time176, current time 197, horizon 21\n", + "adding: mem time177, current time 197, horizon 20\n", + "adding: mem time178, current time 197, horizon 19\n", + "adding: mem time179, current time 197, horizon 18\n", + "adding: mem time180, current time 197, horizon 17\n", + "adding: mem time181, current time 197, horizon 16\n", + "adding: mem time182, current time 197, horizon 15\n", + "adding: mem time183, current time 197, horizon 14\n", + "adding: mem time184, current time 197, horizon 13\n", + "adding: mem time185, current time 197, horizon 12\n", + "adding: mem time186, current time 197, horizon 11\n", + "adding: mem time187, current time 197, horizon 10\n", + "adding: mem time188, current time 197, horizon 9\n", + "adding: mem time189, current time 197, horizon 8\n", + "adding: mem time190, current time 197, horizon 7\n", + "adding: mem time191, current time 197, horizon 6\n", + "adding: mem time192, current time 197, horizon 5\n", + "adding: mem time193, current time 197, horizon 4\n", + "adding: mem time194, current time 197, horizon 3\n", + "adding: mem time195, current time 197, horizon 2\n", + "adding: mem time196, current time 197, horizon 1\n", + "adding: mem time0, current time 198, horizon 198\n", + "adding: mem time1, current time 198, horizon 197\n", + "adding: mem time2, current time 198, horizon 196\n", + "adding: mem time3, current time 198, horizon 195\n", + "adding: mem time4, current time 198, horizon 194\n", + "adding: mem time5, current time 198, horizon 193\n", + "adding: mem time6, current time 198, horizon 192\n", + "adding: mem time7, current time 198, horizon 191\n", + "adding: mem time8, current time 198, horizon 190\n", + "adding: mem time9, current time 198, horizon 189\n", + "adding: mem time10, current time 198, horizon 188\n", + "adding: mem time11, current time 198, horizon 187\n", + "adding: mem time12, current time 198, horizon 186\n", + "adding: mem time13, current time 198, horizon 185\n", + "adding: mem time14, current time 198, horizon 184\n", + "adding: mem time15, current time 198, horizon 183\n", + "adding: mem time16, current time 198, horizon 182\n", + "adding: mem time17, current time 198, horizon 181\n", + "adding: mem time18, current time 198, horizon 180\n", + "adding: mem time19, current time 198, horizon 179\n", + "adding: mem time20, current time 198, horizon 178\n", + "adding: mem time21, current time 198, horizon 177\n", + "adding: mem time22, current time 198, horizon 176\n", + "adding: mem time23, current time 198, horizon 175\n", + "adding: mem time24, current time 198, horizon 174\n", + "adding: mem time25, current time 198, horizon 173\n", + "adding: mem time26, current time 198, horizon 172\n", + "adding: mem time27, current time 198, horizon 171\n", + "adding: mem time28, current time 198, horizon 170\n", + "adding: mem time29, current time 198, horizon 169\n", + "adding: mem time30, current time 198, horizon 168\n", + "adding: mem time31, current time 198, horizon 167\n", + "adding: mem time32, current time 198, horizon 166\n", + "adding: mem time33, current time 198, horizon 165\n", + "adding: mem time34, current time 198, horizon 164\n", + "adding: mem time35, current time 198, horizon 163\n", + "adding: mem time36, current time 198, horizon 162\n", + "adding: mem time37, current time 198, horizon 161\n", + "adding: mem time38, current time 198, horizon 160\n", + "adding: mem time39, current time 198, horizon 159\n", + "adding: mem time40, current time 198, horizon 158\n", + "adding: mem time41, current time 198, horizon 157\n", + "adding: mem time42, current time 198, horizon 156\n", + "adding: mem time43, current time 198, horizon 155\n", + "adding: mem time44, current time 198, horizon 154\n", + "adding: mem time45, current time 198, horizon 153\n", + "adding: mem time46, current time 198, horizon 152\n", + "adding: mem time47, current time 198, horizon 151\n", + "adding: mem time48, current time 198, horizon 150\n", + "adding: mem time49, current time 198, horizon 149\n", + "adding: mem time50, current time 198, horizon 148\n", + "adding: mem time51, current time 198, horizon 147\n", + "adding: mem time52, current time 198, horizon 146\n", + "adding: mem time53, current time 198, horizon 145\n", + "adding: mem time54, current time 198, horizon 144\n", + "adding: mem time55, current time 198, horizon 143\n", + "adding: mem time56, current time 198, horizon 142\n", + "adding: mem time57, current time 198, horizon 141\n", + "adding: mem time58, current time 198, horizon 140\n", + "adding: mem time59, current time 198, horizon 139\n", + "adding: mem time60, current time 198, horizon 138\n", + "adding: mem time61, current time 198, horizon 137\n", + "adding: mem time62, current time 198, horizon 136\n", + "adding: mem time63, current time 198, horizon 135\n", + "adding: mem time64, current time 198, horizon 134\n", + "adding: mem time65, current time 198, horizon 133\n", + "adding: mem time66, current time 198, horizon 132\n", + "adding: mem time67, current time 198, horizon 131\n", + "adding: mem time68, current time 198, horizon 130\n", + "adding: mem time69, current time 198, horizon 129\n", + "adding: mem time70, current time 198, horizon 128\n", + "adding: mem time71, current time 198, horizon 127\n", + "adding: mem time72, current time 198, horizon 126\n", + "adding: mem time73, current time 198, horizon 125\n", + "adding: mem time74, current time 198, horizon 124\n", + "adding: mem time75, current time 198, horizon 123\n", + "adding: mem time76, current time 198, horizon 122\n", + "adding: mem time77, current time 198, horizon 121\n", + "adding: mem time78, current time 198, horizon 120\n", + "adding: mem time79, current time 198, horizon 119\n", + "adding: mem time80, current time 198, horizon 118\n", + "adding: mem time81, current time 198, horizon 117\n", + "adding: mem time82, current time 198, horizon 116\n", + "adding: mem time83, current time 198, horizon 115\n", + "adding: mem time84, current time 198, horizon 114\n", + "adding: mem time85, current time 198, horizon 113\n", + "adding: mem time86, current time 198, horizon 112\n", + "adding: mem time87, current time 198, horizon 111\n", + "adding: mem time88, current time 198, horizon 110\n", + "adding: mem time89, current time 198, horizon 109\n", + "adding: mem time90, current time 198, horizon 108\n", + "adding: mem time91, current time 198, horizon 107\n", + "adding: mem time92, current time 198, horizon 106\n", + "adding: mem time93, current time 198, horizon 105\n", + "adding: mem time94, current time 198, horizon 104\n", + "adding: mem time95, current time 198, horizon 103\n", + "adding: mem time96, current time 198, horizon 102\n", + "adding: mem time97, current time 198, horizon 101\n", + "adding: mem time98, current time 198, horizon 100\n", + "adding: mem time99, current time 198, horizon 99\n", + "adding: mem time100, current time 198, horizon 98\n", + "adding: mem time101, current time 198, horizon 97\n", + "adding: mem time102, current time 198, horizon 96\n", + "adding: mem time103, current time 198, horizon 95\n", + "adding: mem time104, current time 198, horizon 94\n", + "adding: mem time105, current time 198, horizon 93\n", + "adding: mem time106, current time 198, horizon 92\n", + "adding: mem time107, current time 198, horizon 91\n", + "adding: mem time108, current time 198, horizon 90\n", + "adding: mem time109, current time 198, horizon 89\n", + "adding: mem time110, current time 198, horizon 88\n", + "adding: mem time111, current time 198, horizon 87\n", + "adding: mem time112, current time 198, horizon 86\n", + "adding: mem time113, current time 198, horizon 85\n", + "adding: mem time114, current time 198, horizon 84\n", + "adding: mem time115, current time 198, horizon 83\n", + "adding: mem time116, current time 198, horizon 82\n", + "adding: mem time117, current time 198, horizon 81\n", + "adding: mem time118, current time 198, horizon 80\n", + "adding: mem time119, current time 198, horizon 79\n", + "adding: mem time120, current time 198, horizon 78\n", + "adding: mem time121, current time 198, horizon 77\n", + "adding: mem time122, current time 198, horizon 76\n", + "adding: mem time123, current time 198, horizon 75\n", + "adding: mem time124, current time 198, horizon 74\n", + "adding: mem time125, current time 198, horizon 73\n", + "adding: mem time126, current time 198, horizon 72\n", + "adding: mem time127, current time 198, horizon 71\n", + "adding: mem time128, current time 198, horizon 70\n", + "adding: mem time129, current time 198, horizon 69\n", + "adding: mem time130, current time 198, horizon 68\n", + "adding: mem time131, current time 198, horizon 67\n", + "adding: mem time132, current time 198, horizon 66\n", + "adding: mem time133, current time 198, horizon 65\n", + "adding: mem time134, current time 198, horizon 64\n", + "adding: mem time135, current time 198, horizon 63\n", + "adding: mem time136, current time 198, horizon 62\n", + "adding: mem time137, current time 198, horizon 61\n", + "adding: mem time138, current time 198, horizon 60\n", + "adding: mem time139, current time 198, horizon 59\n", + "adding: mem time140, current time 198, horizon 58\n", + "adding: mem time141, current time 198, horizon 57\n", + "adding: mem time142, current time 198, horizon 56\n", + "adding: mem time143, current time 198, horizon 55\n", + "adding: mem time144, current time 198, horizon 54\n", + "adding: mem time145, current time 198, horizon 53\n", + "adding: mem time146, current time 198, horizon 52\n", + "adding: mem time147, current time 198, horizon 51\n", + "adding: mem time148, current time 198, horizon 50\n", + "adding: mem time149, current time 198, horizon 49\n", + "adding: mem time150, current time 198, horizon 48\n", + "adding: mem time151, current time 198, horizon 47\n", + "adding: mem time152, current time 198, horizon 46\n", + "adding: mem time153, current time 198, horizon 45\n", + "adding: mem time154, current time 198, horizon 44\n", + "adding: mem time155, current time 198, horizon 43\n", + "adding: mem time156, current time 198, horizon 42\n", + "adding: mem time157, current time 198, horizon 41\n", + "adding: mem time158, current time 198, horizon 40\n", + "adding: mem time159, current time 198, horizon 39\n", + "adding: mem time160, current time 198, horizon 38\n", + "adding: mem time161, current time 198, horizon 37\n", + "adding: mem time162, current time 198, horizon 36\n", + "adding: mem time163, current time 198, horizon 35\n", + "adding: mem time164, current time 198, horizon 34\n", + "adding: mem time165, current time 198, horizon 33\n", + "adding: mem time166, current time 198, horizon 32\n", + "adding: mem time167, current time 198, horizon 31\n", + "adding: mem time168, current time 198, horizon 30\n", + "adding: mem time169, current time 198, horizon 29\n", + "adding: mem time170, current time 198, horizon 28\n", + "adding: mem time171, current time 198, horizon 27\n", + "adding: mem time172, current time 198, horizon 26\n", + "adding: mem time173, current time 198, horizon 25\n", + "adding: mem time174, current time 198, horizon 24\n", + "adding: mem time175, current time 198, horizon 23\n", + "adding: mem time176, current time 198, horizon 22\n", + "adding: mem time177, current time 198, horizon 21\n", + "adding: mem time178, current time 198, horizon 20\n", + "adding: mem time179, current time 198, horizon 19\n", + "adding: mem time180, current time 198, horizon 18\n", + "adding: mem time181, current time 198, horizon 17\n", + "adding: mem time182, current time 198, horizon 16\n", + "adding: mem time183, current time 198, horizon 15\n", + "adding: mem time184, current time 198, horizon 14\n", + "adding: mem time185, current time 198, horizon 13\n", + "adding: mem time186, current time 198, horizon 12\n", + "adding: mem time187, current time 198, horizon 11\n", + "adding: mem time188, current time 198, horizon 10\n", + "adding: mem time189, current time 198, horizon 9\n", + "adding: mem time190, current time 198, horizon 8\n", + "adding: mem time191, current time 198, horizon 7\n", + "adding: mem time192, current time 198, horizon 6\n", + "adding: mem time193, current time 198, horizon 5\n", + "adding: mem time194, current time 198, horizon 4\n", + "adding: mem time195, current time 198, horizon 3\n", + "adding: mem time196, current time 198, horizon 2\n", + "adding: mem time197, current time 198, horizon 1\n", + "adding: mem time0, current time 199, horizon 199\n", + "adding: mem time1, current time 199, horizon 198\n", + "adding: mem time2, current time 199, horizon 197\n", + "adding: mem time3, current time 199, horizon 196\n", + "adding: mem time4, current time 199, horizon 195\n", + "adding: mem time5, current time 199, horizon 194\n", + "adding: mem time6, current time 199, horizon 193\n", + "adding: mem time7, current time 199, horizon 192\n", + "adding: mem time8, current time 199, horizon 191\n", + "adding: mem time9, current time 199, horizon 190\n", + "adding: mem time10, current time 199, horizon 189\n", + "adding: mem time11, current time 199, horizon 188\n", + "adding: mem time12, current time 199, horizon 187\n", + "adding: mem time13, current time 199, horizon 186\n", + "adding: mem time14, current time 199, horizon 185\n", + "adding: mem time15, current time 199, horizon 184\n", + "adding: mem time16, current time 199, horizon 183\n", + "adding: mem time17, current time 199, horizon 182\n", + "adding: mem time18, current time 199, horizon 181\n", + "adding: mem time19, current time 199, horizon 180\n", + "adding: mem time20, current time 199, horizon 179\n", + "adding: mem time21, current time 199, horizon 178\n", + "adding: mem time22, current time 199, horizon 177\n", + "adding: mem time23, current time 199, horizon 176\n", + "adding: mem time24, current time 199, horizon 175\n", + "adding: mem time25, current time 199, horizon 174\n", + "adding: mem time26, current time 199, horizon 173\n", + "adding: mem time27, current time 199, horizon 172\n", + "adding: mem time28, current time 199, horizon 171\n", + "adding: mem time29, current time 199, horizon 170\n", + "adding: mem time30, current time 199, horizon 169\n", + "adding: mem time31, current time 199, horizon 168\n", + "adding: mem time32, current time 199, horizon 167\n", + "adding: mem time33, current time 199, horizon 166\n", + "adding: mem time34, current time 199, horizon 165\n", + "adding: mem time35, current time 199, horizon 164\n", + "adding: mem time36, current time 199, horizon 163\n", + "adding: mem time37, current time 199, horizon 162\n", + "adding: mem time38, current time 199, horizon 161\n", + "adding: mem time39, current time 199, horizon 160\n", + "adding: mem time40, current time 199, horizon 159\n", + "adding: mem time41, current time 199, horizon 158\n", + "adding: mem time42, current time 199, horizon 157\n", + "adding: mem time43, current time 199, horizon 156\n", + "adding: mem time44, current time 199, horizon 155\n", + "adding: mem time45, current time 199, horizon 154\n", + "adding: mem time46, current time 199, horizon 153\n", + "adding: mem time47, current time 199, horizon 152\n", + "adding: mem time48, current time 199, horizon 151\n", + "adding: mem time49, current time 199, horizon 150\n", + "adding: mem time50, current time 199, horizon 149\n", + "adding: mem time51, current time 199, horizon 148\n", + "adding: mem time52, current time 199, horizon 147\n", + "adding: mem time53, current time 199, horizon 146\n", + "adding: mem time54, current time 199, horizon 145\n", + "adding: mem time55, current time 199, horizon 144\n", + "adding: mem time56, current time 199, horizon 143\n", + "adding: mem time57, current time 199, horizon 142\n", + "adding: mem time58, current time 199, horizon 141\n", + "adding: mem time59, current time 199, horizon 140\n", + "adding: mem time60, current time 199, horizon 139\n", + "adding: mem time61, current time 199, horizon 138\n", + "adding: mem time62, current time 199, horizon 137\n", + "adding: mem time63, current time 199, horizon 136\n", + "adding: mem time64, current time 199, horizon 135\n", + "adding: mem time65, current time 199, horizon 134\n", + "adding: mem time66, current time 199, horizon 133\n", + "adding: mem time67, current time 199, horizon 132\n", + "adding: mem time68, current time 199, horizon 131\n", + "adding: mem time69, current time 199, horizon 130\n", + "adding: mem time70, current time 199, horizon 129\n", + "adding: mem time71, current time 199, horizon 128\n", + "adding: mem time72, current time 199, horizon 127\n", + "adding: mem time73, current time 199, horizon 126\n", + "adding: mem time74, current time 199, horizon 125\n", + "adding: mem time75, current time 199, horizon 124\n", + "adding: mem time76, current time 199, horizon 123\n", + "adding: mem time77, current time 199, horizon 122\n", + "adding: mem time78, current time 199, horizon 121\n", + "adding: mem time79, current time 199, horizon 120\n", + "adding: mem time80, current time 199, horizon 119\n", + "adding: mem time81, current time 199, horizon 118\n", + "adding: mem time82, current time 199, horizon 117\n", + "adding: mem time83, current time 199, horizon 116\n", + "adding: mem time84, current time 199, horizon 115\n", + "adding: mem time85, current time 199, horizon 114\n", + "adding: mem time86, current time 199, horizon 113\n", + "adding: mem time87, current time 199, horizon 112\n", + "adding: mem time88, current time 199, horizon 111\n", + "adding: mem time89, current time 199, horizon 110\n", + "adding: mem time90, current time 199, horizon 109\n", + "adding: mem time91, current time 199, horizon 108\n", + "adding: mem time92, current time 199, horizon 107\n", + "adding: mem time93, current time 199, horizon 106\n", + "adding: mem time94, current time 199, horizon 105\n", + "adding: mem time95, current time 199, horizon 104\n", + "adding: mem time96, current time 199, horizon 103\n", + "adding: mem time97, current time 199, horizon 102\n", + "adding: mem time98, current time 199, horizon 101\n", + "adding: mem time99, current time 199, horizon 100\n", + "adding: mem time100, current time 199, horizon 99\n", + "adding: mem time101, current time 199, horizon 98\n", + "adding: mem time102, current time 199, horizon 97\n", + "adding: mem time103, current time 199, horizon 96\n", + "adding: mem time104, current time 199, horizon 95\n", + "adding: mem time105, current time 199, horizon 94\n", + "adding: mem time106, current time 199, horizon 93\n", + "adding: mem time107, current time 199, horizon 92\n", + "adding: mem time108, current time 199, horizon 91\n", + "adding: mem time109, current time 199, horizon 90\n", + "adding: mem time110, current time 199, horizon 89\n", + "adding: mem time111, current time 199, horizon 88\n", + "adding: mem time112, current time 199, horizon 87\n", + "adding: mem time113, current time 199, horizon 86\n", + "adding: mem time114, current time 199, horizon 85\n", + "adding: mem time115, current time 199, horizon 84\n", + "adding: mem time116, current time 199, horizon 83\n", + "adding: mem time117, current time 199, horizon 82\n", + "adding: mem time118, current time 199, horizon 81\n", + "adding: mem time119, current time 199, horizon 80\n", + "adding: mem time120, current time 199, horizon 79\n", + "adding: mem time121, current time 199, horizon 78\n", + "adding: mem time122, current time 199, horizon 77\n", + "adding: mem time123, current time 199, horizon 76\n", + "adding: mem time124, current time 199, horizon 75\n", + "adding: mem time125, current time 199, horizon 74\n", + "adding: mem time126, current time 199, horizon 73\n", + "adding: mem time127, current time 199, horizon 72\n", + "adding: mem time128, current time 199, horizon 71\n", + "adding: mem time129, current time 199, horizon 70\n", + "adding: mem time130, current time 199, horizon 69\n", + "adding: mem time131, current time 199, horizon 68\n", + "adding: mem time132, current time 199, horizon 67\n", + "adding: mem time133, current time 199, horizon 66\n", + "adding: mem time134, current time 199, horizon 65\n", + "adding: mem time135, current time 199, horizon 64\n", + "adding: mem time136, current time 199, horizon 63\n", + "adding: mem time137, current time 199, horizon 62\n", + "adding: mem time138, current time 199, horizon 61\n", + "adding: mem time139, current time 199, horizon 60\n", + "adding: mem time140, current time 199, horizon 59\n", + "adding: mem time141, current time 199, horizon 58\n", + "adding: mem time142, current time 199, horizon 57\n", + "adding: mem time143, current time 199, horizon 56\n", + "adding: mem time144, current time 199, horizon 55\n", + "adding: mem time145, current time 199, horizon 54\n", + "adding: mem time146, current time 199, horizon 53\n", + "adding: mem time147, current time 199, horizon 52\n", + "adding: mem time148, current time 199, horizon 51\n", + "adding: mem time149, current time 199, horizon 50\n", + "adding: mem time150, current time 199, horizon 49\n", + "adding: mem time151, current time 199, horizon 48\n", + "adding: mem time152, current time 199, horizon 47\n", + "adding: mem time153, current time 199, horizon 46\n", + "adding: mem time154, current time 199, horizon 45\n", + "adding: mem time155, current time 199, horizon 44\n", + "adding: mem time156, current time 199, horizon 43\n", + "adding: mem time157, current time 199, horizon 42\n", + "adding: mem time158, current time 199, horizon 41\n", + "adding: mem time159, current time 199, horizon 40\n", + "adding: mem time160, current time 199, horizon 39\n", + "adding: mem time161, current time 199, horizon 38\n", + "adding: mem time162, current time 199, horizon 37\n", + "adding: mem time163, current time 199, horizon 36\n", + "adding: mem time164, current time 199, horizon 35\n", + "adding: mem time165, current time 199, horizon 34\n", + "adding: mem time166, current time 199, horizon 33\n", + "adding: mem time167, current time 199, horizon 32\n", + "adding: mem time168, current time 199, horizon 31\n", + "adding: mem time169, current time 199, horizon 30\n", + "adding: mem time170, current time 199, horizon 29\n", + "adding: mem time171, current time 199, horizon 28\n", + "adding: mem time172, current time 199, horizon 27\n", + "adding: mem time173, current time 199, horizon 26\n", + "adding: mem time174, current time 199, horizon 25\n", + "adding: mem time175, current time 199, horizon 24\n", + "adding: mem time176, current time 199, horizon 23\n", + "adding: mem time177, current time 199, horizon 22\n", + "adding: mem time178, current time 199, horizon 21\n", + "adding: mem time179, current time 199, horizon 20\n", + "adding: mem time180, current time 199, horizon 19\n", + "adding: mem time181, current time 199, horizon 18\n", + "adding: mem time182, current time 199, horizon 17\n", + "adding: mem time183, current time 199, horizon 16\n", + "adding: mem time184, current time 199, horizon 15\n", + "adding: mem time185, current time 199, horizon 14\n", + "adding: mem time186, current time 199, horizon 13\n", + "adding: mem time187, current time 199, horizon 12\n", + "adding: mem time188, current time 199, horizon 11\n", + "adding: mem time189, current time 199, horizon 10\n", + "adding: mem time190, current time 199, horizon 9\n", + "adding: mem time191, current time 199, horizon 8\n", + "adding: mem time192, current time 199, horizon 7\n", + "adding: mem time193, current time 199, horizon 6\n", + "adding: mem time194, current time 199, horizon 5\n", + "adding: mem time195, current time 199, horizon 4\n", + "adding: mem time196, current time 199, horizon 3\n", + "adding: mem time197, current time 199, horizon 2\n", + "adding: mem time198, current time 199, horizon 1\n", + "adding: mem time200, current time 201, horizon 1\n", + "adding: mem time200, current time 202, horizon 2\n", + "adding: mem time201, current time 202, horizon 1\n", + "adding: mem time200, current time 203, horizon 3\n", + "adding: mem time201, current time 203, horizon 2\n", + "adding: mem time202, current time 203, horizon 1\n", + "adding: mem time200, current time 204, horizon 4\n", + "adding: mem time201, current time 204, horizon 3\n", + "adding: mem time202, current time 204, horizon 2\n", + "adding: mem time203, current time 204, horizon 1\n", + "adding: mem time200, current time 205, horizon 5\n", + "adding: mem time201, current time 205, horizon 4\n", + "adding: mem time202, current time 205, horizon 3\n", + "adding: mem time203, current time 205, horizon 2\n", + "adding: mem time204, current time 205, horizon 1\n", + "adding: mem time200, current time 206, horizon 6\n", + "adding: mem time201, current time 206, horizon 5\n", + "adding: mem time202, current time 206, horizon 4\n", + "adding: mem time203, current time 206, horizon 3\n", + "adding: mem time204, current time 206, horizon 2\n", + "adding: mem time205, current time 206, horizon 1\n", + "adding: mem time200, current time 207, horizon 7\n", + "adding: mem time201, current time 207, horizon 6\n", + "adding: mem time202, current time 207, horizon 5\n", + "adding: mem time203, current time 207, horizon 4\n", + "adding: mem time204, current time 207, horizon 3\n", + "adding: mem time205, current time 207, horizon 2\n", + "adding: mem time206, current time 207, horizon 1\n", + "adding: mem time200, current time 208, horizon 8\n", + "adding: mem time201, current time 208, horizon 7\n", + "adding: mem time202, current time 208, horizon 6\n", + "adding: mem time203, current time 208, horizon 5\n", + "adding: mem time204, current time 208, horizon 4\n", + "adding: mem time205, current time 208, horizon 3\n", + "adding: mem time206, current time 208, horizon 2\n", + "adding: mem time207, current time 208, horizon 1\n", + "adding: mem time200, current time 209, horizon 9\n", + "adding: mem time201, current time 209, horizon 8\n", + "adding: mem time202, current time 209, horizon 7\n", + "adding: mem time203, current time 209, horizon 6\n", + "adding: mem time204, current time 209, horizon 5\n", + "adding: mem time205, current time 209, horizon 4\n", + "adding: mem time206, current time 209, horizon 3\n", + "adding: mem time207, current time 209, horizon 2\n", + "adding: mem time208, current time 209, horizon 1\n", + "adding: mem time200, current time 210, horizon 10\n", + "adding: mem time201, current time 210, horizon 9\n", + "adding: mem time202, current time 210, horizon 8\n", + "adding: mem time203, current time 210, horizon 7\n", + "adding: mem time204, current time 210, horizon 6\n", + "adding: mem time205, current time 210, horizon 5\n", + "adding: mem time206, current time 210, horizon 4\n", + "adding: mem time207, current time 210, horizon 3\n", + "adding: mem time208, current time 210, horizon 2\n", + "adding: mem time209, current time 210, horizon 1\n", + "adding: mem time200, current time 211, horizon 11\n", + "adding: mem time201, current time 211, horizon 10\n", + "adding: mem time202, current time 211, horizon 9\n", + "adding: mem time203, current time 211, horizon 8\n", + "adding: mem time204, current time 211, horizon 7\n", + "adding: mem time205, current time 211, horizon 6\n", + "adding: mem time206, current time 211, horizon 5\n", + "adding: mem time207, current time 211, horizon 4\n", + "adding: mem time208, current time 211, horizon 3\n", + "adding: mem time209, current time 211, horizon 2\n", + "adding: mem time210, current time 211, horizon 1\n", + "adding: mem time200, current time 212, horizon 12\n", + "adding: mem time201, current time 212, horizon 11\n", + "adding: mem time202, current time 212, horizon 10\n", + "adding: mem time203, current time 212, horizon 9\n", + "adding: mem time204, current time 212, horizon 8\n", + "adding: mem time205, current time 212, horizon 7\n", + "adding: mem time206, current time 212, horizon 6\n", + "adding: mem time207, current time 212, horizon 5\n", + "adding: mem time208, current time 212, horizon 4\n", + "adding: mem time209, current time 212, horizon 3\n", + "adding: mem time210, current time 212, horizon 2\n", + "adding: mem time211, current time 212, horizon 1\n", + "adding: mem time200, current time 213, horizon 13\n", + "adding: mem time201, current time 213, horizon 12\n", + "adding: mem time202, current time 213, horizon 11\n", + "adding: mem time203, current time 213, horizon 10\n", + "adding: mem time204, current time 213, horizon 9\n", + "adding: mem time205, current time 213, horizon 8\n", + "adding: mem time206, current time 213, horizon 7\n", + "adding: mem time207, current time 213, horizon 6\n", + "adding: mem time208, current time 213, horizon 5\n", + "adding: mem time209, current time 213, horizon 4\n", + "adding: mem time210, current time 213, horizon 3\n", + "adding: mem time211, current time 213, horizon 2\n", + "adding: mem time212, current time 213, horizon 1\n", + "adding: mem time200, current time 214, horizon 14\n", + "adding: mem time201, current time 214, horizon 13\n", + "adding: mem time202, current time 214, horizon 12\n", + "adding: mem time203, current time 214, horizon 11\n", + "adding: mem time204, current time 214, horizon 10\n", + "adding: mem time205, current time 214, horizon 9\n", + "adding: mem time206, current time 214, horizon 8\n", + "adding: mem time207, current time 214, horizon 7\n", + "adding: mem time208, current time 214, horizon 6\n", + "adding: mem time209, current time 214, horizon 5\n", + "adding: mem time210, current time 214, horizon 4\n", + "adding: mem time211, current time 214, horizon 3\n", + "adding: mem time212, current time 214, horizon 2\n", + "adding: mem time213, current time 214, horizon 1\n", + "adding: mem time200, current time 215, horizon 15\n", + "adding: mem time201, current time 215, horizon 14\n", + "adding: mem time202, current time 215, horizon 13\n", + "adding: mem time203, current time 215, horizon 12\n", + "adding: mem time204, current time 215, horizon 11\n", + "adding: mem time205, current time 215, horizon 10\n", + "adding: mem time206, current time 215, horizon 9\n", + "adding: mem time207, current time 215, horizon 8\n", + "adding: mem time208, current time 215, horizon 7\n", + "adding: mem time209, current time 215, horizon 6\n", + "adding: mem time210, current time 215, horizon 5\n", + "adding: mem time211, current time 215, horizon 4\n", + "adding: mem time212, current time 215, horizon 3\n", + "adding: mem time213, current time 215, horizon 2\n", + "adding: mem time214, current time 215, horizon 1\n", + "adding: mem time200, current time 216, horizon 16\n", + "adding: mem time201, current time 216, horizon 15\n", + "adding: mem time202, current time 216, horizon 14\n", + "adding: mem time203, current time 216, horizon 13\n", + "adding: mem time204, current time 216, horizon 12\n", + "adding: mem time205, current time 216, horizon 11\n", + "adding: mem time206, current time 216, horizon 10\n", + "adding: mem time207, current time 216, horizon 9\n", + "adding: mem time208, current time 216, horizon 8\n", + "adding: mem time209, current time 216, horizon 7\n", + "adding: mem time210, current time 216, horizon 6\n", + "adding: mem time211, current time 216, horizon 5\n", + "adding: mem time212, current time 216, horizon 4\n", + "adding: mem time213, current time 216, horizon 3\n", + "adding: mem time214, current time 216, horizon 2\n", + "adding: mem time215, current time 216, horizon 1\n", + "adding: mem time200, current time 217, horizon 17\n", + "adding: mem time201, current time 217, horizon 16\n", + "adding: mem time202, current time 217, horizon 15\n", + "adding: mem time203, current time 217, horizon 14\n", + "adding: mem time204, current time 217, horizon 13\n", + "adding: mem time205, current time 217, horizon 12\n", + "adding: mem time206, current time 217, horizon 11\n", + "adding: mem time207, current time 217, horizon 10\n", + "adding: mem time208, current time 217, horizon 9\n", + "adding: mem time209, current time 217, horizon 8\n", + "adding: mem time210, current time 217, horizon 7\n", + "adding: mem time211, current time 217, horizon 6\n", + "adding: mem time212, current time 217, horizon 5\n", + "adding: mem time213, current time 217, horizon 4\n", + "adding: mem time214, current time 217, horizon 3\n", + "adding: mem time215, current time 217, horizon 2\n", + "adding: mem time216, current time 217, horizon 1\n", + "adding: mem time200, current time 218, horizon 18\n", + "adding: mem time201, current time 218, horizon 17\n", + "adding: mem time202, current time 218, horizon 16\n", + "adding: mem time203, current time 218, horizon 15\n", + "adding: mem time204, current time 218, horizon 14\n", + "adding: mem time205, current time 218, horizon 13\n", + "adding: mem time206, current time 218, horizon 12\n", + "adding: mem time207, current time 218, horizon 11\n", + "adding: mem time208, current time 218, horizon 10\n", + "adding: mem time209, current time 218, horizon 9\n", + "adding: mem time210, current time 218, horizon 8\n", + "adding: mem time211, current time 218, horizon 7\n", + "adding: mem time212, current time 218, horizon 6\n", + "adding: mem time213, current time 218, horizon 5\n", + "adding: mem time214, current time 218, horizon 4\n", + "adding: mem time215, current time 218, horizon 3\n", + "adding: mem time216, current time 218, horizon 2\n", + "adding: mem time217, current time 218, horizon 1\n", + "adding: mem time200, current time 219, horizon 19\n", + "adding: mem time201, current time 219, horizon 18\n", + "adding: mem time202, current time 219, horizon 17\n", + "adding: mem time203, current time 219, horizon 16\n", + "adding: mem time204, current time 219, horizon 15\n", + "adding: mem time205, current time 219, horizon 14\n", + "adding: mem time206, current time 219, horizon 13\n", + "adding: mem time207, current time 219, horizon 12\n", + "adding: mem time208, current time 219, horizon 11\n", + "adding: mem time209, current time 219, horizon 10\n", + "adding: mem time210, current time 219, horizon 9\n", + "adding: mem time211, current time 219, horizon 8\n", + "adding: mem time212, current time 219, horizon 7\n", + "adding: mem time213, current time 219, horizon 6\n", + "adding: mem time214, current time 219, horizon 5\n", + "adding: mem time215, current time 219, horizon 4\n", + "adding: mem time216, current time 219, horizon 3\n", + "adding: mem time217, current time 219, horizon 2\n", + "adding: mem time218, current time 219, horizon 1\n", + "adding: mem time200, current time 220, horizon 20\n", + "adding: mem time201, current time 220, horizon 19\n", + "adding: mem time202, current time 220, horizon 18\n", + "adding: mem time203, current time 220, horizon 17\n", + "adding: mem time204, current time 220, horizon 16\n", + "adding: mem time205, current time 220, horizon 15\n", + "adding: mem time206, current time 220, horizon 14\n", + "adding: mem time207, current time 220, horizon 13\n", + "adding: mem time208, current time 220, horizon 12\n", + "adding: mem time209, current time 220, horizon 11\n", + "adding: mem time210, current time 220, horizon 10\n", + "adding: mem time211, current time 220, horizon 9\n", + "adding: mem time212, current time 220, horizon 8\n", + "adding: mem time213, current time 220, horizon 7\n", + "adding: mem time214, current time 220, horizon 6\n", + "adding: mem time215, current time 220, horizon 5\n", + "adding: mem time216, current time 220, horizon 4\n", + "adding: mem time217, current time 220, horizon 3\n", + "adding: mem time218, current time 220, horizon 2\n", + "adding: mem time219, current time 220, horizon 1\n", + "adding: mem time200, current time 221, horizon 21\n", + "adding: mem time201, current time 221, horizon 20\n", + "adding: mem time202, current time 221, horizon 19\n", + "adding: mem time203, current time 221, horizon 18\n", + "adding: mem time204, current time 221, horizon 17\n", + "adding: mem time205, current time 221, horizon 16\n", + "adding: mem time206, current time 221, horizon 15\n", + "adding: mem time207, current time 221, horizon 14\n", + "adding: mem time208, current time 221, horizon 13\n", + "adding: mem time209, current time 221, horizon 12\n", + "adding: mem time210, current time 221, horizon 11\n", + "adding: mem time211, current time 221, horizon 10\n", + "adding: mem time212, current time 221, horizon 9\n", + "adding: mem time213, current time 221, horizon 8\n", + "adding: mem time214, current time 221, horizon 7\n", + "adding: mem time215, current time 221, horizon 6\n", + "adding: mem time216, current time 221, horizon 5\n", + "adding: mem time217, current time 221, horizon 4\n", + "adding: mem time218, current time 221, horizon 3\n", + "adding: mem time219, current time 221, horizon 2\n", + "adding: mem time220, current time 221, horizon 1\n", + "adding: mem time200, current time 222, horizon 22\n", + "adding: mem time201, current time 222, horizon 21\n", + "adding: mem time202, current time 222, horizon 20\n", + "adding: mem time203, current time 222, horizon 19\n", + "adding: mem time204, current time 222, horizon 18\n", + "adding: mem time205, current time 222, horizon 17\n", + "adding: mem time206, current time 222, horizon 16\n", + "adding: mem time207, current time 222, horizon 15\n", + "adding: mem time208, current time 222, horizon 14\n", + "adding: mem time209, current time 222, horizon 13\n", + "adding: mem time210, current time 222, horizon 12\n", + "adding: mem time211, current time 222, horizon 11\n", + "adding: mem time212, current time 222, horizon 10\n", + "adding: mem time213, current time 222, horizon 9\n", + "adding: mem time214, current time 222, horizon 8\n", + "adding: mem time215, current time 222, horizon 7\n", + "adding: mem time216, current time 222, horizon 6\n", + "adding: mem time217, current time 222, horizon 5\n", + "adding: mem time218, current time 222, horizon 4\n", + "adding: mem time219, current time 222, horizon 3\n", + "adding: mem time220, current time 222, horizon 2\n", + "adding: mem time221, current time 222, horizon 1\n", + "adding: mem time200, current time 223, horizon 23\n", + "adding: mem time201, current time 223, horizon 22\n", + "adding: mem time202, current time 223, horizon 21\n", + "adding: mem time203, current time 223, horizon 20\n", + "adding: mem time204, current time 223, horizon 19\n", + "adding: mem time205, current time 223, horizon 18\n", + "adding: mem time206, current time 223, horizon 17\n", + "adding: mem time207, current time 223, horizon 16\n", + "adding: mem time208, current time 223, horizon 15\n", + "adding: mem time209, current time 223, horizon 14\n", + "adding: mem time210, current time 223, horizon 13\n", + "adding: mem time211, current time 223, horizon 12\n", + "adding: mem time212, current time 223, horizon 11\n", + "adding: mem time213, current time 223, horizon 10\n", + "adding: mem time214, current time 223, horizon 9\n", + "adding: mem time215, current time 223, horizon 8\n", + "adding: mem time216, current time 223, horizon 7\n", + "adding: mem time217, current time 223, horizon 6\n", + "adding: mem time218, current time 223, horizon 5\n", + "adding: mem time219, current time 223, horizon 4\n", + "adding: mem time220, current time 223, horizon 3\n", + "adding: mem time221, current time 223, horizon 2\n", + "adding: mem time222, current time 223, horizon 1\n", + "adding: mem time200, current time 224, horizon 24\n", + "adding: mem time201, current time 224, horizon 23\n", + "adding: mem time202, current time 224, horizon 22\n", + "adding: mem time203, current time 224, horizon 21\n", + "adding: mem time204, current time 224, horizon 20\n", + "adding: mem time205, current time 224, horizon 19\n", + "adding: mem time206, current time 224, horizon 18\n", + "adding: mem time207, current time 224, horizon 17\n", + "adding: mem time208, current time 224, horizon 16\n", + "adding: mem time209, current time 224, horizon 15\n", + "adding: mem time210, current time 224, horizon 14\n", + "adding: mem time211, current time 224, horizon 13\n", + "adding: mem time212, current time 224, horizon 12\n", + "adding: mem time213, current time 224, horizon 11\n", + "adding: mem time214, current time 224, horizon 10\n", + "adding: mem time215, current time 224, horizon 9\n", + "adding: mem time216, current time 224, horizon 8\n", + "adding: mem time217, current time 224, horizon 7\n", + "adding: mem time218, current time 224, horizon 6\n", + "adding: mem time219, current time 224, horizon 5\n", + "adding: mem time220, current time 224, horizon 4\n", + "adding: mem time221, current time 224, horizon 3\n", + "adding: mem time222, current time 224, horizon 2\n", + "adding: mem time223, current time 224, horizon 1\n", + "adding: mem time200, current time 225, horizon 25\n", + "adding: mem time201, current time 225, horizon 24\n", + "adding: mem time202, current time 225, horizon 23\n", + "adding: mem time203, current time 225, horizon 22\n", + "adding: mem time204, current time 225, horizon 21\n", + "adding: mem time205, current time 225, horizon 20\n", + "adding: mem time206, current time 225, horizon 19\n", + "adding: mem time207, current time 225, horizon 18\n", + "adding: mem time208, current time 225, horizon 17\n", + "adding: mem time209, current time 225, horizon 16\n", + "adding: mem time210, current time 225, horizon 15\n", + "adding: mem time211, current time 225, horizon 14\n", + "adding: mem time212, current time 225, horizon 13\n", + "adding: mem time213, current time 225, horizon 12\n", + "adding: mem time214, current time 225, horizon 11\n", + "adding: mem time215, current time 225, horizon 10\n", + "adding: mem time216, current time 225, horizon 9\n", + "adding: mem time217, current time 225, horizon 8\n", + "adding: mem time218, current time 225, horizon 7\n", + "adding: mem time219, current time 225, horizon 6\n", + "adding: mem time220, current time 225, horizon 5\n", + "adding: mem time221, current time 225, horizon 4\n", + "adding: mem time222, current time 225, horizon 3\n", + "adding: mem time223, current time 225, horizon 2\n", + "adding: mem time224, current time 225, horizon 1\n", + "adding: mem time200, current time 226, horizon 26\n", + "adding: mem time201, current time 226, horizon 25\n", + "adding: mem time202, current time 226, horizon 24\n", + "adding: mem time203, current time 226, horizon 23\n", + "adding: mem time204, current time 226, horizon 22\n", + "adding: mem time205, current time 226, horizon 21\n", + "adding: mem time206, current time 226, horizon 20\n", + "adding: mem time207, current time 226, horizon 19\n", + "adding: mem time208, current time 226, horizon 18\n", + "adding: mem time209, current time 226, horizon 17\n", + "adding: mem time210, current time 226, horizon 16\n", + "adding: mem time211, current time 226, horizon 15\n", + "adding: mem time212, current time 226, horizon 14\n", + "adding: mem time213, current time 226, horizon 13\n", + "adding: mem time214, current time 226, horizon 12\n", + "adding: mem time215, current time 226, horizon 11\n", + "adding: mem time216, current time 226, horizon 10\n", + "adding: mem time217, current time 226, horizon 9\n", + "adding: mem time218, current time 226, horizon 8\n", + "adding: mem time219, current time 226, horizon 7\n", + "adding: mem time220, current time 226, horizon 6\n", + "adding: mem time221, current time 226, horizon 5\n", + "adding: mem time222, current time 226, horizon 4\n", + "adding: mem time223, current time 226, horizon 3\n", + "adding: mem time224, current time 226, horizon 2\n", + "adding: mem time225, current time 226, horizon 1\n", + "adding: mem time200, current time 227, horizon 27\n", + "adding: mem time201, current time 227, horizon 26\n", + "adding: mem time202, current time 227, horizon 25\n", + "adding: mem time203, current time 227, horizon 24\n", + "adding: mem time204, current time 227, horizon 23\n", + "adding: mem time205, current time 227, horizon 22\n", + "adding: mem time206, current time 227, horizon 21\n", + "adding: mem time207, current time 227, horizon 20\n", + "adding: mem time208, current time 227, horizon 19\n", + "adding: mem time209, current time 227, horizon 18\n", + "adding: mem time210, current time 227, horizon 17\n", + "adding: mem time211, current time 227, horizon 16\n", + "adding: mem time212, current time 227, horizon 15\n", + "adding: mem time213, current time 227, horizon 14\n", + "adding: mem time214, current time 227, horizon 13\n", + "adding: mem time215, current time 227, horizon 12\n", + "adding: mem time216, current time 227, horizon 11\n", + "adding: mem time217, current time 227, horizon 10\n", + "adding: mem time218, current time 227, horizon 9\n", + "adding: mem time219, current time 227, horizon 8\n", + "adding: mem time220, current time 227, horizon 7\n", + "adding: mem time221, current time 227, horizon 6\n", + "adding: mem time222, current time 227, horizon 5\n", + "adding: mem time223, current time 227, horizon 4\n", + "adding: mem time224, current time 227, horizon 3\n", + "adding: mem time225, current time 227, horizon 2\n", + "adding: mem time226, current time 227, horizon 1\n", + "adding: mem time200, current time 228, horizon 28\n", + "adding: mem time201, current time 228, horizon 27\n", + "adding: mem time202, current time 228, horizon 26\n", + "adding: mem time203, current time 228, horizon 25\n", + "adding: mem time204, current time 228, horizon 24\n", + "adding: mem time205, current time 228, horizon 23\n", + "adding: mem time206, current time 228, horizon 22\n", + "adding: mem time207, current time 228, horizon 21\n", + "adding: mem time208, current time 228, horizon 20\n", + "adding: mem time209, current time 228, horizon 19\n", + "adding: mem time210, current time 228, horizon 18\n", + "adding: mem time211, current time 228, horizon 17\n", + "adding: mem time212, current time 228, horizon 16\n", + "adding: mem time213, current time 228, horizon 15\n", + "adding: mem time214, current time 228, horizon 14\n", + "adding: mem time215, current time 228, horizon 13\n", + "adding: mem time216, current time 228, horizon 12\n", + "adding: mem time217, current time 228, horizon 11\n", + "adding: mem time218, current time 228, horizon 10\n", + "adding: mem time219, current time 228, horizon 9\n", + "adding: mem time220, current time 228, horizon 8\n", + "adding: mem time221, current time 228, horizon 7\n", + "adding: mem time222, current time 228, horizon 6\n", + "adding: mem time223, current time 228, horizon 5\n", + "adding: mem time224, current time 228, horizon 4\n", + "adding: mem time225, current time 228, horizon 3\n", + "adding: mem time226, current time 228, horizon 2\n", + "adding: mem time227, current time 228, horizon 1\n", + "adding: mem time200, current time 229, horizon 29\n", + "adding: mem time201, current time 229, horizon 28\n", + "adding: mem time202, current time 229, horizon 27\n", + "adding: mem time203, current time 229, horizon 26\n", + "adding: mem time204, current time 229, horizon 25\n", + "adding: mem time205, current time 229, horizon 24\n", + "adding: mem time206, current time 229, horizon 23\n", + "adding: mem time207, current time 229, horizon 22\n", + "adding: mem time208, current time 229, horizon 21\n", + "adding: mem time209, current time 229, horizon 20\n", + "adding: mem time210, current time 229, horizon 19\n", + "adding: mem time211, current time 229, horizon 18\n", + "adding: mem time212, current time 229, horizon 17\n", + "adding: mem time213, current time 229, horizon 16\n", + "adding: mem time214, current time 229, horizon 15\n", + "adding: mem time215, current time 229, horizon 14\n", + "adding: mem time216, current time 229, horizon 13\n", + "adding: mem time217, current time 229, horizon 12\n", + "adding: mem time218, current time 229, horizon 11\n", + "adding: mem time219, current time 229, horizon 10\n", + "adding: mem time220, current time 229, horizon 9\n", + "adding: mem time221, current time 229, horizon 8\n", + "adding: mem time222, current time 229, horizon 7\n", + "adding: mem time223, current time 229, horizon 6\n", + "adding: mem time224, current time 229, horizon 5\n", + "adding: mem time225, current time 229, horizon 4\n", + "adding: mem time226, current time 229, horizon 3\n", + "adding: mem time227, current time 229, horizon 2\n", + "adding: mem time228, current time 229, horizon 1\n", + "adding: mem time200, current time 230, horizon 30\n", + "adding: mem time201, current time 230, horizon 29\n", + "adding: mem time202, current time 230, horizon 28\n", + "adding: mem time203, current time 230, horizon 27\n", + "adding: mem time204, current time 230, horizon 26\n", + "adding: mem time205, current time 230, horizon 25\n", + "adding: mem time206, current time 230, horizon 24\n", + "adding: mem time207, current time 230, horizon 23\n", + "adding: mem time208, current time 230, horizon 22\n", + "adding: mem time209, current time 230, horizon 21\n", + "adding: mem time210, current time 230, horizon 20\n", + "adding: mem time211, current time 230, horizon 19\n", + "adding: mem time212, current time 230, horizon 18\n", + "adding: mem time213, current time 230, horizon 17\n", + "adding: mem time214, current time 230, horizon 16\n", + "adding: mem time215, current time 230, horizon 15\n", + "adding: mem time216, current time 230, horizon 14\n", + "adding: mem time217, current time 230, horizon 13\n", + "adding: mem time218, current time 230, horizon 12\n", + "adding: mem time219, current time 230, horizon 11\n", + "adding: mem time220, current time 230, horizon 10\n", + "adding: mem time221, current time 230, horizon 9\n", + "adding: mem time222, current time 230, horizon 8\n", + "adding: mem time223, current time 230, horizon 7\n", + "adding: mem time224, current time 230, horizon 6\n", + "adding: mem time225, current time 230, horizon 5\n", + "adding: mem time226, current time 230, horizon 4\n", + "adding: mem time227, current time 230, horizon 3\n", + "adding: mem time228, current time 230, horizon 2\n", + "adding: mem time229, current time 230, horizon 1\n", + "adding: mem time200, current time 231, horizon 31\n", + "adding: mem time201, current time 231, horizon 30\n", + "adding: mem time202, current time 231, horizon 29\n", + "adding: mem time203, current time 231, horizon 28\n", + "adding: mem time204, current time 231, horizon 27\n", + "adding: mem time205, current time 231, horizon 26\n", + "adding: mem time206, current time 231, horizon 25\n", + "adding: mem time207, current time 231, horizon 24\n", + "adding: mem time208, current time 231, horizon 23\n", + "adding: mem time209, current time 231, horizon 22\n", + "adding: mem time210, current time 231, horizon 21\n", + "adding: mem time211, current time 231, horizon 20\n", + "adding: mem time212, current time 231, horizon 19\n", + "adding: mem time213, current time 231, horizon 18\n", + "adding: mem time214, current time 231, horizon 17\n", + "adding: mem time215, current time 231, horizon 16\n", + "adding: mem time216, current time 231, horizon 15\n", + "adding: mem time217, current time 231, horizon 14\n", + "adding: mem time218, current time 231, horizon 13\n", + "adding: mem time219, current time 231, horizon 12\n", + "adding: mem time220, current time 231, horizon 11\n", + "adding: mem time221, current time 231, horizon 10\n", + "adding: mem time222, current time 231, horizon 9\n", + "adding: mem time223, current time 231, horizon 8\n", + "adding: mem time224, current time 231, horizon 7\n", + "adding: mem time225, current time 231, horizon 6\n", + "adding: mem time226, current time 231, horizon 5\n", + "adding: mem time227, current time 231, horizon 4\n", + "adding: mem time228, current time 231, horizon 3\n", + "adding: mem time229, current time 231, horizon 2\n", + "adding: mem time230, current time 231, horizon 1\n", + "adding: mem time200, current time 232, horizon 32\n", + "adding: mem time201, current time 232, horizon 31\n", + "adding: mem time202, current time 232, horizon 30\n", + "adding: mem time203, current time 232, horizon 29\n", + "adding: mem time204, current time 232, horizon 28\n", + "adding: mem time205, current time 232, horizon 27\n", + "adding: mem time206, current time 232, horizon 26\n", + "adding: mem time207, current time 232, horizon 25\n", + "adding: mem time208, current time 232, horizon 24\n", + "adding: mem time209, current time 232, horizon 23\n", + "adding: mem time210, current time 232, horizon 22\n", + "adding: mem time211, current time 232, horizon 21\n", + "adding: mem time212, current time 232, horizon 20\n", + "adding: mem time213, current time 232, horizon 19\n", + "adding: mem time214, current time 232, horizon 18\n", + "adding: mem time215, current time 232, horizon 17\n", + "adding: mem time216, current time 232, horizon 16\n", + "adding: mem time217, current time 232, horizon 15\n", + "adding: mem time218, current time 232, horizon 14\n", + "adding: mem time219, current time 232, horizon 13\n", + "adding: mem time220, current time 232, horizon 12\n", + "adding: mem time221, current time 232, horizon 11\n", + "adding: mem time222, current time 232, horizon 10\n", + "adding: mem time223, current time 232, horizon 9\n", + "adding: mem time224, current time 232, horizon 8\n", + "adding: mem time225, current time 232, horizon 7\n", + "adding: mem time226, current time 232, horizon 6\n", + "adding: mem time227, current time 232, horizon 5\n", + "adding: mem time228, current time 232, horizon 4\n", + "adding: mem time229, current time 232, horizon 3\n", + "adding: mem time230, current time 232, horizon 2\n", + "adding: mem time231, current time 232, horizon 1\n", + "adding: mem time200, current time 233, horizon 33\n", + "adding: mem time201, current time 233, horizon 32\n", + "adding: mem time202, current time 233, horizon 31\n", + "adding: mem time203, current time 233, horizon 30\n", + "adding: mem time204, current time 233, horizon 29\n", + "adding: mem time205, current time 233, horizon 28\n", + "adding: mem time206, current time 233, horizon 27\n", + "adding: mem time207, current time 233, horizon 26\n", + "adding: mem time208, current time 233, horizon 25\n", + "adding: mem time209, current time 233, horizon 24\n", + "adding: mem time210, current time 233, horizon 23\n", + "adding: mem time211, current time 233, horizon 22\n", + "adding: mem time212, current time 233, horizon 21\n", + "adding: mem time213, current time 233, horizon 20\n", + "adding: mem time214, current time 233, horizon 19\n", + "adding: mem time215, current time 233, horizon 18\n", + "adding: mem time216, current time 233, horizon 17\n", + "adding: mem time217, current time 233, horizon 16\n", + "adding: mem time218, current time 233, horizon 15\n", + "adding: mem time219, current time 233, horizon 14\n", + "adding: mem time220, current time 233, horizon 13\n", + "adding: mem time221, current time 233, horizon 12\n", + "adding: mem time222, current time 233, horizon 11\n", + "adding: mem time223, current time 233, horizon 10\n", + "adding: mem time224, current time 233, horizon 9\n", + "adding: mem time225, current time 233, horizon 8\n", + "adding: mem time226, current time 233, horizon 7\n", + "adding: mem time227, current time 233, horizon 6\n", + "adding: mem time228, current time 233, horizon 5\n", + "adding: mem time229, current time 233, horizon 4\n", + "adding: mem time230, current time 233, horizon 3\n", + "adding: mem time231, current time 233, horizon 2\n", + "adding: mem time232, current time 233, horizon 1\n", + "adding: mem time200, current time 234, horizon 34\n", + "adding: mem time201, current time 234, horizon 33\n", + "adding: mem time202, current time 234, horizon 32\n", + "adding: mem time203, current time 234, horizon 31\n", + "adding: mem time204, current time 234, horizon 30\n", + "adding: mem time205, current time 234, horizon 29\n", + "adding: mem time206, current time 234, horizon 28\n", + "adding: mem time207, current time 234, horizon 27\n", + "adding: mem time208, current time 234, horizon 26\n", + "adding: mem time209, current time 234, horizon 25\n", + "adding: mem time210, current time 234, horizon 24\n", + "adding: mem time211, current time 234, horizon 23\n", + "adding: mem time212, current time 234, horizon 22\n", + "adding: mem time213, current time 234, horizon 21\n", + "adding: mem time214, current time 234, horizon 20\n", + "adding: mem time215, current time 234, horizon 19\n", + "adding: mem time216, current time 234, horizon 18\n", + "adding: mem time217, current time 234, horizon 17\n", + "adding: mem time218, current time 234, horizon 16\n", + "adding: mem time219, current time 234, horizon 15\n", + "adding: mem time220, current time 234, horizon 14\n", + "adding: mem time221, current time 234, horizon 13\n", + "adding: mem time222, current time 234, horizon 12\n", + "adding: mem time223, current time 234, horizon 11\n", + "adding: mem time224, current time 234, horizon 10\n", + "adding: mem time225, current time 234, horizon 9\n", + "adding: mem time226, current time 234, horizon 8\n", + "adding: mem time227, current time 234, horizon 7\n", + "adding: mem time228, current time 234, horizon 6\n", + "adding: mem time229, current time 234, horizon 5\n", + "adding: mem time230, current time 234, horizon 4\n", + "adding: mem time231, current time 234, horizon 3\n", + "adding: mem time232, current time 234, horizon 2\n", + "adding: mem time233, current time 234, horizon 1\n", + "adding: mem time200, current time 235, horizon 35\n", + "adding: mem time201, current time 235, horizon 34\n", + "adding: mem time202, current time 235, horizon 33\n", + "adding: mem time203, current time 235, horizon 32\n", + "adding: mem time204, current time 235, horizon 31\n", + "adding: mem time205, current time 235, horizon 30\n", + "adding: mem time206, current time 235, horizon 29\n", + "adding: mem time207, current time 235, horizon 28\n", + "adding: mem time208, current time 235, horizon 27\n", + "adding: mem time209, current time 235, horizon 26\n", + "adding: mem time210, current time 235, horizon 25\n", + "adding: mem time211, current time 235, horizon 24\n", + "adding: mem time212, current time 235, horizon 23\n", + "adding: mem time213, current time 235, horizon 22\n", + "adding: mem time214, current time 235, horizon 21\n", + "adding: mem time215, current time 235, horizon 20\n", + "adding: mem time216, current time 235, horizon 19\n", + "adding: mem time217, current time 235, horizon 18\n", + "adding: mem time218, current time 235, horizon 17\n", + "adding: mem time219, current time 235, horizon 16\n", + "adding: mem time220, current time 235, horizon 15\n", + "adding: mem time221, current time 235, horizon 14\n", + "adding: mem time222, current time 235, horizon 13\n", + "adding: mem time223, current time 235, horizon 12\n", + "adding: mem time224, current time 235, horizon 11\n", + "adding: mem time225, current time 235, horizon 10\n", + "adding: mem time226, current time 235, horizon 9\n", + "adding: mem time227, current time 235, horizon 8\n", + "adding: mem time228, current time 235, horizon 7\n", + "adding: mem time229, current time 235, horizon 6\n", + "adding: mem time230, current time 235, horizon 5\n", + "adding: mem time231, current time 235, horizon 4\n", + "adding: mem time232, current time 235, horizon 3\n", + "adding: mem time233, current time 235, horizon 2\n", + "adding: mem time234, current time 235, horizon 1\n", + "adding: mem time200, current time 236, horizon 36\n", + "adding: mem time201, current time 236, horizon 35\n", + "adding: mem time202, current time 236, horizon 34\n", + "adding: mem time203, current time 236, horizon 33\n", + "adding: mem time204, current time 236, horizon 32\n", + "adding: mem time205, current time 236, horizon 31\n", + "adding: mem time206, current time 236, horizon 30\n", + "adding: mem time207, current time 236, horizon 29\n", + "adding: mem time208, current time 236, horizon 28\n", + "adding: mem time209, current time 236, horizon 27\n", + "adding: mem time210, current time 236, horizon 26\n", + "adding: mem time211, current time 236, horizon 25\n", + "adding: mem time212, current time 236, horizon 24\n", + "adding: mem time213, current time 236, horizon 23\n", + "adding: mem time214, current time 236, horizon 22\n", + "adding: mem time215, current time 236, horizon 21\n", + "adding: mem time216, current time 236, horizon 20\n", + "adding: mem time217, current time 236, horizon 19\n", + "adding: mem time218, current time 236, horizon 18\n", + "adding: mem time219, current time 236, horizon 17\n", + "adding: mem time220, current time 236, horizon 16\n", + "adding: mem time221, current time 236, horizon 15\n", + "adding: mem time222, current time 236, horizon 14\n", + "adding: mem time223, current time 236, horizon 13\n", + "adding: mem time224, current time 236, horizon 12\n", + "adding: mem time225, current time 236, horizon 11\n", + "adding: mem time226, current time 236, horizon 10\n", + "adding: mem time227, current time 236, horizon 9\n", + "adding: mem time228, current time 236, horizon 8\n", + "adding: mem time229, current time 236, horizon 7\n", + "adding: mem time230, current time 236, horizon 6\n", + "adding: mem time231, current time 236, horizon 5\n", + "adding: mem time232, current time 236, horizon 4\n", + "adding: mem time233, current time 236, horizon 3\n", + "adding: mem time234, current time 236, horizon 2\n", + "adding: mem time235, current time 236, horizon 1\n", + "adding: mem time200, current time 237, horizon 37\n", + "adding: mem time201, current time 237, horizon 36\n", + "adding: mem time202, current time 237, horizon 35\n", + "adding: mem time203, current time 237, horizon 34\n", + "adding: mem time204, current time 237, horizon 33\n", + "adding: mem time205, current time 237, horizon 32\n", + "adding: mem time206, current time 237, horizon 31\n", + "adding: mem time207, current time 237, horizon 30\n", + "adding: mem time208, current time 237, horizon 29\n", + "adding: mem time209, current time 237, horizon 28\n", + "adding: mem time210, current time 237, horizon 27\n", + "adding: mem time211, current time 237, horizon 26\n", + "adding: mem time212, current time 237, horizon 25\n", + "adding: mem time213, current time 237, horizon 24\n", + "adding: mem time214, current time 237, horizon 23\n", + "adding: mem time215, current time 237, horizon 22\n", + "adding: mem time216, current time 237, horizon 21\n", + "adding: mem time217, current time 237, horizon 20\n", + "adding: mem time218, current time 237, horizon 19\n", + "adding: mem time219, current time 237, horizon 18\n", + "adding: mem time220, current time 237, horizon 17\n", + "adding: mem time221, current time 237, horizon 16\n", + "adding: mem time222, current time 237, horizon 15\n", + "adding: mem time223, current time 237, horizon 14\n", + "adding: mem time224, current time 237, horizon 13\n", + "adding: mem time225, current time 237, horizon 12\n", + "adding: mem time226, current time 237, horizon 11\n", + "adding: mem time227, current time 237, horizon 10\n", + "adding: mem time228, current time 237, horizon 9\n", + "adding: mem time229, current time 237, horizon 8\n", + "adding: mem time230, current time 237, horizon 7\n", + "adding: mem time231, current time 237, horizon 6\n", + "adding: mem time232, current time 237, horizon 5\n", + "adding: mem time233, current time 237, horizon 4\n", + "adding: mem time234, current time 237, horizon 3\n", + "adding: mem time235, current time 237, horizon 2\n", + "adding: mem time236, current time 237, horizon 1\n", + "adding: mem time200, current time 238, horizon 38\n", + "adding: mem time201, current time 238, horizon 37\n", + "adding: mem time202, current time 238, horizon 36\n", + "adding: mem time203, current time 238, horizon 35\n", + "adding: mem time204, current time 238, horizon 34\n", + "adding: mem time205, current time 238, horizon 33\n", + "adding: mem time206, current time 238, horizon 32\n", + "adding: mem time207, current time 238, horizon 31\n", + "adding: mem time208, current time 238, horizon 30\n", + "adding: mem time209, current time 238, horizon 29\n", + "adding: mem time210, current time 238, horizon 28\n", + "adding: mem time211, current time 238, horizon 27\n", + "adding: mem time212, current time 238, horizon 26\n", + "adding: mem time213, current time 238, horizon 25\n", + "adding: mem time214, current time 238, horizon 24\n", + "adding: mem time215, current time 238, horizon 23\n", + "adding: mem time216, current time 238, horizon 22\n", + "adding: mem time217, current time 238, horizon 21\n", + "adding: mem time218, current time 238, horizon 20\n", + "adding: mem time219, current time 238, horizon 19\n", + "adding: mem time220, current time 238, horizon 18\n", + "adding: mem time221, current time 238, horizon 17\n", + "adding: mem time222, current time 238, horizon 16\n", + "adding: mem time223, current time 238, horizon 15\n", + "adding: mem time224, current time 238, horizon 14\n", + "adding: mem time225, current time 238, horizon 13\n", + "adding: mem time226, current time 238, horizon 12\n", + "adding: mem time227, current time 238, horizon 11\n", + "adding: mem time228, current time 238, horizon 10\n", + "adding: mem time229, current time 238, horizon 9\n", + "adding: mem time230, current time 238, horizon 8\n", + "adding: mem time231, current time 238, horizon 7\n", + "adding: mem time232, current time 238, horizon 6\n", + "adding: mem time233, current time 238, horizon 5\n", + "adding: mem time234, current time 238, horizon 4\n", + "adding: mem time235, current time 238, horizon 3\n", + "adding: mem time236, current time 238, horizon 2\n", + "adding: mem time237, current time 238, horizon 1\n", + "adding: mem time200, current time 239, horizon 39\n", + "adding: mem time201, current time 239, horizon 38\n", + "adding: mem time202, current time 239, horizon 37\n", + "adding: mem time203, current time 239, horizon 36\n", + "adding: mem time204, current time 239, horizon 35\n", + "adding: mem time205, current time 239, horizon 34\n", + "adding: mem time206, current time 239, horizon 33\n", + "adding: mem time207, current time 239, horizon 32\n", + "adding: mem time208, current time 239, horizon 31\n", + "adding: mem time209, current time 239, horizon 30\n", + "adding: mem time210, current time 239, horizon 29\n", + "adding: mem time211, current time 239, horizon 28\n", + "adding: mem time212, current time 239, horizon 27\n", + "adding: mem time213, current time 239, horizon 26\n", + "adding: mem time214, current time 239, horizon 25\n", + "adding: mem time215, current time 239, horizon 24\n", + "adding: mem time216, current time 239, horizon 23\n", + "adding: mem time217, current time 239, horizon 22\n", + "adding: mem time218, current time 239, horizon 21\n", + "adding: mem time219, current time 239, horizon 20\n", + "adding: mem time220, current time 239, horizon 19\n", + "adding: mem time221, current time 239, horizon 18\n", + "adding: mem time222, current time 239, horizon 17\n", + "adding: mem time223, current time 239, horizon 16\n", + "adding: mem time224, current time 239, horizon 15\n", + "adding: mem time225, current time 239, horizon 14\n", + "adding: mem time226, current time 239, horizon 13\n", + "adding: mem time227, current time 239, horizon 12\n", + "adding: mem time228, current time 239, horizon 11\n", + "adding: mem time229, current time 239, horizon 10\n", + "adding: mem time230, current time 239, horizon 9\n", + "adding: mem time231, current time 239, horizon 8\n", + "adding: mem time232, current time 239, horizon 7\n", + "adding: mem time233, current time 239, horizon 6\n", + "adding: mem time234, current time 239, horizon 5\n", + "adding: mem time235, current time 239, horizon 4\n", + "adding: mem time236, current time 239, horizon 3\n", + "adding: mem time237, current time 239, horizon 2\n", + "adding: mem time238, current time 239, horizon 1\n", + "adding: mem time200, current time 240, horizon 40\n", + "adding: mem time201, current time 240, horizon 39\n", + "adding: mem time202, current time 240, horizon 38\n", + "adding: mem time203, current time 240, horizon 37\n", + "adding: mem time204, current time 240, horizon 36\n", + "adding: mem time205, current time 240, horizon 35\n", + "adding: mem time206, current time 240, horizon 34\n", + "adding: mem time207, current time 240, horizon 33\n", + "adding: mem time208, current time 240, horizon 32\n", + "adding: mem time209, current time 240, horizon 31\n", + "adding: mem time210, current time 240, horizon 30\n", + "adding: mem time211, current time 240, horizon 29\n", + "adding: mem time212, current time 240, horizon 28\n", + "adding: mem time213, current time 240, horizon 27\n", + "adding: mem time214, current time 240, horizon 26\n", + "adding: mem time215, current time 240, horizon 25\n", + "adding: mem time216, current time 240, horizon 24\n", + "adding: mem time217, current time 240, horizon 23\n", + "adding: mem time218, current time 240, horizon 22\n", + "adding: mem time219, current time 240, horizon 21\n", + "adding: mem time220, current time 240, horizon 20\n", + "adding: mem time221, current time 240, horizon 19\n", + "adding: mem time222, current time 240, horizon 18\n", + "adding: mem time223, current time 240, horizon 17\n", + "adding: mem time224, current time 240, horizon 16\n", + "adding: mem time225, current time 240, horizon 15\n", + "adding: mem time226, current time 240, horizon 14\n", + "adding: mem time227, current time 240, horizon 13\n", + "adding: mem time228, current time 240, horizon 12\n", + "adding: mem time229, current time 240, horizon 11\n", + "adding: mem time230, current time 240, horizon 10\n", + "adding: mem time231, current time 240, horizon 9\n", + "adding: mem time232, current time 240, horizon 8\n", + "adding: mem time233, current time 240, horizon 7\n", + "adding: mem time234, current time 240, horizon 6\n", + "adding: mem time235, current time 240, horizon 5\n", + "adding: mem time236, current time 240, horizon 4\n", + "adding: mem time237, current time 240, horizon 3\n", + "adding: mem time238, current time 240, horizon 2\n", + "adding: mem time239, current time 240, horizon 1\n", + "adding: mem time200, current time 241, horizon 41\n", + "adding: mem time201, current time 241, horizon 40\n", + "adding: mem time202, current time 241, horizon 39\n", + "adding: mem time203, current time 241, horizon 38\n", + "adding: mem time204, current time 241, horizon 37\n", + "adding: mem time205, current time 241, horizon 36\n", + "adding: mem time206, current time 241, horizon 35\n", + "adding: mem time207, current time 241, horizon 34\n", + "adding: mem time208, current time 241, horizon 33\n", + "adding: mem time209, current time 241, horizon 32\n", + "adding: mem time210, current time 241, horizon 31\n", + "adding: mem time211, current time 241, horizon 30\n", + "adding: mem time212, current time 241, horizon 29\n", + "adding: mem time213, current time 241, horizon 28\n", + "adding: mem time214, current time 241, horizon 27\n", + "adding: mem time215, current time 241, horizon 26\n", + "adding: mem time216, current time 241, horizon 25\n", + "adding: mem time217, current time 241, horizon 24\n", + "adding: mem time218, current time 241, horizon 23\n", + "adding: mem time219, current time 241, horizon 22\n", + "adding: mem time220, current time 241, horizon 21\n", + "adding: mem time221, current time 241, horizon 20\n", + "adding: mem time222, current time 241, horizon 19\n", + "adding: mem time223, current time 241, horizon 18\n", + "adding: mem time224, current time 241, horizon 17\n", + "adding: mem time225, current time 241, horizon 16\n", + "adding: mem time226, current time 241, horizon 15\n", + "adding: mem time227, current time 241, horizon 14\n", + "adding: mem time228, current time 241, horizon 13\n", + "adding: mem time229, current time 241, horizon 12\n", + "adding: mem time230, current time 241, horizon 11\n", + "adding: mem time231, current time 241, horizon 10\n", + "adding: mem time232, current time 241, horizon 9\n", + "adding: mem time233, current time 241, horizon 8\n", + "adding: mem time234, current time 241, horizon 7\n", + "adding: mem time235, current time 241, horizon 6\n", + "adding: mem time236, current time 241, horizon 5\n", + "adding: mem time237, current time 241, horizon 4\n", + "adding: mem time238, current time 241, horizon 3\n", + "adding: mem time239, current time 241, horizon 2\n", + "adding: mem time240, current time 241, horizon 1\n", + "adding: mem time200, current time 242, horizon 42\n", + "adding: mem time201, current time 242, horizon 41\n", + "adding: mem time202, current time 242, horizon 40\n", + "adding: mem time203, current time 242, horizon 39\n", + "adding: mem time204, current time 242, horizon 38\n", + "adding: mem time205, current time 242, horizon 37\n", + "adding: mem time206, current time 242, horizon 36\n", + "adding: mem time207, current time 242, horizon 35\n", + "adding: mem time208, current time 242, horizon 34\n", + "adding: mem time209, current time 242, horizon 33\n", + "adding: mem time210, current time 242, horizon 32\n", + "adding: mem time211, current time 242, horizon 31\n", + "adding: mem time212, current time 242, horizon 30\n", + "adding: mem time213, current time 242, horizon 29\n", + "adding: mem time214, current time 242, horizon 28\n", + "adding: mem time215, current time 242, horizon 27\n", + "adding: mem time216, current time 242, horizon 26\n", + "adding: mem time217, current time 242, horizon 25\n", + "adding: mem time218, current time 242, horizon 24\n", + "adding: mem time219, current time 242, horizon 23\n", + "adding: mem time220, current time 242, horizon 22\n", + "adding: mem time221, current time 242, horizon 21\n", + "adding: mem time222, current time 242, horizon 20\n", + "adding: mem time223, current time 242, horizon 19\n", + "adding: mem time224, current time 242, horizon 18\n", + "adding: mem time225, current time 242, horizon 17\n", + "adding: mem time226, current time 242, horizon 16\n", + "adding: mem time227, current time 242, horizon 15\n", + "adding: mem time228, current time 242, horizon 14\n", + "adding: mem time229, current time 242, horizon 13\n", + "adding: mem time230, current time 242, horizon 12\n", + "adding: mem time231, current time 242, horizon 11\n", + "adding: mem time232, current time 242, horizon 10\n", + "adding: mem time233, current time 242, horizon 9\n", + "adding: mem time234, current time 242, horizon 8\n", + "adding: mem time235, current time 242, horizon 7\n", + "adding: mem time236, current time 242, horizon 6\n", + "adding: mem time237, current time 242, horizon 5\n", + "adding: mem time238, current time 242, horizon 4\n", + "adding: mem time239, current time 242, horizon 3\n", + "adding: mem time240, current time 242, horizon 2\n", + "adding: mem time241, current time 242, horizon 1\n", + "adding: mem time200, current time 243, horizon 43\n", + "adding: mem time201, current time 243, horizon 42\n", + "adding: mem time202, current time 243, horizon 41\n", + "adding: mem time203, current time 243, horizon 40\n", + "adding: mem time204, current time 243, horizon 39\n", + "adding: mem time205, current time 243, horizon 38\n", + "adding: mem time206, current time 243, horizon 37\n", + "adding: mem time207, current time 243, horizon 36\n", + "adding: mem time208, current time 243, horizon 35\n", + "adding: mem time209, current time 243, horizon 34\n", + "adding: mem time210, current time 243, horizon 33\n", + "adding: mem time211, current time 243, horizon 32\n", + "adding: mem time212, current time 243, horizon 31\n", + "adding: mem time213, current time 243, horizon 30\n", + "adding: mem time214, current time 243, horizon 29\n", + "adding: mem time215, current time 243, horizon 28\n", + "adding: mem time216, current time 243, horizon 27\n", + "adding: mem time217, current time 243, horizon 26\n", + "adding: mem time218, current time 243, horizon 25\n", + "adding: mem time219, current time 243, horizon 24\n", + "adding: mem time220, current time 243, horizon 23\n", + "adding: mem time221, current time 243, horizon 22\n", + "adding: mem time222, current time 243, horizon 21\n", + "adding: mem time223, current time 243, horizon 20\n", + "adding: mem time224, current time 243, horizon 19\n", + "adding: mem time225, current time 243, horizon 18\n", + "adding: mem time226, current time 243, horizon 17\n", + "adding: mem time227, current time 243, horizon 16\n", + "adding: mem time228, current time 243, horizon 15\n", + "adding: mem time229, current time 243, horizon 14\n", + "adding: mem time230, current time 243, horizon 13\n", + "adding: mem time231, current time 243, horizon 12\n", + "adding: mem time232, current time 243, horizon 11\n", + "adding: mem time233, current time 243, horizon 10\n", + "adding: mem time234, current time 243, horizon 9\n", + "adding: mem time235, current time 243, horizon 8\n", + "adding: mem time236, current time 243, horizon 7\n", + "adding: mem time237, current time 243, horizon 6\n", + "adding: mem time238, current time 243, horizon 5\n", + "adding: mem time239, current time 243, horizon 4\n", + "adding: mem time240, current time 243, horizon 3\n", + "adding: mem time241, current time 243, horizon 2\n", + "adding: mem time242, current time 243, horizon 1\n", + "adding: mem time200, current time 244, horizon 44\n", + "adding: mem time201, current time 244, horizon 43\n", + "adding: mem time202, current time 244, horizon 42\n", + "adding: mem time203, current time 244, horizon 41\n", + "adding: mem time204, current time 244, horizon 40\n", + "adding: mem time205, current time 244, horizon 39\n", + "adding: mem time206, current time 244, horizon 38\n", + "adding: mem time207, current time 244, horizon 37\n", + "adding: mem time208, current time 244, horizon 36\n", + "adding: mem time209, current time 244, horizon 35\n", + "adding: mem time210, current time 244, horizon 34\n", + "adding: mem time211, current time 244, horizon 33\n", + "adding: mem time212, current time 244, horizon 32\n", + "adding: mem time213, current time 244, horizon 31\n", + "adding: mem time214, current time 244, horizon 30\n", + "adding: mem time215, current time 244, horizon 29\n", + "adding: mem time216, current time 244, horizon 28\n", + "adding: mem time217, current time 244, horizon 27\n", + "adding: mem time218, current time 244, horizon 26\n", + "adding: mem time219, current time 244, horizon 25\n", + "adding: mem time220, current time 244, horizon 24\n", + "adding: mem time221, current time 244, horizon 23\n", + "adding: mem time222, current time 244, horizon 22\n", + "adding: mem time223, current time 244, horizon 21\n", + "adding: mem time224, current time 244, horizon 20\n", + "adding: mem time225, current time 244, horizon 19\n", + "adding: mem time226, current time 244, horizon 18\n", + "adding: mem time227, current time 244, horizon 17\n", + "adding: mem time228, current time 244, horizon 16\n", + "adding: mem time229, current time 244, horizon 15\n", + "adding: mem time230, current time 244, horizon 14\n", + "adding: mem time231, current time 244, horizon 13\n", + "adding: mem time232, current time 244, horizon 12\n", + "adding: mem time233, current time 244, horizon 11\n", + "adding: mem time234, current time 244, horizon 10\n", + "adding: mem time235, current time 244, horizon 9\n", + "adding: mem time236, current time 244, horizon 8\n", + "adding: mem time237, current time 244, horizon 7\n", + "adding: mem time238, current time 244, horizon 6\n", + "adding: mem time239, current time 244, horizon 5\n", + "adding: mem time240, current time 244, horizon 4\n", + "adding: mem time241, current time 244, horizon 3\n", + "adding: mem time242, current time 244, horizon 2\n", + "adding: mem time243, current time 244, horizon 1\n", + "adding: mem time200, current time 245, horizon 45\n", + "adding: mem time201, current time 245, horizon 44\n", + "adding: mem time202, current time 245, horizon 43\n", + "adding: mem time203, current time 245, horizon 42\n", + "adding: mem time204, current time 245, horizon 41\n", + "adding: mem time205, current time 245, horizon 40\n", + "adding: mem time206, current time 245, horizon 39\n", + "adding: mem time207, current time 245, horizon 38\n", + "adding: mem time208, current time 245, horizon 37\n", + "adding: mem time209, current time 245, horizon 36\n", + "adding: mem time210, current time 245, horizon 35\n", + "adding: mem time211, current time 245, horizon 34\n", + "adding: mem time212, current time 245, horizon 33\n", + "adding: mem time213, current time 245, horizon 32\n", + "adding: mem time214, current time 245, horizon 31\n", + "adding: mem time215, current time 245, horizon 30\n", + "adding: mem time216, current time 245, horizon 29\n", + "adding: mem time217, current time 245, horizon 28\n", + "adding: mem time218, current time 245, horizon 27\n", + "adding: mem time219, current time 245, horizon 26\n", + "adding: mem time220, current time 245, horizon 25\n", + "adding: mem time221, current time 245, horizon 24\n", + "adding: mem time222, current time 245, horizon 23\n", + "adding: mem time223, current time 245, horizon 22\n", + "adding: mem time224, current time 245, horizon 21\n", + "adding: mem time225, current time 245, horizon 20\n", + "adding: mem time226, current time 245, horizon 19\n", + "adding: mem time227, current time 245, horizon 18\n", + "adding: mem time228, current time 245, horizon 17\n", + "adding: mem time229, current time 245, horizon 16\n", + "adding: mem time230, current time 245, horizon 15\n", + "adding: mem time231, current time 245, horizon 14\n", + "adding: mem time232, current time 245, horizon 13\n", + "adding: mem time233, current time 245, horizon 12\n", + "adding: mem time234, current time 245, horizon 11\n", + "adding: mem time235, current time 245, horizon 10\n", + "adding: mem time236, current time 245, horizon 9\n", + "adding: mem time237, current time 245, horizon 8\n", + "adding: mem time238, current time 245, horizon 7\n", + "adding: mem time239, current time 245, horizon 6\n", + "adding: mem time240, current time 245, horizon 5\n", + "adding: mem time241, current time 245, horizon 4\n", + "adding: mem time242, current time 245, horizon 3\n", + "adding: mem time243, current time 245, horizon 2\n", + "adding: mem time244, current time 245, horizon 1\n", + "adding: mem time200, current time 246, horizon 46\n", + "adding: mem time201, current time 246, horizon 45\n", + "adding: mem time202, current time 246, horizon 44\n", + "adding: mem time203, current time 246, horizon 43\n", + "adding: mem time204, current time 246, horizon 42\n", + "adding: mem time205, current time 246, horizon 41\n", + "adding: mem time206, current time 246, horizon 40\n", + "adding: mem time207, current time 246, horizon 39\n", + "adding: mem time208, current time 246, horizon 38\n", + "adding: mem time209, current time 246, horizon 37\n", + "adding: mem time210, current time 246, horizon 36\n", + "adding: mem time211, current time 246, horizon 35\n", + "adding: mem time212, current time 246, horizon 34\n", + "adding: mem time213, current time 246, horizon 33\n", + "adding: mem time214, current time 246, horizon 32\n", + "adding: mem time215, current time 246, horizon 31\n", + "adding: mem time216, current time 246, horizon 30\n", + "adding: mem time217, current time 246, horizon 29\n", + "adding: mem time218, current time 246, horizon 28\n", + "adding: mem time219, current time 246, horizon 27\n", + "adding: mem time220, current time 246, horizon 26\n", + "adding: mem time221, current time 246, horizon 25\n", + "adding: mem time222, current time 246, horizon 24\n", + "adding: mem time223, current time 246, horizon 23\n", + "adding: mem time224, current time 246, horizon 22\n", + "adding: mem time225, current time 246, horizon 21\n", + "adding: mem time226, current time 246, horizon 20\n", + "adding: mem time227, current time 246, horizon 19\n", + "adding: mem time228, current time 246, horizon 18\n", + "adding: mem time229, current time 246, horizon 17\n", + "adding: mem time230, current time 246, horizon 16\n", + "adding: mem time231, current time 246, horizon 15\n", + "adding: mem time232, current time 246, horizon 14\n", + "adding: mem time233, current time 246, horizon 13\n", + "adding: mem time234, current time 246, horizon 12\n", + "adding: mem time235, current time 246, horizon 11\n", + "adding: mem time236, current time 246, horizon 10\n", + "adding: mem time237, current time 246, horizon 9\n", + "adding: mem time238, current time 246, horizon 8\n", + "adding: mem time239, current time 246, horizon 7\n", + "adding: mem time240, current time 246, horizon 6\n", + "adding: mem time241, current time 246, horizon 5\n", + "adding: mem time242, current time 246, horizon 4\n", + "adding: mem time243, current time 246, horizon 3\n", + "adding: mem time244, current time 246, horizon 2\n", + "adding: mem time245, current time 246, horizon 1\n", + "adding: mem time200, current time 247, horizon 47\n", + "adding: mem time201, current time 247, horizon 46\n", + "adding: mem time202, current time 247, horizon 45\n", + "adding: mem time203, current time 247, horizon 44\n", + "adding: mem time204, current time 247, horizon 43\n", + "adding: mem time205, current time 247, horizon 42\n", + "adding: mem time206, current time 247, horizon 41\n", + "adding: mem time207, current time 247, horizon 40\n", + "adding: mem time208, current time 247, horizon 39\n", + "adding: mem time209, current time 247, horizon 38\n", + "adding: mem time210, current time 247, horizon 37\n", + "adding: mem time211, current time 247, horizon 36\n", + "adding: mem time212, current time 247, horizon 35\n", + "adding: mem time213, current time 247, horizon 34\n", + "adding: mem time214, current time 247, horizon 33\n", + "adding: mem time215, current time 247, horizon 32\n", + "adding: mem time216, current time 247, horizon 31\n", + "adding: mem time217, current time 247, horizon 30\n", + "adding: mem time218, current time 247, horizon 29\n", + "adding: mem time219, current time 247, horizon 28\n", + "adding: mem time220, current time 247, horizon 27\n", + "adding: mem time221, current time 247, horizon 26\n", + "adding: mem time222, current time 247, horizon 25\n", + "adding: mem time223, current time 247, horizon 24\n", + "adding: mem time224, current time 247, horizon 23\n", + "adding: mem time225, current time 247, horizon 22\n", + "adding: mem time226, current time 247, horizon 21\n", + "adding: mem time227, current time 247, horizon 20\n", + "adding: mem time228, current time 247, horizon 19\n", + "adding: mem time229, current time 247, horizon 18\n", + "adding: mem time230, current time 247, horizon 17\n", + "adding: mem time231, current time 247, horizon 16\n", + "adding: mem time232, current time 247, horizon 15\n", + "adding: mem time233, current time 247, horizon 14\n", + "adding: mem time234, current time 247, horizon 13\n", + "adding: mem time235, current time 247, horizon 12\n", + "adding: mem time236, current time 247, horizon 11\n", + "adding: mem time237, current time 247, horizon 10\n", + "adding: mem time238, current time 247, horizon 9\n", + "adding: mem time239, current time 247, horizon 8\n", + "adding: mem time240, current time 247, horizon 7\n", + "adding: mem time241, current time 247, horizon 6\n", + "adding: mem time242, current time 247, horizon 5\n", + "adding: mem time243, current time 247, horizon 4\n", + "adding: mem time244, current time 247, horizon 3\n", + "adding: mem time245, current time 247, horizon 2\n", + "adding: mem time246, current time 247, horizon 1\n", + "adding: mem time200, current time 248, horizon 48\n", + "adding: mem time201, current time 248, horizon 47\n", + "adding: mem time202, current time 248, horizon 46\n", + "adding: mem time203, current time 248, horizon 45\n", + "adding: mem time204, current time 248, horizon 44\n", + "adding: mem time205, current time 248, horizon 43\n", + "adding: mem time206, current time 248, horizon 42\n", + "adding: mem time207, current time 248, horizon 41\n", + "adding: mem time208, current time 248, horizon 40\n", + "adding: mem time209, current time 248, horizon 39\n", + "adding: mem time210, current time 248, horizon 38\n", + "adding: mem time211, current time 248, horizon 37\n", + "adding: mem time212, current time 248, horizon 36\n", + "adding: mem time213, current time 248, horizon 35\n", + "adding: mem time214, current time 248, horizon 34\n", + "adding: mem time215, current time 248, horizon 33\n", + "adding: mem time216, current time 248, horizon 32\n", + "adding: mem time217, current time 248, horizon 31\n", + "adding: mem time218, current time 248, horizon 30\n", + "adding: mem time219, current time 248, horizon 29\n", + "adding: mem time220, current time 248, horizon 28\n", + "adding: mem time221, current time 248, horizon 27\n", + "adding: mem time222, current time 248, horizon 26\n", + "adding: mem time223, current time 248, horizon 25\n", + "adding: mem time224, current time 248, horizon 24\n", + "adding: mem time225, current time 248, horizon 23\n", + "adding: mem time226, current time 248, horizon 22\n", + "adding: mem time227, current time 248, horizon 21\n", + "adding: mem time228, current time 248, horizon 20\n", + "adding: mem time229, current time 248, horizon 19\n", + "adding: mem time230, current time 248, horizon 18\n", + "adding: mem time231, current time 248, horizon 17\n", + "adding: mem time232, current time 248, horizon 16\n", + "adding: mem time233, current time 248, horizon 15\n", + "adding: mem time234, current time 248, horizon 14\n", + "adding: mem time235, current time 248, horizon 13\n", + "adding: mem time236, current time 248, horizon 12\n", + "adding: mem time237, current time 248, horizon 11\n", + "adding: mem time238, current time 248, horizon 10\n", + "adding: mem time239, current time 248, horizon 9\n", + "adding: mem time240, current time 248, horizon 8\n", + "adding: mem time241, current time 248, horizon 7\n", + "adding: mem time242, current time 248, horizon 6\n", + "adding: mem time243, current time 248, horizon 5\n", + "adding: mem time244, current time 248, horizon 4\n", + "adding: mem time245, current time 248, horizon 3\n", + "adding: mem time246, current time 248, horizon 2\n", + "adding: mem time247, current time 248, horizon 1\n", + "adding: mem time200, current time 249, horizon 49\n", + "adding: mem time201, current time 249, horizon 48\n", + "adding: mem time202, current time 249, horizon 47\n", + "adding: mem time203, current time 249, horizon 46\n", + "adding: mem time204, current time 249, horizon 45\n", + "adding: mem time205, current time 249, horizon 44\n", + "adding: mem time206, current time 249, horizon 43\n", + "adding: mem time207, current time 249, horizon 42\n", + "adding: mem time208, current time 249, horizon 41\n", + "adding: mem time209, current time 249, horizon 40\n", + "adding: mem time210, current time 249, horizon 39\n", + "adding: mem time211, current time 249, horizon 38\n", + "adding: mem time212, current time 249, horizon 37\n", + "adding: mem time213, current time 249, horizon 36\n", + "adding: mem time214, current time 249, horizon 35\n", + "adding: mem time215, current time 249, horizon 34\n", + "adding: mem time216, current time 249, horizon 33\n", + "adding: mem time217, current time 249, horizon 32\n", + "adding: mem time218, current time 249, horizon 31\n", + "adding: mem time219, current time 249, horizon 30\n", + "adding: mem time220, current time 249, horizon 29\n", + "adding: mem time221, current time 249, horizon 28\n", + "adding: mem time222, current time 249, horizon 27\n", + "adding: mem time223, current time 249, horizon 26\n", + "adding: mem time224, current time 249, horizon 25\n", + "adding: mem time225, current time 249, horizon 24\n", + "adding: mem time226, current time 249, horizon 23\n", + "adding: mem time227, current time 249, horizon 22\n", + "adding: mem time228, current time 249, horizon 21\n", + "adding: mem time229, current time 249, horizon 20\n", + "adding: mem time230, current time 249, horizon 19\n", + "adding: mem time231, current time 249, horizon 18\n", + "adding: mem time232, current time 249, horizon 17\n", + "adding: mem time233, current time 249, horizon 16\n", + "adding: mem time234, current time 249, horizon 15\n", + "adding: mem time235, current time 249, horizon 14\n", + "adding: mem time236, current time 249, horizon 13\n", + "adding: mem time237, current time 249, horizon 12\n", + "adding: mem time238, current time 249, horizon 11\n", + "adding: mem time239, current time 249, horizon 10\n", + "adding: mem time240, current time 249, horizon 9\n", + "adding: mem time241, current time 249, horizon 8\n", + "adding: mem time242, current time 249, horizon 7\n", + "adding: mem time243, current time 249, horizon 6\n", + "adding: mem time244, current time 249, horizon 5\n", + "adding: mem time245, current time 249, horizon 4\n", + "adding: mem time246, current time 249, horizon 3\n", + "adding: mem time247, current time 249, horizon 2\n", + "adding: mem time248, current time 249, horizon 1\n", + "adding: mem time200, current time 250, horizon 50\n", + "adding: mem time201, current time 250, horizon 49\n", + "adding: mem time202, current time 250, horizon 48\n", + "adding: mem time203, current time 250, horizon 47\n", + "adding: mem time204, current time 250, horizon 46\n", + "adding: mem time205, current time 250, horizon 45\n", + "adding: mem time206, current time 250, horizon 44\n", + "adding: mem time207, current time 250, horizon 43\n", + "adding: mem time208, current time 250, horizon 42\n", + "adding: mem time209, current time 250, horizon 41\n", + "adding: mem time210, current time 250, horizon 40\n", + "adding: mem time211, current time 250, horizon 39\n", + "adding: mem time212, current time 250, horizon 38\n", + "adding: mem time213, current time 250, horizon 37\n", + "adding: mem time214, current time 250, horizon 36\n", + "adding: mem time215, current time 250, horizon 35\n", + "adding: mem time216, current time 250, horizon 34\n", + "adding: mem time217, current time 250, horizon 33\n", + "adding: mem time218, current time 250, horizon 32\n", + "adding: mem time219, current time 250, horizon 31\n", + "adding: mem time220, current time 250, horizon 30\n", + "adding: mem time221, current time 250, horizon 29\n", + "adding: mem time222, current time 250, horizon 28\n", + "adding: mem time223, current time 250, horizon 27\n", + "adding: mem time224, current time 250, horizon 26\n", + "adding: mem time225, current time 250, horizon 25\n", + "adding: mem time226, current time 250, horizon 24\n", + "adding: mem time227, current time 250, horizon 23\n", + "adding: mem time228, current time 250, horizon 22\n", + "adding: mem time229, current time 250, horizon 21\n", + "adding: mem time230, current time 250, horizon 20\n", + "adding: mem time231, current time 250, horizon 19\n", + "adding: mem time232, current time 250, horizon 18\n", + "adding: mem time233, current time 250, horizon 17\n", + "adding: mem time234, current time 250, horizon 16\n", + "adding: mem time235, current time 250, horizon 15\n", + "adding: mem time236, current time 250, horizon 14\n", + "adding: mem time237, current time 250, horizon 13\n", + "adding: mem time238, current time 250, horizon 12\n", + "adding: mem time239, current time 250, horizon 11\n", + "adding: mem time240, current time 250, horizon 10\n", + "adding: mem time241, current time 250, horizon 9\n", + "adding: mem time242, current time 250, horizon 8\n", + "adding: mem time243, current time 250, horizon 7\n", + "adding: mem time244, current time 250, horizon 6\n", + "adding: mem time245, current time 250, horizon 5\n", + "adding: mem time246, current time 250, horizon 4\n", + "adding: mem time247, current time 250, horizon 3\n", + "adding: mem time248, current time 250, horizon 2\n", + "adding: mem time249, current time 250, horizon 1\n", + "adding: mem time200, current time 251, horizon 51\n", + "adding: mem time201, current time 251, horizon 50\n", + "adding: mem time202, current time 251, horizon 49\n", + "adding: mem time203, current time 251, horizon 48\n", + "adding: mem time204, current time 251, horizon 47\n", + "adding: mem time205, current time 251, horizon 46\n", + "adding: mem time206, current time 251, horizon 45\n", + "adding: mem time207, current time 251, horizon 44\n", + "adding: mem time208, current time 251, horizon 43\n", + "adding: mem time209, current time 251, horizon 42\n", + "adding: mem time210, current time 251, horizon 41\n", + "adding: mem time211, current time 251, horizon 40\n", + "adding: mem time212, current time 251, horizon 39\n", + "adding: mem time213, current time 251, horizon 38\n", + "adding: mem time214, current time 251, horizon 37\n", + "adding: mem time215, current time 251, horizon 36\n", + "adding: mem time216, current time 251, horizon 35\n", + "adding: mem time217, current time 251, horizon 34\n", + "adding: mem time218, current time 251, horizon 33\n", + "adding: mem time219, current time 251, horizon 32\n", + "adding: mem time220, current time 251, horizon 31\n", + "adding: mem time221, current time 251, horizon 30\n", + "adding: mem time222, current time 251, horizon 29\n", + "adding: mem time223, current time 251, horizon 28\n", + "adding: mem time224, current time 251, horizon 27\n", + "adding: mem time225, current time 251, horizon 26\n", + "adding: mem time226, current time 251, horizon 25\n", + "adding: mem time227, current time 251, horizon 24\n", + "adding: mem time228, current time 251, horizon 23\n", + "adding: mem time229, current time 251, horizon 22\n", + "adding: mem time230, current time 251, horizon 21\n", + "adding: mem time231, current time 251, horizon 20\n", + "adding: mem time232, current time 251, horizon 19\n", + "adding: mem time233, current time 251, horizon 18\n", + "adding: mem time234, current time 251, horizon 17\n", + "adding: mem time235, current time 251, horizon 16\n", + "adding: mem time236, current time 251, horizon 15\n", + "adding: mem time237, current time 251, horizon 14\n", + "adding: mem time238, current time 251, horizon 13\n", + "adding: mem time239, current time 251, horizon 12\n", + "adding: mem time240, current time 251, horizon 11\n", + "adding: mem time241, current time 251, horizon 10\n", + "adding: mem time242, current time 251, horizon 9\n", + "adding: mem time243, current time 251, horizon 8\n", + "adding: mem time244, current time 251, horizon 7\n", + "adding: mem time245, current time 251, horizon 6\n", + "adding: mem time246, current time 251, horizon 5\n", + "adding: mem time247, current time 251, horizon 4\n", + "adding: mem time248, current time 251, horizon 3\n", + "adding: mem time249, current time 251, horizon 2\n", + "adding: mem time250, current time 251, horizon 1\n", + "adding: mem time200, current time 252, horizon 52\n", + "adding: mem time201, current time 252, horizon 51\n", + "adding: mem time202, current time 252, horizon 50\n", + "adding: mem time203, current time 252, horizon 49\n", + "adding: mem time204, current time 252, horizon 48\n", + "adding: mem time205, current time 252, horizon 47\n", + "adding: mem time206, current time 252, horizon 46\n", + "adding: mem time207, current time 252, horizon 45\n", + "adding: mem time208, current time 252, horizon 44\n", + "adding: mem time209, current time 252, horizon 43\n", + "adding: mem time210, current time 252, horizon 42\n", + "adding: mem time211, current time 252, horizon 41\n", + "adding: mem time212, current time 252, horizon 40\n", + "adding: mem time213, current time 252, horizon 39\n", + "adding: mem time214, current time 252, horizon 38\n", + "adding: mem time215, current time 252, horizon 37\n", + "adding: mem time216, current time 252, horizon 36\n", + "adding: mem time217, current time 252, horizon 35\n", + "adding: mem time218, current time 252, horizon 34\n", + "adding: mem time219, current time 252, horizon 33\n", + "adding: mem time220, current time 252, horizon 32\n", + "adding: mem time221, current time 252, horizon 31\n", + "adding: mem time222, current time 252, horizon 30\n", + "adding: mem time223, current time 252, horizon 29\n", + "adding: mem time224, current time 252, horizon 28\n", + "adding: mem time225, current time 252, horizon 27\n", + "adding: mem time226, current time 252, horizon 26\n", + "adding: mem time227, current time 252, horizon 25\n", + "adding: mem time228, current time 252, horizon 24\n", + "adding: mem time229, current time 252, horizon 23\n", + "adding: mem time230, current time 252, horizon 22\n", + "adding: mem time231, current time 252, horizon 21\n", + "adding: mem time232, current time 252, horizon 20\n", + "adding: mem time233, current time 252, horizon 19\n", + "adding: mem time234, current time 252, horizon 18\n", + "adding: mem time235, current time 252, horizon 17\n", + "adding: mem time236, current time 252, horizon 16\n", + "adding: mem time237, current time 252, horizon 15\n", + "adding: mem time238, current time 252, horizon 14\n", + "adding: mem time239, current time 252, horizon 13\n", + "adding: mem time240, current time 252, horizon 12\n", + "adding: mem time241, current time 252, horizon 11\n", + "adding: mem time242, current time 252, horizon 10\n", + "adding: mem time243, current time 252, horizon 9\n", + "adding: mem time244, current time 252, horizon 8\n", + "adding: mem time245, current time 252, horizon 7\n", + "adding: mem time246, current time 252, horizon 6\n", + "adding: mem time247, current time 252, horizon 5\n", + "adding: mem time248, current time 252, horizon 4\n", + "adding: mem time249, current time 252, horizon 3\n", + "adding: mem time250, current time 252, horizon 2\n", + "adding: mem time251, current time 252, horizon 1\n", + "adding: mem time200, current time 253, horizon 53\n", + "adding: mem time201, current time 253, horizon 52\n", + "adding: mem time202, current time 253, horizon 51\n", + "adding: mem time203, current time 253, horizon 50\n", + "adding: mem time204, current time 253, horizon 49\n", + "adding: mem time205, current time 253, horizon 48\n", + "adding: mem time206, current time 253, horizon 47\n", + "adding: mem time207, current time 253, horizon 46\n", + "adding: mem time208, current time 253, horizon 45\n", + "adding: mem time209, current time 253, horizon 44\n", + "adding: mem time210, current time 253, horizon 43\n", + "adding: mem time211, current time 253, horizon 42\n", + "adding: mem time212, current time 253, horizon 41\n", + "adding: mem time213, current time 253, horizon 40\n", + "adding: mem time214, current time 253, horizon 39\n", + "adding: mem time215, current time 253, horizon 38\n", + "adding: mem time216, current time 253, horizon 37\n", + "adding: mem time217, current time 253, horizon 36\n", + "adding: mem time218, current time 253, horizon 35\n", + "adding: mem time219, current time 253, horizon 34\n", + "adding: mem time220, current time 253, horizon 33\n", + "adding: mem time221, current time 253, horizon 32\n", + "adding: mem time222, current time 253, horizon 31\n", + "adding: mem time223, current time 253, horizon 30\n", + "adding: mem time224, current time 253, horizon 29\n", + "adding: mem time225, current time 253, horizon 28\n", + "adding: mem time226, current time 253, horizon 27\n", + "adding: mem time227, current time 253, horizon 26\n", + "adding: mem time228, current time 253, horizon 25\n", + "adding: mem time229, current time 253, horizon 24\n", + "adding: mem time230, current time 253, horizon 23\n", + "adding: mem time231, current time 253, horizon 22\n", + "adding: mem time232, current time 253, horizon 21\n", + "adding: mem time233, current time 253, horizon 20\n", + "adding: mem time234, current time 253, horizon 19\n", + "adding: mem time235, current time 253, horizon 18\n", + "adding: mem time236, current time 253, horizon 17\n", + "adding: mem time237, current time 253, horizon 16\n", + "adding: mem time238, current time 253, horizon 15\n", + "adding: mem time239, current time 253, horizon 14\n", + "adding: mem time240, current time 253, horizon 13\n", + "adding: mem time241, current time 253, horizon 12\n", + "adding: mem time242, current time 253, horizon 11\n", + "adding: mem time243, current time 253, horizon 10\n", + "adding: mem time244, current time 253, horizon 9\n", + "adding: mem time245, current time 253, horizon 8\n", + "adding: mem time246, current time 253, horizon 7\n", + "adding: mem time247, current time 253, horizon 6\n", + "adding: mem time248, current time 253, horizon 5\n", + "adding: mem time249, current time 253, horizon 4\n", + "adding: mem time250, current time 253, horizon 3\n", + "adding: mem time251, current time 253, horizon 2\n", + "adding: mem time252, current time 253, horizon 1\n", + "adding: mem time200, current time 254, horizon 54\n", + "adding: mem time201, current time 254, horizon 53\n", + "adding: mem time202, current time 254, horizon 52\n", + "adding: mem time203, current time 254, horizon 51\n", + "adding: mem time204, current time 254, horizon 50\n", + "adding: mem time205, current time 254, horizon 49\n", + "adding: mem time206, current time 254, horizon 48\n", + "adding: mem time207, current time 254, horizon 47\n", + "adding: mem time208, current time 254, horizon 46\n", + "adding: mem time209, current time 254, horizon 45\n", + "adding: mem time210, current time 254, horizon 44\n", + "adding: mem time211, current time 254, horizon 43\n", + "adding: mem time212, current time 254, horizon 42\n", + "adding: mem time213, current time 254, horizon 41\n", + "adding: mem time214, current time 254, horizon 40\n", + "adding: mem time215, current time 254, horizon 39\n", + "adding: mem time216, current time 254, horizon 38\n", + "adding: mem time217, current time 254, horizon 37\n", + "adding: mem time218, current time 254, horizon 36\n", + "adding: mem time219, current time 254, horizon 35\n", + "adding: mem time220, current time 254, horizon 34\n", + "adding: mem time221, current time 254, horizon 33\n", + "adding: mem time222, current time 254, horizon 32\n", + "adding: mem time223, current time 254, horizon 31\n", + "adding: mem time224, current time 254, horizon 30\n", + "adding: mem time225, current time 254, horizon 29\n", + "adding: mem time226, current time 254, horizon 28\n", + "adding: mem time227, current time 254, horizon 27\n", + "adding: mem time228, current time 254, horizon 26\n", + "adding: mem time229, current time 254, horizon 25\n", + "adding: mem time230, current time 254, horizon 24\n", + "adding: mem time231, current time 254, horizon 23\n", + "adding: mem time232, current time 254, horizon 22\n", + "adding: mem time233, current time 254, horizon 21\n", + "adding: mem time234, current time 254, horizon 20\n", + "adding: mem time235, current time 254, horizon 19\n", + "adding: mem time236, current time 254, horizon 18\n", + "adding: mem time237, current time 254, horizon 17\n", + "adding: mem time238, current time 254, horizon 16\n", + "adding: mem time239, current time 254, horizon 15\n", + "adding: mem time240, current time 254, horizon 14\n", + "adding: mem time241, current time 254, horizon 13\n", + "adding: mem time242, current time 254, horizon 12\n", + "adding: mem time243, current time 254, horizon 11\n", + "adding: mem time244, current time 254, horizon 10\n", + "adding: mem time245, current time 254, horizon 9\n", + "adding: mem time246, current time 254, horizon 8\n", + "adding: mem time247, current time 254, horizon 7\n", + "adding: mem time248, current time 254, horizon 6\n", + "adding: mem time249, current time 254, horizon 5\n", + "adding: mem time250, current time 254, horizon 4\n", + "adding: mem time251, current time 254, horizon 3\n", + "adding: mem time252, current time 254, horizon 2\n", + "adding: mem time253, current time 254, horizon 1\n", + "adding: mem time200, current time 255, horizon 55\n", + "adding: mem time201, current time 255, horizon 54\n", + "adding: mem time202, current time 255, horizon 53\n", + "adding: mem time203, current time 255, horizon 52\n", + "adding: mem time204, current time 255, horizon 51\n", + "adding: mem time205, current time 255, horizon 50\n", + "adding: mem time206, current time 255, horizon 49\n", + "adding: mem time207, current time 255, horizon 48\n", + "adding: mem time208, current time 255, horizon 47\n", + "adding: mem time209, current time 255, horizon 46\n", + "adding: mem time210, current time 255, horizon 45\n", + "adding: mem time211, current time 255, horizon 44\n", + "adding: mem time212, current time 255, horizon 43\n", + "adding: mem time213, current time 255, horizon 42\n", + "adding: mem time214, current time 255, horizon 41\n", + "adding: mem time215, current time 255, horizon 40\n", + "adding: mem time216, current time 255, horizon 39\n", + "adding: mem time217, current time 255, horizon 38\n", + "adding: mem time218, current time 255, horizon 37\n", + "adding: mem time219, current time 255, horizon 36\n", + "adding: mem time220, current time 255, horizon 35\n", + "adding: mem time221, current time 255, horizon 34\n", + "adding: mem time222, current time 255, horizon 33\n", + "adding: mem time223, current time 255, horizon 32\n", + "adding: mem time224, current time 255, horizon 31\n", + "adding: mem time225, current time 255, horizon 30\n", + "adding: mem time226, current time 255, horizon 29\n", + "adding: mem time227, current time 255, horizon 28\n", + "adding: mem time228, current time 255, horizon 27\n", + "adding: mem time229, current time 255, horizon 26\n", + "adding: mem time230, current time 255, horizon 25\n", + "adding: mem time231, current time 255, horizon 24\n", + "adding: mem time232, current time 255, horizon 23\n", + "adding: mem time233, current time 255, horizon 22\n", + "adding: mem time234, current time 255, horizon 21\n", + "adding: mem time235, current time 255, horizon 20\n", + "adding: mem time236, current time 255, horizon 19\n", + "adding: mem time237, current time 255, horizon 18\n", + "adding: mem time238, current time 255, horizon 17\n", + "adding: mem time239, current time 255, horizon 16\n", + "adding: mem time240, current time 255, horizon 15\n", + "adding: mem time241, current time 255, horizon 14\n", + "adding: mem time242, current time 255, horizon 13\n", + "adding: mem time243, current time 255, horizon 12\n", + "adding: mem time244, current time 255, horizon 11\n", + "adding: mem time245, current time 255, horizon 10\n", + "adding: mem time246, current time 255, horizon 9\n", + "adding: mem time247, current time 255, horizon 8\n", + "adding: mem time248, current time 255, horizon 7\n", + "adding: mem time249, current time 255, horizon 6\n", + "adding: mem time250, current time 255, horizon 5\n", + "adding: mem time251, current time 255, horizon 4\n", + "adding: mem time252, current time 255, horizon 3\n", + "adding: mem time253, current time 255, horizon 2\n", + "adding: mem time254, current time 255, horizon 1\n", + "adding: mem time200, current time 256, horizon 56\n", + "adding: mem time201, current time 256, horizon 55\n", + "adding: mem time202, current time 256, horizon 54\n", + "adding: mem time203, current time 256, horizon 53\n", + "adding: mem time204, current time 256, horizon 52\n", + "adding: mem time205, current time 256, horizon 51\n", + "adding: mem time206, current time 256, horizon 50\n", + "adding: mem time207, current time 256, horizon 49\n", + "adding: mem time208, current time 256, horizon 48\n", + "adding: mem time209, current time 256, horizon 47\n", + "adding: mem time210, current time 256, horizon 46\n", + "adding: mem time211, current time 256, horizon 45\n", + "adding: mem time212, current time 256, horizon 44\n", + "adding: mem time213, current time 256, horizon 43\n", + "adding: mem time214, current time 256, horizon 42\n", + "adding: mem time215, current time 256, horizon 41\n", + "adding: mem time216, current time 256, horizon 40\n", + "adding: mem time217, current time 256, horizon 39\n", + "adding: mem time218, current time 256, horizon 38\n", + "adding: mem time219, current time 256, horizon 37\n", + "adding: mem time220, current time 256, horizon 36\n", + "adding: mem time221, current time 256, horizon 35\n", + "adding: mem time222, current time 256, horizon 34\n", + "adding: mem time223, current time 256, horizon 33\n", + "adding: mem time224, current time 256, horizon 32\n", + "adding: mem time225, current time 256, horizon 31\n", + "adding: mem time226, current time 256, horizon 30\n", + "adding: mem time227, current time 256, horizon 29\n", + "adding: mem time228, current time 256, horizon 28\n", + "adding: mem time229, current time 256, horizon 27\n", + "adding: mem time230, current time 256, horizon 26\n", + "adding: mem time231, current time 256, horizon 25\n", + "adding: mem time232, current time 256, horizon 24\n", + "adding: mem time233, current time 256, horizon 23\n", + "adding: mem time234, current time 256, horizon 22\n", + "adding: mem time235, current time 256, horizon 21\n", + "adding: mem time236, current time 256, horizon 20\n", + "adding: mem time237, current time 256, horizon 19\n", + "adding: mem time238, current time 256, horizon 18\n", + "adding: mem time239, current time 256, horizon 17\n", + "adding: mem time240, current time 256, horizon 16\n", + "adding: mem time241, current time 256, horizon 15\n", + "adding: mem time242, current time 256, horizon 14\n", + "adding: mem time243, current time 256, horizon 13\n", + "adding: mem time244, current time 256, horizon 12\n", + "adding: mem time245, current time 256, horizon 11\n", + "adding: mem time246, current time 256, horizon 10\n", + "adding: mem time247, current time 256, horizon 9\n", + "adding: mem time248, current time 256, horizon 8\n", + "adding: mem time249, current time 256, horizon 7\n", + "adding: mem time250, current time 256, horizon 6\n", + "adding: mem time251, current time 256, horizon 5\n", + "adding: mem time252, current time 256, horizon 4\n", + "adding: mem time253, current time 256, horizon 3\n", + "adding: mem time254, current time 256, horizon 2\n", + "adding: mem time255, current time 256, horizon 1\n", + "adding: mem time200, current time 257, horizon 57\n", + "adding: mem time201, current time 257, horizon 56\n", + "adding: mem time202, current time 257, horizon 55\n", + "adding: mem time203, current time 257, horizon 54\n", + "adding: mem time204, current time 257, horizon 53\n", + "adding: mem time205, current time 257, horizon 52\n", + "adding: mem time206, current time 257, horizon 51\n", + "adding: mem time207, current time 257, horizon 50\n", + "adding: mem time208, current time 257, horizon 49\n", + "adding: mem time209, current time 257, horizon 48\n", + "adding: mem time210, current time 257, horizon 47\n", + "adding: mem time211, current time 257, horizon 46\n", + "adding: mem time212, current time 257, horizon 45\n", + "adding: mem time213, current time 257, horizon 44\n", + "adding: mem time214, current time 257, horizon 43\n", + "adding: mem time215, current time 257, horizon 42\n", + "adding: mem time216, current time 257, horizon 41\n", + "adding: mem time217, current time 257, horizon 40\n", + "adding: mem time218, current time 257, horizon 39\n", + "adding: mem time219, current time 257, horizon 38\n", + "adding: mem time220, current time 257, horizon 37\n", + "adding: mem time221, current time 257, horizon 36\n", + "adding: mem time222, current time 257, horizon 35\n", + "adding: mem time223, current time 257, horizon 34\n", + "adding: mem time224, current time 257, horizon 33\n", + "adding: mem time225, current time 257, horizon 32\n", + "adding: mem time226, current time 257, horizon 31\n", + "adding: mem time227, current time 257, horizon 30\n", + "adding: mem time228, current time 257, horizon 29\n", + "adding: mem time229, current time 257, horizon 28\n", + "adding: mem time230, current time 257, horizon 27\n", + "adding: mem time231, current time 257, horizon 26\n", + "adding: mem time232, current time 257, horizon 25\n", + "adding: mem time233, current time 257, horizon 24\n", + "adding: mem time234, current time 257, horizon 23\n", + "adding: mem time235, current time 257, horizon 22\n", + "adding: mem time236, current time 257, horizon 21\n", + "adding: mem time237, current time 257, horizon 20\n", + "adding: mem time238, current time 257, horizon 19\n", + "adding: mem time239, current time 257, horizon 18\n", + "adding: mem time240, current time 257, horizon 17\n", + "adding: mem time241, current time 257, horizon 16\n", + "adding: mem time242, current time 257, horizon 15\n", + "adding: mem time243, current time 257, horizon 14\n", + "adding: mem time244, current time 257, horizon 13\n", + "adding: mem time245, current time 257, horizon 12\n", + "adding: mem time246, current time 257, horizon 11\n", + "adding: mem time247, current time 257, horizon 10\n", + "adding: mem time248, current time 257, horizon 9\n", + "adding: mem time249, current time 257, horizon 8\n", + "adding: mem time250, current time 257, horizon 7\n", + "adding: mem time251, current time 257, horizon 6\n", + "adding: mem time252, current time 257, horizon 5\n", + "adding: mem time253, current time 257, horizon 4\n", + "adding: mem time254, current time 257, horizon 3\n", + "adding: mem time255, current time 257, horizon 2\n", + "adding: mem time256, current time 257, horizon 1\n", + "adding: mem time200, current time 258, horizon 58\n", + "adding: mem time201, current time 258, horizon 57\n", + "adding: mem time202, current time 258, horizon 56\n", + "adding: mem time203, current time 258, horizon 55\n", + "adding: mem time204, current time 258, horizon 54\n", + "adding: mem time205, current time 258, horizon 53\n", + "adding: mem time206, current time 258, horizon 52\n", + "adding: mem time207, current time 258, horizon 51\n", + "adding: mem time208, current time 258, horizon 50\n", + "adding: mem time209, current time 258, horizon 49\n", + "adding: mem time210, current time 258, horizon 48\n", + "adding: mem time211, current time 258, horizon 47\n", + "adding: mem time212, current time 258, horizon 46\n", + "adding: mem time213, current time 258, horizon 45\n", + "adding: mem time214, current time 258, horizon 44\n", + "adding: mem time215, current time 258, horizon 43\n", + "adding: mem time216, current time 258, horizon 42\n", + "adding: mem time217, current time 258, horizon 41\n", + "adding: mem time218, current time 258, horizon 40\n", + "adding: mem time219, current time 258, horizon 39\n", + "adding: mem time220, current time 258, horizon 38\n", + "adding: mem time221, current time 258, horizon 37\n", + "adding: mem time222, current time 258, horizon 36\n", + "adding: mem time223, current time 258, horizon 35\n", + "adding: mem time224, current time 258, horizon 34\n", + "adding: mem time225, current time 258, horizon 33\n", + "adding: mem time226, current time 258, horizon 32\n", + "adding: mem time227, current time 258, horizon 31\n", + "adding: mem time228, current time 258, horizon 30\n", + "adding: mem time229, current time 258, horizon 29\n", + "adding: mem time230, current time 258, horizon 28\n", + "adding: mem time231, current time 258, horizon 27\n", + "adding: mem time232, current time 258, horizon 26\n", + "adding: mem time233, current time 258, horizon 25\n", + "adding: mem time234, current time 258, horizon 24\n", + "adding: mem time235, current time 258, horizon 23\n", + "adding: mem time236, current time 258, horizon 22\n", + "adding: mem time237, current time 258, horizon 21\n", + "adding: mem time238, current time 258, horizon 20\n", + "adding: mem time239, current time 258, horizon 19\n", + "adding: mem time240, current time 258, horizon 18\n", + "adding: mem time241, current time 258, horizon 17\n", + "adding: mem time242, current time 258, horizon 16\n", + "adding: mem time243, current time 258, horizon 15\n", + "adding: mem time244, current time 258, horizon 14\n", + "adding: mem time245, current time 258, horizon 13\n", + "adding: mem time246, current time 258, horizon 12\n", + "adding: mem time247, current time 258, horizon 11\n", + "adding: mem time248, current time 258, horizon 10\n", + "adding: mem time249, current time 258, horizon 9\n", + "adding: mem time250, current time 258, horizon 8\n", + "adding: mem time251, current time 258, horizon 7\n", + "adding: mem time252, current time 258, horizon 6\n", + "adding: mem time253, current time 258, horizon 5\n", + "adding: mem time254, current time 258, horizon 4\n", + "adding: mem time255, current time 258, horizon 3\n", + "adding: mem time256, current time 258, horizon 2\n", + "adding: mem time257, current time 258, horizon 1\n", + "adding: mem time200, current time 259, horizon 59\n", + "adding: mem time201, current time 259, horizon 58\n", + "adding: mem time202, current time 259, horizon 57\n", + "adding: mem time203, current time 259, horizon 56\n", + "adding: mem time204, current time 259, horizon 55\n", + "adding: mem time205, current time 259, horizon 54\n", + "adding: mem time206, current time 259, horizon 53\n", + "adding: mem time207, current time 259, horizon 52\n", + "adding: mem time208, current time 259, horizon 51\n", + "adding: mem time209, current time 259, horizon 50\n", + "adding: mem time210, current time 259, horizon 49\n", + "adding: mem time211, current time 259, horizon 48\n", + "adding: mem time212, current time 259, horizon 47\n", + "adding: mem time213, current time 259, horizon 46\n", + "adding: mem time214, current time 259, horizon 45\n", + "adding: mem time215, current time 259, horizon 44\n", + "adding: mem time216, current time 259, horizon 43\n", + "adding: mem time217, current time 259, horizon 42\n", + "adding: mem time218, current time 259, horizon 41\n", + "adding: mem time219, current time 259, horizon 40\n", + "adding: mem time220, current time 259, horizon 39\n", + "adding: mem time221, current time 259, horizon 38\n", + "adding: mem time222, current time 259, horizon 37\n", + "adding: mem time223, current time 259, horizon 36\n", + "adding: mem time224, current time 259, horizon 35\n", + "adding: mem time225, current time 259, horizon 34\n", + "adding: mem time226, current time 259, horizon 33\n", + "adding: mem time227, current time 259, horizon 32\n", + "adding: mem time228, current time 259, horizon 31\n", + "adding: mem time229, current time 259, horizon 30\n", + "adding: mem time230, current time 259, horizon 29\n", + "adding: mem time231, current time 259, horizon 28\n", + "adding: mem time232, current time 259, horizon 27\n", + "adding: mem time233, current time 259, horizon 26\n", + "adding: mem time234, current time 259, horizon 25\n", + "adding: mem time235, current time 259, horizon 24\n", + "adding: mem time236, current time 259, horizon 23\n", + "adding: mem time237, current time 259, horizon 22\n", + "adding: mem time238, current time 259, horizon 21\n", + "adding: mem time239, current time 259, horizon 20\n", + "adding: mem time240, current time 259, horizon 19\n", + "adding: mem time241, current time 259, horizon 18\n", + "adding: mem time242, current time 259, horizon 17\n", + "adding: mem time243, current time 259, horizon 16\n", + "adding: mem time244, current time 259, horizon 15\n", + "adding: mem time245, current time 259, horizon 14\n", + "adding: mem time246, current time 259, horizon 13\n", + "adding: mem time247, current time 259, horizon 12\n", + "adding: mem time248, current time 259, horizon 11\n", + "adding: mem time249, current time 259, horizon 10\n", + "adding: mem time250, current time 259, horizon 9\n", + "adding: mem time251, current time 259, horizon 8\n", + "adding: mem time252, current time 259, horizon 7\n", + "adding: mem time253, current time 259, horizon 6\n", + "adding: mem time254, current time 259, horizon 5\n", + "adding: mem time255, current time 259, horizon 4\n", + "adding: mem time256, current time 259, horizon 3\n", + "adding: mem time257, current time 259, horizon 2\n", + "adding: mem time258, current time 259, horizon 1\n", + "adding: mem time200, current time 260, horizon 60\n", + "adding: mem time201, current time 260, horizon 59\n", + "adding: mem time202, current time 260, horizon 58\n", + "adding: mem time203, current time 260, horizon 57\n", + "adding: mem time204, current time 260, horizon 56\n", + "adding: mem time205, current time 260, horizon 55\n", + "adding: mem time206, current time 260, horizon 54\n", + "adding: mem time207, current time 260, horizon 53\n", + "adding: mem time208, current time 260, horizon 52\n", + "adding: mem time209, current time 260, horizon 51\n", + "adding: mem time210, current time 260, horizon 50\n", + "adding: mem time211, current time 260, horizon 49\n", + "adding: mem time212, current time 260, horizon 48\n", + "adding: mem time213, current time 260, horizon 47\n", + "adding: mem time214, current time 260, horizon 46\n", + "adding: mem time215, current time 260, horizon 45\n", + "adding: mem time216, current time 260, horizon 44\n", + "adding: mem time217, current time 260, horizon 43\n", + "adding: mem time218, current time 260, horizon 42\n", + "adding: mem time219, current time 260, horizon 41\n", + "adding: mem time220, current time 260, horizon 40\n", + "adding: mem time221, current time 260, horizon 39\n", + "adding: mem time222, current time 260, horizon 38\n", + "adding: mem time223, current time 260, horizon 37\n", + "adding: mem time224, current time 260, horizon 36\n", + "adding: mem time225, current time 260, horizon 35\n", + "adding: mem time226, current time 260, horizon 34\n", + "adding: mem time227, current time 260, horizon 33\n", + "adding: mem time228, current time 260, horizon 32\n", + "adding: mem time229, current time 260, horizon 31\n", + "adding: mem time230, current time 260, horizon 30\n", + "adding: mem time231, current time 260, horizon 29\n", + "adding: mem time232, current time 260, horizon 28\n", + "adding: mem time233, current time 260, horizon 27\n", + "adding: mem time234, current time 260, horizon 26\n", + "adding: mem time235, current time 260, horizon 25\n", + "adding: mem time236, current time 260, horizon 24\n", + "adding: mem time237, current time 260, horizon 23\n", + "adding: mem time238, current time 260, horizon 22\n", + "adding: mem time239, current time 260, horizon 21\n", + "adding: mem time240, current time 260, horizon 20\n", + "adding: mem time241, current time 260, horizon 19\n", + "adding: mem time242, current time 260, horizon 18\n", + "adding: mem time243, current time 260, horizon 17\n", + "adding: mem time244, current time 260, horizon 16\n", + "adding: mem time245, current time 260, horizon 15\n", + "adding: mem time246, current time 260, horizon 14\n", + "adding: mem time247, current time 260, horizon 13\n", + "adding: mem time248, current time 260, horizon 12\n", + "adding: mem time249, current time 260, horizon 11\n", + "adding: mem time250, current time 260, horizon 10\n", + "adding: mem time251, current time 260, horizon 9\n", + "adding: mem time252, current time 260, horizon 8\n", + "adding: mem time253, current time 260, horizon 7\n", + "adding: mem time254, current time 260, horizon 6\n", + "adding: mem time255, current time 260, horizon 5\n", + "adding: mem time256, current time 260, horizon 4\n", + "adding: mem time257, current time 260, horizon 3\n", + "adding: mem time258, current time 260, horizon 2\n", + "adding: mem time259, current time 260, horizon 1\n", + "adding: mem time200, current time 261, horizon 61\n", + "adding: mem time201, current time 261, horizon 60\n", + "adding: mem time202, current time 261, horizon 59\n", + "adding: mem time203, current time 261, horizon 58\n", + "adding: mem time204, current time 261, horizon 57\n", + "adding: mem time205, current time 261, horizon 56\n", + "adding: mem time206, current time 261, horizon 55\n", + "adding: mem time207, current time 261, horizon 54\n", + "adding: mem time208, current time 261, horizon 53\n", + "adding: mem time209, current time 261, horizon 52\n", + "adding: mem time210, current time 261, horizon 51\n", + "adding: mem time211, current time 261, horizon 50\n", + "adding: mem time212, current time 261, horizon 49\n", + "adding: mem time213, current time 261, horizon 48\n", + "adding: mem time214, current time 261, horizon 47\n", + "adding: mem time215, current time 261, horizon 46\n", + "adding: mem time216, current time 261, horizon 45\n", + "adding: mem time217, current time 261, horizon 44\n", + "adding: mem time218, current time 261, horizon 43\n", + "adding: mem time219, current time 261, horizon 42\n", + "adding: mem time220, current time 261, horizon 41\n", + "adding: mem time221, current time 261, horizon 40\n", + "adding: mem time222, current time 261, horizon 39\n", + "adding: mem time223, current time 261, horizon 38\n", + "adding: mem time224, current time 261, horizon 37\n", + "adding: mem time225, current time 261, horizon 36\n", + "adding: mem time226, current time 261, horizon 35\n", + "adding: mem time227, current time 261, horizon 34\n", + "adding: mem time228, current time 261, horizon 33\n", + "adding: mem time229, current time 261, horizon 32\n", + "adding: mem time230, current time 261, horizon 31\n", + "adding: mem time231, current time 261, horizon 30\n", + "adding: mem time232, current time 261, horizon 29\n", + "adding: mem time233, current time 261, horizon 28\n", + "adding: mem time234, current time 261, horizon 27\n", + "adding: mem time235, current time 261, horizon 26\n", + "adding: mem time236, current time 261, horizon 25\n", + "adding: mem time237, current time 261, horizon 24\n", + "adding: mem time238, current time 261, horizon 23\n", + "adding: mem time239, current time 261, horizon 22\n", + "adding: mem time240, current time 261, horizon 21\n", + "adding: mem time241, current time 261, horizon 20\n", + "adding: mem time242, current time 261, horizon 19\n", + "adding: mem time243, current time 261, horizon 18\n", + "adding: mem time244, current time 261, horizon 17\n", + "adding: mem time245, current time 261, horizon 16\n", + "adding: mem time246, current time 261, horizon 15\n", + "adding: mem time247, current time 261, horizon 14\n", + "adding: mem time248, current time 261, horizon 13\n", + "adding: mem time249, current time 261, horizon 12\n", + "adding: mem time250, current time 261, horizon 11\n", + "adding: mem time251, current time 261, horizon 10\n", + "adding: mem time252, current time 261, horizon 9\n", + "adding: mem time253, current time 261, horizon 8\n", + "adding: mem time254, current time 261, horizon 7\n", + "adding: mem time255, current time 261, horizon 6\n", + "adding: mem time256, current time 261, horizon 5\n", + "adding: mem time257, current time 261, horizon 4\n", + "adding: mem time258, current time 261, horizon 3\n", + "adding: mem time259, current time 261, horizon 2\n", + "adding: mem time260, current time 261, horizon 1\n", + "adding: mem time200, current time 262, horizon 62\n", + "adding: mem time201, current time 262, horizon 61\n", + "adding: mem time202, current time 262, horizon 60\n", + "adding: mem time203, current time 262, horizon 59\n", + "adding: mem time204, current time 262, horizon 58\n", + "adding: mem time205, current time 262, horizon 57\n", + "adding: mem time206, current time 262, horizon 56\n", + "adding: mem time207, current time 262, horizon 55\n", + "adding: mem time208, current time 262, horizon 54\n", + "adding: mem time209, current time 262, horizon 53\n", + "adding: mem time210, current time 262, horizon 52\n", + "adding: mem time211, current time 262, horizon 51\n", + "adding: mem time212, current time 262, horizon 50\n", + "adding: mem time213, current time 262, horizon 49\n", + "adding: mem time214, current time 262, horizon 48\n", + "adding: mem time215, current time 262, horizon 47\n", + "adding: mem time216, current time 262, horizon 46\n", + "adding: mem time217, current time 262, horizon 45\n", + "adding: mem time218, current time 262, horizon 44\n", + "adding: mem time219, current time 262, horizon 43\n", + "adding: mem time220, current time 262, horizon 42\n", + "adding: mem time221, current time 262, horizon 41\n", + "adding: mem time222, current time 262, horizon 40\n", + "adding: mem time223, current time 262, horizon 39\n", + "adding: mem time224, current time 262, horizon 38\n", + "adding: mem time225, current time 262, horizon 37\n", + "adding: mem time226, current time 262, horizon 36\n", + "adding: mem time227, current time 262, horizon 35\n", + "adding: mem time228, current time 262, horizon 34\n", + "adding: mem time229, current time 262, horizon 33\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "adding: mem time230, current time 262, horizon 32\n", + "adding: mem time231, current time 262, horizon 31\n", + "adding: mem time232, current time 262, horizon 30\n", + "adding: mem time233, current time 262, horizon 29\n", + "adding: mem time234, current time 262, horizon 28\n", + "adding: mem time235, current time 262, horizon 27\n", + "adding: mem time236, current time 262, horizon 26\n", + "adding: mem time237, current time 262, horizon 25\n", + "adding: mem time238, current time 262, horizon 24\n", + "adding: mem time239, current time 262, horizon 23\n", + "adding: mem time240, current time 262, horizon 22\n", + "adding: mem time241, current time 262, horizon 21\n", + "adding: mem time242, current time 262, horizon 20\n", + "adding: mem time243, current time 262, horizon 19\n", + "adding: mem time244, current time 262, horizon 18\n", + "adding: mem time245, current time 262, horizon 17\n", + "adding: mem time246, current time 262, horizon 16\n", + "adding: mem time247, current time 262, horizon 15\n", + "adding: mem time248, current time 262, horizon 14\n", + "adding: mem time249, current time 262, horizon 13\n", + "adding: mem time250, current time 262, horizon 12\n", + "adding: mem time251, current time 262, horizon 11\n", + "adding: mem time252, current time 262, horizon 10\n", + "adding: mem time253, current time 262, horizon 9\n", + "adding: mem time254, current time 262, horizon 8\n", + "adding: mem time255, current time 262, horizon 7\n", + "adding: mem time256, current time 262, horizon 6\n", + "adding: mem time257, current time 262, horizon 5\n", + "adding: mem time258, current time 262, horizon 4\n", + "adding: mem time259, current time 262, horizon 3\n", + "adding: mem time260, current time 262, horizon 2\n", + "adding: mem time261, current time 262, horizon 1\n", + "adding: mem time200, current time 263, horizon 63\n", + "adding: mem time201, current time 263, horizon 62\n", + "adding: mem time202, current time 263, horizon 61\n", + "adding: mem time203, current time 263, horizon 60\n", + "adding: mem time204, current time 263, horizon 59\n", + "adding: mem time205, current time 263, horizon 58\n", + "adding: mem time206, current time 263, horizon 57\n", + "adding: mem time207, current time 263, horizon 56\n", + "adding: mem time208, current time 263, horizon 55\n", + "adding: mem time209, current time 263, horizon 54\n", + "adding: mem time210, current time 263, horizon 53\n", + "adding: mem time211, current time 263, horizon 52\n", + "adding: mem time212, current time 263, horizon 51\n", + "adding: mem time213, current time 263, horizon 50\n", + "adding: mem time214, current time 263, horizon 49\n", + "adding: mem time215, current time 263, horizon 48\n", + "adding: mem time216, current time 263, horizon 47\n", + "adding: mem time217, current time 263, horizon 46\n", + "adding: mem time218, current time 263, horizon 45\n", + "adding: mem time219, current time 263, horizon 44\n", + "adding: mem time220, current time 263, horizon 43\n", + "adding: mem time221, current time 263, horizon 42\n", + "adding: mem time222, current time 263, horizon 41\n", + "adding: mem time223, current time 263, horizon 40\n", + "adding: mem time224, current time 263, horizon 39\n", + "adding: mem time225, current time 263, horizon 38\n", + "adding: mem time226, current time 263, horizon 37\n", + "adding: mem time227, current time 263, horizon 36\n", + "adding: mem time228, current time 263, horizon 35\n", + "adding: mem time229, current time 263, horizon 34\n", + "adding: mem time230, current time 263, horizon 33\n", + "adding: mem time231, current time 263, horizon 32\n", + "adding: mem time232, current time 263, horizon 31\n", + "adding: mem time233, current time 263, horizon 30\n", + "adding: mem time234, current time 263, horizon 29\n", + "adding: mem time235, current time 263, horizon 28\n", + "adding: mem time236, current time 263, horizon 27\n", + "adding: mem time237, current time 263, horizon 26\n", + "adding: mem time238, current time 263, horizon 25\n", + "adding: mem time239, current time 263, horizon 24\n", + "adding: mem time240, current time 263, horizon 23\n", + "adding: mem time241, current time 263, horizon 22\n", + "adding: mem time242, current time 263, horizon 21\n", + "adding: mem time243, current time 263, horizon 20\n", + "adding: mem time244, current time 263, horizon 19\n", + "adding: mem time245, current time 263, horizon 18\n", + "adding: mem time246, current time 263, horizon 17\n", + "adding: mem time247, current time 263, horizon 16\n", + "adding: mem time248, current time 263, horizon 15\n", + "adding: mem time249, current time 263, horizon 14\n", + "adding: mem time250, current time 263, horizon 13\n", + "adding: mem time251, current time 263, horizon 12\n", + "adding: mem time252, current time 263, horizon 11\n", + "adding: mem time253, current time 263, horizon 10\n", + "adding: mem time254, current time 263, horizon 9\n", + "adding: mem time255, current time 263, horizon 8\n", + "adding: mem time256, current time 263, horizon 7\n", + "adding: mem time257, current time 263, horizon 6\n", + "adding: mem time258, current time 263, horizon 5\n", + "adding: mem time259, current time 263, horizon 4\n", + "adding: mem time260, current time 263, horizon 3\n", + "adding: mem time261, current time 263, horizon 2\n", + "adding: mem time262, current time 263, horizon 1\n", + "adding: mem time200, current time 264, horizon 64\n", + "adding: mem time201, current time 264, horizon 63\n", + "adding: mem time202, current time 264, horizon 62\n", + "adding: mem time203, current time 264, horizon 61\n", + "adding: mem time204, current time 264, horizon 60\n", + "adding: mem time205, current time 264, horizon 59\n", + "adding: mem time206, current time 264, horizon 58\n", + "adding: mem time207, current time 264, horizon 57\n", + "adding: mem time208, current time 264, horizon 56\n", + "adding: mem time209, current time 264, horizon 55\n", + "adding: mem time210, current time 264, horizon 54\n", + "adding: mem time211, current time 264, horizon 53\n", + "adding: mem time212, current time 264, horizon 52\n", + "adding: mem time213, current time 264, horizon 51\n", + "adding: mem time214, current time 264, horizon 50\n", + "adding: mem time215, current time 264, horizon 49\n", + "adding: mem time216, current time 264, horizon 48\n", + "adding: mem time217, current time 264, horizon 47\n", + "adding: mem time218, current time 264, horizon 46\n", + "adding: mem time219, current time 264, horizon 45\n", + "adding: mem time220, current time 264, horizon 44\n", + "adding: mem time221, current time 264, horizon 43\n", + "adding: mem time222, current time 264, horizon 42\n", + "adding: mem time223, current time 264, horizon 41\n", + "adding: mem time224, current time 264, horizon 40\n", + "adding: mem time225, current time 264, horizon 39\n", + "adding: mem time226, current time 264, horizon 38\n", + "adding: mem time227, current time 264, horizon 37\n", + "adding: mem time228, current time 264, horizon 36\n", + "adding: mem time229, current time 264, horizon 35\n", + "adding: mem time230, current time 264, horizon 34\n", + "adding: mem time231, current time 264, horizon 33\n", + "adding: mem time232, current time 264, horizon 32\n", + "adding: mem time233, current time 264, horizon 31\n", + "adding: mem time234, current time 264, horizon 30\n", + "adding: mem time235, current time 264, horizon 29\n", + "adding: mem time236, current time 264, horizon 28\n", + "adding: mem time237, current time 264, horizon 27\n", + "adding: mem time238, current time 264, horizon 26\n", + "adding: mem time239, current time 264, horizon 25\n", + "adding: mem time240, current time 264, horizon 24\n", + "adding: mem time241, current time 264, horizon 23\n", + "adding: mem time242, current time 264, horizon 22\n", + "adding: mem time243, current time 264, horizon 21\n", + "adding: mem time244, current time 264, horizon 20\n", + "adding: mem time245, current time 264, horizon 19\n", + "adding: mem time246, current time 264, horizon 18\n", + "adding: mem time247, current time 264, horizon 17\n", + "adding: mem time248, current time 264, horizon 16\n", + "adding: mem time249, current time 264, horizon 15\n", + "adding: mem time250, current time 264, horizon 14\n", + "adding: mem time251, current time 264, horizon 13\n", + "adding: mem time252, current time 264, horizon 12\n", + "adding: mem time253, current time 264, horizon 11\n", + "adding: mem time254, current time 264, horizon 10\n", + "adding: mem time255, current time 264, horizon 9\n", + "adding: mem time256, current time 264, horizon 8\n", + "adding: mem time257, current time 264, horizon 7\n", + "adding: mem time258, current time 264, horizon 6\n", + "adding: mem time259, current time 264, horizon 5\n", + "adding: mem time260, current time 264, horizon 4\n", + "adding: mem time261, current time 264, horizon 3\n", + "adding: mem time262, current time 264, horizon 2\n", + "adding: mem time263, current time 264, horizon 1\n", + "adding: mem time200, current time 265, horizon 65\n", + "adding: mem time201, current time 265, horizon 64\n", + "adding: mem time202, current time 265, horizon 63\n", + "adding: mem time203, current time 265, horizon 62\n", + "adding: mem time204, current time 265, horizon 61\n", + "adding: mem time205, current time 265, horizon 60\n", + "adding: mem time206, current time 265, horizon 59\n", + "adding: mem time207, current time 265, horizon 58\n", + "adding: mem time208, current time 265, horizon 57\n", + "adding: mem time209, current time 265, horizon 56\n", + "adding: mem time210, current time 265, horizon 55\n", + "adding: mem time211, current time 265, horizon 54\n", + "adding: mem time212, current time 265, horizon 53\n", + "adding: mem time213, current time 265, horizon 52\n", + "adding: mem time214, current time 265, horizon 51\n", + "adding: mem time215, current time 265, horizon 50\n", + "adding: mem time216, current time 265, horizon 49\n", + "adding: mem time217, current time 265, horizon 48\n", + "adding: mem time218, current time 265, horizon 47\n", + "adding: mem time219, current time 265, horizon 46\n", + "adding: mem time220, current time 265, horizon 45\n", + "adding: mem time221, current time 265, horizon 44\n", + "adding: mem time222, current time 265, horizon 43\n", + "adding: mem time223, current time 265, horizon 42\n", + "adding: mem time224, current time 265, horizon 41\n", + "adding: mem time225, current time 265, horizon 40\n", + "adding: mem time226, current time 265, horizon 39\n", + "adding: mem time227, current time 265, horizon 38\n", + "adding: mem time228, current time 265, horizon 37\n", + "adding: mem time229, current time 265, horizon 36\n", + "adding: mem time230, current time 265, horizon 35\n", + "adding: mem time231, current time 265, horizon 34\n", + "adding: mem time232, current time 265, horizon 33\n", + "adding: mem time233, current time 265, horizon 32\n", + "adding: mem time234, current time 265, horizon 31\n", + "adding: mem time235, current time 265, horizon 30\n", + "adding: mem time236, current time 265, horizon 29\n", + "adding: mem time237, current time 265, horizon 28\n", + "adding: mem time238, current time 265, horizon 27\n", + "adding: mem time239, current time 265, horizon 26\n", + "adding: mem time240, current time 265, horizon 25\n", + "adding: mem time241, current time 265, horizon 24\n", + "adding: mem time242, current time 265, horizon 23\n", + "adding: mem time243, current time 265, horizon 22\n", + "adding: mem time244, current time 265, horizon 21\n", + "adding: mem time245, current time 265, horizon 20\n", + "adding: mem time246, current time 265, horizon 19\n", + "adding: mem time247, current time 265, horizon 18\n", + "adding: mem time248, current time 265, horizon 17\n", + "adding: mem time249, current time 265, horizon 16\n", + "adding: mem time250, current time 265, horizon 15\n", + "adding: mem time251, current time 265, horizon 14\n", + "adding: mem time252, current time 265, horizon 13\n", + "adding: mem time253, current time 265, horizon 12\n", + "adding: mem time254, current time 265, horizon 11\n", + "adding: mem time255, current time 265, horizon 10\n", + "adding: mem time256, current time 265, horizon 9\n", + "adding: mem time257, current time 265, horizon 8\n", + "adding: mem time258, current time 265, horizon 7\n", + "adding: mem time259, current time 265, horizon 6\n", + "adding: mem time260, current time 265, horizon 5\n", + "adding: mem time261, current time 265, horizon 4\n", + "adding: mem time262, current time 265, horizon 3\n", + "adding: mem time263, current time 265, horizon 2\n", + "adding: mem time264, current time 265, horizon 1\n", + "adding: mem time200, current time 266, horizon 66\n", + "adding: mem time201, current time 266, horizon 65\n", + "adding: mem time202, current time 266, horizon 64\n", + "adding: mem time203, current time 266, horizon 63\n", + "adding: mem time204, current time 266, horizon 62\n", + "adding: mem time205, current time 266, horizon 61\n", + "adding: mem time206, current time 266, horizon 60\n", + "adding: mem time207, current time 266, horizon 59\n", + "adding: mem time208, current time 266, horizon 58\n", + "adding: mem time209, current time 266, horizon 57\n", + "adding: mem time210, current time 266, horizon 56\n", + "adding: mem time211, current time 266, horizon 55\n", + "adding: mem time212, current time 266, horizon 54\n", + "adding: mem time213, current time 266, horizon 53\n", + "adding: mem time214, current time 266, horizon 52\n", + "adding: mem time215, current time 266, horizon 51\n", + "adding: mem time216, current time 266, horizon 50\n", + "adding: mem time217, current time 266, horizon 49\n", + "adding: mem time218, current time 266, horizon 48\n", + "adding: mem time219, current time 266, horizon 47\n", + "adding: mem time220, current time 266, horizon 46\n", + "adding: mem time221, current time 266, horizon 45\n", + "adding: mem time222, current time 266, horizon 44\n", + "adding: mem time223, current time 266, horizon 43\n", + "adding: mem time224, current time 266, horizon 42\n", + "adding: mem time225, current time 266, horizon 41\n", + "adding: mem time226, current time 266, horizon 40\n", + "adding: mem time227, current time 266, horizon 39\n", + "adding: mem time228, current time 266, horizon 38\n", + "adding: mem time229, current time 266, horizon 37\n", + "adding: mem time230, current time 266, horizon 36\n", + "adding: mem time231, current time 266, horizon 35\n", + "adding: mem time232, current time 266, horizon 34\n", + "adding: mem time233, current time 266, horizon 33\n", + "adding: mem time234, current time 266, horizon 32\n", + "adding: mem time235, current time 266, horizon 31\n", + "adding: mem time236, current time 266, horizon 30\n", + "adding: mem time237, current time 266, horizon 29\n", + "adding: mem time238, current time 266, horizon 28\n", + "adding: mem time239, current time 266, horizon 27\n", + "adding: mem time240, current time 266, horizon 26\n", + "adding: mem time241, current time 266, horizon 25\n", + "adding: mem time242, current time 266, horizon 24\n", + "adding: mem time243, current time 266, horizon 23\n", + "adding: mem time244, current time 266, horizon 22\n", + "adding: mem time245, current time 266, horizon 21\n", + "adding: mem time246, current time 266, horizon 20\n", + "adding: mem time247, current time 266, horizon 19\n", + "adding: mem time248, current time 266, horizon 18\n", + "adding: mem time249, current time 266, horizon 17\n", + "adding: mem time250, current time 266, horizon 16\n", + "adding: mem time251, current time 266, horizon 15\n", + "adding: mem time252, current time 266, horizon 14\n", + "adding: mem time253, current time 266, horizon 13\n", + "adding: mem time254, current time 266, horizon 12\n", + "adding: mem time255, current time 266, horizon 11\n", + "adding: mem time256, current time 266, horizon 10\n", + "adding: mem time257, current time 266, horizon 9\n", + "adding: mem time258, current time 266, horizon 8\n", + "adding: mem time259, current time 266, horizon 7\n", + "adding: mem time260, current time 266, horizon 6\n", + "adding: mem time261, current time 266, horizon 5\n", + "adding: mem time262, current time 266, horizon 4\n", + "adding: mem time263, current time 266, horizon 3\n", + "adding: mem time264, current time 266, horizon 2\n", + "adding: mem time265, current time 266, horizon 1\n", + "adding: mem time200, current time 267, horizon 67\n", + "adding: mem time201, current time 267, horizon 66\n", + "adding: mem time202, current time 267, horizon 65\n", + "adding: mem time203, current time 267, horizon 64\n", + "adding: mem time204, current time 267, horizon 63\n", + "adding: mem time205, current time 267, horizon 62\n", + "adding: mem time206, current time 267, horizon 61\n", + "adding: mem time207, current time 267, horizon 60\n", + "adding: mem time208, current time 267, horizon 59\n", + "adding: mem time209, current time 267, horizon 58\n", + "adding: mem time210, current time 267, horizon 57\n", + "adding: mem time211, current time 267, horizon 56\n", + "adding: mem time212, current time 267, horizon 55\n", + "adding: mem time213, current time 267, horizon 54\n", + "adding: mem time214, current time 267, horizon 53\n", + "adding: mem time215, current time 267, horizon 52\n", + "adding: mem time216, current time 267, horizon 51\n", + "adding: mem time217, current time 267, horizon 50\n", + "adding: mem time218, current time 267, horizon 49\n", + "adding: mem time219, current time 267, horizon 48\n", + "adding: mem time220, current time 267, horizon 47\n", + "adding: mem time221, current time 267, horizon 46\n", + "adding: mem time222, current time 267, horizon 45\n", + "adding: mem time223, current time 267, horizon 44\n", + "adding: mem time224, current time 267, horizon 43\n", + "adding: mem time225, current time 267, horizon 42\n", + "adding: mem time226, current time 267, horizon 41\n", + "adding: mem time227, current time 267, horizon 40\n", + "adding: mem time228, current time 267, horizon 39\n", + "adding: mem time229, current time 267, horizon 38\n", + "adding: mem time230, current time 267, horizon 37\n", + "adding: mem time231, current time 267, horizon 36\n", + "adding: mem time232, current time 267, horizon 35\n", + "adding: mem time233, current time 267, horizon 34\n", + "adding: mem time234, current time 267, horizon 33\n", + "adding: mem time235, current time 267, horizon 32\n", + "adding: mem time236, current time 267, horizon 31\n", + "adding: mem time237, current time 267, horizon 30\n", + "adding: mem time238, current time 267, horizon 29\n", + "adding: mem time239, current time 267, horizon 28\n", + "adding: mem time240, current time 267, horizon 27\n", + "adding: mem time241, current time 267, horizon 26\n", + "adding: mem time242, current time 267, horizon 25\n", + "adding: mem time243, current time 267, horizon 24\n", + "adding: mem time244, current time 267, horizon 23\n", + "adding: mem time245, current time 267, horizon 22\n", + "adding: mem time246, current time 267, horizon 21\n", + "adding: mem time247, current time 267, horizon 20\n", + "adding: mem time248, current time 267, horizon 19\n", + "adding: mem time249, current time 267, horizon 18\n", + "adding: mem time250, current time 267, horizon 17\n", + "adding: mem time251, current time 267, horizon 16\n", + "adding: mem time252, current time 267, horizon 15\n", + "adding: mem time253, current time 267, horizon 14\n", + "adding: mem time254, current time 267, horizon 13\n", + "adding: mem time255, current time 267, horizon 12\n", + "adding: mem time256, current time 267, horizon 11\n", + "adding: mem time257, current time 267, horizon 10\n", + "adding: mem time258, current time 267, horizon 9\n", + "adding: mem time259, current time 267, horizon 8\n", + "adding: mem time260, current time 267, horizon 7\n", + "adding: mem time261, current time 267, horizon 6\n", + "adding: mem time262, current time 267, horizon 5\n", + "adding: mem time263, current time 267, horizon 4\n", + "adding: mem time264, current time 267, horizon 3\n", + "adding: mem time265, current time 267, horizon 2\n", + "adding: mem time266, current time 267, horizon 1\n", + "adding: mem time200, current time 268, horizon 68\n", + "adding: mem time201, current time 268, horizon 67\n", + "adding: mem time202, current time 268, horizon 66\n", + "adding: mem time203, current time 268, horizon 65\n", + "adding: mem time204, current time 268, horizon 64\n", + "adding: mem time205, current time 268, horizon 63\n", + "adding: mem time206, current time 268, horizon 62\n", + "adding: mem time207, current time 268, horizon 61\n", + "adding: mem time208, current time 268, horizon 60\n", + "adding: mem time209, current time 268, horizon 59\n", + "adding: mem time210, current time 268, horizon 58\n", + "adding: mem time211, current time 268, horizon 57\n", + "adding: mem time212, current time 268, horizon 56\n", + "adding: mem time213, current time 268, horizon 55\n", + "adding: mem time214, current time 268, horizon 54\n", + "adding: mem time215, current time 268, horizon 53\n", + "adding: mem time216, current time 268, horizon 52\n", + "adding: mem time217, current time 268, horizon 51\n", + "adding: mem time218, current time 268, horizon 50\n", + "adding: mem time219, current time 268, horizon 49\n", + "adding: mem time220, current time 268, horizon 48\n", + "adding: mem time221, current time 268, horizon 47\n", + "adding: mem time222, current time 268, horizon 46\n", + "adding: mem time223, current time 268, horizon 45\n", + "adding: mem time224, current time 268, horizon 44\n", + "adding: mem time225, current time 268, horizon 43\n", + "adding: mem time226, current time 268, horizon 42\n", + "adding: mem time227, current time 268, horizon 41\n", + "adding: mem time228, current time 268, horizon 40\n", + "adding: mem time229, current time 268, horizon 39\n", + "adding: mem time230, current time 268, horizon 38\n", + "adding: mem time231, current time 268, horizon 37\n", + "adding: mem time232, current time 268, horizon 36\n", + "adding: mem time233, current time 268, horizon 35\n", + "adding: mem time234, current time 268, horizon 34\n", + "adding: mem time235, current time 268, horizon 33\n", + "adding: mem time236, current time 268, horizon 32\n", + "adding: mem time237, current time 268, horizon 31\n", + "adding: mem time238, current time 268, horizon 30\n", + "adding: mem time239, current time 268, horizon 29\n", + "adding: mem time240, current time 268, horizon 28\n", + "adding: mem time241, current time 268, horizon 27\n", + "adding: mem time242, current time 268, horizon 26\n", + "adding: mem time243, current time 268, horizon 25\n", + "adding: mem time244, current time 268, horizon 24\n", + "adding: mem time245, current time 268, horizon 23\n", + "adding: mem time246, current time 268, horizon 22\n", + "adding: mem time247, current time 268, horizon 21\n", + "adding: mem time248, current time 268, horizon 20\n", + "adding: mem time249, current time 268, horizon 19\n", + "adding: mem time250, current time 268, horizon 18\n", + "adding: mem time251, current time 268, horizon 17\n", + "adding: mem time252, current time 268, horizon 16\n", + "adding: mem time253, current time 268, horizon 15\n", + "adding: mem time254, current time 268, horizon 14\n", + "adding: mem time255, current time 268, horizon 13\n", + "adding: mem time256, current time 268, horizon 12\n", + "adding: mem time257, current time 268, horizon 11\n", + "adding: mem time258, current time 268, horizon 10\n", + "adding: mem time259, current time 268, horizon 9\n", + "adding: mem time260, current time 268, horizon 8\n", + "adding: mem time261, current time 268, horizon 7\n", + "adding: mem time262, current time 268, horizon 6\n", + "adding: mem time263, current time 268, horizon 5\n", + "adding: mem time264, current time 268, horizon 4\n", + "adding: mem time265, current time 268, horizon 3\n", + "adding: mem time266, current time 268, horizon 2\n", + "adding: mem time267, current time 268, horizon 1\n", + "adding: mem time200, current time 269, horizon 69\n", + "adding: mem time201, current time 269, horizon 68\n", + "adding: mem time202, current time 269, horizon 67\n", + "adding: mem time203, current time 269, horizon 66\n", + "adding: mem time204, current time 269, horizon 65\n", + "adding: mem time205, current time 269, horizon 64\n", + "adding: mem time206, current time 269, horizon 63\n", + "adding: mem time207, current time 269, horizon 62\n", + "adding: mem time208, current time 269, horizon 61\n", + "adding: mem time209, current time 269, horizon 60\n", + "adding: mem time210, current time 269, horizon 59\n", + "adding: mem time211, current time 269, horizon 58\n", + "adding: mem time212, current time 269, horizon 57\n", + "adding: mem time213, current time 269, horizon 56\n", + "adding: mem time214, current time 269, horizon 55\n", + "adding: mem time215, current time 269, horizon 54\n", + "adding: mem time216, current time 269, horizon 53\n", + "adding: mem time217, current time 269, horizon 52\n", + "adding: mem time218, current time 269, horizon 51\n", + "adding: mem time219, current time 269, horizon 50\n", + "adding: mem time220, current time 269, horizon 49\n", + "adding: mem time221, current time 269, horizon 48\n", + "adding: mem time222, current time 269, horizon 47\n", + "adding: mem time223, current time 269, horizon 46\n", + "adding: mem time224, current time 269, horizon 45\n", + "adding: mem time225, current time 269, horizon 44\n", + "adding: mem time226, current time 269, horizon 43\n", + "adding: mem time227, current time 269, horizon 42\n", + "adding: mem time228, current time 269, horizon 41\n", + "adding: mem time229, current time 269, horizon 40\n", + "adding: mem time230, current time 269, horizon 39\n", + "adding: mem time231, current time 269, horizon 38\n", + "adding: mem time232, current time 269, horizon 37\n", + "adding: mem time233, current time 269, horizon 36\n", + "adding: mem time234, current time 269, horizon 35\n", + "adding: mem time235, current time 269, horizon 34\n", + "adding: mem time236, current time 269, horizon 33\n", + "adding: mem time237, current time 269, horizon 32\n", + "adding: mem time238, current time 269, horizon 31\n", + "adding: mem time239, current time 269, horizon 30\n", + "adding: mem time240, current time 269, horizon 29\n", + "adding: mem time241, current time 269, horizon 28\n", + "adding: mem time242, current time 269, horizon 27\n", + "adding: mem time243, current time 269, horizon 26\n", + "adding: mem time244, current time 269, horizon 25\n", + "adding: mem time245, current time 269, horizon 24\n", + "adding: mem time246, current time 269, horizon 23\n", + "adding: mem time247, current time 269, horizon 22\n", + "adding: mem time248, current time 269, horizon 21\n", + "adding: mem time249, current time 269, horizon 20\n", + "adding: mem time250, current time 269, horizon 19\n", + "adding: mem time251, current time 269, horizon 18\n", + "adding: mem time252, current time 269, horizon 17\n", + "adding: mem time253, current time 269, horizon 16\n", + "adding: mem time254, current time 269, horizon 15\n", + "adding: mem time255, current time 269, horizon 14\n", + "adding: mem time256, current time 269, horizon 13\n", + "adding: mem time257, current time 269, horizon 12\n", + "adding: mem time258, current time 269, horizon 11\n", + "adding: mem time259, current time 269, horizon 10\n", + "adding: mem time260, current time 269, horizon 9\n", + "adding: mem time261, current time 269, horizon 8\n", + "adding: mem time262, current time 269, horizon 7\n", + "adding: mem time263, current time 269, horizon 6\n", + "adding: mem time264, current time 269, horizon 5\n", + "adding: mem time265, current time 269, horizon 4\n", + "adding: mem time266, current time 269, horizon 3\n", + "adding: mem time267, current time 269, horizon 2\n", + "adding: mem time268, current time 269, horizon 1\n", + "adding: mem time200, current time 270, horizon 70\n", + "adding: mem time201, current time 270, horizon 69\n", + "adding: mem time202, current time 270, horizon 68\n", + "adding: mem time203, current time 270, horizon 67\n", + "adding: mem time204, current time 270, horizon 66\n", + "adding: mem time205, current time 270, horizon 65\n", + "adding: mem time206, current time 270, horizon 64\n", + "adding: mem time207, current time 270, horizon 63\n", + "adding: mem time208, current time 270, horizon 62\n", + "adding: mem time209, current time 270, horizon 61\n", + "adding: mem time210, current time 270, horizon 60\n", + "adding: mem time211, current time 270, horizon 59\n", + "adding: mem time212, current time 270, horizon 58\n", + "adding: mem time213, current time 270, horizon 57\n", + "adding: mem time214, current time 270, horizon 56\n", + "adding: mem time215, current time 270, horizon 55\n", + "adding: mem time216, current time 270, horizon 54\n", + "adding: mem time217, current time 270, horizon 53\n", + "adding: mem time218, current time 270, horizon 52\n", + "adding: mem time219, current time 270, horizon 51\n", + "adding: mem time220, current time 270, horizon 50\n", + "adding: mem time221, current time 270, horizon 49\n", + "adding: mem time222, current time 270, horizon 48\n", + "adding: mem time223, current time 270, horizon 47\n", + "adding: mem time224, current time 270, horizon 46\n", + "adding: mem time225, current time 270, horizon 45\n", + "adding: mem time226, current time 270, horizon 44\n", + "adding: mem time227, current time 270, horizon 43\n", + "adding: mem time228, current time 270, horizon 42\n", + "adding: mem time229, current time 270, horizon 41\n", + "adding: mem time230, current time 270, horizon 40\n", + "adding: mem time231, current time 270, horizon 39\n", + "adding: mem time232, current time 270, horizon 38\n", + "adding: mem time233, current time 270, horizon 37\n", + "adding: mem time234, current time 270, horizon 36\n", + "adding: mem time235, current time 270, horizon 35\n", + "adding: mem time236, current time 270, horizon 34\n", + "adding: mem time237, current time 270, horizon 33\n", + "adding: mem time238, current time 270, horizon 32\n", + "adding: mem time239, current time 270, horizon 31\n", + "adding: mem time240, current time 270, horizon 30\n", + "adding: mem time241, current time 270, horizon 29\n", + "adding: mem time242, current time 270, horizon 28\n", + "adding: mem time243, current time 270, horizon 27\n", + "adding: mem time244, current time 270, horizon 26\n", + "adding: mem time245, current time 270, horizon 25\n", + "adding: mem time246, current time 270, horizon 24\n", + "adding: mem time247, current time 270, horizon 23\n", + "adding: mem time248, current time 270, horizon 22\n", + "adding: mem time249, current time 270, horizon 21\n", + "adding: mem time250, current time 270, horizon 20\n", + "adding: mem time251, current time 270, horizon 19\n", + "adding: mem time252, current time 270, horizon 18\n", + "adding: mem time253, current time 270, horizon 17\n", + "adding: mem time254, current time 270, horizon 16\n", + "adding: mem time255, current time 270, horizon 15\n", + "adding: mem time256, current time 270, horizon 14\n", + "adding: mem time257, current time 270, horizon 13\n", + "adding: mem time258, current time 270, horizon 12\n", + "adding: mem time259, current time 270, horizon 11\n", + "adding: mem time260, current time 270, horizon 10\n", + "adding: mem time261, current time 270, horizon 9\n", + "adding: mem time262, current time 270, horizon 8\n", + "adding: mem time263, current time 270, horizon 7\n", + "adding: mem time264, current time 270, horizon 6\n", + "adding: mem time265, current time 270, horizon 5\n", + "adding: mem time266, current time 270, horizon 4\n", + "adding: mem time267, current time 270, horizon 3\n", + "adding: mem time268, current time 270, horizon 2\n", + "adding: mem time269, current time 270, horizon 1\n", + "adding: mem time200, current time 271, horizon 71\n", + "adding: mem time201, current time 271, horizon 70\n", + "adding: mem time202, current time 271, horizon 69\n", + "adding: mem time203, current time 271, horizon 68\n", + "adding: mem time204, current time 271, horizon 67\n", + "adding: mem time205, current time 271, horizon 66\n", + "adding: mem time206, current time 271, horizon 65\n", + "adding: mem time207, current time 271, horizon 64\n", + "adding: mem time208, current time 271, horizon 63\n", + "adding: mem time209, current time 271, horizon 62\n", + "adding: mem time210, current time 271, horizon 61\n", + "adding: mem time211, current time 271, horizon 60\n", + "adding: mem time212, current time 271, horizon 59\n", + "adding: mem time213, current time 271, horizon 58\n", + "adding: mem time214, current time 271, horizon 57\n", + "adding: mem time215, current time 271, horizon 56\n", + "adding: mem time216, current time 271, horizon 55\n", + "adding: mem time217, current time 271, horizon 54\n", + "adding: mem time218, current time 271, horizon 53\n", + "adding: mem time219, current time 271, horizon 52\n", + "adding: mem time220, current time 271, horizon 51\n", + "adding: mem time221, current time 271, horizon 50\n", + "adding: mem time222, current time 271, horizon 49\n", + "adding: mem time223, current time 271, horizon 48\n", + "adding: mem time224, current time 271, horizon 47\n", + "adding: mem time225, current time 271, horizon 46\n", + "adding: mem time226, current time 271, horizon 45\n", + "adding: mem time227, current time 271, horizon 44\n", + "adding: mem time228, current time 271, horizon 43\n", + "adding: mem time229, current time 271, horizon 42\n", + "adding: mem time230, current time 271, horizon 41\n", + "adding: mem time231, current time 271, horizon 40\n", + "adding: mem time232, current time 271, horizon 39\n", + "adding: mem time233, current time 271, horizon 38\n", + "adding: mem time234, current time 271, horizon 37\n", + "adding: mem time235, current time 271, horizon 36\n", + "adding: mem time236, current time 271, horizon 35\n", + "adding: mem time237, current time 271, horizon 34\n", + "adding: mem time238, current time 271, horizon 33\n", + "adding: mem time239, current time 271, horizon 32\n", + "adding: mem time240, current time 271, horizon 31\n", + "adding: mem time241, current time 271, horizon 30\n", + "adding: mem time242, current time 271, horizon 29\n", + "adding: mem time243, current time 271, horizon 28\n", + "adding: mem time244, current time 271, horizon 27\n", + "adding: mem time245, current time 271, horizon 26\n", + "adding: mem time246, current time 271, horizon 25\n", + "adding: mem time247, current time 271, horizon 24\n", + "adding: mem time248, current time 271, horizon 23\n", + "adding: mem time249, current time 271, horizon 22\n", + "adding: mem time250, current time 271, horizon 21\n", + "adding: mem time251, current time 271, horizon 20\n", + "adding: mem time252, current time 271, horizon 19\n", + "adding: mem time253, current time 271, horizon 18\n", + "adding: mem time254, current time 271, horizon 17\n", + "adding: mem time255, current time 271, horizon 16\n", + "adding: mem time256, current time 271, horizon 15\n", + "adding: mem time257, current time 271, horizon 14\n", + "adding: mem time258, current time 271, horizon 13\n", + "adding: mem time259, current time 271, horizon 12\n", + "adding: mem time260, current time 271, horizon 11\n", + "adding: mem time261, current time 271, horizon 10\n", + "adding: mem time262, current time 271, horizon 9\n", + "adding: mem time263, current time 271, horizon 8\n", + "adding: mem time264, current time 271, horizon 7\n", + "adding: mem time265, current time 271, horizon 6\n", + "adding: mem time266, current time 271, horizon 5\n", + "adding: mem time267, current time 271, horizon 4\n", + "adding: mem time268, current time 271, horizon 3\n", + "adding: mem time269, current time 271, horizon 2\n", + "adding: mem time270, current time 271, horizon 1\n", + "adding: mem time200, current time 272, horizon 72\n", + "adding: mem time201, current time 272, horizon 71\n", + "adding: mem time202, current time 272, horizon 70\n", + "adding: mem time203, current time 272, horizon 69\n", + "adding: mem time204, current time 272, horizon 68\n", + "adding: mem time205, current time 272, horizon 67\n", + "adding: mem time206, current time 272, horizon 66\n", + "adding: mem time207, current time 272, horizon 65\n", + "adding: mem time208, current time 272, horizon 64\n", + "adding: mem time209, current time 272, horizon 63\n", + "adding: mem time210, current time 272, horizon 62\n", + "adding: mem time211, current time 272, horizon 61\n", + "adding: mem time212, current time 272, horizon 60\n", + "adding: mem time213, current time 272, horizon 59\n", + "adding: mem time214, current time 272, horizon 58\n", + "adding: mem time215, current time 272, horizon 57\n", + "adding: mem time216, current time 272, horizon 56\n", + "adding: mem time217, current time 272, horizon 55\n", + "adding: mem time218, current time 272, horizon 54\n", + "adding: mem time219, current time 272, horizon 53\n", + "adding: mem time220, current time 272, horizon 52\n", + "adding: mem time221, current time 272, horizon 51\n", + "adding: mem time222, current time 272, horizon 50\n", + "adding: mem time223, current time 272, horizon 49\n", + "adding: mem time224, current time 272, horizon 48\n", + "adding: mem time225, current time 272, horizon 47\n", + "adding: mem time226, current time 272, horizon 46\n", + "adding: mem time227, current time 272, horizon 45\n", + "adding: mem time228, current time 272, horizon 44\n", + "adding: mem time229, current time 272, horizon 43\n", + "adding: mem time230, current time 272, horizon 42\n", + "adding: mem time231, current time 272, horizon 41\n", + "adding: mem time232, current time 272, horizon 40\n", + "adding: mem time233, current time 272, horizon 39\n", + "adding: mem time234, current time 272, horizon 38\n", + "adding: mem time235, current time 272, horizon 37\n", + "adding: mem time236, current time 272, horizon 36\n", + "adding: mem time237, current time 272, horizon 35\n", + "adding: mem time238, current time 272, horizon 34\n", + "adding: mem time239, current time 272, horizon 33\n", + "adding: mem time240, current time 272, horizon 32\n", + "adding: mem time241, current time 272, horizon 31\n", + "adding: mem time242, current time 272, horizon 30\n", + "adding: mem time243, current time 272, horizon 29\n", + "adding: mem time244, current time 272, horizon 28\n", + "adding: mem time245, current time 272, horizon 27\n", + "adding: mem time246, current time 272, horizon 26\n", + "adding: mem time247, current time 272, horizon 25\n", + "adding: mem time248, current time 272, horizon 24\n", + "adding: mem time249, current time 272, horizon 23\n", + "adding: mem time250, current time 272, horizon 22\n", + "adding: mem time251, current time 272, horizon 21\n", + "adding: mem time252, current time 272, horizon 20\n", + "adding: mem time253, current time 272, horizon 19\n", + "adding: mem time254, current time 272, horizon 18\n", + "adding: mem time255, current time 272, horizon 17\n", + "adding: mem time256, current time 272, horizon 16\n", + "adding: mem time257, current time 272, horizon 15\n", + "adding: mem time258, current time 272, horizon 14\n", + "adding: mem time259, current time 272, horizon 13\n", + "adding: mem time260, current time 272, horizon 12\n", + "adding: mem time261, current time 272, horizon 11\n", + "adding: mem time262, current time 272, horizon 10\n", + "adding: mem time263, current time 272, horizon 9\n", + "adding: mem time264, current time 272, horizon 8\n", + "adding: mem time265, current time 272, horizon 7\n", + "adding: mem time266, current time 272, horizon 6\n", + "adding: mem time267, current time 272, horizon 5\n", + "adding: mem time268, current time 272, horizon 4\n", + "adding: mem time269, current time 272, horizon 3\n", + "adding: mem time270, current time 272, horizon 2\n", + "adding: mem time271, current time 272, horizon 1\n", + "adding: mem time200, current time 273, horizon 73\n", + "adding: mem time201, current time 273, horizon 72\n", + "adding: mem time202, current time 273, horizon 71\n", + "adding: mem time203, current time 273, horizon 70\n", + "adding: mem time204, current time 273, horizon 69\n", + "adding: mem time205, current time 273, horizon 68\n", + "adding: mem time206, current time 273, horizon 67\n", + "adding: mem time207, current time 273, horizon 66\n", + "adding: mem time208, current time 273, horizon 65\n", + "adding: mem time209, current time 273, horizon 64\n", + "adding: mem time210, current time 273, horizon 63\n", + "adding: mem time211, current time 273, horizon 62\n", + "adding: mem time212, current time 273, horizon 61\n", + "adding: mem time213, current time 273, horizon 60\n", + "adding: mem time214, current time 273, horizon 59\n", + "adding: mem time215, current time 273, horizon 58\n", + "adding: mem time216, current time 273, horizon 57\n", + "adding: mem time217, current time 273, horizon 56\n", + "adding: mem time218, current time 273, horizon 55\n", + "adding: mem time219, current time 273, horizon 54\n", + "adding: mem time220, current time 273, horizon 53\n", + "adding: mem time221, current time 273, horizon 52\n", + "adding: mem time222, current time 273, horizon 51\n", + "adding: mem time223, current time 273, horizon 50\n", + "adding: mem time224, current time 273, horizon 49\n", + "adding: mem time225, current time 273, horizon 48\n", + "adding: mem time226, current time 273, horizon 47\n", + "adding: mem time227, current time 273, horizon 46\n", + "adding: mem time228, current time 273, horizon 45\n", + "adding: mem time229, current time 273, horizon 44\n", + "adding: mem time230, current time 273, horizon 43\n", + "adding: mem time231, current time 273, horizon 42\n", + "adding: mem time232, current time 273, horizon 41\n", + "adding: mem time233, current time 273, horizon 40\n", + "adding: mem time234, current time 273, horizon 39\n", + "adding: mem time235, current time 273, horizon 38\n", + "adding: mem time236, current time 273, horizon 37\n", + "adding: mem time237, current time 273, horizon 36\n", + "adding: mem time238, current time 273, horizon 35\n", + "adding: mem time239, current time 273, horizon 34\n", + "adding: mem time240, current time 273, horizon 33\n", + "adding: mem time241, current time 273, horizon 32\n", + "adding: mem time242, current time 273, horizon 31\n", + "adding: mem time243, current time 273, horizon 30\n", + "adding: mem time244, current time 273, horizon 29\n", + "adding: mem time245, current time 273, horizon 28\n", + "adding: mem time246, current time 273, horizon 27\n", + "adding: mem time247, current time 273, horizon 26\n", + "adding: mem time248, current time 273, horizon 25\n", + "adding: mem time249, current time 273, horizon 24\n", + "adding: mem time250, current time 273, horizon 23\n", + "adding: mem time251, current time 273, horizon 22\n", + "adding: mem time252, current time 273, horizon 21\n", + "adding: mem time253, current time 273, horizon 20\n", + "adding: mem time254, current time 273, horizon 19\n", + "adding: mem time255, current time 273, horizon 18\n", + "adding: mem time256, current time 273, horizon 17\n", + "adding: mem time257, current time 273, horizon 16\n", + "adding: mem time258, current time 273, horizon 15\n", + "adding: mem time259, current time 273, horizon 14\n", + "adding: mem time260, current time 273, horizon 13\n", + "adding: mem time261, current time 273, horizon 12\n", + "adding: mem time262, current time 273, horizon 11\n", + "adding: mem time263, current time 273, horizon 10\n", + "adding: mem time264, current time 273, horizon 9\n", + "adding: mem time265, current time 273, horizon 8\n", + "adding: mem time266, current time 273, horizon 7\n", + "adding: mem time267, current time 273, horizon 6\n", + "adding: mem time268, current time 273, horizon 5\n", + "adding: mem time269, current time 273, horizon 4\n", + "adding: mem time270, current time 273, horizon 3\n", + "adding: mem time271, current time 273, horizon 2\n", + "adding: mem time272, current time 273, horizon 1\n", + "adding: mem time200, current time 274, horizon 74\n", + "adding: mem time201, current time 274, horizon 73\n", + "adding: mem time202, current time 274, horizon 72\n", + "adding: mem time203, current time 274, horizon 71\n", + "adding: mem time204, current time 274, horizon 70\n", + "adding: mem time205, current time 274, horizon 69\n", + "adding: mem time206, current time 274, horizon 68\n", + "adding: mem time207, current time 274, horizon 67\n", + "adding: mem time208, current time 274, horizon 66\n", + "adding: mem time209, current time 274, horizon 65\n", + "adding: mem time210, current time 274, horizon 64\n", + "adding: mem time211, current time 274, horizon 63\n", + "adding: mem time212, current time 274, horizon 62\n", + "adding: mem time213, current time 274, horizon 61\n", + "adding: mem time214, current time 274, horizon 60\n", + "adding: mem time215, current time 274, horizon 59\n", + "adding: mem time216, current time 274, horizon 58\n", + "adding: mem time217, current time 274, horizon 57\n", + "adding: mem time218, current time 274, horizon 56\n", + "adding: mem time219, current time 274, horizon 55\n", + "adding: mem time220, current time 274, horizon 54\n", + "adding: mem time221, current time 274, horizon 53\n", + "adding: mem time222, current time 274, horizon 52\n", + "adding: mem time223, current time 274, horizon 51\n", + "adding: mem time224, current time 274, horizon 50\n", + "adding: mem time225, current time 274, horizon 49\n", + "adding: mem time226, current time 274, horizon 48\n", + "adding: mem time227, current time 274, horizon 47\n", + "adding: mem time228, current time 274, horizon 46\n", + "adding: mem time229, current time 274, horizon 45\n", + "adding: mem time230, current time 274, horizon 44\n", + "adding: mem time231, current time 274, horizon 43\n", + "adding: mem time232, current time 274, horizon 42\n", + "adding: mem time233, current time 274, horizon 41\n", + "adding: mem time234, current time 274, horizon 40\n", + "adding: mem time235, current time 274, horizon 39\n", + "adding: mem time236, current time 274, horizon 38\n", + "adding: mem time237, current time 274, horizon 37\n", + "adding: mem time238, current time 274, horizon 36\n", + "adding: mem time239, current time 274, horizon 35\n", + "adding: mem time240, current time 274, horizon 34\n", + "adding: mem time241, current time 274, horizon 33\n", + "adding: mem time242, current time 274, horizon 32\n", + "adding: mem time243, current time 274, horizon 31\n", + "adding: mem time244, current time 274, horizon 30\n", + "adding: mem time245, current time 274, horizon 29\n", + "adding: mem time246, current time 274, horizon 28\n", + "adding: mem time247, current time 274, horizon 27\n", + "adding: mem time248, current time 274, horizon 26\n", + "adding: mem time249, current time 274, horizon 25\n", + "adding: mem time250, current time 274, horizon 24\n", + "adding: mem time251, current time 274, horizon 23\n", + "adding: mem time252, current time 274, horizon 22\n", + "adding: mem time253, current time 274, horizon 21\n", + "adding: mem time254, current time 274, horizon 20\n", + "adding: mem time255, current time 274, horizon 19\n", + "adding: mem time256, current time 274, horizon 18\n", + "adding: mem time257, current time 274, horizon 17\n", + "adding: mem time258, current time 274, horizon 16\n", + "adding: mem time259, current time 274, horizon 15\n", + "adding: mem time260, current time 274, horizon 14\n", + "adding: mem time261, current time 274, horizon 13\n", + "adding: mem time262, current time 274, horizon 12\n", + "adding: mem time263, current time 274, horizon 11\n", + "adding: mem time264, current time 274, horizon 10\n", + "adding: mem time265, current time 274, horizon 9\n", + "adding: mem time266, current time 274, horizon 8\n", + "adding: mem time267, current time 274, horizon 7\n", + "adding: mem time268, current time 274, horizon 6\n", + "adding: mem time269, current time 274, horizon 5\n", + "adding: mem time270, current time 274, horizon 4\n", + "adding: mem time271, current time 274, horizon 3\n", + "adding: mem time272, current time 274, horizon 2\n", + "adding: mem time273, current time 274, horizon 1\n", + "adding: mem time200, current time 275, horizon 75\n", + "adding: mem time201, current time 275, horizon 74\n", + "adding: mem time202, current time 275, horizon 73\n", + "adding: mem time203, current time 275, horizon 72\n", + "adding: mem time204, current time 275, horizon 71\n", + "adding: mem time205, current time 275, horizon 70\n", + "adding: mem time206, current time 275, horizon 69\n", + "adding: mem time207, current time 275, horizon 68\n", + "adding: mem time208, current time 275, horizon 67\n", + "adding: mem time209, current time 275, horizon 66\n", + "adding: mem time210, current time 275, horizon 65\n", + "adding: mem time211, current time 275, horizon 64\n", + "adding: mem time212, current time 275, horizon 63\n", + "adding: mem time213, current time 275, horizon 62\n", + "adding: mem time214, current time 275, horizon 61\n", + "adding: mem time215, current time 275, horizon 60\n", + "adding: mem time216, current time 275, horizon 59\n", + "adding: mem time217, current time 275, horizon 58\n", + "adding: mem time218, current time 275, horizon 57\n", + "adding: mem time219, current time 275, horizon 56\n", + "adding: mem time220, current time 275, horizon 55\n", + "adding: mem time221, current time 275, horizon 54\n", + "adding: mem time222, current time 275, horizon 53\n", + "adding: mem time223, current time 275, horizon 52\n", + "adding: mem time224, current time 275, horizon 51\n", + "adding: mem time225, current time 275, horizon 50\n", + "adding: mem time226, current time 275, horizon 49\n", + "adding: mem time227, current time 275, horizon 48\n", + "adding: mem time228, current time 275, horizon 47\n", + "adding: mem time229, current time 275, horizon 46\n", + "adding: mem time230, current time 275, horizon 45\n", + "adding: mem time231, current time 275, horizon 44\n", + "adding: mem time232, current time 275, horizon 43\n", + "adding: mem time233, current time 275, horizon 42\n", + "adding: mem time234, current time 275, horizon 41\n", + "adding: mem time235, current time 275, horizon 40\n", + "adding: mem time236, current time 275, horizon 39\n", + "adding: mem time237, current time 275, horizon 38\n", + "adding: mem time238, current time 275, horizon 37\n", + "adding: mem time239, current time 275, horizon 36\n", + "adding: mem time240, current time 275, horizon 35\n", + "adding: mem time241, current time 275, horizon 34\n", + "adding: mem time242, current time 275, horizon 33\n", + "adding: mem time243, current time 275, horizon 32\n", + "adding: mem time244, current time 275, horizon 31\n", + "adding: mem time245, current time 275, horizon 30\n", + "adding: mem time246, current time 275, horizon 29\n", + "adding: mem time247, current time 275, horizon 28\n", + "adding: mem time248, current time 275, horizon 27\n", + "adding: mem time249, current time 275, horizon 26\n", + "adding: mem time250, current time 275, horizon 25\n", + "adding: mem time251, current time 275, horizon 24\n", + "adding: mem time252, current time 275, horizon 23\n", + "adding: mem time253, current time 275, horizon 22\n", + "adding: mem time254, current time 275, horizon 21\n", + "adding: mem time255, current time 275, horizon 20\n", + "adding: mem time256, current time 275, horizon 19\n", + "adding: mem time257, current time 275, horizon 18\n", + "adding: mem time258, current time 275, horizon 17\n", + "adding: mem time259, current time 275, horizon 16\n", + "adding: mem time260, current time 275, horizon 15\n", + "adding: mem time261, current time 275, horizon 14\n", + "adding: mem time262, current time 275, horizon 13\n", + "adding: mem time263, current time 275, horizon 12\n", + "adding: mem time264, current time 275, horizon 11\n", + "adding: mem time265, current time 275, horizon 10\n", + "adding: mem time266, current time 275, horizon 9\n", + "adding: mem time267, current time 275, horizon 8\n", + "adding: mem time268, current time 275, horizon 7\n", + "adding: mem time269, current time 275, horizon 6\n", + "adding: mem time270, current time 275, horizon 5\n", + "adding: mem time271, current time 275, horizon 4\n", + "adding: mem time272, current time 275, horizon 3\n", + "adding: mem time273, current time 275, horizon 2\n", + "adding: mem time274, current time 275, horizon 1\n", + "adding: mem time200, current time 276, horizon 76\n", + "adding: mem time201, current time 276, horizon 75\n", + "adding: mem time202, current time 276, horizon 74\n", + "adding: mem time203, current time 276, horizon 73\n", + "adding: mem time204, current time 276, horizon 72\n", + "adding: mem time205, current time 276, horizon 71\n", + "adding: mem time206, current time 276, horizon 70\n", + "adding: mem time207, current time 276, horizon 69\n", + "adding: mem time208, current time 276, horizon 68\n", + "adding: mem time209, current time 276, horizon 67\n", + "adding: mem time210, current time 276, horizon 66\n", + "adding: mem time211, current time 276, horizon 65\n", + "adding: mem time212, current time 276, horizon 64\n", + "adding: mem time213, current time 276, horizon 63\n", + "adding: mem time214, current time 276, horizon 62\n", + "adding: mem time215, current time 276, horizon 61\n", + "adding: mem time216, current time 276, horizon 60\n", + "adding: mem time217, current time 276, horizon 59\n", + "adding: mem time218, current time 276, horizon 58\n", + "adding: mem time219, current time 276, horizon 57\n", + "adding: mem time220, current time 276, horizon 56\n", + "adding: mem time221, current time 276, horizon 55\n", + "adding: mem time222, current time 276, horizon 54\n", + "adding: mem time223, current time 276, horizon 53\n", + "adding: mem time224, current time 276, horizon 52\n", + "adding: mem time225, current time 276, horizon 51\n", + "adding: mem time226, current time 276, horizon 50\n", + "adding: mem time227, current time 276, horizon 49\n", + "adding: mem time228, current time 276, horizon 48\n", + "adding: mem time229, current time 276, horizon 47\n", + "adding: mem time230, current time 276, horizon 46\n", + "adding: mem time231, current time 276, horizon 45\n", + "adding: mem time232, current time 276, horizon 44\n", + "adding: mem time233, current time 276, horizon 43\n", + "adding: mem time234, current time 276, horizon 42\n", + "adding: mem time235, current time 276, horizon 41\n", + "adding: mem time236, current time 276, horizon 40\n", + "adding: mem time237, current time 276, horizon 39\n", + "adding: mem time238, current time 276, horizon 38\n", + "adding: mem time239, current time 276, horizon 37\n", + "adding: mem time240, current time 276, horizon 36\n", + "adding: mem time241, current time 276, horizon 35\n", + "adding: mem time242, current time 276, horizon 34\n", + "adding: mem time243, current time 276, horizon 33\n", + "adding: mem time244, current time 276, horizon 32\n", + "adding: mem time245, current time 276, horizon 31\n", + "adding: mem time246, current time 276, horizon 30\n", + "adding: mem time247, current time 276, horizon 29\n", + "adding: mem time248, current time 276, horizon 28\n", + "adding: mem time249, current time 276, horizon 27\n", + "adding: mem time250, current time 276, horizon 26\n", + "adding: mem time251, current time 276, horizon 25\n", + "adding: mem time252, current time 276, horizon 24\n", + "adding: mem time253, current time 276, horizon 23\n", + "adding: mem time254, current time 276, horizon 22\n", + "adding: mem time255, current time 276, horizon 21\n", + "adding: mem time256, current time 276, horizon 20\n", + "adding: mem time257, current time 276, horizon 19\n", + "adding: mem time258, current time 276, horizon 18\n", + "adding: mem time259, current time 276, horizon 17\n", + "adding: mem time260, current time 276, horizon 16\n", + "adding: mem time261, current time 276, horizon 15\n", + "adding: mem time262, current time 276, horizon 14\n", + "adding: mem time263, current time 276, horizon 13\n", + "adding: mem time264, current time 276, horizon 12\n", + "adding: mem time265, current time 276, horizon 11\n", + "adding: mem time266, current time 276, horizon 10\n", + "adding: mem time267, current time 276, horizon 9\n", + "adding: mem time268, current time 276, horizon 8\n", + "adding: mem time269, current time 276, horizon 7\n", + "adding: mem time270, current time 276, horizon 6\n", + "adding: mem time271, current time 276, horizon 5\n", + "adding: mem time272, current time 276, horizon 4\n", + "adding: mem time273, current time 276, horizon 3\n", + "adding: mem time274, current time 276, horizon 2\n", + "adding: mem time275, current time 276, horizon 1\n", + "adding: mem time200, current time 277, horizon 77\n", + "adding: mem time201, current time 277, horizon 76\n", + "adding: mem time202, current time 277, horizon 75\n", + "adding: mem time203, current time 277, horizon 74\n", + "adding: mem time204, current time 277, horizon 73\n", + "adding: mem time205, current time 277, horizon 72\n", + "adding: mem time206, current time 277, horizon 71\n", + "adding: mem time207, current time 277, horizon 70\n", + "adding: mem time208, current time 277, horizon 69\n", + "adding: mem time209, current time 277, horizon 68\n", + "adding: mem time210, current time 277, horizon 67\n", + "adding: mem time211, current time 277, horizon 66\n", + "adding: mem time212, current time 277, horizon 65\n", + "adding: mem time213, current time 277, horizon 64\n", + "adding: mem time214, current time 277, horizon 63\n", + "adding: mem time215, current time 277, horizon 62\n", + "adding: mem time216, current time 277, horizon 61\n", + "adding: mem time217, current time 277, horizon 60\n", + "adding: mem time218, current time 277, horizon 59\n", + "adding: mem time219, current time 277, horizon 58\n", + "adding: mem time220, current time 277, horizon 57\n", + "adding: mem time221, current time 277, horizon 56\n", + "adding: mem time222, current time 277, horizon 55\n", + "adding: mem time223, current time 277, horizon 54\n", + "adding: mem time224, current time 277, horizon 53\n", + "adding: mem time225, current time 277, horizon 52\n", + "adding: mem time226, current time 277, horizon 51\n", + "adding: mem time227, current time 277, horizon 50\n", + "adding: mem time228, current time 277, horizon 49\n", + "adding: mem time229, current time 277, horizon 48\n", + "adding: mem time230, current time 277, horizon 47\n", + "adding: mem time231, current time 277, horizon 46\n", + "adding: mem time232, current time 277, horizon 45\n", + "adding: mem time233, current time 277, horizon 44\n", + "adding: mem time234, current time 277, horizon 43\n", + "adding: mem time235, current time 277, horizon 42\n", + "adding: mem time236, current time 277, horizon 41\n", + "adding: mem time237, current time 277, horizon 40\n", + "adding: mem time238, current time 277, horizon 39\n", + "adding: mem time239, current time 277, horizon 38\n", + "adding: mem time240, current time 277, horizon 37\n", + "adding: mem time241, current time 277, horizon 36\n", + "adding: mem time242, current time 277, horizon 35\n", + "adding: mem time243, current time 277, horizon 34\n", + "adding: mem time244, current time 277, horizon 33\n", + "adding: mem time245, current time 277, horizon 32\n", + "adding: mem time246, current time 277, horizon 31\n", + "adding: mem time247, current time 277, horizon 30\n", + "adding: mem time248, current time 277, horizon 29\n", + "adding: mem time249, current time 277, horizon 28\n", + "adding: mem time250, current time 277, horizon 27\n", + "adding: mem time251, current time 277, horizon 26\n", + "adding: mem time252, current time 277, horizon 25\n", + "adding: mem time253, current time 277, horizon 24\n", + "adding: mem time254, current time 277, horizon 23\n", + "adding: mem time255, current time 277, horizon 22\n", + "adding: mem time256, current time 277, horizon 21\n", + "adding: mem time257, current time 277, horizon 20\n", + "adding: mem time258, current time 277, horizon 19\n", + "adding: mem time259, current time 277, horizon 18\n", + "adding: mem time260, current time 277, horizon 17\n", + "adding: mem time261, current time 277, horizon 16\n", + "adding: mem time262, current time 277, horizon 15\n", + "adding: mem time263, current time 277, horizon 14\n", + "adding: mem time264, current time 277, horizon 13\n", + "adding: mem time265, current time 277, horizon 12\n", + "adding: mem time266, current time 277, horizon 11\n", + "adding: mem time267, current time 277, horizon 10\n", + "adding: mem time268, current time 277, horizon 9\n", + "adding: mem time269, current time 277, horizon 8\n", + "adding: mem time270, current time 277, horizon 7\n", + "adding: mem time271, current time 277, horizon 6\n", + "adding: mem time272, current time 277, horizon 5\n", + "adding: mem time273, current time 277, horizon 4\n", + "adding: mem time274, current time 277, horizon 3\n", + "adding: mem time275, current time 277, horizon 2\n", + "adding: mem time276, current time 277, horizon 1\n", + "adding: mem time200, current time 278, horizon 78\n", + "adding: mem time201, current time 278, horizon 77\n", + "adding: mem time202, current time 278, horizon 76\n", + "adding: mem time203, current time 278, horizon 75\n", + "adding: mem time204, current time 278, horizon 74\n", + "adding: mem time205, current time 278, horizon 73\n", + "adding: mem time206, current time 278, horizon 72\n", + "adding: mem time207, current time 278, horizon 71\n", + "adding: mem time208, current time 278, horizon 70\n", + "adding: mem time209, current time 278, horizon 69\n", + "adding: mem time210, current time 278, horizon 68\n", + "adding: mem time211, current time 278, horizon 67\n", + "adding: mem time212, current time 278, horizon 66\n", + "adding: mem time213, current time 278, horizon 65\n", + "adding: mem time214, current time 278, horizon 64\n", + "adding: mem time215, current time 278, horizon 63\n", + "adding: mem time216, current time 278, horizon 62\n", + "adding: mem time217, current time 278, horizon 61\n", + "adding: mem time218, current time 278, horizon 60\n", + "adding: mem time219, current time 278, horizon 59\n", + "adding: mem time220, current time 278, horizon 58\n", + "adding: mem time221, current time 278, horizon 57\n", + "adding: mem time222, current time 278, horizon 56\n", + "adding: mem time223, current time 278, horizon 55\n", + "adding: mem time224, current time 278, horizon 54\n", + "adding: mem time225, current time 278, horizon 53\n", + "adding: mem time226, current time 278, horizon 52\n", + "adding: mem time227, current time 278, horizon 51\n", + "adding: mem time228, current time 278, horizon 50\n", + "adding: mem time229, current time 278, horizon 49\n", + "adding: mem time230, current time 278, horizon 48\n", + "adding: mem time231, current time 278, horizon 47\n", + "adding: mem time232, current time 278, horizon 46\n", + "adding: mem time233, current time 278, horizon 45\n", + "adding: mem time234, current time 278, horizon 44\n", + "adding: mem time235, current time 278, horizon 43\n", + "adding: mem time236, current time 278, horizon 42\n", + "adding: mem time237, current time 278, horizon 41\n", + "adding: mem time238, current time 278, horizon 40\n", + "adding: mem time239, current time 278, horizon 39\n", + "adding: mem time240, current time 278, horizon 38\n", + "adding: mem time241, current time 278, horizon 37\n", + "adding: mem time242, current time 278, horizon 36\n", + "adding: mem time243, current time 278, horizon 35\n", + "adding: mem time244, current time 278, horizon 34\n", + "adding: mem time245, current time 278, horizon 33\n", + "adding: mem time246, current time 278, horizon 32\n", + "adding: mem time247, current time 278, horizon 31\n", + "adding: mem time248, current time 278, horizon 30\n", + "adding: mem time249, current time 278, horizon 29\n", + "adding: mem time250, current time 278, horizon 28\n", + "adding: mem time251, current time 278, horizon 27\n", + "adding: mem time252, current time 278, horizon 26\n", + "adding: mem time253, current time 278, horizon 25\n", + "adding: mem time254, current time 278, horizon 24\n", + "adding: mem time255, current time 278, horizon 23\n", + "adding: mem time256, current time 278, horizon 22\n", + "adding: mem time257, current time 278, horizon 21\n", + "adding: mem time258, current time 278, horizon 20\n", + "adding: mem time259, current time 278, horizon 19\n", + "adding: mem time260, current time 278, horizon 18\n", + "adding: mem time261, current time 278, horizon 17\n", + "adding: mem time262, current time 278, horizon 16\n", + "adding: mem time263, current time 278, horizon 15\n", + "adding: mem time264, current time 278, horizon 14\n", + "adding: mem time265, current time 278, horizon 13\n", + "adding: mem time266, current time 278, horizon 12\n", + "adding: mem time267, current time 278, horizon 11\n", + "adding: mem time268, current time 278, horizon 10\n", + "adding: mem time269, current time 278, horizon 9\n", + "adding: mem time270, current time 278, horizon 8\n", + "adding: mem time271, current time 278, horizon 7\n", + "adding: mem time272, current time 278, horizon 6\n", + "adding: mem time273, current time 278, horizon 5\n", + "adding: mem time274, current time 278, horizon 4\n", + "adding: mem time275, current time 278, horizon 3\n", + "adding: mem time276, current time 278, horizon 2\n", + "adding: mem time277, current time 278, horizon 1\n", + "adding: mem time200, current time 279, horizon 79\n", + "adding: mem time201, current time 279, horizon 78\n", + "adding: mem time202, current time 279, horizon 77\n", + "adding: mem time203, current time 279, horizon 76\n", + "adding: mem time204, current time 279, horizon 75\n", + "adding: mem time205, current time 279, horizon 74\n", + "adding: mem time206, current time 279, horizon 73\n", + "adding: mem time207, current time 279, horizon 72\n", + "adding: mem time208, current time 279, horizon 71\n", + "adding: mem time209, current time 279, horizon 70\n", + "adding: mem time210, current time 279, horizon 69\n", + "adding: mem time211, current time 279, horizon 68\n", + "adding: mem time212, current time 279, horizon 67\n", + "adding: mem time213, current time 279, horizon 66\n", + "adding: mem time214, current time 279, horizon 65\n", + "adding: mem time215, current time 279, horizon 64\n", + "adding: mem time216, current time 279, horizon 63\n", + "adding: mem time217, current time 279, horizon 62\n", + "adding: mem time218, current time 279, horizon 61\n", + "adding: mem time219, current time 279, horizon 60\n", + "adding: mem time220, current time 279, horizon 59\n", + "adding: mem time221, current time 279, horizon 58\n", + "adding: mem time222, current time 279, horizon 57\n", + "adding: mem time223, current time 279, horizon 56\n", + "adding: mem time224, current time 279, horizon 55\n", + "adding: mem time225, current time 279, horizon 54\n", + "adding: mem time226, current time 279, horizon 53\n", + "adding: mem time227, current time 279, horizon 52\n", + "adding: mem time228, current time 279, horizon 51\n", + "adding: mem time229, current time 279, horizon 50\n", + "adding: mem time230, current time 279, horizon 49\n", + "adding: mem time231, current time 279, horizon 48\n", + "adding: mem time232, current time 279, horizon 47\n", + "adding: mem time233, current time 279, horizon 46\n", + "adding: mem time234, current time 279, horizon 45\n", + "adding: mem time235, current time 279, horizon 44\n", + "adding: mem time236, current time 279, horizon 43\n", + "adding: mem time237, current time 279, horizon 42\n", + "adding: mem time238, current time 279, horizon 41\n", + "adding: mem time239, current time 279, horizon 40\n", + "adding: mem time240, current time 279, horizon 39\n", + "adding: mem time241, current time 279, horizon 38\n", + "adding: mem time242, current time 279, horizon 37\n", + "adding: mem time243, current time 279, horizon 36\n", + "adding: mem time244, current time 279, horizon 35\n", + "adding: mem time245, current time 279, horizon 34\n", + "adding: mem time246, current time 279, horizon 33\n", + "adding: mem time247, current time 279, horizon 32\n", + "adding: mem time248, current time 279, horizon 31\n", + "adding: mem time249, current time 279, horizon 30\n", + "adding: mem time250, current time 279, horizon 29\n", + "adding: mem time251, current time 279, horizon 28\n", + "adding: mem time252, current time 279, horizon 27\n", + "adding: mem time253, current time 279, horizon 26\n", + "adding: mem time254, current time 279, horizon 25\n", + "adding: mem time255, current time 279, horizon 24\n", + "adding: mem time256, current time 279, horizon 23\n", + "adding: mem time257, current time 279, horizon 22\n", + "adding: mem time258, current time 279, horizon 21\n", + "adding: mem time259, current time 279, horizon 20\n", + "adding: mem time260, current time 279, horizon 19\n", + "adding: mem time261, current time 279, horizon 18\n", + "adding: mem time262, current time 279, horizon 17\n", + "adding: mem time263, current time 279, horizon 16\n", + "adding: mem time264, current time 279, horizon 15\n", + "adding: mem time265, current time 279, horizon 14\n", + "adding: mem time266, current time 279, horizon 13\n", + "adding: mem time267, current time 279, horizon 12\n", + "adding: mem time268, current time 279, horizon 11\n", + "adding: mem time269, current time 279, horizon 10\n", + "adding: mem time270, current time 279, horizon 9\n", + "adding: mem time271, current time 279, horizon 8\n", + "adding: mem time272, current time 279, horizon 7\n", + "adding: mem time273, current time 279, horizon 6\n", + "adding: mem time274, current time 279, horizon 5\n", + "adding: mem time275, current time 279, horizon 4\n", + "adding: mem time276, current time 279, horizon 3\n", + "adding: mem time277, current time 279, horizon 2\n", + "adding: mem time278, current time 279, horizon 1\n", + "adding: mem time200, current time 280, horizon 80\n", + "adding: mem time201, current time 280, horizon 79\n", + "adding: mem time202, current time 280, horizon 78\n", + "adding: mem time203, current time 280, horizon 77\n", + "adding: mem time204, current time 280, horizon 76\n", + "adding: mem time205, current time 280, horizon 75\n", + "adding: mem time206, current time 280, horizon 74\n", + "adding: mem time207, current time 280, horizon 73\n", + "adding: mem time208, current time 280, horizon 72\n", + "adding: mem time209, current time 280, horizon 71\n", + "adding: mem time210, current time 280, horizon 70\n", + "adding: mem time211, current time 280, horizon 69\n", + "adding: mem time212, current time 280, horizon 68\n", + "adding: mem time213, current time 280, horizon 67\n", + "adding: mem time214, current time 280, horizon 66\n", + "adding: mem time215, current time 280, horizon 65\n", + "adding: mem time216, current time 280, horizon 64\n", + "adding: mem time217, current time 280, horizon 63\n", + "adding: mem time218, current time 280, horizon 62\n", + "adding: mem time219, current time 280, horizon 61\n", + "adding: mem time220, current time 280, horizon 60\n", + "adding: mem time221, current time 280, horizon 59\n", + "adding: mem time222, current time 280, horizon 58\n", + "adding: mem time223, current time 280, horizon 57\n", + "adding: mem time224, current time 280, horizon 56\n", + "adding: mem time225, current time 280, horizon 55\n", + "adding: mem time226, current time 280, horizon 54\n", + "adding: mem time227, current time 280, horizon 53\n", + "adding: mem time228, current time 280, horizon 52\n", + "adding: mem time229, current time 280, horizon 51\n", + "adding: mem time230, current time 280, horizon 50\n", + "adding: mem time231, current time 280, horizon 49\n", + "adding: mem time232, current time 280, horizon 48\n", + "adding: mem time233, current time 280, horizon 47\n", + "adding: mem time234, current time 280, horizon 46\n", + "adding: mem time235, current time 280, horizon 45\n", + "adding: mem time236, current time 280, horizon 44\n", + "adding: mem time237, current time 280, horizon 43\n", + "adding: mem time238, current time 280, horizon 42\n", + "adding: mem time239, current time 280, horizon 41\n", + "adding: mem time240, current time 280, horizon 40\n", + "adding: mem time241, current time 280, horizon 39\n", + "adding: mem time242, current time 280, horizon 38\n", + "adding: mem time243, current time 280, horizon 37\n", + "adding: mem time244, current time 280, horizon 36\n", + "adding: mem time245, current time 280, horizon 35\n", + "adding: mem time246, current time 280, horizon 34\n", + "adding: mem time247, current time 280, horizon 33\n", + "adding: mem time248, current time 280, horizon 32\n", + "adding: mem time249, current time 280, horizon 31\n", + "adding: mem time250, current time 280, horizon 30\n", + "adding: mem time251, current time 280, horizon 29\n", + "adding: mem time252, current time 280, horizon 28\n", + "adding: mem time253, current time 280, horizon 27\n", + "adding: mem time254, current time 280, horizon 26\n", + "adding: mem time255, current time 280, horizon 25\n", + "adding: mem time256, current time 280, horizon 24\n", + "adding: mem time257, current time 280, horizon 23\n", + "adding: mem time258, current time 280, horizon 22\n", + "adding: mem time259, current time 280, horizon 21\n", + "adding: mem time260, current time 280, horizon 20\n", + "adding: mem time261, current time 280, horizon 19\n", + "adding: mem time262, current time 280, horizon 18\n", + "adding: mem time263, current time 280, horizon 17\n", + "adding: mem time264, current time 280, horizon 16\n", + "adding: mem time265, current time 280, horizon 15\n", + "adding: mem time266, current time 280, horizon 14\n", + "adding: mem time267, current time 280, horizon 13\n", + "adding: mem time268, current time 280, horizon 12\n", + "adding: mem time269, current time 280, horizon 11\n", + "adding: mem time270, current time 280, horizon 10\n", + "adding: mem time271, current time 280, horizon 9\n", + "adding: mem time272, current time 280, horizon 8\n", + "adding: mem time273, current time 280, horizon 7\n", + "adding: mem time274, current time 280, horizon 6\n", + "adding: mem time275, current time 280, horizon 5\n", + "adding: mem time276, current time 280, horizon 4\n", + "adding: mem time277, current time 280, horizon 3\n", + "adding: mem time278, current time 280, horizon 2\n", + "adding: mem time279, current time 280, horizon 1\n", + "adding: mem time200, current time 281, horizon 81\n", + "adding: mem time201, current time 281, horizon 80\n", + "adding: mem time202, current time 281, horizon 79\n", + "adding: mem time203, current time 281, horizon 78\n", + "adding: mem time204, current time 281, horizon 77\n", + "adding: mem time205, current time 281, horizon 76\n", + "adding: mem time206, current time 281, horizon 75\n", + "adding: mem time207, current time 281, horizon 74\n", + "adding: mem time208, current time 281, horizon 73\n", + "adding: mem time209, current time 281, horizon 72\n", + "adding: mem time210, current time 281, horizon 71\n", + "adding: mem time211, current time 281, horizon 70\n", + "adding: mem time212, current time 281, horizon 69\n", + "adding: mem time213, current time 281, horizon 68\n", + "adding: mem time214, current time 281, horizon 67\n", + "adding: mem time215, current time 281, horizon 66\n", + "adding: mem time216, current time 281, horizon 65\n", + "adding: mem time217, current time 281, horizon 64\n", + "adding: mem time218, current time 281, horizon 63\n", + "adding: mem time219, current time 281, horizon 62\n", + "adding: mem time220, current time 281, horizon 61\n", + "adding: mem time221, current time 281, horizon 60\n", + "adding: mem time222, current time 281, horizon 59\n", + "adding: mem time223, current time 281, horizon 58\n", + "adding: mem time224, current time 281, horizon 57\n", + "adding: mem time225, current time 281, horizon 56\n", + "adding: mem time226, current time 281, horizon 55\n", + "adding: mem time227, current time 281, horizon 54\n", + "adding: mem time228, current time 281, horizon 53\n", + "adding: mem time229, current time 281, horizon 52\n", + "adding: mem time230, current time 281, horizon 51\n", + "adding: mem time231, current time 281, horizon 50\n", + "adding: mem time232, current time 281, horizon 49\n", + "adding: mem time233, current time 281, horizon 48\n", + "adding: mem time234, current time 281, horizon 47\n", + "adding: mem time235, current time 281, horizon 46\n", + "adding: mem time236, current time 281, horizon 45\n", + "adding: mem time237, current time 281, horizon 44\n", + "adding: mem time238, current time 281, horizon 43\n", + "adding: mem time239, current time 281, horizon 42\n", + "adding: mem time240, current time 281, horizon 41\n", + "adding: mem time241, current time 281, horizon 40\n", + "adding: mem time242, current time 281, horizon 39\n", + "adding: mem time243, current time 281, horizon 38\n", + "adding: mem time244, current time 281, horizon 37\n", + "adding: mem time245, current time 281, horizon 36\n", + "adding: mem time246, current time 281, horizon 35\n", + "adding: mem time247, current time 281, horizon 34\n", + "adding: mem time248, current time 281, horizon 33\n", + "adding: mem time249, current time 281, horizon 32\n", + "adding: mem time250, current time 281, horizon 31\n", + "adding: mem time251, current time 281, horizon 30\n", + "adding: mem time252, current time 281, horizon 29\n", + "adding: mem time253, current time 281, horizon 28\n", + "adding: mem time254, current time 281, horizon 27\n", + "adding: mem time255, current time 281, horizon 26\n", + "adding: mem time256, current time 281, horizon 25\n", + "adding: mem time257, current time 281, horizon 24\n", + "adding: mem time258, current time 281, horizon 23\n", + "adding: mem time259, current time 281, horizon 22\n", + "adding: mem time260, current time 281, horizon 21\n", + "adding: mem time261, current time 281, horizon 20\n", + "adding: mem time262, current time 281, horizon 19\n", + "adding: mem time263, current time 281, horizon 18\n", + "adding: mem time264, current time 281, horizon 17\n", + "adding: mem time265, current time 281, horizon 16\n", + "adding: mem time266, current time 281, horizon 15\n", + "adding: mem time267, current time 281, horizon 14\n", + "adding: mem time268, current time 281, horizon 13\n", + "adding: mem time269, current time 281, horizon 12\n", + "adding: mem time270, current time 281, horizon 11\n", + "adding: mem time271, current time 281, horizon 10\n", + "adding: mem time272, current time 281, horizon 9\n", + "adding: mem time273, current time 281, horizon 8\n", + "adding: mem time274, current time 281, horizon 7\n", + "adding: mem time275, current time 281, horizon 6\n", + "adding: mem time276, current time 281, horizon 5\n", + "adding: mem time277, current time 281, horizon 4\n", + "adding: mem time278, current time 281, horizon 3\n", + "adding: mem time279, current time 281, horizon 2\n", + "adding: mem time280, current time 281, horizon 1\n", + "adding: mem time200, current time 282, horizon 82\n", + "adding: mem time201, current time 282, horizon 81\n", + "adding: mem time202, current time 282, horizon 80\n", + "adding: mem time203, current time 282, horizon 79\n", + "adding: mem time204, current time 282, horizon 78\n", + "adding: mem time205, current time 282, horizon 77\n", + "adding: mem time206, current time 282, horizon 76\n", + "adding: mem time207, current time 282, horizon 75\n", + "adding: mem time208, current time 282, horizon 74\n", + "adding: mem time209, current time 282, horizon 73\n", + "adding: mem time210, current time 282, horizon 72\n", + "adding: mem time211, current time 282, horizon 71\n", + "adding: mem time212, current time 282, horizon 70\n", + "adding: mem time213, current time 282, horizon 69\n", + "adding: mem time214, current time 282, horizon 68\n", + "adding: mem time215, current time 282, horizon 67\n", + "adding: mem time216, current time 282, horizon 66\n", + "adding: mem time217, current time 282, horizon 65\n", + "adding: mem time218, current time 282, horizon 64\n", + "adding: mem time219, current time 282, horizon 63\n", + "adding: mem time220, current time 282, horizon 62\n", + "adding: mem time221, current time 282, horizon 61\n", + "adding: mem time222, current time 282, horizon 60\n", + "adding: mem time223, current time 282, horizon 59\n", + "adding: mem time224, current time 282, horizon 58\n", + "adding: mem time225, current time 282, horizon 57\n", + "adding: mem time226, current time 282, horizon 56\n", + "adding: mem time227, current time 282, horizon 55\n", + "adding: mem time228, current time 282, horizon 54\n", + "adding: mem time229, current time 282, horizon 53\n", + "adding: mem time230, current time 282, horizon 52\n", + "adding: mem time231, current time 282, horizon 51\n", + "adding: mem time232, current time 282, horizon 50\n", + "adding: mem time233, current time 282, horizon 49\n", + "adding: mem time234, current time 282, horizon 48\n", + "adding: mem time235, current time 282, horizon 47\n", + "adding: mem time236, current time 282, horizon 46\n", + "adding: mem time237, current time 282, horizon 45\n", + "adding: mem time238, current time 282, horizon 44\n", + "adding: mem time239, current time 282, horizon 43\n", + "adding: mem time240, current time 282, horizon 42\n", + "adding: mem time241, current time 282, horizon 41\n", + "adding: mem time242, current time 282, horizon 40\n", + "adding: mem time243, current time 282, horizon 39\n", + "adding: mem time244, current time 282, horizon 38\n", + "adding: mem time245, current time 282, horizon 37\n", + "adding: mem time246, current time 282, horizon 36\n", + "adding: mem time247, current time 282, horizon 35\n", + "adding: mem time248, current time 282, horizon 34\n", + "adding: mem time249, current time 282, horizon 33\n", + "adding: mem time250, current time 282, horizon 32\n", + "adding: mem time251, current time 282, horizon 31\n", + "adding: mem time252, current time 282, horizon 30\n", + "adding: mem time253, current time 282, horizon 29\n", + "adding: mem time254, current time 282, horizon 28\n", + "adding: mem time255, current time 282, horizon 27\n", + "adding: mem time256, current time 282, horizon 26\n", + "adding: mem time257, current time 282, horizon 25\n", + "adding: mem time258, current time 282, horizon 24\n", + "adding: mem time259, current time 282, horizon 23\n", + "adding: mem time260, current time 282, horizon 22\n", + "adding: mem time261, current time 282, horizon 21\n", + "adding: mem time262, current time 282, horizon 20\n", + "adding: mem time263, current time 282, horizon 19\n", + "adding: mem time264, current time 282, horizon 18\n", + "adding: mem time265, current time 282, horizon 17\n", + "adding: mem time266, current time 282, horizon 16\n", + "adding: mem time267, current time 282, horizon 15\n", + "adding: mem time268, current time 282, horizon 14\n", + "adding: mem time269, current time 282, horizon 13\n", + "adding: mem time270, current time 282, horizon 12\n", + "adding: mem time271, current time 282, horizon 11\n", + "adding: mem time272, current time 282, horizon 10\n", + "adding: mem time273, current time 282, horizon 9\n", + "adding: mem time274, current time 282, horizon 8\n", + "adding: mem time275, current time 282, horizon 7\n", + "adding: mem time276, current time 282, horizon 6\n", + "adding: mem time277, current time 282, horizon 5\n", + "adding: mem time278, current time 282, horizon 4\n", + "adding: mem time279, current time 282, horizon 3\n", + "adding: mem time280, current time 282, horizon 2\n", + "adding: mem time281, current time 282, horizon 1\n", + "adding: mem time200, current time 283, horizon 83\n", + "adding: mem time201, current time 283, horizon 82\n", + "adding: mem time202, current time 283, horizon 81\n", + "adding: mem time203, current time 283, horizon 80\n", + "adding: mem time204, current time 283, horizon 79\n", + "adding: mem time205, current time 283, horizon 78\n", + "adding: mem time206, current time 283, horizon 77\n", + "adding: mem time207, current time 283, horizon 76\n", + "adding: mem time208, current time 283, horizon 75\n", + "adding: mem time209, current time 283, horizon 74\n", + "adding: mem time210, current time 283, horizon 73\n", + "adding: mem time211, current time 283, horizon 72\n", + "adding: mem time212, current time 283, horizon 71\n", + "adding: mem time213, current time 283, horizon 70\n", + "adding: mem time214, current time 283, horizon 69\n", + "adding: mem time215, current time 283, horizon 68\n", + "adding: mem time216, current time 283, horizon 67\n", + "adding: mem time217, current time 283, horizon 66\n", + "adding: mem time218, current time 283, horizon 65\n", + "adding: mem time219, current time 283, horizon 64\n", + "adding: mem time220, current time 283, horizon 63\n", + "adding: mem time221, current time 283, horizon 62\n", + "adding: mem time222, current time 283, horizon 61\n", + "adding: mem time223, current time 283, horizon 60\n", + "adding: mem time224, current time 283, horizon 59\n", + "adding: mem time225, current time 283, horizon 58\n", + "adding: mem time226, current time 283, horizon 57\n", + "adding: mem time227, current time 283, horizon 56\n", + "adding: mem time228, current time 283, horizon 55\n", + "adding: mem time229, current time 283, horizon 54\n", + "adding: mem time230, current time 283, horizon 53\n", + "adding: mem time231, current time 283, horizon 52\n", + "adding: mem time232, current time 283, horizon 51\n", + "adding: mem time233, current time 283, horizon 50\n", + "adding: mem time234, current time 283, horizon 49\n", + "adding: mem time235, current time 283, horizon 48\n", + "adding: mem time236, current time 283, horizon 47\n", + "adding: mem time237, current time 283, horizon 46\n", + "adding: mem time238, current time 283, horizon 45\n", + "adding: mem time239, current time 283, horizon 44\n", + "adding: mem time240, current time 283, horizon 43\n", + "adding: mem time241, current time 283, horizon 42\n", + "adding: mem time242, current time 283, horizon 41\n", + "adding: mem time243, current time 283, horizon 40\n", + "adding: mem time244, current time 283, horizon 39\n", + "adding: mem time245, current time 283, horizon 38\n", + "adding: mem time246, current time 283, horizon 37\n", + "adding: mem time247, current time 283, horizon 36\n", + "adding: mem time248, current time 283, horizon 35\n", + "adding: mem time249, current time 283, horizon 34\n", + "adding: mem time250, current time 283, horizon 33\n", + "adding: mem time251, current time 283, horizon 32\n", + "adding: mem time252, current time 283, horizon 31\n", + "adding: mem time253, current time 283, horizon 30\n", + "adding: mem time254, current time 283, horizon 29\n", + "adding: mem time255, current time 283, horizon 28\n", + "adding: mem time256, current time 283, horizon 27\n", + "adding: mem time257, current time 283, horizon 26\n", + "adding: mem time258, current time 283, horizon 25\n", + "adding: mem time259, current time 283, horizon 24\n", + "adding: mem time260, current time 283, horizon 23\n", + "adding: mem time261, current time 283, horizon 22\n", + "adding: mem time262, current time 283, horizon 21\n", + "adding: mem time263, current time 283, horizon 20\n", + "adding: mem time264, current time 283, horizon 19\n", + "adding: mem time265, current time 283, horizon 18\n", + "adding: mem time266, current time 283, horizon 17\n", + "adding: mem time267, current time 283, horizon 16\n", + "adding: mem time268, current time 283, horizon 15\n", + "adding: mem time269, current time 283, horizon 14\n", + "adding: mem time270, current time 283, horizon 13\n", + "adding: mem time271, current time 283, horizon 12\n", + "adding: mem time272, current time 283, horizon 11\n", + "adding: mem time273, current time 283, horizon 10\n", + "adding: mem time274, current time 283, horizon 9\n", + "adding: mem time275, current time 283, horizon 8\n", + "adding: mem time276, current time 283, horizon 7\n", + "adding: mem time277, current time 283, horizon 6\n", + "adding: mem time278, current time 283, horizon 5\n", + "adding: mem time279, current time 283, horizon 4\n", + "adding: mem time280, current time 283, horizon 3\n", + "adding: mem time281, current time 283, horizon 2\n", + "adding: mem time282, current time 283, horizon 1\n", + "adding: mem time200, current time 284, horizon 84\n", + "adding: mem time201, current time 284, horizon 83\n", + "adding: mem time202, current time 284, horizon 82\n", + "adding: mem time203, current time 284, horizon 81\n", + "adding: mem time204, current time 284, horizon 80\n", + "adding: mem time205, current time 284, horizon 79\n", + "adding: mem time206, current time 284, horizon 78\n", + "adding: mem time207, current time 284, horizon 77\n", + "adding: mem time208, current time 284, horizon 76\n", + "adding: mem time209, current time 284, horizon 75\n", + "adding: mem time210, current time 284, horizon 74\n", + "adding: mem time211, current time 284, horizon 73\n", + "adding: mem time212, current time 284, horizon 72\n", + "adding: mem time213, current time 284, horizon 71\n", + "adding: mem time214, current time 284, horizon 70\n", + "adding: mem time215, current time 284, horizon 69\n", + "adding: mem time216, current time 284, horizon 68\n", + "adding: mem time217, current time 284, horizon 67\n", + "adding: mem time218, current time 284, horizon 66\n", + "adding: mem time219, current time 284, horizon 65\n", + "adding: mem time220, current time 284, horizon 64\n", + "adding: mem time221, current time 284, horizon 63\n", + "adding: mem time222, current time 284, horizon 62\n", + "adding: mem time223, current time 284, horizon 61\n", + "adding: mem time224, current time 284, horizon 60\n", + "adding: mem time225, current time 284, horizon 59\n", + "adding: mem time226, current time 284, horizon 58\n", + "adding: mem time227, current time 284, horizon 57\n", + "adding: mem time228, current time 284, horizon 56\n", + "adding: mem time229, current time 284, horizon 55\n", + "adding: mem time230, current time 284, horizon 54\n", + "adding: mem time231, current time 284, horizon 53\n", + "adding: mem time232, current time 284, horizon 52\n", + "adding: mem time233, current time 284, horizon 51\n", + "adding: mem time234, current time 284, horizon 50\n", + "adding: mem time235, current time 284, horizon 49\n", + "adding: mem time236, current time 284, horizon 48\n", + "adding: mem time237, current time 284, horizon 47\n", + "adding: mem time238, current time 284, horizon 46\n", + "adding: mem time239, current time 284, horizon 45\n", + "adding: mem time240, current time 284, horizon 44\n", + "adding: mem time241, current time 284, horizon 43\n", + "adding: mem time242, current time 284, horizon 42\n", + "adding: mem time243, current time 284, horizon 41\n", + "adding: mem time244, current time 284, horizon 40\n", + "adding: mem time245, current time 284, horizon 39\n", + "adding: mem time246, current time 284, horizon 38\n", + "adding: mem time247, current time 284, horizon 37\n", + "adding: mem time248, current time 284, horizon 36\n", + "adding: mem time249, current time 284, horizon 35\n", + "adding: mem time250, current time 284, horizon 34\n", + "adding: mem time251, current time 284, horizon 33\n", + "adding: mem time252, current time 284, horizon 32\n", + "adding: mem time253, current time 284, horizon 31\n", + "adding: mem time254, current time 284, horizon 30\n", + "adding: mem time255, current time 284, horizon 29\n", + "adding: mem time256, current time 284, horizon 28\n", + "adding: mem time257, current time 284, horizon 27\n", + "adding: mem time258, current time 284, horizon 26\n", + "adding: mem time259, current time 284, horizon 25\n", + "adding: mem time260, current time 284, horizon 24\n", + "adding: mem time261, current time 284, horizon 23\n", + "adding: mem time262, current time 284, horizon 22\n", + "adding: mem time263, current time 284, horizon 21\n", + "adding: mem time264, current time 284, horizon 20\n", + "adding: mem time265, current time 284, horizon 19\n", + "adding: mem time266, current time 284, horizon 18\n", + "adding: mem time267, current time 284, horizon 17\n", + "adding: mem time268, current time 284, horizon 16\n", + "adding: mem time269, current time 284, horizon 15\n", + "adding: mem time270, current time 284, horizon 14\n", + "adding: mem time271, current time 284, horizon 13\n", + "adding: mem time272, current time 284, horizon 12\n", + "adding: mem time273, current time 284, horizon 11\n", + "adding: mem time274, current time 284, horizon 10\n", + "adding: mem time275, current time 284, horizon 9\n", + "adding: mem time276, current time 284, horizon 8\n", + "adding: mem time277, current time 284, horizon 7\n", + "adding: mem time278, current time 284, horizon 6\n", + "adding: mem time279, current time 284, horizon 5\n", + "adding: mem time280, current time 284, horizon 4\n", + "adding: mem time281, current time 284, horizon 3\n", + "adding: mem time282, current time 284, horizon 2\n", + "adding: mem time283, current time 284, horizon 1\n", + "adding: mem time200, current time 285, horizon 85\n", + "adding: mem time201, current time 285, horizon 84\n", + "adding: mem time202, current time 285, horizon 83\n", + "adding: mem time203, current time 285, horizon 82\n", + "adding: mem time204, current time 285, horizon 81\n", + "adding: mem time205, current time 285, horizon 80\n", + "adding: mem time206, current time 285, horizon 79\n", + "adding: mem time207, current time 285, horizon 78\n", + "adding: mem time208, current time 285, horizon 77\n", + "adding: mem time209, current time 285, horizon 76\n", + "adding: mem time210, current time 285, horizon 75\n", + "adding: mem time211, current time 285, horizon 74\n", + "adding: mem time212, current time 285, horizon 73\n", + "adding: mem time213, current time 285, horizon 72\n", + "adding: mem time214, current time 285, horizon 71\n", + "adding: mem time215, current time 285, horizon 70\n", + "adding: mem time216, current time 285, horizon 69\n", + "adding: mem time217, current time 285, horizon 68\n", + "adding: mem time218, current time 285, horizon 67\n", + "adding: mem time219, current time 285, horizon 66\n", + "adding: mem time220, current time 285, horizon 65\n", + "adding: mem time221, current time 285, horizon 64\n", + "adding: mem time222, current time 285, horizon 63\n", + "adding: mem time223, current time 285, horizon 62\n", + "adding: mem time224, current time 285, horizon 61\n", + "adding: mem time225, current time 285, horizon 60\n", + "adding: mem time226, current time 285, horizon 59\n", + "adding: mem time227, current time 285, horizon 58\n", + "adding: mem time228, current time 285, horizon 57\n", + "adding: mem time229, current time 285, horizon 56\n", + "adding: mem time230, current time 285, horizon 55\n", + "adding: mem time231, current time 285, horizon 54\n", + "adding: mem time232, current time 285, horizon 53\n", + "adding: mem time233, current time 285, horizon 52\n", + "adding: mem time234, current time 285, horizon 51\n", + "adding: mem time235, current time 285, horizon 50\n", + "adding: mem time236, current time 285, horizon 49\n", + "adding: mem time237, current time 285, horizon 48\n", + "adding: mem time238, current time 285, horizon 47\n", + "adding: mem time239, current time 285, horizon 46\n", + "adding: mem time240, current time 285, horizon 45\n", + "adding: mem time241, current time 285, horizon 44\n", + "adding: mem time242, current time 285, horizon 43\n", + "adding: mem time243, current time 285, horizon 42\n", + "adding: mem time244, current time 285, horizon 41\n", + "adding: mem time245, current time 285, horizon 40\n", + "adding: mem time246, current time 285, horizon 39\n", + "adding: mem time247, current time 285, horizon 38\n", + "adding: mem time248, current time 285, horizon 37\n", + "adding: mem time249, current time 285, horizon 36\n", + "adding: mem time250, current time 285, horizon 35\n", + "adding: mem time251, current time 285, horizon 34\n", + "adding: mem time252, current time 285, horizon 33\n", + "adding: mem time253, current time 285, horizon 32\n", + "adding: mem time254, current time 285, horizon 31\n", + "adding: mem time255, current time 285, horizon 30\n", + "adding: mem time256, current time 285, horizon 29\n", + "adding: mem time257, current time 285, horizon 28\n", + "adding: mem time258, current time 285, horizon 27\n", + "adding: mem time259, current time 285, horizon 26\n", + "adding: mem time260, current time 285, horizon 25\n", + "adding: mem time261, current time 285, horizon 24\n", + "adding: mem time262, current time 285, horizon 23\n", + "adding: mem time263, current time 285, horizon 22\n", + "adding: mem time264, current time 285, horizon 21\n", + "adding: mem time265, current time 285, horizon 20\n", + "adding: mem time266, current time 285, horizon 19\n", + "adding: mem time267, current time 285, horizon 18\n", + "adding: mem time268, current time 285, horizon 17\n", + "adding: mem time269, current time 285, horizon 16\n", + "adding: mem time270, current time 285, horizon 15\n", + "adding: mem time271, current time 285, horizon 14\n", + "adding: mem time272, current time 285, horizon 13\n", + "adding: mem time273, current time 285, horizon 12\n", + "adding: mem time274, current time 285, horizon 11\n", + "adding: mem time275, current time 285, horizon 10\n", + "adding: mem time276, current time 285, horizon 9\n", + "adding: mem time277, current time 285, horizon 8\n", + "adding: mem time278, current time 285, horizon 7\n", + "adding: mem time279, current time 285, horizon 6\n", + "adding: mem time280, current time 285, horizon 5\n", + "adding: mem time281, current time 285, horizon 4\n", + "adding: mem time282, current time 285, horizon 3\n", + "adding: mem time283, current time 285, horizon 2\n", + "adding: mem time284, current time 285, horizon 1\n", + "adding: mem time200, current time 286, horizon 86\n", + "adding: mem time201, current time 286, horizon 85\n", + "adding: mem time202, current time 286, horizon 84\n", + "adding: mem time203, current time 286, horizon 83\n", + "adding: mem time204, current time 286, horizon 82\n", + "adding: mem time205, current time 286, horizon 81\n", + "adding: mem time206, current time 286, horizon 80\n", + "adding: mem time207, current time 286, horizon 79\n", + "adding: mem time208, current time 286, horizon 78\n", + "adding: mem time209, current time 286, horizon 77\n", + "adding: mem time210, current time 286, horizon 76\n", + "adding: mem time211, current time 286, horizon 75\n", + "adding: mem time212, current time 286, horizon 74\n", + "adding: mem time213, current time 286, horizon 73\n", + "adding: mem time214, current time 286, horizon 72\n", + "adding: mem time215, current time 286, horizon 71\n", + "adding: mem time216, current time 286, horizon 70\n", + "adding: mem time217, current time 286, horizon 69\n", + "adding: mem time218, current time 286, horizon 68\n", + "adding: mem time219, current time 286, horizon 67\n", + "adding: mem time220, current time 286, horizon 66\n", + "adding: mem time221, current time 286, horizon 65\n", + "adding: mem time222, current time 286, horizon 64\n", + "adding: mem time223, current time 286, horizon 63\n", + "adding: mem time224, current time 286, horizon 62\n", + "adding: mem time225, current time 286, horizon 61\n", + "adding: mem time226, current time 286, horizon 60\n", + "adding: mem time227, current time 286, horizon 59\n", + "adding: mem time228, current time 286, horizon 58\n", + "adding: mem time229, current time 286, horizon 57\n", + "adding: mem time230, current time 286, horizon 56\n", + "adding: mem time231, current time 286, horizon 55\n", + "adding: mem time232, current time 286, horizon 54\n", + "adding: mem time233, current time 286, horizon 53\n", + "adding: mem time234, current time 286, horizon 52\n", + "adding: mem time235, current time 286, horizon 51\n", + "adding: mem time236, current time 286, horizon 50\n", + "adding: mem time237, current time 286, horizon 49\n", + "adding: mem time238, current time 286, horizon 48\n", + "adding: mem time239, current time 286, horizon 47\n", + "adding: mem time240, current time 286, horizon 46\n", + "adding: mem time241, current time 286, horizon 45\n", + "adding: mem time242, current time 286, horizon 44\n", + "adding: mem time243, current time 286, horizon 43\n", + "adding: mem time244, current time 286, horizon 42\n", + "adding: mem time245, current time 286, horizon 41\n", + "adding: mem time246, current time 286, horizon 40\n", + "adding: mem time247, current time 286, horizon 39\n", + "adding: mem time248, current time 286, horizon 38\n", + "adding: mem time249, current time 286, horizon 37\n", + "adding: mem time250, current time 286, horizon 36\n", + "adding: mem time251, current time 286, horizon 35\n", + "adding: mem time252, current time 286, horizon 34\n", + "adding: mem time253, current time 286, horizon 33\n", + "adding: mem time254, current time 286, horizon 32\n", + "adding: mem time255, current time 286, horizon 31\n", + "adding: mem time256, current time 286, horizon 30\n", + "adding: mem time257, current time 286, horizon 29\n", + "adding: mem time258, current time 286, horizon 28\n", + "adding: mem time259, current time 286, horizon 27\n", + "adding: mem time260, current time 286, horizon 26\n", + "adding: mem time261, current time 286, horizon 25\n", + "adding: mem time262, current time 286, horizon 24\n", + "adding: mem time263, current time 286, horizon 23\n", + "adding: mem time264, current time 286, horizon 22\n", + "adding: mem time265, current time 286, horizon 21\n", + "adding: mem time266, current time 286, horizon 20\n", + "adding: mem time267, current time 286, horizon 19\n", + "adding: mem time268, current time 286, horizon 18\n", + "adding: mem time269, current time 286, horizon 17\n", + "adding: mem time270, current time 286, horizon 16\n", + "adding: mem time271, current time 286, horizon 15\n", + "adding: mem time272, current time 286, horizon 14\n", + "adding: mem time273, current time 286, horizon 13\n", + "adding: mem time274, current time 286, horizon 12\n", + "adding: mem time275, current time 286, horizon 11\n", + "adding: mem time276, current time 286, horizon 10\n", + "adding: mem time277, current time 286, horizon 9\n", + "adding: mem time278, current time 286, horizon 8\n", + "adding: mem time279, current time 286, horizon 7\n", + "adding: mem time280, current time 286, horizon 6\n", + "adding: mem time281, current time 286, horizon 5\n", + "adding: mem time282, current time 286, horizon 4\n", + "adding: mem time283, current time 286, horizon 3\n", + "adding: mem time284, current time 286, horizon 2\n", + "adding: mem time285, current time 286, horizon 1\n", + "adding: mem time200, current time 287, horizon 87\n", + "adding: mem time201, current time 287, horizon 86\n", + "adding: mem time202, current time 287, horizon 85\n", + "adding: mem time203, current time 287, horizon 84\n", + "adding: mem time204, current time 287, horizon 83\n", + "adding: mem time205, current time 287, horizon 82\n", + "adding: mem time206, current time 287, horizon 81\n", + "adding: mem time207, current time 287, horizon 80\n", + "adding: mem time208, current time 287, horizon 79\n", + "adding: mem time209, current time 287, horizon 78\n", + "adding: mem time210, current time 287, horizon 77\n", + "adding: mem time211, current time 287, horizon 76\n", + "adding: mem time212, current time 287, horizon 75\n", + "adding: mem time213, current time 287, horizon 74\n", + "adding: mem time214, current time 287, horizon 73\n", + "adding: mem time215, current time 287, horizon 72\n", + "adding: mem time216, current time 287, horizon 71\n", + "adding: mem time217, current time 287, horizon 70\n", + "adding: mem time218, current time 287, horizon 69\n", + "adding: mem time219, current time 287, horizon 68\n", + "adding: mem time220, current time 287, horizon 67\n", + "adding: mem time221, current time 287, horizon 66\n", + "adding: mem time222, current time 287, horizon 65\n", + "adding: mem time223, current time 287, horizon 64\n", + "adding: mem time224, current time 287, horizon 63\n", + "adding: mem time225, current time 287, horizon 62\n", + "adding: mem time226, current time 287, horizon 61\n", + "adding: mem time227, current time 287, horizon 60\n", + "adding: mem time228, current time 287, horizon 59\n", + "adding: mem time229, current time 287, horizon 58\n", + "adding: mem time230, current time 287, horizon 57\n", + "adding: mem time231, current time 287, horizon 56\n", + "adding: mem time232, current time 287, horizon 55\n", + "adding: mem time233, current time 287, horizon 54\n", + "adding: mem time234, current time 287, horizon 53\n", + "adding: mem time235, current time 287, horizon 52\n", + "adding: mem time236, current time 287, horizon 51\n", + "adding: mem time237, current time 287, horizon 50\n", + "adding: mem time238, current time 287, horizon 49\n", + "adding: mem time239, current time 287, horizon 48\n", + "adding: mem time240, current time 287, horizon 47\n", + "adding: mem time241, current time 287, horizon 46\n", + "adding: mem time242, current time 287, horizon 45\n", + "adding: mem time243, current time 287, horizon 44\n", + "adding: mem time244, current time 287, horizon 43\n", + "adding: mem time245, current time 287, horizon 42\n", + "adding: mem time246, current time 287, horizon 41\n", + "adding: mem time247, current time 287, horizon 40\n", + "adding: mem time248, current time 287, horizon 39\n", + "adding: mem time249, current time 287, horizon 38\n", + "adding: mem time250, current time 287, horizon 37\n", + "adding: mem time251, current time 287, horizon 36\n", + "adding: mem time252, current time 287, horizon 35\n", + "adding: mem time253, current time 287, horizon 34\n", + "adding: mem time254, current time 287, horizon 33\n", + "adding: mem time255, current time 287, horizon 32\n", + "adding: mem time256, current time 287, horizon 31\n", + "adding: mem time257, current time 287, horizon 30\n", + "adding: mem time258, current time 287, horizon 29\n", + "adding: mem time259, current time 287, horizon 28\n", + "adding: mem time260, current time 287, horizon 27\n", + "adding: mem time261, current time 287, horizon 26\n", + "adding: mem time262, current time 287, horizon 25\n", + "adding: mem time263, current time 287, horizon 24\n", + "adding: mem time264, current time 287, horizon 23\n", + "adding: mem time265, current time 287, horizon 22\n", + "adding: mem time266, current time 287, horizon 21\n", + "adding: mem time267, current time 287, horizon 20\n", + "adding: mem time268, current time 287, horizon 19\n", + "adding: mem time269, current time 287, horizon 18\n", + "adding: mem time270, current time 287, horizon 17\n", + "adding: mem time271, current time 287, horizon 16\n", + "adding: mem time272, current time 287, horizon 15\n", + "adding: mem time273, current time 287, horizon 14\n", + "adding: mem time274, current time 287, horizon 13\n", + "adding: mem time275, current time 287, horizon 12\n", + "adding: mem time276, current time 287, horizon 11\n", + "adding: mem time277, current time 287, horizon 10\n", + "adding: mem time278, current time 287, horizon 9\n", + "adding: mem time279, current time 287, horizon 8\n", + "adding: mem time280, current time 287, horizon 7\n", + "adding: mem time281, current time 287, horizon 6\n", + "adding: mem time282, current time 287, horizon 5\n", + "adding: mem time283, current time 287, horizon 4\n", + "adding: mem time284, current time 287, horizon 3\n", + "adding: mem time285, current time 287, horizon 2\n", + "adding: mem time286, current time 287, horizon 1\n", + "adding: mem time200, current time 288, horizon 88\n", + "adding: mem time201, current time 288, horizon 87\n", + "adding: mem time202, current time 288, horizon 86\n", + "adding: mem time203, current time 288, horizon 85\n", + "adding: mem time204, current time 288, horizon 84\n", + "adding: mem time205, current time 288, horizon 83\n", + "adding: mem time206, current time 288, horizon 82\n", + "adding: mem time207, current time 288, horizon 81\n", + "adding: mem time208, current time 288, horizon 80\n", + "adding: mem time209, current time 288, horizon 79\n", + "adding: mem time210, current time 288, horizon 78\n", + "adding: mem time211, current time 288, horizon 77\n", + "adding: mem time212, current time 288, horizon 76\n", + "adding: mem time213, current time 288, horizon 75\n", + "adding: mem time214, current time 288, horizon 74\n", + "adding: mem time215, current time 288, horizon 73\n", + "adding: mem time216, current time 288, horizon 72\n", + "adding: mem time217, current time 288, horizon 71\n", + "adding: mem time218, current time 288, horizon 70\n", + "adding: mem time219, current time 288, horizon 69\n", + "adding: mem time220, current time 288, horizon 68\n", + "adding: mem time221, current time 288, horizon 67\n", + "adding: mem time222, current time 288, horizon 66\n", + "adding: mem time223, current time 288, horizon 65\n", + "adding: mem time224, current time 288, horizon 64\n", + "adding: mem time225, current time 288, horizon 63\n", + "adding: mem time226, current time 288, horizon 62\n", + "adding: mem time227, current time 288, horizon 61\n", + "adding: mem time228, current time 288, horizon 60\n", + "adding: mem time229, current time 288, horizon 59\n", + "adding: mem time230, current time 288, horizon 58\n", + "adding: mem time231, current time 288, horizon 57\n", + "adding: mem time232, current time 288, horizon 56\n", + "adding: mem time233, current time 288, horizon 55\n", + "adding: mem time234, current time 288, horizon 54\n", + "adding: mem time235, current time 288, horizon 53\n", + "adding: mem time236, current time 288, horizon 52\n", + "adding: mem time237, current time 288, horizon 51\n", + "adding: mem time238, current time 288, horizon 50\n", + "adding: mem time239, current time 288, horizon 49\n", + "adding: mem time240, current time 288, horizon 48\n", + "adding: mem time241, current time 288, horizon 47\n", + "adding: mem time242, current time 288, horizon 46\n", + "adding: mem time243, current time 288, horizon 45\n", + "adding: mem time244, current time 288, horizon 44\n", + "adding: mem time245, current time 288, horizon 43\n", + "adding: mem time246, current time 288, horizon 42\n", + "adding: mem time247, current time 288, horizon 41\n", + "adding: mem time248, current time 288, horizon 40\n", + "adding: mem time249, current time 288, horizon 39\n", + "adding: mem time250, current time 288, horizon 38\n", + "adding: mem time251, current time 288, horizon 37\n", + "adding: mem time252, current time 288, horizon 36\n", + "adding: mem time253, current time 288, horizon 35\n", + "adding: mem time254, current time 288, horizon 34\n", + "adding: mem time255, current time 288, horizon 33\n", + "adding: mem time256, current time 288, horizon 32\n", + "adding: mem time257, current time 288, horizon 31\n", + "adding: mem time258, current time 288, horizon 30\n", + "adding: mem time259, current time 288, horizon 29\n", + "adding: mem time260, current time 288, horizon 28\n", + "adding: mem time261, current time 288, horizon 27\n", + "adding: mem time262, current time 288, horizon 26\n", + "adding: mem time263, current time 288, horizon 25\n", + "adding: mem time264, current time 288, horizon 24\n", + "adding: mem time265, current time 288, horizon 23\n", + "adding: mem time266, current time 288, horizon 22\n", + "adding: mem time267, current time 288, horizon 21\n", + "adding: mem time268, current time 288, horizon 20\n", + "adding: mem time269, current time 288, horizon 19\n", + "adding: mem time270, current time 288, horizon 18\n", + "adding: mem time271, current time 288, horizon 17\n", + "adding: mem time272, current time 288, horizon 16\n", + "adding: mem time273, current time 288, horizon 15\n", + "adding: mem time274, current time 288, horizon 14\n", + "adding: mem time275, current time 288, horizon 13\n", + "adding: mem time276, current time 288, horizon 12\n", + "adding: mem time277, current time 288, horizon 11\n", + "adding: mem time278, current time 288, horizon 10\n", + "adding: mem time279, current time 288, horizon 9\n", + "adding: mem time280, current time 288, horizon 8\n", + "adding: mem time281, current time 288, horizon 7\n", + "adding: mem time282, current time 288, horizon 6\n", + "adding: mem time283, current time 288, horizon 5\n", + "adding: mem time284, current time 288, horizon 4\n", + "adding: mem time285, current time 288, horizon 3\n", + "adding: mem time286, current time 288, horizon 2\n", + "adding: mem time287, current time 288, horizon 1\n", + "adding: mem time200, current time 289, horizon 89\n", + "adding: mem time201, current time 289, horizon 88\n", + "adding: mem time202, current time 289, horizon 87\n", + "adding: mem time203, current time 289, horizon 86\n", + "adding: mem time204, current time 289, horizon 85\n", + "adding: mem time205, current time 289, horizon 84\n", + "adding: mem time206, current time 289, horizon 83\n", + "adding: mem time207, current time 289, horizon 82\n", + "adding: mem time208, current time 289, horizon 81\n", + "adding: mem time209, current time 289, horizon 80\n", + "adding: mem time210, current time 289, horizon 79\n", + "adding: mem time211, current time 289, horizon 78\n", + "adding: mem time212, current time 289, horizon 77\n", + "adding: mem time213, current time 289, horizon 76\n", + "adding: mem time214, current time 289, horizon 75\n", + "adding: mem time215, current time 289, horizon 74\n", + "adding: mem time216, current time 289, horizon 73\n", + "adding: mem time217, current time 289, horizon 72\n", + "adding: mem time218, current time 289, horizon 71\n", + "adding: mem time219, current time 289, horizon 70\n", + "adding: mem time220, current time 289, horizon 69\n", + "adding: mem time221, current time 289, horizon 68\n", + "adding: mem time222, current time 289, horizon 67\n", + "adding: mem time223, current time 289, horizon 66\n", + "adding: mem time224, current time 289, horizon 65\n", + "adding: mem time225, current time 289, horizon 64\n", + "adding: mem time226, current time 289, horizon 63\n", + "adding: mem time227, current time 289, horizon 62\n", + "adding: mem time228, current time 289, horizon 61\n", + "adding: mem time229, current time 289, horizon 60\n", + "adding: mem time230, current time 289, horizon 59\n", + "adding: mem time231, current time 289, horizon 58\n", + "adding: mem time232, current time 289, horizon 57\n", + "adding: mem time233, current time 289, horizon 56\n", + "adding: mem time234, current time 289, horizon 55\n", + "adding: mem time235, current time 289, horizon 54\n", + "adding: mem time236, current time 289, horizon 53\n", + "adding: mem time237, current time 289, horizon 52\n", + "adding: mem time238, current time 289, horizon 51\n", + "adding: mem time239, current time 289, horizon 50\n", + "adding: mem time240, current time 289, horizon 49\n", + "adding: mem time241, current time 289, horizon 48\n", + "adding: mem time242, current time 289, horizon 47\n", + "adding: mem time243, current time 289, horizon 46\n", + "adding: mem time244, current time 289, horizon 45\n", + "adding: mem time245, current time 289, horizon 44\n", + "adding: mem time246, current time 289, horizon 43\n", + "adding: mem time247, current time 289, horizon 42\n", + "adding: mem time248, current time 289, horizon 41\n", + "adding: mem time249, current time 289, horizon 40\n", + "adding: mem time250, current time 289, horizon 39\n", + "adding: mem time251, current time 289, horizon 38\n", + "adding: mem time252, current time 289, horizon 37\n", + "adding: mem time253, current time 289, horizon 36\n", + "adding: mem time254, current time 289, horizon 35\n", + "adding: mem time255, current time 289, horizon 34\n", + "adding: mem time256, current time 289, horizon 33\n", + "adding: mem time257, current time 289, horizon 32\n", + "adding: mem time258, current time 289, horizon 31\n", + "adding: mem time259, current time 289, horizon 30\n", + "adding: mem time260, current time 289, horizon 29\n", + "adding: mem time261, current time 289, horizon 28\n", + "adding: mem time262, current time 289, horizon 27\n", + "adding: mem time263, current time 289, horizon 26\n", + "adding: mem time264, current time 289, horizon 25\n", + "adding: mem time265, current time 289, horizon 24\n", + "adding: mem time266, current time 289, horizon 23\n", + "adding: mem time267, current time 289, horizon 22\n", + "adding: mem time268, current time 289, horizon 21\n", + "adding: mem time269, current time 289, horizon 20\n", + "adding: mem time270, current time 289, horizon 19\n", + "adding: mem time271, current time 289, horizon 18\n", + "adding: mem time272, current time 289, horizon 17\n", + "adding: mem time273, current time 289, horizon 16\n", + "adding: mem time274, current time 289, horizon 15\n", + "adding: mem time275, current time 289, horizon 14\n", + "adding: mem time276, current time 289, horizon 13\n", + "adding: mem time277, current time 289, horizon 12\n", + "adding: mem time278, current time 289, horizon 11\n", + "adding: mem time279, current time 289, horizon 10\n", + "adding: mem time280, current time 289, horizon 9\n", + "adding: mem time281, current time 289, horizon 8\n", + "adding: mem time282, current time 289, horizon 7\n", + "adding: mem time283, current time 289, horizon 6\n", + "adding: mem time284, current time 289, horizon 5\n", + "adding: mem time285, current time 289, horizon 4\n", + "adding: mem time286, current time 289, horizon 3\n", + "adding: mem time287, current time 289, horizon 2\n", + "adding: mem time288, current time 289, horizon 1\n", + "adding: mem time200, current time 290, horizon 90\n", + "adding: mem time201, current time 290, horizon 89\n", + "adding: mem time202, current time 290, horizon 88\n", + "adding: mem time203, current time 290, horizon 87\n", + "adding: mem time204, current time 290, horizon 86\n", + "adding: mem time205, current time 290, horizon 85\n", + "adding: mem time206, current time 290, horizon 84\n", + "adding: mem time207, current time 290, horizon 83\n", + "adding: mem time208, current time 290, horizon 82\n", + "adding: mem time209, current time 290, horizon 81\n", + "adding: mem time210, current time 290, horizon 80\n", + "adding: mem time211, current time 290, horizon 79\n", + "adding: mem time212, current time 290, horizon 78\n", + "adding: mem time213, current time 290, horizon 77\n", + "adding: mem time214, current time 290, horizon 76\n", + "adding: mem time215, current time 290, horizon 75\n", + "adding: mem time216, current time 290, horizon 74\n", + "adding: mem time217, current time 290, horizon 73\n", + "adding: mem time218, current time 290, horizon 72\n", + "adding: mem time219, current time 290, horizon 71\n", + "adding: mem time220, current time 290, horizon 70\n", + "adding: mem time221, current time 290, horizon 69\n", + "adding: mem time222, current time 290, horizon 68\n", + "adding: mem time223, current time 290, horizon 67\n", + "adding: mem time224, current time 290, horizon 66\n", + "adding: mem time225, current time 290, horizon 65\n", + "adding: mem time226, current time 290, horizon 64\n", + "adding: mem time227, current time 290, horizon 63\n", + "adding: mem time228, current time 290, horizon 62\n", + "adding: mem time229, current time 290, horizon 61\n", + "adding: mem time230, current time 290, horizon 60\n", + "adding: mem time231, current time 290, horizon 59\n", + "adding: mem time232, current time 290, horizon 58\n", + "adding: mem time233, current time 290, horizon 57\n", + "adding: mem time234, current time 290, horizon 56\n", + "adding: mem time235, current time 290, horizon 55\n", + "adding: mem time236, current time 290, horizon 54\n", + "adding: mem time237, current time 290, horizon 53\n", + "adding: mem time238, current time 290, horizon 52\n", + "adding: mem time239, current time 290, horizon 51\n", + "adding: mem time240, current time 290, horizon 50\n", + "adding: mem time241, current time 290, horizon 49\n", + "adding: mem time242, current time 290, horizon 48\n", + "adding: mem time243, current time 290, horizon 47\n", + "adding: mem time244, current time 290, horizon 46\n", + "adding: mem time245, current time 290, horizon 45\n", + "adding: mem time246, current time 290, horizon 44\n", + "adding: mem time247, current time 290, horizon 43\n", + "adding: mem time248, current time 290, horizon 42\n", + "adding: mem time249, current time 290, horizon 41\n", + "adding: mem time250, current time 290, horizon 40\n", + "adding: mem time251, current time 290, horizon 39\n", + "adding: mem time252, current time 290, horizon 38\n", + "adding: mem time253, current time 290, horizon 37\n", + "adding: mem time254, current time 290, horizon 36\n", + "adding: mem time255, current time 290, horizon 35\n", + "adding: mem time256, current time 290, horizon 34\n", + "adding: mem time257, current time 290, horizon 33\n", + "adding: mem time258, current time 290, horizon 32\n", + "adding: mem time259, current time 290, horizon 31\n", + "adding: mem time260, current time 290, horizon 30\n", + "adding: mem time261, current time 290, horizon 29\n", + "adding: mem time262, current time 290, horizon 28\n", + "adding: mem time263, current time 290, horizon 27\n", + "adding: mem time264, current time 290, horizon 26\n", + "adding: mem time265, current time 290, horizon 25\n", + "adding: mem time266, current time 290, horizon 24\n", + "adding: mem time267, current time 290, horizon 23\n", + "adding: mem time268, current time 290, horizon 22\n", + "adding: mem time269, current time 290, horizon 21\n", + "adding: mem time270, current time 290, horizon 20\n", + "adding: mem time271, current time 290, horizon 19\n", + "adding: mem time272, current time 290, horizon 18\n", + "adding: mem time273, current time 290, horizon 17\n", + "adding: mem time274, current time 290, horizon 16\n", + "adding: mem time275, current time 290, horizon 15\n", + "adding: mem time276, current time 290, horizon 14\n", + "adding: mem time277, current time 290, horizon 13\n", + "adding: mem time278, current time 290, horizon 12\n", + "adding: mem time279, current time 290, horizon 11\n", + "adding: mem time280, current time 290, horizon 10\n", + "adding: mem time281, current time 290, horizon 9\n", + "adding: mem time282, current time 290, horizon 8\n", + "adding: mem time283, current time 290, horizon 7\n", + "adding: mem time284, current time 290, horizon 6\n", + "adding: mem time285, current time 290, horizon 5\n", + "adding: mem time286, current time 290, horizon 4\n", + "adding: mem time287, current time 290, horizon 3\n", + "adding: mem time288, current time 290, horizon 2\n", + "adding: mem time289, current time 290, horizon 1\n", + "adding: mem time200, current time 291, horizon 91\n", + "adding: mem time201, current time 291, horizon 90\n", + "adding: mem time202, current time 291, horizon 89\n", + "adding: mem time203, current time 291, horizon 88\n", + "adding: mem time204, current time 291, horizon 87\n", + "adding: mem time205, current time 291, horizon 86\n", + "adding: mem time206, current time 291, horizon 85\n", + "adding: mem time207, current time 291, horizon 84\n", + "adding: mem time208, current time 291, horizon 83\n", + "adding: mem time209, current time 291, horizon 82\n", + "adding: mem time210, current time 291, horizon 81\n", + "adding: mem time211, current time 291, horizon 80\n", + "adding: mem time212, current time 291, horizon 79\n", + "adding: mem time213, current time 291, horizon 78\n", + "adding: mem time214, current time 291, horizon 77\n", + "adding: mem time215, current time 291, horizon 76\n", + "adding: mem time216, current time 291, horizon 75\n", + "adding: mem time217, current time 291, horizon 74\n", + "adding: mem time218, current time 291, horizon 73\n", + "adding: mem time219, current time 291, horizon 72\n", + "adding: mem time220, current time 291, horizon 71\n", + "adding: mem time221, current time 291, horizon 70\n", + "adding: mem time222, current time 291, horizon 69\n", + "adding: mem time223, current time 291, horizon 68\n", + "adding: mem time224, current time 291, horizon 67\n", + "adding: mem time225, current time 291, horizon 66\n", + "adding: mem time226, current time 291, horizon 65\n", + "adding: mem time227, current time 291, horizon 64\n", + "adding: mem time228, current time 291, horizon 63\n", + "adding: mem time229, current time 291, horizon 62\n", + "adding: mem time230, current time 291, horizon 61\n", + "adding: mem time231, current time 291, horizon 60\n", + "adding: mem time232, current time 291, horizon 59\n", + "adding: mem time233, current time 291, horizon 58\n", + "adding: mem time234, current time 291, horizon 57\n", + "adding: mem time235, current time 291, horizon 56\n", + "adding: mem time236, current time 291, horizon 55\n", + "adding: mem time237, current time 291, horizon 54\n", + "adding: mem time238, current time 291, horizon 53\n", + "adding: mem time239, current time 291, horizon 52\n", + "adding: mem time240, current time 291, horizon 51\n", + "adding: mem time241, current time 291, horizon 50\n", + "adding: mem time242, current time 291, horizon 49\n", + "adding: mem time243, current time 291, horizon 48\n", + "adding: mem time244, current time 291, horizon 47\n", + "adding: mem time245, current time 291, horizon 46\n", + "adding: mem time246, current time 291, horizon 45\n", + "adding: mem time247, current time 291, horizon 44\n", + "adding: mem time248, current time 291, horizon 43\n", + "adding: mem time249, current time 291, horizon 42\n", + "adding: mem time250, current time 291, horizon 41\n", + "adding: mem time251, current time 291, horizon 40\n", + "adding: mem time252, current time 291, horizon 39\n", + "adding: mem time253, current time 291, horizon 38\n", + "adding: mem time254, current time 291, horizon 37\n", + "adding: mem time255, current time 291, horizon 36\n", + "adding: mem time256, current time 291, horizon 35\n", + "adding: mem time257, current time 291, horizon 34\n", + "adding: mem time258, current time 291, horizon 33\n", + "adding: mem time259, current time 291, horizon 32\n", + "adding: mem time260, current time 291, horizon 31\n", + "adding: mem time261, current time 291, horizon 30\n", + "adding: mem time262, current time 291, horizon 29\n", + "adding: mem time263, current time 291, horizon 28\n", + "adding: mem time264, current time 291, horizon 27\n", + "adding: mem time265, current time 291, horizon 26\n", + "adding: mem time266, current time 291, horizon 25\n", + "adding: mem time267, current time 291, horizon 24\n", + "adding: mem time268, current time 291, horizon 23\n", + "adding: mem time269, current time 291, horizon 22\n", + "adding: mem time270, current time 291, horizon 21\n", + "adding: mem time271, current time 291, horizon 20\n", + "adding: mem time272, current time 291, horizon 19\n", + "adding: mem time273, current time 291, horizon 18\n", + "adding: mem time274, current time 291, horizon 17\n", + "adding: mem time275, current time 291, horizon 16\n", + "adding: mem time276, current time 291, horizon 15\n", + "adding: mem time277, current time 291, horizon 14\n", + "adding: mem time278, current time 291, horizon 13\n", + "adding: mem time279, current time 291, horizon 12\n", + "adding: mem time280, current time 291, horizon 11\n", + "adding: mem time281, current time 291, horizon 10\n", + "adding: mem time282, current time 291, horizon 9\n", + "adding: mem time283, current time 291, horizon 8\n", + "adding: mem time284, current time 291, horizon 7\n", + "adding: mem time285, current time 291, horizon 6\n", + "adding: mem time286, current time 291, horizon 5\n", + "adding: mem time287, current time 291, horizon 4\n", + "adding: mem time288, current time 291, horizon 3\n", + "adding: mem time289, current time 291, horizon 2\n", + "adding: mem time290, current time 291, horizon 1\n", + "adding: mem time200, current time 292, horizon 92\n", + "adding: mem time201, current time 292, horizon 91\n", + "adding: mem time202, current time 292, horizon 90\n", + "adding: mem time203, current time 292, horizon 89\n", + "adding: mem time204, current time 292, horizon 88\n", + "adding: mem time205, current time 292, horizon 87\n", + "adding: mem time206, current time 292, horizon 86\n", + "adding: mem time207, current time 292, horizon 85\n", + "adding: mem time208, current time 292, horizon 84\n", + "adding: mem time209, current time 292, horizon 83\n", + "adding: mem time210, current time 292, horizon 82\n", + "adding: mem time211, current time 292, horizon 81\n", + "adding: mem time212, current time 292, horizon 80\n", + "adding: mem time213, current time 292, horizon 79\n", + "adding: mem time214, current time 292, horizon 78\n", + "adding: mem time215, current time 292, horizon 77\n", + "adding: mem time216, current time 292, horizon 76\n", + "adding: mem time217, current time 292, horizon 75\n", + "adding: mem time218, current time 292, horizon 74\n", + "adding: mem time219, current time 292, horizon 73\n", + "adding: mem time220, current time 292, horizon 72\n", + "adding: mem time221, current time 292, horizon 71\n", + "adding: mem time222, current time 292, horizon 70\n", + "adding: mem time223, current time 292, horizon 69\n", + "adding: mem time224, current time 292, horizon 68\n", + "adding: mem time225, current time 292, horizon 67\n", + "adding: mem time226, current time 292, horizon 66\n", + "adding: mem time227, current time 292, horizon 65\n", + "adding: mem time228, current time 292, horizon 64\n", + "adding: mem time229, current time 292, horizon 63\n", + "adding: mem time230, current time 292, horizon 62\n", + "adding: mem time231, current time 292, horizon 61\n", + "adding: mem time232, current time 292, horizon 60\n", + "adding: mem time233, current time 292, horizon 59\n", + "adding: mem time234, current time 292, horizon 58\n", + "adding: mem time235, current time 292, horizon 57\n", + "adding: mem time236, current time 292, horizon 56\n", + "adding: mem time237, current time 292, horizon 55\n", + "adding: mem time238, current time 292, horizon 54\n", + "adding: mem time239, current time 292, horizon 53\n", + "adding: mem time240, current time 292, horizon 52\n", + "adding: mem time241, current time 292, horizon 51\n", + "adding: mem time242, current time 292, horizon 50\n", + "adding: mem time243, current time 292, horizon 49\n", + "adding: mem time244, current time 292, horizon 48\n", + "adding: mem time245, current time 292, horizon 47\n", + "adding: mem time246, current time 292, horizon 46\n", + "adding: mem time247, current time 292, horizon 45\n", + "adding: mem time248, current time 292, horizon 44\n", + "adding: mem time249, current time 292, horizon 43\n", + "adding: mem time250, current time 292, horizon 42\n", + "adding: mem time251, current time 292, horizon 41\n", + "adding: mem time252, current time 292, horizon 40\n", + "adding: mem time253, current time 292, horizon 39\n", + "adding: mem time254, current time 292, horizon 38\n", + "adding: mem time255, current time 292, horizon 37\n", + "adding: mem time256, current time 292, horizon 36\n", + "adding: mem time257, current time 292, horizon 35\n", + "adding: mem time258, current time 292, horizon 34\n", + "adding: mem time259, current time 292, horizon 33\n", + "adding: mem time260, current time 292, horizon 32\n", + "adding: mem time261, current time 292, horizon 31\n", + "adding: mem time262, current time 292, horizon 30\n", + "adding: mem time263, current time 292, horizon 29\n", + "adding: mem time264, current time 292, horizon 28\n", + "adding: mem time265, current time 292, horizon 27\n", + "adding: mem time266, current time 292, horizon 26\n", + "adding: mem time267, current time 292, horizon 25\n", + "adding: mem time268, current time 292, horizon 24\n", + "adding: mem time269, current time 292, horizon 23\n", + "adding: mem time270, current time 292, horizon 22\n", + "adding: mem time271, current time 292, horizon 21\n", + "adding: mem time272, current time 292, horizon 20\n", + "adding: mem time273, current time 292, horizon 19\n", + "adding: mem time274, current time 292, horizon 18\n", + "adding: mem time275, current time 292, horizon 17\n", + "adding: mem time276, current time 292, horizon 16\n", + "adding: mem time277, current time 292, horizon 15\n", + "adding: mem time278, current time 292, horizon 14\n", + "adding: mem time279, current time 292, horizon 13\n", + "adding: mem time280, current time 292, horizon 12\n", + "adding: mem time281, current time 292, horizon 11\n", + "adding: mem time282, current time 292, horizon 10\n", + "adding: mem time283, current time 292, horizon 9\n", + "adding: mem time284, current time 292, horizon 8\n", + "adding: mem time285, current time 292, horizon 7\n", + "adding: mem time286, current time 292, horizon 6\n", + "adding: mem time287, current time 292, horizon 5\n", + "adding: mem time288, current time 292, horizon 4\n", + "adding: mem time289, current time 292, horizon 3\n", + "adding: mem time290, current time 292, horizon 2\n", + "adding: mem time291, current time 292, horizon 1\n", + "adding: mem time200, current time 293, horizon 93\n", + "adding: mem time201, current time 293, horizon 92\n", + "adding: mem time202, current time 293, horizon 91\n", + "adding: mem time203, current time 293, horizon 90\n", + "adding: mem time204, current time 293, horizon 89\n", + "adding: mem time205, current time 293, horizon 88\n", + "adding: mem time206, current time 293, horizon 87\n", + "adding: mem time207, current time 293, horizon 86\n", + "adding: mem time208, current time 293, horizon 85\n", + "adding: mem time209, current time 293, horizon 84\n", + "adding: mem time210, current time 293, horizon 83\n", + "adding: mem time211, current time 293, horizon 82\n", + "adding: mem time212, current time 293, horizon 81\n", + "adding: mem time213, current time 293, horizon 80\n", + "adding: mem time214, current time 293, horizon 79\n", + "adding: mem time215, current time 293, horizon 78\n", + "adding: mem time216, current time 293, horizon 77\n", + "adding: mem time217, current time 293, horizon 76\n", + "adding: mem time218, current time 293, horizon 75\n", + "adding: mem time219, current time 293, horizon 74\n", + "adding: mem time220, current time 293, horizon 73\n", + "adding: mem time221, current time 293, horizon 72\n", + "adding: mem time222, current time 293, horizon 71\n", + "adding: mem time223, current time 293, horizon 70\n", + "adding: mem time224, current time 293, horizon 69\n", + "adding: mem time225, current time 293, horizon 68\n", + "adding: mem time226, current time 293, horizon 67\n", + "adding: mem time227, current time 293, horizon 66\n", + "adding: mem time228, current time 293, horizon 65\n", + "adding: mem time229, current time 293, horizon 64\n", + "adding: mem time230, current time 293, horizon 63\n", + "adding: mem time231, current time 293, horizon 62\n", + "adding: mem time232, current time 293, horizon 61\n", + "adding: mem time233, current time 293, horizon 60\n", + "adding: mem time234, current time 293, horizon 59\n", + "adding: mem time235, current time 293, horizon 58\n", + "adding: mem time236, current time 293, horizon 57\n", + "adding: mem time237, current time 293, horizon 56\n", + "adding: mem time238, current time 293, horizon 55\n", + "adding: mem time239, current time 293, horizon 54\n", + "adding: mem time240, current time 293, horizon 53\n", + "adding: mem time241, current time 293, horizon 52\n", + "adding: mem time242, current time 293, horizon 51\n", + "adding: mem time243, current time 293, horizon 50\n", + "adding: mem time244, current time 293, horizon 49\n", + "adding: mem time245, current time 293, horizon 48\n", + "adding: mem time246, current time 293, horizon 47\n", + "adding: mem time247, current time 293, horizon 46\n", + "adding: mem time248, current time 293, horizon 45\n", + "adding: mem time249, current time 293, horizon 44\n", + "adding: mem time250, current time 293, horizon 43\n", + "adding: mem time251, current time 293, horizon 42\n", + "adding: mem time252, current time 293, horizon 41\n", + "adding: mem time253, current time 293, horizon 40\n", + "adding: mem time254, current time 293, horizon 39\n", + "adding: mem time255, current time 293, horizon 38\n", + "adding: mem time256, current time 293, horizon 37\n", + "adding: mem time257, current time 293, horizon 36\n", + "adding: mem time258, current time 293, horizon 35\n", + "adding: mem time259, current time 293, horizon 34\n", + "adding: mem time260, current time 293, horizon 33\n", + "adding: mem time261, current time 293, horizon 32\n", + "adding: mem time262, current time 293, horizon 31\n", + "adding: mem time263, current time 293, horizon 30\n", + "adding: mem time264, current time 293, horizon 29\n", + "adding: mem time265, current time 293, horizon 28\n", + "adding: mem time266, current time 293, horizon 27\n", + "adding: mem time267, current time 293, horizon 26\n", + "adding: mem time268, current time 293, horizon 25\n", + "adding: mem time269, current time 293, horizon 24\n", + "adding: mem time270, current time 293, horizon 23\n", + "adding: mem time271, current time 293, horizon 22\n", + "adding: mem time272, current time 293, horizon 21\n", + "adding: mem time273, current time 293, horizon 20\n", + "adding: mem time274, current time 293, horizon 19\n", + "adding: mem time275, current time 293, horizon 18\n", + "adding: mem time276, current time 293, horizon 17\n", + "adding: mem time277, current time 293, horizon 16\n", + "adding: mem time278, current time 293, horizon 15\n", + "adding: mem time279, current time 293, horizon 14\n", + "adding: mem time280, current time 293, horizon 13\n", + "adding: mem time281, current time 293, horizon 12\n", + "adding: mem time282, current time 293, horizon 11\n", + "adding: mem time283, current time 293, horizon 10\n", + "adding: mem time284, current time 293, horizon 9\n", + "adding: mem time285, current time 293, horizon 8\n", + "adding: mem time286, current time 293, horizon 7\n", + "adding: mem time287, current time 293, horizon 6\n", + "adding: mem time288, current time 293, horizon 5\n", + "adding: mem time289, current time 293, horizon 4\n", + "adding: mem time290, current time 293, horizon 3\n", + "adding: mem time291, current time 293, horizon 2\n", + "adding: mem time292, current time 293, horizon 1\n", + "adding: mem time200, current time 294, horizon 94\n", + "adding: mem time201, current time 294, horizon 93\n", + "adding: mem time202, current time 294, horizon 92\n", + "adding: mem time203, current time 294, horizon 91\n", + "adding: mem time204, current time 294, horizon 90\n", + "adding: mem time205, current time 294, horizon 89\n", + "adding: mem time206, current time 294, horizon 88\n", + "adding: mem time207, current time 294, horizon 87\n", + "adding: mem time208, current time 294, horizon 86\n", + "adding: mem time209, current time 294, horizon 85\n", + "adding: mem time210, current time 294, horizon 84\n", + "adding: mem time211, current time 294, horizon 83\n", + "adding: mem time212, current time 294, horizon 82\n", + "adding: mem time213, current time 294, horizon 81\n", + "adding: mem time214, current time 294, horizon 80\n", + "adding: mem time215, current time 294, horizon 79\n", + "adding: mem time216, current time 294, horizon 78\n", + "adding: mem time217, current time 294, horizon 77\n", + "adding: mem time218, current time 294, horizon 76\n", + "adding: mem time219, current time 294, horizon 75\n", + "adding: mem time220, current time 294, horizon 74\n", + "adding: mem time221, current time 294, horizon 73\n", + "adding: mem time222, current time 294, horizon 72\n", + "adding: mem time223, current time 294, horizon 71\n", + "adding: mem time224, current time 294, horizon 70\n", + "adding: mem time225, current time 294, horizon 69\n", + "adding: mem time226, current time 294, horizon 68\n", + "adding: mem time227, current time 294, horizon 67\n", + "adding: mem time228, current time 294, horizon 66\n", + "adding: mem time229, current time 294, horizon 65\n", + "adding: mem time230, current time 294, horizon 64\n", + "adding: mem time231, current time 294, horizon 63\n", + "adding: mem time232, current time 294, horizon 62\n", + "adding: mem time233, current time 294, horizon 61\n", + "adding: mem time234, current time 294, horizon 60\n", + "adding: mem time235, current time 294, horizon 59\n", + "adding: mem time236, current time 294, horizon 58\n", + "adding: mem time237, current time 294, horizon 57\n", + "adding: mem time238, current time 294, horizon 56\n", + "adding: mem time239, current time 294, horizon 55\n", + "adding: mem time240, current time 294, horizon 54\n", + "adding: mem time241, current time 294, horizon 53\n", + "adding: mem time242, current time 294, horizon 52\n", + "adding: mem time243, current time 294, horizon 51\n", + "adding: mem time244, current time 294, horizon 50\n", + "adding: mem time245, current time 294, horizon 49\n", + "adding: mem time246, current time 294, horizon 48\n", + "adding: mem time247, current time 294, horizon 47\n", + "adding: mem time248, current time 294, horizon 46\n", + "adding: mem time249, current time 294, horizon 45\n", + "adding: mem time250, current time 294, horizon 44\n", + "adding: mem time251, current time 294, horizon 43\n", + "adding: mem time252, current time 294, horizon 42\n", + "adding: mem time253, current time 294, horizon 41\n", + "adding: mem time254, current time 294, horizon 40\n", + "adding: mem time255, current time 294, horizon 39\n", + "adding: mem time256, current time 294, horizon 38\n", + "adding: mem time257, current time 294, horizon 37\n", + "adding: mem time258, current time 294, horizon 36\n", + "adding: mem time259, current time 294, horizon 35\n", + "adding: mem time260, current time 294, horizon 34\n", + "adding: mem time261, current time 294, horizon 33\n", + "adding: mem time262, current time 294, horizon 32\n", + "adding: mem time263, current time 294, horizon 31\n", + "adding: mem time264, current time 294, horizon 30\n", + "adding: mem time265, current time 294, horizon 29\n", + "adding: mem time266, current time 294, horizon 28\n", + "adding: mem time267, current time 294, horizon 27\n", + "adding: mem time268, current time 294, horizon 26\n", + "adding: mem time269, current time 294, horizon 25\n", + "adding: mem time270, current time 294, horizon 24\n", + "adding: mem time271, current time 294, horizon 23\n", + "adding: mem time272, current time 294, horizon 22\n", + "adding: mem time273, current time 294, horizon 21\n", + "adding: mem time274, current time 294, horizon 20\n", + "adding: mem time275, current time 294, horizon 19\n", + "adding: mem time276, current time 294, horizon 18\n", + "adding: mem time277, current time 294, horizon 17\n", + "adding: mem time278, current time 294, horizon 16\n", + "adding: mem time279, current time 294, horizon 15\n", + "adding: mem time280, current time 294, horizon 14\n", + "adding: mem time281, current time 294, horizon 13\n", + "adding: mem time282, current time 294, horizon 12\n", + "adding: mem time283, current time 294, horizon 11\n", + "adding: mem time284, current time 294, horizon 10\n", + "adding: mem time285, current time 294, horizon 9\n", + "adding: mem time286, current time 294, horizon 8\n", + "adding: mem time287, current time 294, horizon 7\n", + "adding: mem time288, current time 294, horizon 6\n", + "adding: mem time289, current time 294, horizon 5\n", + "adding: mem time290, current time 294, horizon 4\n", + "adding: mem time291, current time 294, horizon 3\n", + "adding: mem time292, current time 294, horizon 2\n", + "adding: mem time293, current time 294, horizon 1\n", + "adding: mem time200, current time 295, horizon 95\n", + "adding: mem time201, current time 295, horizon 94\n", + "adding: mem time202, current time 295, horizon 93\n", + "adding: mem time203, current time 295, horizon 92\n", + "adding: mem time204, current time 295, horizon 91\n", + "adding: mem time205, current time 295, horizon 90\n", + "adding: mem time206, current time 295, horizon 89\n", + "adding: mem time207, current time 295, horizon 88\n", + "adding: mem time208, current time 295, horizon 87\n", + "adding: mem time209, current time 295, horizon 86\n", + "adding: mem time210, current time 295, horizon 85\n", + "adding: mem time211, current time 295, horizon 84\n", + "adding: mem time212, current time 295, horizon 83\n", + "adding: mem time213, current time 295, horizon 82\n", + "adding: mem time214, current time 295, horizon 81\n", + "adding: mem time215, current time 295, horizon 80\n", + "adding: mem time216, current time 295, horizon 79\n", + "adding: mem time217, current time 295, horizon 78\n", + "adding: mem time218, current time 295, horizon 77\n", + "adding: mem time219, current time 295, horizon 76\n", + "adding: mem time220, current time 295, horizon 75\n", + "adding: mem time221, current time 295, horizon 74\n", + "adding: mem time222, current time 295, horizon 73\n", + "adding: mem time223, current time 295, horizon 72\n", + "adding: mem time224, current time 295, horizon 71\n", + "adding: mem time225, current time 295, horizon 70\n", + "adding: mem time226, current time 295, horizon 69\n", + "adding: mem time227, current time 295, horizon 68\n", + "adding: mem time228, current time 295, horizon 67\n", + "adding: mem time229, current time 295, horizon 66\n", + "adding: mem time230, current time 295, horizon 65\n", + "adding: mem time231, current time 295, horizon 64\n", + "adding: mem time232, current time 295, horizon 63\n", + "adding: mem time233, current time 295, horizon 62\n", + "adding: mem time234, current time 295, horizon 61\n", + "adding: mem time235, current time 295, horizon 60\n", + "adding: mem time236, current time 295, horizon 59\n", + "adding: mem time237, current time 295, horizon 58\n", + "adding: mem time238, current time 295, horizon 57\n", + "adding: mem time239, current time 295, horizon 56\n", + "adding: mem time240, current time 295, horizon 55\n", + "adding: mem time241, current time 295, horizon 54\n", + "adding: mem time242, current time 295, horizon 53\n", + "adding: mem time243, current time 295, horizon 52\n", + "adding: mem time244, current time 295, horizon 51\n", + "adding: mem time245, current time 295, horizon 50\n", + "adding: mem time246, current time 295, horizon 49\n", + "adding: mem time247, current time 295, horizon 48\n", + "adding: mem time248, current time 295, horizon 47\n", + "adding: mem time249, current time 295, horizon 46\n", + "adding: mem time250, current time 295, horizon 45\n", + "adding: mem time251, current time 295, horizon 44\n", + "adding: mem time252, current time 295, horizon 43\n", + "adding: mem time253, current time 295, horizon 42\n", + "adding: mem time254, current time 295, horizon 41\n", + "adding: mem time255, current time 295, horizon 40\n", + "adding: mem time256, current time 295, horizon 39\n", + "adding: mem time257, current time 295, horizon 38\n", + "adding: mem time258, current time 295, horizon 37\n", + "adding: mem time259, current time 295, horizon 36\n", + "adding: mem time260, current time 295, horizon 35\n", + "adding: mem time261, current time 295, horizon 34\n", + "adding: mem time262, current time 295, horizon 33\n", + "adding: mem time263, current time 295, horizon 32\n", + "adding: mem time264, current time 295, horizon 31\n", + "adding: mem time265, current time 295, horizon 30\n", + "adding: mem time266, current time 295, horizon 29\n", + "adding: mem time267, current time 295, horizon 28\n", + "adding: mem time268, current time 295, horizon 27\n", + "adding: mem time269, current time 295, horizon 26\n", + "adding: mem time270, current time 295, horizon 25\n", + "adding: mem time271, current time 295, horizon 24\n", + "adding: mem time272, current time 295, horizon 23\n", + "adding: mem time273, current time 295, horizon 22\n", + "adding: mem time274, current time 295, horizon 21\n", + "adding: mem time275, current time 295, horizon 20\n", + "adding: mem time276, current time 295, horizon 19\n", + "adding: mem time277, current time 295, horizon 18\n", + "adding: mem time278, current time 295, horizon 17\n", + "adding: mem time279, current time 295, horizon 16\n", + "adding: mem time280, current time 295, horizon 15\n", + "adding: mem time281, current time 295, horizon 14\n", + "adding: mem time282, current time 295, horizon 13\n", + "adding: mem time283, current time 295, horizon 12\n", + "adding: mem time284, current time 295, horizon 11\n", + "adding: mem time285, current time 295, horizon 10\n", + "adding: mem time286, current time 295, horizon 9\n", + "adding: mem time287, current time 295, horizon 8\n", + "adding: mem time288, current time 295, horizon 7\n", + "adding: mem time289, current time 295, horizon 6\n", + "adding: mem time290, current time 295, horizon 5\n", + "adding: mem time291, current time 295, horizon 4\n", + "adding: mem time292, current time 295, horizon 3\n", + "adding: mem time293, current time 295, horizon 2\n", + "adding: mem time294, current time 295, horizon 1\n", + "adding: mem time200, current time 296, horizon 96\n", + "adding: mem time201, current time 296, horizon 95\n", + "adding: mem time202, current time 296, horizon 94\n", + "adding: mem time203, current time 296, horizon 93\n", + "adding: mem time204, current time 296, horizon 92\n", + "adding: mem time205, current time 296, horizon 91\n", + "adding: mem time206, current time 296, horizon 90\n", + "adding: mem time207, current time 296, horizon 89\n", + "adding: mem time208, current time 296, horizon 88\n", + "adding: mem time209, current time 296, horizon 87\n", + "adding: mem time210, current time 296, horizon 86\n", + "adding: mem time211, current time 296, horizon 85\n", + "adding: mem time212, current time 296, horizon 84\n", + "adding: mem time213, current time 296, horizon 83\n", + "adding: mem time214, current time 296, horizon 82\n", + "adding: mem time215, current time 296, horizon 81\n", + "adding: mem time216, current time 296, horizon 80\n", + "adding: mem time217, current time 296, horizon 79\n", + "adding: mem time218, current time 296, horizon 78\n", + "adding: mem time219, current time 296, horizon 77\n", + "adding: mem time220, current time 296, horizon 76\n", + "adding: mem time221, current time 296, horizon 75\n", + "adding: mem time222, current time 296, horizon 74\n", + "adding: mem time223, current time 296, horizon 73\n", + "adding: mem time224, current time 296, horizon 72\n", + "adding: mem time225, current time 296, horizon 71\n", + "adding: mem time226, current time 296, horizon 70\n", + "adding: mem time227, current time 296, horizon 69\n", + "adding: mem time228, current time 296, horizon 68\n", + "adding: mem time229, current time 296, horizon 67\n", + "adding: mem time230, current time 296, horizon 66\n", + "adding: mem time231, current time 296, horizon 65\n", + "adding: mem time232, current time 296, horizon 64\n", + "adding: mem time233, current time 296, horizon 63\n", + "adding: mem time234, current time 296, horizon 62\n", + "adding: mem time235, current time 296, horizon 61\n", + "adding: mem time236, current time 296, horizon 60\n", + "adding: mem time237, current time 296, horizon 59\n", + "adding: mem time238, current time 296, horizon 58\n", + "adding: mem time239, current time 296, horizon 57\n", + "adding: mem time240, current time 296, horizon 56\n", + "adding: mem time241, current time 296, horizon 55\n", + "adding: mem time242, current time 296, horizon 54\n", + "adding: mem time243, current time 296, horizon 53\n", + "adding: mem time244, current time 296, horizon 52\n", + "adding: mem time245, current time 296, horizon 51\n", + "adding: mem time246, current time 296, horizon 50\n", + "adding: mem time247, current time 296, horizon 49\n", + "adding: mem time248, current time 296, horizon 48\n", + "adding: mem time249, current time 296, horizon 47\n", + "adding: mem time250, current time 296, horizon 46\n", + "adding: mem time251, current time 296, horizon 45\n", + "adding: mem time252, current time 296, horizon 44\n", + "adding: mem time253, current time 296, horizon 43\n", + "adding: mem time254, current time 296, horizon 42\n", + "adding: mem time255, current time 296, horizon 41\n", + "adding: mem time256, current time 296, horizon 40\n", + "adding: mem time257, current time 296, horizon 39\n", + "adding: mem time258, current time 296, horizon 38\n", + "adding: mem time259, current time 296, horizon 37\n", + "adding: mem time260, current time 296, horizon 36\n", + "adding: mem time261, current time 296, horizon 35\n", + "adding: mem time262, current time 296, horizon 34\n", + "adding: mem time263, current time 296, horizon 33\n", + "adding: mem time264, current time 296, horizon 32\n", + "adding: mem time265, current time 296, horizon 31\n", + "adding: mem time266, current time 296, horizon 30\n", + "adding: mem time267, current time 296, horizon 29\n", + "adding: mem time268, current time 296, horizon 28\n", + "adding: mem time269, current time 296, horizon 27\n", + "adding: mem time270, current time 296, horizon 26\n", + "adding: mem time271, current time 296, horizon 25\n", + "adding: mem time272, current time 296, horizon 24\n", + "adding: mem time273, current time 296, horizon 23\n", + "adding: mem time274, current time 296, horizon 22\n", + "adding: mem time275, current time 296, horizon 21\n", + "adding: mem time276, current time 296, horizon 20\n", + "adding: mem time277, current time 296, horizon 19\n", + "adding: mem time278, current time 296, horizon 18\n", + "adding: mem time279, current time 296, horizon 17\n", + "adding: mem time280, current time 296, horizon 16\n", + "adding: mem time281, current time 296, horizon 15\n", + "adding: mem time282, current time 296, horizon 14\n", + "adding: mem time283, current time 296, horizon 13\n", + "adding: mem time284, current time 296, horizon 12\n", + "adding: mem time285, current time 296, horizon 11\n", + "adding: mem time286, current time 296, horizon 10\n", + "adding: mem time287, current time 296, horizon 9\n", + "adding: mem time288, current time 296, horizon 8\n", + "adding: mem time289, current time 296, horizon 7\n", + "adding: mem time290, current time 296, horizon 6\n", + "adding: mem time291, current time 296, horizon 5\n", + "adding: mem time292, current time 296, horizon 4\n", + "adding: mem time293, current time 296, horizon 3\n", + "adding: mem time294, current time 296, horizon 2\n", + "adding: mem time295, current time 296, horizon 1\n", + "adding: mem time200, current time 297, horizon 97\n", + "adding: mem time201, current time 297, horizon 96\n", + "adding: mem time202, current time 297, horizon 95\n", + "adding: mem time203, current time 297, horizon 94\n", + "adding: mem time204, current time 297, horizon 93\n", + "adding: mem time205, current time 297, horizon 92\n", + "adding: mem time206, current time 297, horizon 91\n", + "adding: mem time207, current time 297, horizon 90\n", + "adding: mem time208, current time 297, horizon 89\n", + "adding: mem time209, current time 297, horizon 88\n", + "adding: mem time210, current time 297, horizon 87\n", + "adding: mem time211, current time 297, horizon 86\n", + "adding: mem time212, current time 297, horizon 85\n", + "adding: mem time213, current time 297, horizon 84\n", + "adding: mem time214, current time 297, horizon 83\n", + "adding: mem time215, current time 297, horizon 82\n", + "adding: mem time216, current time 297, horizon 81\n", + "adding: mem time217, current time 297, horizon 80\n", + "adding: mem time218, current time 297, horizon 79\n", + "adding: mem time219, current time 297, horizon 78\n", + "adding: mem time220, current time 297, horizon 77\n", + "adding: mem time221, current time 297, horizon 76\n", + "adding: mem time222, current time 297, horizon 75\n", + "adding: mem time223, current time 297, horizon 74\n", + "adding: mem time224, current time 297, horizon 73\n", + "adding: mem time225, current time 297, horizon 72\n", + "adding: mem time226, current time 297, horizon 71\n", + "adding: mem time227, current time 297, horizon 70\n", + "adding: mem time228, current time 297, horizon 69\n", + "adding: mem time229, current time 297, horizon 68\n", + "adding: mem time230, current time 297, horizon 67\n", + "adding: mem time231, current time 297, horizon 66\n", + "adding: mem time232, current time 297, horizon 65\n", + "adding: mem time233, current time 297, horizon 64\n", + "adding: mem time234, current time 297, horizon 63\n", + "adding: mem time235, current time 297, horizon 62\n", + "adding: mem time236, current time 297, horizon 61\n", + "adding: mem time237, current time 297, horizon 60\n", + "adding: mem time238, current time 297, horizon 59\n", + "adding: mem time239, current time 297, horizon 58\n", + "adding: mem time240, current time 297, horizon 57\n", + "adding: mem time241, current time 297, horizon 56\n", + "adding: mem time242, current time 297, horizon 55\n", + "adding: mem time243, current time 297, horizon 54\n", + "adding: mem time244, current time 297, horizon 53\n", + "adding: mem time245, current time 297, horizon 52\n", + "adding: mem time246, current time 297, horizon 51\n", + "adding: mem time247, current time 297, horizon 50\n", + "adding: mem time248, current time 297, horizon 49\n", + "adding: mem time249, current time 297, horizon 48\n", + "adding: mem time250, current time 297, horizon 47\n", + "adding: mem time251, current time 297, horizon 46\n", + "adding: mem time252, current time 297, horizon 45\n", + "adding: mem time253, current time 297, horizon 44\n", + "adding: mem time254, current time 297, horizon 43\n", + "adding: mem time255, current time 297, horizon 42\n", + "adding: mem time256, current time 297, horizon 41\n", + "adding: mem time257, current time 297, horizon 40\n", + "adding: mem time258, current time 297, horizon 39\n", + "adding: mem time259, current time 297, horizon 38\n", + "adding: mem time260, current time 297, horizon 37\n", + "adding: mem time261, current time 297, horizon 36\n", + "adding: mem time262, current time 297, horizon 35\n", + "adding: mem time263, current time 297, horizon 34\n", + "adding: mem time264, current time 297, horizon 33\n", + "adding: mem time265, current time 297, horizon 32\n", + "adding: mem time266, current time 297, horizon 31\n", + "adding: mem time267, current time 297, horizon 30\n", + "adding: mem time268, current time 297, horizon 29\n", + "adding: mem time269, current time 297, horizon 28\n", + "adding: mem time270, current time 297, horizon 27\n", + "adding: mem time271, current time 297, horizon 26\n", + "adding: mem time272, current time 297, horizon 25\n", + "adding: mem time273, current time 297, horizon 24\n", + "adding: mem time274, current time 297, horizon 23\n", + "adding: mem time275, current time 297, horizon 22\n", + "adding: mem time276, current time 297, horizon 21\n", + "adding: mem time277, current time 297, horizon 20\n", + "adding: mem time278, current time 297, horizon 19\n", + "adding: mem time279, current time 297, horizon 18\n", + "adding: mem time280, current time 297, horizon 17\n", + "adding: mem time281, current time 297, horizon 16\n", + "adding: mem time282, current time 297, horizon 15\n", + "adding: mem time283, current time 297, horizon 14\n", + "adding: mem time284, current time 297, horizon 13\n", + "adding: mem time285, current time 297, horizon 12\n", + "adding: mem time286, current time 297, horizon 11\n", + "adding: mem time287, current time 297, horizon 10\n", + "adding: mem time288, current time 297, horizon 9\n", + "adding: mem time289, current time 297, horizon 8\n", + "adding: mem time290, current time 297, horizon 7\n", + "adding: mem time291, current time 297, horizon 6\n", + "adding: mem time292, current time 297, horizon 5\n", + "adding: mem time293, current time 297, horizon 4\n", + "adding: mem time294, current time 297, horizon 3\n", + "adding: mem time295, current time 297, horizon 2\n", + "adding: mem time296, current time 297, horizon 1\n", + "adding: mem time200, current time 298, horizon 98\n", + "adding: mem time201, current time 298, horizon 97\n", + "adding: mem time202, current time 298, horizon 96\n", + "adding: mem time203, current time 298, horizon 95\n", + "adding: mem time204, current time 298, horizon 94\n", + "adding: mem time205, current time 298, horizon 93\n", + "adding: mem time206, current time 298, horizon 92\n", + "adding: mem time207, current time 298, horizon 91\n", + "adding: mem time208, current time 298, horizon 90\n", + "adding: mem time209, current time 298, horizon 89\n", + "adding: mem time210, current time 298, horizon 88\n", + "adding: mem time211, current time 298, horizon 87\n", + "adding: mem time212, current time 298, horizon 86\n", + "adding: mem time213, current time 298, horizon 85\n", + "adding: mem time214, current time 298, horizon 84\n", + "adding: mem time215, current time 298, horizon 83\n", + "adding: mem time216, current time 298, horizon 82\n", + "adding: mem time217, current time 298, horizon 81\n", + "adding: mem time218, current time 298, horizon 80\n", + "adding: mem time219, current time 298, horizon 79\n", + "adding: mem time220, current time 298, horizon 78\n", + "adding: mem time221, current time 298, horizon 77\n", + "adding: mem time222, current time 298, horizon 76\n", + "adding: mem time223, current time 298, horizon 75\n", + "adding: mem time224, current time 298, horizon 74\n", + "adding: mem time225, current time 298, horizon 73\n", + "adding: mem time226, current time 298, horizon 72\n", + "adding: mem time227, current time 298, horizon 71\n", + "adding: mem time228, current time 298, horizon 70\n", + "adding: mem time229, current time 298, horizon 69\n", + "adding: mem time230, current time 298, horizon 68\n", + "adding: mem time231, current time 298, horizon 67\n", + "adding: mem time232, current time 298, horizon 66\n", + "adding: mem time233, current time 298, horizon 65\n", + "adding: mem time234, current time 298, horizon 64\n", + "adding: mem time235, current time 298, horizon 63\n", + "adding: mem time236, current time 298, horizon 62\n", + "adding: mem time237, current time 298, horizon 61\n", + "adding: mem time238, current time 298, horizon 60\n", + "adding: mem time239, current time 298, horizon 59\n", + "adding: mem time240, current time 298, horizon 58\n", + "adding: mem time241, current time 298, horizon 57\n", + "adding: mem time242, current time 298, horizon 56\n", + "adding: mem time243, current time 298, horizon 55\n", + "adding: mem time244, current time 298, horizon 54\n", + "adding: mem time245, current time 298, horizon 53\n", + "adding: mem time246, current time 298, horizon 52\n", + "adding: mem time247, current time 298, horizon 51\n", + "adding: mem time248, current time 298, horizon 50\n", + "adding: mem time249, current time 298, horizon 49\n", + "adding: mem time250, current time 298, horizon 48\n", + "adding: mem time251, current time 298, horizon 47\n", + "adding: mem time252, current time 298, horizon 46\n", + "adding: mem time253, current time 298, horizon 45\n", + "adding: mem time254, current time 298, horizon 44\n", + "adding: mem time255, current time 298, horizon 43\n", + "adding: mem time256, current time 298, horizon 42\n", + "adding: mem time257, current time 298, horizon 41\n", + "adding: mem time258, current time 298, horizon 40\n", + "adding: mem time259, current time 298, horizon 39\n", + "adding: mem time260, current time 298, horizon 38\n", + "adding: mem time261, current time 298, horizon 37\n", + "adding: mem time262, current time 298, horizon 36\n", + "adding: mem time263, current time 298, horizon 35\n", + "adding: mem time264, current time 298, horizon 34\n", + "adding: mem time265, current time 298, horizon 33\n", + "adding: mem time266, current time 298, horizon 32\n", + "adding: mem time267, current time 298, horizon 31\n", + "adding: mem time268, current time 298, horizon 30\n", + "adding: mem time269, current time 298, horizon 29\n", + "adding: mem time270, current time 298, horizon 28\n", + "adding: mem time271, current time 298, horizon 27\n", + "adding: mem time272, current time 298, horizon 26\n", + "adding: mem time273, current time 298, horizon 25\n", + "adding: mem time274, current time 298, horizon 24\n", + "adding: mem time275, current time 298, horizon 23\n", + "adding: mem time276, current time 298, horizon 22\n", + "adding: mem time277, current time 298, horizon 21\n", + "adding: mem time278, current time 298, horizon 20\n", + "adding: mem time279, current time 298, horizon 19\n", + "adding: mem time280, current time 298, horizon 18\n", + "adding: mem time281, current time 298, horizon 17\n", + "adding: mem time282, current time 298, horizon 16\n", + "adding: mem time283, current time 298, horizon 15\n", + "adding: mem time284, current time 298, horizon 14\n", + "adding: mem time285, current time 298, horizon 13\n", + "adding: mem time286, current time 298, horizon 12\n", + "adding: mem time287, current time 298, horizon 11\n", + "adding: mem time288, current time 298, horizon 10\n", + "adding: mem time289, current time 298, horizon 9\n", + "adding: mem time290, current time 298, horizon 8\n", + "adding: mem time291, current time 298, horizon 7\n", + "adding: mem time292, current time 298, horizon 6\n", + "adding: mem time293, current time 298, horizon 5\n", + "adding: mem time294, current time 298, horizon 4\n", + "adding: mem time295, current time 298, horizon 3\n", + "adding: mem time296, current time 298, horizon 2\n", + "adding: mem time297, current time 298, horizon 1\n", + "adding: mem time200, current time 299, horizon 99\n", + "adding: mem time201, current time 299, horizon 98\n", + "adding: mem time202, current time 299, horizon 97\n", + "adding: mem time203, current time 299, horizon 96\n", + "adding: mem time204, current time 299, horizon 95\n", + "adding: mem time205, current time 299, horizon 94\n", + "adding: mem time206, current time 299, horizon 93\n", + "adding: mem time207, current time 299, horizon 92\n", + "adding: mem time208, current time 299, horizon 91\n", + "adding: mem time209, current time 299, horizon 90\n", + "adding: mem time210, current time 299, horizon 89\n", + "adding: mem time211, current time 299, horizon 88\n", + "adding: mem time212, current time 299, horizon 87\n", + "adding: mem time213, current time 299, horizon 86\n", + "adding: mem time214, current time 299, horizon 85\n", + "adding: mem time215, current time 299, horizon 84\n", + "adding: mem time216, current time 299, horizon 83\n", + "adding: mem time217, current time 299, horizon 82\n", + "adding: mem time218, current time 299, horizon 81\n", + "adding: mem time219, current time 299, horizon 80\n", + "adding: mem time220, current time 299, horizon 79\n", + "adding: mem time221, current time 299, horizon 78\n", + "adding: mem time222, current time 299, horizon 77\n", + "adding: mem time223, current time 299, horizon 76\n", + "adding: mem time224, current time 299, horizon 75\n", + "adding: mem time225, current time 299, horizon 74\n", + "adding: mem time226, current time 299, horizon 73\n", + "adding: mem time227, current time 299, horizon 72\n", + "adding: mem time228, current time 299, horizon 71\n", + "adding: mem time229, current time 299, horizon 70\n", + "adding: mem time230, current time 299, horizon 69\n", + "adding: mem time231, current time 299, horizon 68\n", + "adding: mem time232, current time 299, horizon 67\n", + "adding: mem time233, current time 299, horizon 66\n", + "adding: mem time234, current time 299, horizon 65\n", + "adding: mem time235, current time 299, horizon 64\n", + "adding: mem time236, current time 299, horizon 63\n", + "adding: mem time237, current time 299, horizon 62\n", + "adding: mem time238, current time 299, horizon 61\n", + "adding: mem time239, current time 299, horizon 60\n", + "adding: mem time240, current time 299, horizon 59\n", + "adding: mem time241, current time 299, horizon 58\n", + "adding: mem time242, current time 299, horizon 57\n", + "adding: mem time243, current time 299, horizon 56\n", + "adding: mem time244, current time 299, horizon 55\n", + "adding: mem time245, current time 299, horizon 54\n", + "adding: mem time246, current time 299, horizon 53\n", + "adding: mem time247, current time 299, horizon 52\n", + "adding: mem time248, current time 299, horizon 51\n", + "adding: mem time249, current time 299, horizon 50\n", + "adding: mem time250, current time 299, horizon 49\n", + "adding: mem time251, current time 299, horizon 48\n", + "adding: mem time252, current time 299, horizon 47\n", + "adding: mem time253, current time 299, horizon 46\n", + "adding: mem time254, current time 299, horizon 45\n", + "adding: mem time255, current time 299, horizon 44\n", + "adding: mem time256, current time 299, horizon 43\n", + "adding: mem time257, current time 299, horizon 42\n", + "adding: mem time258, current time 299, horizon 41\n", + "adding: mem time259, current time 299, horizon 40\n", + "adding: mem time260, current time 299, horizon 39\n", + "adding: mem time261, current time 299, horizon 38\n", + "adding: mem time262, current time 299, horizon 37\n", + "adding: mem time263, current time 299, horizon 36\n", + "adding: mem time264, current time 299, horizon 35\n", + "adding: mem time265, current time 299, horizon 34\n", + "adding: mem time266, current time 299, horizon 33\n", + "adding: mem time267, current time 299, horizon 32\n", + "adding: mem time268, current time 299, horizon 31\n", + "adding: mem time269, current time 299, horizon 30\n", + "adding: mem time270, current time 299, horizon 29\n", + "adding: mem time271, current time 299, horizon 28\n", + "adding: mem time272, current time 299, horizon 27\n", + "adding: mem time273, current time 299, horizon 26\n", + "adding: mem time274, current time 299, horizon 25\n", + "adding: mem time275, current time 299, horizon 24\n", + "adding: mem time276, current time 299, horizon 23\n", + "adding: mem time277, current time 299, horizon 22\n", + "adding: mem time278, current time 299, horizon 21\n", + "adding: mem time279, current time 299, horizon 20\n", + "adding: mem time280, current time 299, horizon 19\n", + "adding: mem time281, current time 299, horizon 18\n", + "adding: mem time282, current time 299, horizon 17\n", + "adding: mem time283, current time 299, horizon 16\n", + "adding: mem time284, current time 299, horizon 15\n", + "adding: mem time285, current time 299, horizon 14\n", + "adding: mem time286, current time 299, horizon 13\n", + "adding: mem time287, current time 299, horizon 12\n", + "adding: mem time288, current time 299, horizon 11\n", + "adding: mem time289, current time 299, horizon 10\n", + "adding: mem time290, current time 299, horizon 9\n", + "adding: mem time291, current time 299, horizon 8\n", + "adding: mem time292, current time 299, horizon 7\n", + "adding: mem time293, current time 299, horizon 6\n", + "adding: mem time294, current time 299, horizon 5\n", + "adding: mem time295, current time 299, horizon 4\n", + "adding: mem time296, current time 299, horizon 3\n", + "adding: mem time297, current time 299, horizon 2\n", + "adding: mem time298, current time 299, horizon 1\n", + "adding: mem time200, current time 300, horizon 100\n", + "adding: mem time201, current time 300, horizon 99\n", + "adding: mem time202, current time 300, horizon 98\n", + "adding: mem time203, current time 300, horizon 97\n", + "adding: mem time204, current time 300, horizon 96\n", + "adding: mem time205, current time 300, horizon 95\n", + "adding: mem time206, current time 300, horizon 94\n", + "adding: mem time207, current time 300, horizon 93\n", + "adding: mem time208, current time 300, horizon 92\n", + "adding: mem time209, current time 300, horizon 91\n", + "adding: mem time210, current time 300, horizon 90\n", + "adding: mem time211, current time 300, horizon 89\n", + "adding: mem time212, current time 300, horizon 88\n", + "adding: mem time213, current time 300, horizon 87\n", + "adding: mem time214, current time 300, horizon 86\n", + "adding: mem time215, current time 300, horizon 85\n", + "adding: mem time216, current time 300, horizon 84\n", + "adding: mem time217, current time 300, horizon 83\n", + "adding: mem time218, current time 300, horizon 82\n", + "adding: mem time219, current time 300, horizon 81\n", + "adding: mem time220, current time 300, horizon 80\n", + "adding: mem time221, current time 300, horizon 79\n", + "adding: mem time222, current time 300, horizon 78\n", + "adding: mem time223, current time 300, horizon 77\n", + "adding: mem time224, current time 300, horizon 76\n", + "adding: mem time225, current time 300, horizon 75\n", + "adding: mem time226, current time 300, horizon 74\n", + "adding: mem time227, current time 300, horizon 73\n", + "adding: mem time228, current time 300, horizon 72\n", + "adding: mem time229, current time 300, horizon 71\n", + "adding: mem time230, current time 300, horizon 70\n", + "adding: mem time231, current time 300, horizon 69\n", + "adding: mem time232, current time 300, horizon 68\n", + "adding: mem time233, current time 300, horizon 67\n", + "adding: mem time234, current time 300, horizon 66\n", + "adding: mem time235, current time 300, horizon 65\n", + "adding: mem time236, current time 300, horizon 64\n", + "adding: mem time237, current time 300, horizon 63\n", + "adding: mem time238, current time 300, horizon 62\n", + "adding: mem time239, current time 300, horizon 61\n", + "adding: mem time240, current time 300, horizon 60\n", + "adding: mem time241, current time 300, horizon 59\n", + "adding: mem time242, current time 300, horizon 58\n", + "adding: mem time243, current time 300, horizon 57\n", + "adding: mem time244, current time 300, horizon 56\n", + "adding: mem time245, current time 300, horizon 55\n", + "adding: mem time246, current time 300, horizon 54\n", + "adding: mem time247, current time 300, horizon 53\n", + "adding: mem time248, current time 300, horizon 52\n", + "adding: mem time249, current time 300, horizon 51\n", + "adding: mem time250, current time 300, horizon 50\n", + "adding: mem time251, current time 300, horizon 49\n", + "adding: mem time252, current time 300, horizon 48\n", + "adding: mem time253, current time 300, horizon 47\n", + "adding: mem time254, current time 300, horizon 46\n", + "adding: mem time255, current time 300, horizon 45\n", + "adding: mem time256, current time 300, horizon 44\n", + "adding: mem time257, current time 300, horizon 43\n", + "adding: mem time258, current time 300, horizon 42\n", + "adding: mem time259, current time 300, horizon 41\n", + "adding: mem time260, current time 300, horizon 40\n", + "adding: mem time261, current time 300, horizon 39\n", + "adding: mem time262, current time 300, horizon 38\n", + "adding: mem time263, current time 300, horizon 37\n", + "adding: mem time264, current time 300, horizon 36\n", + "adding: mem time265, current time 300, horizon 35\n", + "adding: mem time266, current time 300, horizon 34\n", + "adding: mem time267, current time 300, horizon 33\n", + "adding: mem time268, current time 300, horizon 32\n", + "adding: mem time269, current time 300, horizon 31\n", + "adding: mem time270, current time 300, horizon 30\n", + "adding: mem time271, current time 300, horizon 29\n", + "adding: mem time272, current time 300, horizon 28\n", + "adding: mem time273, current time 300, horizon 27\n", + "adding: mem time274, current time 300, horizon 26\n", + "adding: mem time275, current time 300, horizon 25\n", + "adding: mem time276, current time 300, horizon 24\n", + "adding: mem time277, current time 300, horizon 23\n", + "adding: mem time278, current time 300, horizon 22\n", + "adding: mem time279, current time 300, horizon 21\n", + "adding: mem time280, current time 300, horizon 20\n", + "adding: mem time281, current time 300, horizon 19\n", + "adding: mem time282, current time 300, horizon 18\n", + "adding: mem time283, current time 300, horizon 17\n", + "adding: mem time284, current time 300, horizon 16\n", + "adding: mem time285, current time 300, horizon 15\n", + "adding: mem time286, current time 300, horizon 14\n", + "adding: mem time287, current time 300, horizon 13\n", + "adding: mem time288, current time 300, horizon 12\n", + "adding: mem time289, current time 300, horizon 11\n", + "adding: mem time290, current time 300, horizon 10\n", + "adding: mem time291, current time 300, horizon 9\n", + "adding: mem time292, current time 300, horizon 8\n", + "adding: mem time293, current time 300, horizon 7\n", + "adding: mem time294, current time 300, horizon 6\n", + "adding: mem time295, current time 300, horizon 5\n", + "adding: mem time296, current time 300, horizon 4\n", + "adding: mem time297, current time 300, horizon 3\n", + "adding: mem time298, current time 300, horizon 2\n", + "adding: mem time299, current time 300, horizon 1\n", + "adding: mem time200, current time 301, horizon 101\n", + "adding: mem time201, current time 301, horizon 100\n", + "adding: mem time202, current time 301, horizon 99\n", + "adding: mem time203, current time 301, horizon 98\n", + "adding: mem time204, current time 301, horizon 97\n", + "adding: mem time205, current time 301, horizon 96\n", + "adding: mem time206, current time 301, horizon 95\n", + "adding: mem time207, current time 301, horizon 94\n", + "adding: mem time208, current time 301, horizon 93\n", + "adding: mem time209, current time 301, horizon 92\n", + "adding: mem time210, current time 301, horizon 91\n", + "adding: mem time211, current time 301, horizon 90\n", + "adding: mem time212, current time 301, horizon 89\n", + "adding: mem time213, current time 301, horizon 88\n", + "adding: mem time214, current time 301, horizon 87\n", + "adding: mem time215, current time 301, horizon 86\n", + "adding: mem time216, current time 301, horizon 85\n", + "adding: mem time217, current time 301, horizon 84\n", + "adding: mem time218, current time 301, horizon 83\n", + "adding: mem time219, current time 301, horizon 82\n", + "adding: mem time220, current time 301, horizon 81\n", + "adding: mem time221, current time 301, horizon 80\n", + "adding: mem time222, current time 301, horizon 79\n", + "adding: mem time223, current time 301, horizon 78\n", + "adding: mem time224, current time 301, horizon 77\n", + "adding: mem time225, current time 301, horizon 76\n", + "adding: mem time226, current time 301, horizon 75\n", + "adding: mem time227, current time 301, horizon 74\n", + "adding: mem time228, current time 301, horizon 73\n", + "adding: mem time229, current time 301, horizon 72\n", + "adding: mem time230, current time 301, horizon 71\n", + "adding: mem time231, current time 301, horizon 70\n", + "adding: mem time232, current time 301, horizon 69\n", + "adding: mem time233, current time 301, horizon 68\n", + "adding: mem time234, current time 301, horizon 67\n", + "adding: mem time235, current time 301, horizon 66\n", + "adding: mem time236, current time 301, horizon 65\n", + "adding: mem time237, current time 301, horizon 64\n", + "adding: mem time238, current time 301, horizon 63\n", + "adding: mem time239, current time 301, horizon 62\n", + "adding: mem time240, current time 301, horizon 61\n", + "adding: mem time241, current time 301, horizon 60\n", + "adding: mem time242, current time 301, horizon 59\n", + "adding: mem time243, current time 301, horizon 58\n", + "adding: mem time244, current time 301, horizon 57\n", + "adding: mem time245, current time 301, horizon 56\n", + "adding: mem time246, current time 301, horizon 55\n", + "adding: mem time247, current time 301, horizon 54\n", + "adding: mem time248, current time 301, horizon 53\n", + "adding: mem time249, current time 301, horizon 52\n", + "adding: mem time250, current time 301, horizon 51\n", + "adding: mem time251, current time 301, horizon 50\n", + "adding: mem time252, current time 301, horizon 49\n", + "adding: mem time253, current time 301, horizon 48\n", + "adding: mem time254, current time 301, horizon 47\n", + "adding: mem time255, current time 301, horizon 46\n", + "adding: mem time256, current time 301, horizon 45\n", + "adding: mem time257, current time 301, horizon 44\n", + "adding: mem time258, current time 301, horizon 43\n", + "adding: mem time259, current time 301, horizon 42\n", + "adding: mem time260, current time 301, horizon 41\n", + "adding: mem time261, current time 301, horizon 40\n", + "adding: mem time262, current time 301, horizon 39\n", + "adding: mem time263, current time 301, horizon 38\n", + "adding: mem time264, current time 301, horizon 37\n", + "adding: mem time265, current time 301, horizon 36\n", + "adding: mem time266, current time 301, horizon 35\n", + "adding: mem time267, current time 301, horizon 34\n", + "adding: mem time268, current time 301, horizon 33\n", + "adding: mem time269, current time 301, horizon 32\n", + "adding: mem time270, current time 301, horizon 31\n", + "adding: mem time271, current time 301, horizon 30\n", + "adding: mem time272, current time 301, horizon 29\n", + "adding: mem time273, current time 301, horizon 28\n", + "adding: mem time274, current time 301, horizon 27\n", + "adding: mem time275, current time 301, horizon 26\n", + "adding: mem time276, current time 301, horizon 25\n", + "adding: mem time277, current time 301, horizon 24\n", + "adding: mem time278, current time 301, horizon 23\n", + "adding: mem time279, current time 301, horizon 22\n", + "adding: mem time280, current time 301, horizon 21\n", + "adding: mem time281, current time 301, horizon 20\n", + "adding: mem time282, current time 301, horizon 19\n", + "adding: mem time283, current time 301, horizon 18\n", + "adding: mem time284, current time 301, horizon 17\n", + "adding: mem time285, current time 301, horizon 16\n", + "adding: mem time286, current time 301, horizon 15\n", + "adding: mem time287, current time 301, horizon 14\n", + "adding: mem time288, current time 301, horizon 13\n", + "adding: mem time289, current time 301, horizon 12\n", + "adding: mem time290, current time 301, horizon 11\n", + "adding: mem time291, current time 301, horizon 10\n", + "adding: mem time292, current time 301, horizon 9\n", + "adding: mem time293, current time 301, horizon 8\n", + "adding: mem time294, current time 301, horizon 7\n", + "adding: mem time295, current time 301, horizon 6\n", + "adding: mem time296, current time 301, horizon 5\n", + "adding: mem time297, current time 301, horizon 4\n", + "adding: mem time298, current time 301, horizon 3\n", + "adding: mem time299, current time 301, horizon 2\n", + "adding: mem time300, current time 301, horizon 1\n", + "adding: mem time200, current time 302, horizon 102\n", + "adding: mem time201, current time 302, horizon 101\n", + "adding: mem time202, current time 302, horizon 100\n", + "adding: mem time203, current time 302, horizon 99\n", + "adding: mem time204, current time 302, horizon 98\n", + "adding: mem time205, current time 302, horizon 97\n", + "adding: mem time206, current time 302, horizon 96\n", + "adding: mem time207, current time 302, horizon 95\n", + "adding: mem time208, current time 302, horizon 94\n", + "adding: mem time209, current time 302, horizon 93\n", + "adding: mem time210, current time 302, horizon 92\n", + "adding: mem time211, current time 302, horizon 91\n", + "adding: mem time212, current time 302, horizon 90\n", + "adding: mem time213, current time 302, horizon 89\n", + "adding: mem time214, current time 302, horizon 88\n", + "adding: mem time215, current time 302, horizon 87\n", + "adding: mem time216, current time 302, horizon 86\n", + "adding: mem time217, current time 302, horizon 85\n", + "adding: mem time218, current time 302, horizon 84\n", + "adding: mem time219, current time 302, horizon 83\n", + "adding: mem time220, current time 302, horizon 82\n", + "adding: mem time221, current time 302, horizon 81\n", + "adding: mem time222, current time 302, horizon 80\n", + "adding: mem time223, current time 302, horizon 79\n", + "adding: mem time224, current time 302, horizon 78\n", + "adding: mem time225, current time 302, horizon 77\n", + "adding: mem time226, current time 302, horizon 76\n", + "adding: mem time227, current time 302, horizon 75\n", + "adding: mem time228, current time 302, horizon 74\n", + "adding: mem time229, current time 302, horizon 73\n", + "adding: mem time230, current time 302, horizon 72\n", + "adding: mem time231, current time 302, horizon 71\n", + "adding: mem time232, current time 302, horizon 70\n", + "adding: mem time233, current time 302, horizon 69\n", + "adding: mem time234, current time 302, horizon 68\n", + "adding: mem time235, current time 302, horizon 67\n", + "adding: mem time236, current time 302, horizon 66\n", + "adding: mem time237, current time 302, horizon 65\n", + "adding: mem time238, current time 302, horizon 64\n", + "adding: mem time239, current time 302, horizon 63\n", + "adding: mem time240, current time 302, horizon 62\n", + "adding: mem time241, current time 302, horizon 61\n", + "adding: mem time242, current time 302, horizon 60\n", + "adding: mem time243, current time 302, horizon 59\n", + "adding: mem time244, current time 302, horizon 58\n", + "adding: mem time245, current time 302, horizon 57\n", + "adding: mem time246, current time 302, horizon 56\n", + "adding: mem time247, current time 302, horizon 55\n", + "adding: mem time248, current time 302, horizon 54\n", + "adding: mem time249, current time 302, horizon 53\n", + "adding: mem time250, current time 302, horizon 52\n", + "adding: mem time251, current time 302, horizon 51\n", + "adding: mem time252, current time 302, horizon 50\n", + "adding: mem time253, current time 302, horizon 49\n", + "adding: mem time254, current time 302, horizon 48\n", + "adding: mem time255, current time 302, horizon 47\n", + "adding: mem time256, current time 302, horizon 46\n", + "adding: mem time257, current time 302, horizon 45\n", + "adding: mem time258, current time 302, horizon 44\n", + "adding: mem time259, current time 302, horizon 43\n", + "adding: mem time260, current time 302, horizon 42\n", + "adding: mem time261, current time 302, horizon 41\n", + "adding: mem time262, current time 302, horizon 40\n", + "adding: mem time263, current time 302, horizon 39\n", + "adding: mem time264, current time 302, horizon 38\n", + "adding: mem time265, current time 302, horizon 37\n", + "adding: mem time266, current time 302, horizon 36\n", + "adding: mem time267, current time 302, horizon 35\n", + "adding: mem time268, current time 302, horizon 34\n", + "adding: mem time269, current time 302, horizon 33\n", + "adding: mem time270, current time 302, horizon 32\n", + "adding: mem time271, current time 302, horizon 31\n", + "adding: mem time272, current time 302, horizon 30\n", + "adding: mem time273, current time 302, horizon 29\n", + "adding: mem time274, current time 302, horizon 28\n", + "adding: mem time275, current time 302, horizon 27\n", + "adding: mem time276, current time 302, horizon 26\n", + "adding: mem time277, current time 302, horizon 25\n", + "adding: mem time278, current time 302, horizon 24\n", + "adding: mem time279, current time 302, horizon 23\n", + "adding: mem time280, current time 302, horizon 22\n", + "adding: mem time281, current time 302, horizon 21\n", + "adding: mem time282, current time 302, horizon 20\n", + "adding: mem time283, current time 302, horizon 19\n", + "adding: mem time284, current time 302, horizon 18\n", + "adding: mem time285, current time 302, horizon 17\n", + "adding: mem time286, current time 302, horizon 16\n", + "adding: mem time287, current time 302, horizon 15\n", + "adding: mem time288, current time 302, horizon 14\n", + "adding: mem time289, current time 302, horizon 13\n", + "adding: mem time290, current time 302, horizon 12\n", + "adding: mem time291, current time 302, horizon 11\n", + "adding: mem time292, current time 302, horizon 10\n", + "adding: mem time293, current time 302, horizon 9\n", + "adding: mem time294, current time 302, horizon 8\n", + "adding: mem time295, current time 302, horizon 7\n", + "adding: mem time296, current time 302, horizon 6\n", + "adding: mem time297, current time 302, horizon 5\n", + "adding: mem time298, current time 302, horizon 4\n", + "adding: mem time299, current time 302, horizon 3\n", + "adding: mem time300, current time 302, horizon 2\n", + "adding: mem time301, current time 302, horizon 1\n", + "adding: mem time200, current time 303, horizon 103\n", + "adding: mem time201, current time 303, horizon 102\n", + "adding: mem time202, current time 303, horizon 101\n", + "adding: mem time203, current time 303, horizon 100\n", + "adding: mem time204, current time 303, horizon 99\n", + "adding: mem time205, current time 303, horizon 98\n", + "adding: mem time206, current time 303, horizon 97\n", + "adding: mem time207, current time 303, horizon 96\n", + "adding: mem time208, current time 303, horizon 95\n", + "adding: mem time209, current time 303, horizon 94\n", + "adding: mem time210, current time 303, horizon 93\n", + "adding: mem time211, current time 303, horizon 92\n", + "adding: mem time212, current time 303, horizon 91\n", + "adding: mem time213, current time 303, horizon 90\n", + "adding: mem time214, current time 303, horizon 89\n", + "adding: mem time215, current time 303, horizon 88\n", + "adding: mem time216, current time 303, horizon 87\n", + "adding: mem time217, current time 303, horizon 86\n", + "adding: mem time218, current time 303, horizon 85\n", + "adding: mem time219, current time 303, horizon 84\n", + "adding: mem time220, current time 303, horizon 83\n", + "adding: mem time221, current time 303, horizon 82\n", + "adding: mem time222, current time 303, horizon 81\n", + "adding: mem time223, current time 303, horizon 80\n", + "adding: mem time224, current time 303, horizon 79\n", + "adding: mem time225, current time 303, horizon 78\n", + "adding: mem time226, current time 303, horizon 77\n", + "adding: mem time227, current time 303, horizon 76\n", + "adding: mem time228, current time 303, horizon 75\n", + "adding: mem time229, current time 303, horizon 74\n", + "adding: mem time230, current time 303, horizon 73\n", + "adding: mem time231, current time 303, horizon 72\n", + "adding: mem time232, current time 303, horizon 71\n", + "adding: mem time233, current time 303, horizon 70\n", + "adding: mem time234, current time 303, horizon 69\n", + "adding: mem time235, current time 303, horizon 68\n", + "adding: mem time236, current time 303, horizon 67\n", + "adding: mem time237, current time 303, horizon 66\n", + "adding: mem time238, current time 303, horizon 65\n", + "adding: mem time239, current time 303, horizon 64\n", + "adding: mem time240, current time 303, horizon 63\n", + "adding: mem time241, current time 303, horizon 62\n", + "adding: mem time242, current time 303, horizon 61\n", + "adding: mem time243, current time 303, horizon 60\n", + "adding: mem time244, current time 303, horizon 59\n", + "adding: mem time245, current time 303, horizon 58\n", + "adding: mem time246, current time 303, horizon 57\n", + "adding: mem time247, current time 303, horizon 56\n", + "adding: mem time248, current time 303, horizon 55\n", + "adding: mem time249, current time 303, horizon 54\n", + "adding: mem time250, current time 303, horizon 53\n", + "adding: mem time251, current time 303, horizon 52\n", + "adding: mem time252, current time 303, horizon 51\n", + "adding: mem time253, current time 303, horizon 50\n", + "adding: mem time254, current time 303, horizon 49\n", + "adding: mem time255, current time 303, horizon 48\n", + "adding: mem time256, current time 303, horizon 47\n", + "adding: mem time257, current time 303, horizon 46\n", + "adding: mem time258, current time 303, horizon 45\n", + "adding: mem time259, current time 303, horizon 44\n", + "adding: mem time260, current time 303, horizon 43\n", + "adding: mem time261, current time 303, horizon 42\n", + "adding: mem time262, current time 303, horizon 41\n", + "adding: mem time263, current time 303, horizon 40\n", + "adding: mem time264, current time 303, horizon 39\n", + "adding: mem time265, current time 303, horizon 38\n", + "adding: mem time266, current time 303, horizon 37\n", + "adding: mem time267, current time 303, horizon 36\n", + "adding: mem time268, current time 303, horizon 35\n", + "adding: mem time269, current time 303, horizon 34\n", + "adding: mem time270, current time 303, horizon 33\n", + "adding: mem time271, current time 303, horizon 32\n", + "adding: mem time272, current time 303, horizon 31\n", + "adding: mem time273, current time 303, horizon 30\n", + "adding: mem time274, current time 303, horizon 29\n", + "adding: mem time275, current time 303, horizon 28\n", + "adding: mem time276, current time 303, horizon 27\n", + "adding: mem time277, current time 303, horizon 26\n", + "adding: mem time278, current time 303, horizon 25\n", + "adding: mem time279, current time 303, horizon 24\n", + "adding: mem time280, current time 303, horizon 23\n", + "adding: mem time281, current time 303, horizon 22\n", + "adding: mem time282, current time 303, horizon 21\n", + "adding: mem time283, current time 303, horizon 20\n", + "adding: mem time284, current time 303, horizon 19\n", + "adding: mem time285, current time 303, horizon 18\n", + "adding: mem time286, current time 303, horizon 17\n", + "adding: mem time287, current time 303, horizon 16\n", + "adding: mem time288, current time 303, horizon 15\n", + "adding: mem time289, current time 303, horizon 14\n", + "adding: mem time290, current time 303, horizon 13\n", + "adding: mem time291, current time 303, horizon 12\n", + "adding: mem time292, current time 303, horizon 11\n", + "adding: mem time293, current time 303, horizon 10\n", + "adding: mem time294, current time 303, horizon 9\n", + "adding: mem time295, current time 303, horizon 8\n", + "adding: mem time296, current time 303, horizon 7\n", + "adding: mem time297, current time 303, horizon 6\n", + "adding: mem time298, current time 303, horizon 5\n", + "adding: mem time299, current time 303, horizon 4\n", + "adding: mem time300, current time 303, horizon 3\n", + "adding: mem time301, current time 303, horizon 2\n", + "adding: mem time302, current time 303, horizon 1\n", + "adding: mem time200, current time 304, horizon 104\n", + "adding: mem time201, current time 304, horizon 103\n", + "adding: mem time202, current time 304, horizon 102\n", + "adding: mem time203, current time 304, horizon 101\n", + "adding: mem time204, current time 304, horizon 100\n", + "adding: mem time205, current time 304, horizon 99\n", + "adding: mem time206, current time 304, horizon 98\n", + "adding: mem time207, current time 304, horizon 97\n", + "adding: mem time208, current time 304, horizon 96\n", + "adding: mem time209, current time 304, horizon 95\n", + "adding: mem time210, current time 304, horizon 94\n", + "adding: mem time211, current time 304, horizon 93\n", + "adding: mem time212, current time 304, horizon 92\n", + "adding: mem time213, current time 304, horizon 91\n", + "adding: mem time214, current time 304, horizon 90\n", + "adding: mem time215, current time 304, horizon 89\n", + "adding: mem time216, current time 304, horizon 88\n", + "adding: mem time217, current time 304, horizon 87\n", + "adding: mem time218, current time 304, horizon 86\n", + "adding: mem time219, current time 304, horizon 85\n", + "adding: mem time220, current time 304, horizon 84\n", + "adding: mem time221, current time 304, horizon 83\n", + "adding: mem time222, current time 304, horizon 82\n", + "adding: mem time223, current time 304, horizon 81\n", + "adding: mem time224, current time 304, horizon 80\n", + "adding: mem time225, current time 304, horizon 79\n", + "adding: mem time226, current time 304, horizon 78\n", + "adding: mem time227, current time 304, horizon 77\n", + "adding: mem time228, current time 304, horizon 76\n", + "adding: mem time229, current time 304, horizon 75\n", + "adding: mem time230, current time 304, horizon 74\n", + "adding: mem time231, current time 304, horizon 73\n", + "adding: mem time232, current time 304, horizon 72\n", + "adding: mem time233, current time 304, horizon 71\n", + "adding: mem time234, current time 304, horizon 70\n", + "adding: mem time235, current time 304, horizon 69\n", + "adding: mem time236, current time 304, horizon 68\n", + "adding: mem time237, current time 304, horizon 67\n", + "adding: mem time238, current time 304, horizon 66\n", + "adding: mem time239, current time 304, horizon 65\n", + "adding: mem time240, current time 304, horizon 64\n", + "adding: mem time241, current time 304, horizon 63\n", + "adding: mem time242, current time 304, horizon 62\n", + "adding: mem time243, current time 304, horizon 61\n", + "adding: mem time244, current time 304, horizon 60\n", + "adding: mem time245, current time 304, horizon 59\n", + "adding: mem time246, current time 304, horizon 58\n", + "adding: mem time247, current time 304, horizon 57\n", + "adding: mem time248, current time 304, horizon 56\n", + "adding: mem time249, current time 304, horizon 55\n", + "adding: mem time250, current time 304, horizon 54\n", + "adding: mem time251, current time 304, horizon 53\n", + "adding: mem time252, current time 304, horizon 52\n", + "adding: mem time253, current time 304, horizon 51\n", + "adding: mem time254, current time 304, horizon 50\n", + "adding: mem time255, current time 304, horizon 49\n", + "adding: mem time256, current time 304, horizon 48\n", + "adding: mem time257, current time 304, horizon 47\n", + "adding: mem time258, current time 304, horizon 46\n", + "adding: mem time259, current time 304, horizon 45\n", + "adding: mem time260, current time 304, horizon 44\n", + "adding: mem time261, current time 304, horizon 43\n", + "adding: mem time262, current time 304, horizon 42\n", + "adding: mem time263, current time 304, horizon 41\n", + "adding: mem time264, current time 304, horizon 40\n", + "adding: mem time265, current time 304, horizon 39\n", + "adding: mem time266, current time 304, horizon 38\n", + "adding: mem time267, current time 304, horizon 37\n", + "adding: mem time268, current time 304, horizon 36\n", + "adding: mem time269, current time 304, horizon 35\n", + "adding: mem time270, current time 304, horizon 34\n", + "adding: mem time271, current time 304, horizon 33\n", + "adding: mem time272, current time 304, horizon 32\n", + "adding: mem time273, current time 304, horizon 31\n", + "adding: mem time274, current time 304, horizon 30\n", + "adding: mem time275, current time 304, horizon 29\n", + "adding: mem time276, current time 304, horizon 28\n", + "adding: mem time277, current time 304, horizon 27\n", + "adding: mem time278, current time 304, horizon 26\n", + "adding: mem time279, current time 304, horizon 25\n", + "adding: mem time280, current time 304, horizon 24\n", + "adding: mem time281, current time 304, horizon 23\n", + "adding: mem time282, current time 304, horizon 22\n", + "adding: mem time283, current time 304, horizon 21\n", + "adding: mem time284, current time 304, horizon 20\n", + "adding: mem time285, current time 304, horizon 19\n", + "adding: mem time286, current time 304, horizon 18\n", + "adding: mem time287, current time 304, horizon 17\n", + "adding: mem time288, current time 304, horizon 16\n", + "adding: mem time289, current time 304, horizon 15\n", + "adding: mem time290, current time 304, horizon 14\n", + "adding: mem time291, current time 304, horizon 13\n", + "adding: mem time292, current time 304, horizon 12\n", + "adding: mem time293, current time 304, horizon 11\n", + "adding: mem time294, current time 304, horizon 10\n", + "adding: mem time295, current time 304, horizon 9\n", + "adding: mem time296, current time 304, horizon 8\n", + "adding: mem time297, current time 304, horizon 7\n", + "adding: mem time298, current time 304, horizon 6\n", + "adding: mem time299, current time 304, horizon 5\n", + "adding: mem time300, current time 304, horizon 4\n", + "adding: mem time301, current time 304, horizon 3\n", + "adding: mem time302, current time 304, horizon 2\n", + "adding: mem time303, current time 304, horizon 1\n", + "adding: mem time200, current time 305, horizon 105\n", + "adding: mem time201, current time 305, horizon 104\n", + "adding: mem time202, current time 305, horizon 103\n", + "adding: mem time203, current time 305, horizon 102\n", + "adding: mem time204, current time 305, horizon 101\n", + "adding: mem time205, current time 305, horizon 100\n", + "adding: mem time206, current time 305, horizon 99\n", + "adding: mem time207, current time 305, horizon 98\n", + "adding: mem time208, current time 305, horizon 97\n", + "adding: mem time209, current time 305, horizon 96\n", + "adding: mem time210, current time 305, horizon 95\n", + "adding: mem time211, current time 305, horizon 94\n", + "adding: mem time212, current time 305, horizon 93\n", + "adding: mem time213, current time 305, horizon 92\n", + "adding: mem time214, current time 305, horizon 91\n", + "adding: mem time215, current time 305, horizon 90\n", + "adding: mem time216, current time 305, horizon 89\n", + "adding: mem time217, current time 305, horizon 88\n", + "adding: mem time218, current time 305, horizon 87\n", + "adding: mem time219, current time 305, horizon 86\n", + "adding: mem time220, current time 305, horizon 85\n", + "adding: mem time221, current time 305, horizon 84\n", + "adding: mem time222, current time 305, horizon 83\n", + "adding: mem time223, current time 305, horizon 82\n", + "adding: mem time224, current time 305, horizon 81\n", + "adding: mem time225, current time 305, horizon 80\n", + "adding: mem time226, current time 305, horizon 79\n", + "adding: mem time227, current time 305, horizon 78\n", + "adding: mem time228, current time 305, horizon 77\n", + "adding: mem time229, current time 305, horizon 76\n", + "adding: mem time230, current time 305, horizon 75\n", + "adding: mem time231, current time 305, horizon 74\n", + "adding: mem time232, current time 305, horizon 73\n", + "adding: mem time233, current time 305, horizon 72\n", + "adding: mem time234, current time 305, horizon 71\n", + "adding: mem time235, current time 305, horizon 70\n", + "adding: mem time236, current time 305, horizon 69\n", + "adding: mem time237, current time 305, horizon 68\n", + "adding: mem time238, current time 305, horizon 67\n", + "adding: mem time239, current time 305, horizon 66\n", + "adding: mem time240, current time 305, horizon 65\n", + "adding: mem time241, current time 305, horizon 64\n", + "adding: mem time242, current time 305, horizon 63\n", + "adding: mem time243, current time 305, horizon 62\n", + "adding: mem time244, current time 305, horizon 61\n", + "adding: mem time245, current time 305, horizon 60\n", + "adding: mem time246, current time 305, horizon 59\n", + "adding: mem time247, current time 305, horizon 58\n", + "adding: mem time248, current time 305, horizon 57\n", + "adding: mem time249, current time 305, horizon 56\n", + "adding: mem time250, current time 305, horizon 55\n", + "adding: mem time251, current time 305, horizon 54\n", + "adding: mem time252, current time 305, horizon 53\n", + "adding: mem time253, current time 305, horizon 52\n", + "adding: mem time254, current time 305, horizon 51\n", + "adding: mem time255, current time 305, horizon 50\n", + "adding: mem time256, current time 305, horizon 49\n", + "adding: mem time257, current time 305, horizon 48\n", + "adding: mem time258, current time 305, horizon 47\n", + "adding: mem time259, current time 305, horizon 46\n", + "adding: mem time260, current time 305, horizon 45\n", + "adding: mem time261, current time 305, horizon 44\n", + "adding: mem time262, current time 305, horizon 43\n", + "adding: mem time263, current time 305, horizon 42\n", + "adding: mem time264, current time 305, horizon 41\n", + "adding: mem time265, current time 305, horizon 40\n", + "adding: mem time266, current time 305, horizon 39\n", + "adding: mem time267, current time 305, horizon 38\n", + "adding: mem time268, current time 305, horizon 37\n", + "adding: mem time269, current time 305, horizon 36\n", + "adding: mem time270, current time 305, horizon 35\n", + "adding: mem time271, current time 305, horizon 34\n", + "adding: mem time272, current time 305, horizon 33\n", + "adding: mem time273, current time 305, horizon 32\n", + "adding: mem time274, current time 305, horizon 31\n", + "adding: mem time275, current time 305, horizon 30\n", + "adding: mem time276, current time 305, horizon 29\n", + "adding: mem time277, current time 305, horizon 28\n", + "adding: mem time278, current time 305, horizon 27\n", + "adding: mem time279, current time 305, horizon 26\n", + "adding: mem time280, current time 305, horizon 25\n", + "adding: mem time281, current time 305, horizon 24\n", + "adding: mem time282, current time 305, horizon 23\n", + "adding: mem time283, current time 305, horizon 22\n", + "adding: mem time284, current time 305, horizon 21\n", + "adding: mem time285, current time 305, horizon 20\n", + "adding: mem time286, current time 305, horizon 19\n", + "adding: mem time287, current time 305, horizon 18\n", + "adding: mem time288, current time 305, horizon 17\n", + "adding: mem time289, current time 305, horizon 16\n", + "adding: mem time290, current time 305, horizon 15\n", + "adding: mem time291, current time 305, horizon 14\n", + "adding: mem time292, current time 305, horizon 13\n", + "adding: mem time293, current time 305, horizon 12\n", + "adding: mem time294, current time 305, horizon 11\n", + "adding: mem time295, current time 305, horizon 10\n", + "adding: mem time296, current time 305, horizon 9\n", + "adding: mem time297, current time 305, horizon 8\n", + "adding: mem time298, current time 305, horizon 7\n", + "adding: mem time299, current time 305, horizon 6\n", + "adding: mem time300, current time 305, horizon 5\n", + "adding: mem time301, current time 305, horizon 4\n", + "adding: mem time302, current time 305, horizon 3\n", + "adding: mem time303, current time 305, horizon 2\n", + "adding: mem time304, current time 305, horizon 1\n", + "adding: mem time200, current time 306, horizon 106\n", + "adding: mem time201, current time 306, horizon 105\n", + "adding: mem time202, current time 306, horizon 104\n", + "adding: mem time203, current time 306, horizon 103\n", + "adding: mem time204, current time 306, horizon 102\n", + "adding: mem time205, current time 306, horizon 101\n", + "adding: mem time206, current time 306, horizon 100\n", + "adding: mem time207, current time 306, horizon 99\n", + "adding: mem time208, current time 306, horizon 98\n", + "adding: mem time209, current time 306, horizon 97\n", + "adding: mem time210, current time 306, horizon 96\n", + "adding: mem time211, current time 306, horizon 95\n", + "adding: mem time212, current time 306, horizon 94\n", + "adding: mem time213, current time 306, horizon 93\n", + "adding: mem time214, current time 306, horizon 92\n", + "adding: mem time215, current time 306, horizon 91\n", + "adding: mem time216, current time 306, horizon 90\n", + "adding: mem time217, current time 306, horizon 89\n", + "adding: mem time218, current time 306, horizon 88\n", + "adding: mem time219, current time 306, horizon 87\n", + "adding: mem time220, current time 306, horizon 86\n", + "adding: mem time221, current time 306, horizon 85\n", + "adding: mem time222, current time 306, horizon 84\n", + "adding: mem time223, current time 306, horizon 83\n", + "adding: mem time224, current time 306, horizon 82\n", + "adding: mem time225, current time 306, horizon 81\n", + "adding: mem time226, current time 306, horizon 80\n", + "adding: mem time227, current time 306, horizon 79\n", + "adding: mem time228, current time 306, horizon 78\n", + "adding: mem time229, current time 306, horizon 77\n", + "adding: mem time230, current time 306, horizon 76\n", + "adding: mem time231, current time 306, horizon 75\n", + "adding: mem time232, current time 306, horizon 74\n", + "adding: mem time233, current time 306, horizon 73\n", + "adding: mem time234, current time 306, horizon 72\n", + "adding: mem time235, current time 306, horizon 71\n", + "adding: mem time236, current time 306, horizon 70\n", + "adding: mem time237, current time 306, horizon 69\n", + "adding: mem time238, current time 306, horizon 68\n", + "adding: mem time239, current time 306, horizon 67\n", + "adding: mem time240, current time 306, horizon 66\n", + "adding: mem time241, current time 306, horizon 65\n", + "adding: mem time242, current time 306, horizon 64\n", + "adding: mem time243, current time 306, horizon 63\n", + "adding: mem time244, current time 306, horizon 62\n", + "adding: mem time245, current time 306, horizon 61\n", + "adding: mem time246, current time 306, horizon 60\n", + "adding: mem time247, current time 306, horizon 59\n", + "adding: mem time248, current time 306, horizon 58\n", + "adding: mem time249, current time 306, horizon 57\n", + "adding: mem time250, current time 306, horizon 56\n", + "adding: mem time251, current time 306, horizon 55\n", + "adding: mem time252, current time 306, horizon 54\n", + "adding: mem time253, current time 306, horizon 53\n", + "adding: mem time254, current time 306, horizon 52\n", + "adding: mem time255, current time 306, horizon 51\n", + "adding: mem time256, current time 306, horizon 50\n", + "adding: mem time257, current time 306, horizon 49\n", + "adding: mem time258, current time 306, horizon 48\n", + "adding: mem time259, current time 306, horizon 47\n", + "adding: mem time260, current time 306, horizon 46\n", + "adding: mem time261, current time 306, horizon 45\n", + "adding: mem time262, current time 306, horizon 44\n", + "adding: mem time263, current time 306, horizon 43\n", + "adding: mem time264, current time 306, horizon 42\n", + "adding: mem time265, current time 306, horizon 41\n", + "adding: mem time266, current time 306, horizon 40\n", + "adding: mem time267, current time 306, horizon 39\n", + "adding: mem time268, current time 306, horizon 38\n", + "adding: mem time269, current time 306, horizon 37\n", + "adding: mem time270, current time 306, horizon 36\n", + "adding: mem time271, current time 306, horizon 35\n", + "adding: mem time272, current time 306, horizon 34\n", + "adding: mem time273, current time 306, horizon 33\n", + "adding: mem time274, current time 306, horizon 32\n", + "adding: mem time275, current time 306, horizon 31\n", + "adding: mem time276, current time 306, horizon 30\n", + "adding: mem time277, current time 306, horizon 29\n", + "adding: mem time278, current time 306, horizon 28\n", + "adding: mem time279, current time 306, horizon 27\n", + "adding: mem time280, current time 306, horizon 26\n", + "adding: mem time281, current time 306, horizon 25\n", + "adding: mem time282, current time 306, horizon 24\n", + "adding: mem time283, current time 306, horizon 23\n", + "adding: mem time284, current time 306, horizon 22\n", + "adding: mem time285, current time 306, horizon 21\n", + "adding: mem time286, current time 306, horizon 20\n", + "adding: mem time287, current time 306, horizon 19\n", + "adding: mem time288, current time 306, horizon 18\n", + "adding: mem time289, current time 306, horizon 17\n", + "adding: mem time290, current time 306, horizon 16\n", + "adding: mem time291, current time 306, horizon 15\n", + "adding: mem time292, current time 306, horizon 14\n", + "adding: mem time293, current time 306, horizon 13\n", + "adding: mem time294, current time 306, horizon 12\n", + "adding: mem time295, current time 306, horizon 11\n", + "adding: mem time296, current time 306, horizon 10\n", + "adding: mem time297, current time 306, horizon 9\n", + "adding: mem time298, current time 306, horizon 8\n", + "adding: mem time299, current time 306, horizon 7\n", + "adding: mem time300, current time 306, horizon 6\n", + "adding: mem time301, current time 306, horizon 5\n", + "adding: mem time302, current time 306, horizon 4\n", + "adding: mem time303, current time 306, horizon 3\n", + "adding: mem time304, current time 306, horizon 2\n", + "adding: mem time305, current time 306, horizon 1\n", + "adding: mem time200, current time 307, horizon 107\n", + "adding: mem time201, current time 307, horizon 106\n", + "adding: mem time202, current time 307, horizon 105\n", + "adding: mem time203, current time 307, horizon 104\n", + "adding: mem time204, current time 307, horizon 103\n", + "adding: mem time205, current time 307, horizon 102\n", + "adding: mem time206, current time 307, horizon 101\n", + "adding: mem time207, current time 307, horizon 100\n", + "adding: mem time208, current time 307, horizon 99\n", + "adding: mem time209, current time 307, horizon 98\n", + "adding: mem time210, current time 307, horizon 97\n", + "adding: mem time211, current time 307, horizon 96\n", + "adding: mem time212, current time 307, horizon 95\n", + "adding: mem time213, current time 307, horizon 94\n", + "adding: mem time214, current time 307, horizon 93\n", + "adding: mem time215, current time 307, horizon 92\n", + "adding: mem time216, current time 307, horizon 91\n", + "adding: mem time217, current time 307, horizon 90\n", + "adding: mem time218, current time 307, horizon 89\n", + "adding: mem time219, current time 307, horizon 88\n", + "adding: mem time220, current time 307, horizon 87\n", + "adding: mem time221, current time 307, horizon 86\n", + "adding: mem time222, current time 307, horizon 85\n", + "adding: mem time223, current time 307, horizon 84\n", + "adding: mem time224, current time 307, horizon 83\n", + "adding: mem time225, current time 307, horizon 82\n", + "adding: mem time226, current time 307, horizon 81\n", + "adding: mem time227, current time 307, horizon 80\n", + "adding: mem time228, current time 307, horizon 79\n", + "adding: mem time229, current time 307, horizon 78\n", + "adding: mem time230, current time 307, horizon 77\n", + "adding: mem time231, current time 307, horizon 76\n", + "adding: mem time232, current time 307, horizon 75\n", + "adding: mem time233, current time 307, horizon 74\n", + "adding: mem time234, current time 307, horizon 73\n", + "adding: mem time235, current time 307, horizon 72\n", + "adding: mem time236, current time 307, horizon 71\n", + "adding: mem time237, current time 307, horizon 70\n", + "adding: mem time238, current time 307, horizon 69\n", + "adding: mem time239, current time 307, horizon 68\n", + "adding: mem time240, current time 307, horizon 67\n", + "adding: mem time241, current time 307, horizon 66\n", + "adding: mem time242, current time 307, horizon 65\n", + "adding: mem time243, current time 307, horizon 64\n", + "adding: mem time244, current time 307, horizon 63\n", + "adding: mem time245, current time 307, horizon 62\n", + "adding: mem time246, current time 307, horizon 61\n", + "adding: mem time247, current time 307, horizon 60\n", + "adding: mem time248, current time 307, horizon 59\n", + "adding: mem time249, current time 307, horizon 58\n", + "adding: mem time250, current time 307, horizon 57\n", + "adding: mem time251, current time 307, horizon 56\n", + "adding: mem time252, current time 307, horizon 55\n", + "adding: mem time253, current time 307, horizon 54\n", + "adding: mem time254, current time 307, horizon 53\n", + "adding: mem time255, current time 307, horizon 52\n", + "adding: mem time256, current time 307, horizon 51\n", + "adding: mem time257, current time 307, horizon 50\n", + "adding: mem time258, current time 307, horizon 49\n", + "adding: mem time259, current time 307, horizon 48\n", + "adding: mem time260, current time 307, horizon 47\n", + "adding: mem time261, current time 307, horizon 46\n", + "adding: mem time262, current time 307, horizon 45\n", + "adding: mem time263, current time 307, horizon 44\n", + "adding: mem time264, current time 307, horizon 43\n", + "adding: mem time265, current time 307, horizon 42\n", + "adding: mem time266, current time 307, horizon 41\n", + "adding: mem time267, current time 307, horizon 40\n", + "adding: mem time268, current time 307, horizon 39\n", + "adding: mem time269, current time 307, horizon 38\n", + "adding: mem time270, current time 307, horizon 37\n", + "adding: mem time271, current time 307, horizon 36\n", + "adding: mem time272, current time 307, horizon 35\n", + "adding: mem time273, current time 307, horizon 34\n", + "adding: mem time274, current time 307, horizon 33\n", + "adding: mem time275, current time 307, horizon 32\n", + "adding: mem time276, current time 307, horizon 31\n", + "adding: mem time277, current time 307, horizon 30\n", + "adding: mem time278, current time 307, horizon 29\n", + "adding: mem time279, current time 307, horizon 28\n", + "adding: mem time280, current time 307, horizon 27\n", + "adding: mem time281, current time 307, horizon 26\n", + "adding: mem time282, current time 307, horizon 25\n", + "adding: mem time283, current time 307, horizon 24\n", + "adding: mem time284, current time 307, horizon 23\n", + "adding: mem time285, current time 307, horizon 22\n", + "adding: mem time286, current time 307, horizon 21\n", + "adding: mem time287, current time 307, horizon 20\n", + "adding: mem time288, current time 307, horizon 19\n", + "adding: mem time289, current time 307, horizon 18\n", + "adding: mem time290, current time 307, horizon 17\n", + "adding: mem time291, current time 307, horizon 16\n", + "adding: mem time292, current time 307, horizon 15\n", + "adding: mem time293, current time 307, horizon 14\n", + "adding: mem time294, current time 307, horizon 13\n", + "adding: mem time295, current time 307, horizon 12\n", + "adding: mem time296, current time 307, horizon 11\n", + "adding: mem time297, current time 307, horizon 10\n", + "adding: mem time298, current time 307, horizon 9\n", + "adding: mem time299, current time 307, horizon 8\n", + "adding: mem time300, current time 307, horizon 7\n", + "adding: mem time301, current time 307, horizon 6\n", + "adding: mem time302, current time 307, horizon 5\n", + "adding: mem time303, current time 307, horizon 4\n", + "adding: mem time304, current time 307, horizon 3\n", + "adding: mem time305, current time 307, horizon 2\n", + "adding: mem time306, current time 307, horizon 1\n", + "adding: mem time200, current time 308, horizon 108\n", + "adding: mem time201, current time 308, horizon 107\n", + "adding: mem time202, current time 308, horizon 106\n", + "adding: mem time203, current time 308, horizon 105\n", + "adding: mem time204, current time 308, horizon 104\n", + "adding: mem time205, current time 308, horizon 103\n", + "adding: mem time206, current time 308, horizon 102\n", + "adding: mem time207, current time 308, horizon 101\n", + "adding: mem time208, current time 308, horizon 100\n", + "adding: mem time209, current time 308, horizon 99\n", + "adding: mem time210, current time 308, horizon 98\n", + "adding: mem time211, current time 308, horizon 97\n", + "adding: mem time212, current time 308, horizon 96\n", + "adding: mem time213, current time 308, horizon 95\n", + "adding: mem time214, current time 308, horizon 94\n", + "adding: mem time215, current time 308, horizon 93\n", + "adding: mem time216, current time 308, horizon 92\n", + "adding: mem time217, current time 308, horizon 91\n", + "adding: mem time218, current time 308, horizon 90\n", + "adding: mem time219, current time 308, horizon 89\n", + "adding: mem time220, current time 308, horizon 88\n", + "adding: mem time221, current time 308, horizon 87\n", + "adding: mem time222, current time 308, horizon 86\n", + "adding: mem time223, current time 308, horizon 85\n", + "adding: mem time224, current time 308, horizon 84\n", + "adding: mem time225, current time 308, horizon 83\n", + "adding: mem time226, current time 308, horizon 82\n", + "adding: mem time227, current time 308, horizon 81\n", + "adding: mem time228, current time 308, horizon 80\n", + "adding: mem time229, current time 308, horizon 79\n", + "adding: mem time230, current time 308, horizon 78\n", + "adding: mem time231, current time 308, horizon 77\n", + "adding: mem time232, current time 308, horizon 76\n", + "adding: mem time233, current time 308, horizon 75\n", + "adding: mem time234, current time 308, horizon 74\n", + "adding: mem time235, current time 308, horizon 73\n", + "adding: mem time236, current time 308, horizon 72\n", + "adding: mem time237, current time 308, horizon 71\n", + "adding: mem time238, current time 308, horizon 70\n", + "adding: mem time239, current time 308, horizon 69\n", + "adding: mem time240, current time 308, horizon 68\n", + "adding: mem time241, current time 308, horizon 67\n", + "adding: mem time242, current time 308, horizon 66\n", + "adding: mem time243, current time 308, horizon 65\n", + "adding: mem time244, current time 308, horizon 64\n", + "adding: mem time245, current time 308, horizon 63\n", + "adding: mem time246, current time 308, horizon 62\n", + "adding: mem time247, current time 308, horizon 61\n", + "adding: mem time248, current time 308, horizon 60\n", + "adding: mem time249, current time 308, horizon 59\n", + "adding: mem time250, current time 308, horizon 58\n", + "adding: mem time251, current time 308, horizon 57\n", + "adding: mem time252, current time 308, horizon 56\n", + "adding: mem time253, current time 308, horizon 55\n", + "adding: mem time254, current time 308, horizon 54\n", + "adding: mem time255, current time 308, horizon 53\n", + "adding: mem time256, current time 308, horizon 52\n", + "adding: mem time257, current time 308, horizon 51\n", + "adding: mem time258, current time 308, horizon 50\n", + "adding: mem time259, current time 308, horizon 49\n", + "adding: mem time260, current time 308, horizon 48\n", + "adding: mem time261, current time 308, horizon 47\n", + "adding: mem time262, current time 308, horizon 46\n", + "adding: mem time263, current time 308, horizon 45\n", + "adding: mem time264, current time 308, horizon 44\n", + "adding: mem time265, current time 308, horizon 43\n", + "adding: mem time266, current time 308, horizon 42\n", + "adding: mem time267, current time 308, horizon 41\n", + "adding: mem time268, current time 308, horizon 40\n", + "adding: mem time269, current time 308, horizon 39\n", + "adding: mem time270, current time 308, horizon 38\n", + "adding: mem time271, current time 308, horizon 37\n", + "adding: mem time272, current time 308, horizon 36\n", + "adding: mem time273, current time 308, horizon 35\n", + "adding: mem time274, current time 308, horizon 34\n", + "adding: mem time275, current time 308, horizon 33\n", + "adding: mem time276, current time 308, horizon 32\n", + "adding: mem time277, current time 308, horizon 31\n", + "adding: mem time278, current time 308, horizon 30\n", + "adding: mem time279, current time 308, horizon 29\n", + "adding: mem time280, current time 308, horizon 28\n", + "adding: mem time281, current time 308, horizon 27\n", + "adding: mem time282, current time 308, horizon 26\n", + "adding: mem time283, current time 308, horizon 25\n", + "adding: mem time284, current time 308, horizon 24\n", + "adding: mem time285, current time 308, horizon 23\n", + "adding: mem time286, current time 308, horizon 22\n", + "adding: mem time287, current time 308, horizon 21\n", + "adding: mem time288, current time 308, horizon 20\n", + "adding: mem time289, current time 308, horizon 19\n", + "adding: mem time290, current time 308, horizon 18\n", + "adding: mem time291, current time 308, horizon 17\n", + "adding: mem time292, current time 308, horizon 16\n", + "adding: mem time293, current time 308, horizon 15\n", + "adding: mem time294, current time 308, horizon 14\n", + "adding: mem time295, current time 308, horizon 13\n", + "adding: mem time296, current time 308, horizon 12\n", + "adding: mem time297, current time 308, horizon 11\n", + "adding: mem time298, current time 308, horizon 10\n", + "adding: mem time299, current time 308, horizon 9\n", + "adding: mem time300, current time 308, horizon 8\n", + "adding: mem time301, current time 308, horizon 7\n", + "adding: mem time302, current time 308, horizon 6\n", + "adding: mem time303, current time 308, horizon 5\n", + "adding: mem time304, current time 308, horizon 4\n", + "adding: mem time305, current time 308, horizon 3\n", + "adding: mem time306, current time 308, horizon 2\n", + "adding: mem time307, current time 308, horizon 1\n", + "adding: mem time200, current time 309, horizon 109\n", + "adding: mem time201, current time 309, horizon 108\n", + "adding: mem time202, current time 309, horizon 107\n", + "adding: mem time203, current time 309, horizon 106\n", + "adding: mem time204, current time 309, horizon 105\n", + "adding: mem time205, current time 309, horizon 104\n", + "adding: mem time206, current time 309, horizon 103\n", + "adding: mem time207, current time 309, horizon 102\n", + "adding: mem time208, current time 309, horizon 101\n", + "adding: mem time209, current time 309, horizon 100\n", + "adding: mem time210, current time 309, horizon 99\n", + "adding: mem time211, current time 309, horizon 98\n", + "adding: mem time212, current time 309, horizon 97\n", + "adding: mem time213, current time 309, horizon 96\n", + "adding: mem time214, current time 309, horizon 95\n", + "adding: mem time215, current time 309, horizon 94\n", + "adding: mem time216, current time 309, horizon 93\n", + "adding: mem time217, current time 309, horizon 92\n", + "adding: mem time218, current time 309, horizon 91\n", + "adding: mem time219, current time 309, horizon 90\n", + "adding: mem time220, current time 309, horizon 89\n", + "adding: mem time221, current time 309, horizon 88\n", + "adding: mem time222, current time 309, horizon 87\n", + "adding: mem time223, current time 309, horizon 86\n", + "adding: mem time224, current time 309, horizon 85\n", + "adding: mem time225, current time 309, horizon 84\n", + "adding: mem time226, current time 309, horizon 83\n", + "adding: mem time227, current time 309, horizon 82\n", + "adding: mem time228, current time 309, horizon 81\n", + "adding: mem time229, current time 309, horizon 80\n", + "adding: mem time230, current time 309, horizon 79\n", + "adding: mem time231, current time 309, horizon 78\n", + "adding: mem time232, current time 309, horizon 77\n", + "adding: mem time233, current time 309, horizon 76\n", + "adding: mem time234, current time 309, horizon 75\n", + "adding: mem time235, current time 309, horizon 74\n", + "adding: mem time236, current time 309, horizon 73\n", + "adding: mem time237, current time 309, horizon 72\n", + "adding: mem time238, current time 309, horizon 71\n", + "adding: mem time239, current time 309, horizon 70\n", + "adding: mem time240, current time 309, horizon 69\n", + "adding: mem time241, current time 309, horizon 68\n", + "adding: mem time242, current time 309, horizon 67\n", + "adding: mem time243, current time 309, horizon 66\n", + "adding: mem time244, current time 309, horizon 65\n", + "adding: mem time245, current time 309, horizon 64\n", + "adding: mem time246, current time 309, horizon 63\n", + "adding: mem time247, current time 309, horizon 62\n", + "adding: mem time248, current time 309, horizon 61\n", + "adding: mem time249, current time 309, horizon 60\n", + "adding: mem time250, current time 309, horizon 59\n", + "adding: mem time251, current time 309, horizon 58\n", + "adding: mem time252, current time 309, horizon 57\n", + "adding: mem time253, current time 309, horizon 56\n", + "adding: mem time254, current time 309, horizon 55\n", + "adding: mem time255, current time 309, horizon 54\n", + "adding: mem time256, current time 309, horizon 53\n", + "adding: mem time257, current time 309, horizon 52\n", + "adding: mem time258, current time 309, horizon 51\n", + "adding: mem time259, current time 309, horizon 50\n", + "adding: mem time260, current time 309, horizon 49\n", + "adding: mem time261, current time 309, horizon 48\n", + "adding: mem time262, current time 309, horizon 47\n", + "adding: mem time263, current time 309, horizon 46\n", + "adding: mem time264, current time 309, horizon 45\n", + "adding: mem time265, current time 309, horizon 44\n", + "adding: mem time266, current time 309, horizon 43\n", + "adding: mem time267, current time 309, horizon 42\n", + "adding: mem time268, current time 309, horizon 41\n", + "adding: mem time269, current time 309, horizon 40\n", + "adding: mem time270, current time 309, horizon 39\n", + "adding: mem time271, current time 309, horizon 38\n", + "adding: mem time272, current time 309, horizon 37\n", + "adding: mem time273, current time 309, horizon 36\n", + "adding: mem time274, current time 309, horizon 35\n", + "adding: mem time275, current time 309, horizon 34\n", + "adding: mem time276, current time 309, horizon 33\n", + "adding: mem time277, current time 309, horizon 32\n", + "adding: mem time278, current time 309, horizon 31\n", + "adding: mem time279, current time 309, horizon 30\n", + "adding: mem time280, current time 309, horizon 29\n", + "adding: mem time281, current time 309, horizon 28\n", + "adding: mem time282, current time 309, horizon 27\n", + "adding: mem time283, current time 309, horizon 26\n", + "adding: mem time284, current time 309, horizon 25\n", + "adding: mem time285, current time 309, horizon 24\n", + "adding: mem time286, current time 309, horizon 23\n", + "adding: mem time287, current time 309, horizon 22\n", + "adding: mem time288, current time 309, horizon 21\n", + "adding: mem time289, current time 309, horizon 20\n", + "adding: mem time290, current time 309, horizon 19\n", + "adding: mem time291, current time 309, horizon 18\n", + "adding: mem time292, current time 309, horizon 17\n", + "adding: mem time293, current time 309, horizon 16\n", + "adding: mem time294, current time 309, horizon 15\n", + "adding: mem time295, current time 309, horizon 14\n", + "adding: mem time296, current time 309, horizon 13\n", + "adding: mem time297, current time 309, horizon 12\n", + "adding: mem time298, current time 309, horizon 11\n", + "adding: mem time299, current time 309, horizon 10\n", + "adding: mem time300, current time 309, horizon 9\n", + "adding: mem time301, current time 309, horizon 8\n", + "adding: mem time302, current time 309, horizon 7\n", + "adding: mem time303, current time 309, horizon 6\n", + "adding: mem time304, current time 309, horizon 5\n", + "adding: mem time305, current time 309, horizon 4\n", + "adding: mem time306, current time 309, horizon 3\n", + "adding: mem time307, current time 309, horizon 2\n", + "adding: mem time308, current time 309, horizon 1\n", + "adding: mem time200, current time 310, horizon 110\n", + "adding: mem time201, current time 310, horizon 109\n", + "adding: mem time202, current time 310, horizon 108\n", + "adding: mem time203, current time 310, horizon 107\n", + "adding: mem time204, current time 310, horizon 106\n", + "adding: mem time205, current time 310, horizon 105\n", + "adding: mem time206, current time 310, horizon 104\n", + "adding: mem time207, current time 310, horizon 103\n", + "adding: mem time208, current time 310, horizon 102\n", + "adding: mem time209, current time 310, horizon 101\n", + "adding: mem time210, current time 310, horizon 100\n", + "adding: mem time211, current time 310, horizon 99\n", + "adding: mem time212, current time 310, horizon 98\n", + "adding: mem time213, current time 310, horizon 97\n", + "adding: mem time214, current time 310, horizon 96\n", + "adding: mem time215, current time 310, horizon 95\n", + "adding: mem time216, current time 310, horizon 94\n", + "adding: mem time217, current time 310, horizon 93\n", + "adding: mem time218, current time 310, horizon 92\n", + "adding: mem time219, current time 310, horizon 91\n", + "adding: mem time220, current time 310, horizon 90\n", + "adding: mem time221, current time 310, horizon 89\n", + "adding: mem time222, current time 310, horizon 88\n", + "adding: mem time223, current time 310, horizon 87\n", + "adding: mem time224, current time 310, horizon 86\n", + "adding: mem time225, current time 310, horizon 85\n", + "adding: mem time226, current time 310, horizon 84\n", + "adding: mem time227, current time 310, horizon 83\n", + "adding: mem time228, current time 310, horizon 82\n", + "adding: mem time229, current time 310, horizon 81\n", + "adding: mem time230, current time 310, horizon 80\n", + "adding: mem time231, current time 310, horizon 79\n", + "adding: mem time232, current time 310, horizon 78\n", + "adding: mem time233, current time 310, horizon 77\n", + "adding: mem time234, current time 310, horizon 76\n", + "adding: mem time235, current time 310, horizon 75\n", + "adding: mem time236, current time 310, horizon 74\n", + "adding: mem time237, current time 310, horizon 73\n", + "adding: mem time238, current time 310, horizon 72\n", + "adding: mem time239, current time 310, horizon 71\n", + "adding: mem time240, current time 310, horizon 70\n", + "adding: mem time241, current time 310, horizon 69\n", + "adding: mem time242, current time 310, horizon 68\n", + "adding: mem time243, current time 310, horizon 67\n", + "adding: mem time244, current time 310, horizon 66\n", + "adding: mem time245, current time 310, horizon 65\n", + "adding: mem time246, current time 310, horizon 64\n", + "adding: mem time247, current time 310, horizon 63\n", + "adding: mem time248, current time 310, horizon 62\n", + "adding: mem time249, current time 310, horizon 61\n", + "adding: mem time250, current time 310, horizon 60\n", + "adding: mem time251, current time 310, horizon 59\n", + "adding: mem time252, current time 310, horizon 58\n", + "adding: mem time253, current time 310, horizon 57\n", + "adding: mem time254, current time 310, horizon 56\n", + "adding: mem time255, current time 310, horizon 55\n", + "adding: mem time256, current time 310, horizon 54\n", + "adding: mem time257, current time 310, horizon 53\n", + "adding: mem time258, current time 310, horizon 52\n", + "adding: mem time259, current time 310, horizon 51\n", + "adding: mem time260, current time 310, horizon 50\n", + "adding: mem time261, current time 310, horizon 49\n", + "adding: mem time262, current time 310, horizon 48\n", + "adding: mem time263, current time 310, horizon 47\n", + "adding: mem time264, current time 310, horizon 46\n", + "adding: mem time265, current time 310, horizon 45\n", + "adding: mem time266, current time 310, horizon 44\n", + "adding: mem time267, current time 310, horizon 43\n", + "adding: mem time268, current time 310, horizon 42\n", + "adding: mem time269, current time 310, horizon 41\n", + "adding: mem time270, current time 310, horizon 40\n", + "adding: mem time271, current time 310, horizon 39\n", + "adding: mem time272, current time 310, horizon 38\n", + "adding: mem time273, current time 310, horizon 37\n", + "adding: mem time274, current time 310, horizon 36\n", + "adding: mem time275, current time 310, horizon 35\n", + "adding: mem time276, current time 310, horizon 34\n", + "adding: mem time277, current time 310, horizon 33\n", + "adding: mem time278, current time 310, horizon 32\n", + "adding: mem time279, current time 310, horizon 31\n", + "adding: mem time280, current time 310, horizon 30\n", + "adding: mem time281, current time 310, horizon 29\n", + "adding: mem time282, current time 310, horizon 28\n", + "adding: mem time283, current time 310, horizon 27\n", + "adding: mem time284, current time 310, horizon 26\n", + "adding: mem time285, current time 310, horizon 25\n", + "adding: mem time286, current time 310, horizon 24\n", + "adding: mem time287, current time 310, horizon 23\n", + "adding: mem time288, current time 310, horizon 22\n", + "adding: mem time289, current time 310, horizon 21\n", + "adding: mem time290, current time 310, horizon 20\n", + "adding: mem time291, current time 310, horizon 19\n", + "adding: mem time292, current time 310, horizon 18\n", + "adding: mem time293, current time 310, horizon 17\n", + "adding: mem time294, current time 310, horizon 16\n", + "adding: mem time295, current time 310, horizon 15\n", + "adding: mem time296, current time 310, horizon 14\n", + "adding: mem time297, current time 310, horizon 13\n", + "adding: mem time298, current time 310, horizon 12\n", + "adding: mem time299, current time 310, horizon 11\n", + "adding: mem time300, current time 310, horizon 10\n", + "adding: mem time301, current time 310, horizon 9\n", + "adding: mem time302, current time 310, horizon 8\n", + "adding: mem time303, current time 310, horizon 7\n", + "adding: mem time304, current time 310, horizon 6\n", + "adding: mem time305, current time 310, horizon 5\n", + "adding: mem time306, current time 310, horizon 4\n", + "adding: mem time307, current time 310, horizon 3\n", + "adding: mem time308, current time 310, horizon 2\n", + "adding: mem time309, current time 310, horizon 1\n", + "adding: mem time200, current time 311, horizon 111\n", + "adding: mem time201, current time 311, horizon 110\n", + "adding: mem time202, current time 311, horizon 109\n", + "adding: mem time203, current time 311, horizon 108\n", + "adding: mem time204, current time 311, horizon 107\n", + "adding: mem time205, current time 311, horizon 106\n", + "adding: mem time206, current time 311, horizon 105\n", + "adding: mem time207, current time 311, horizon 104\n", + "adding: mem time208, current time 311, horizon 103\n", + "adding: mem time209, current time 311, horizon 102\n", + "adding: mem time210, current time 311, horizon 101\n", + "adding: mem time211, current time 311, horizon 100\n", + "adding: mem time212, current time 311, horizon 99\n", + "adding: mem time213, current time 311, horizon 98\n", + "adding: mem time214, current time 311, horizon 97\n", + "adding: mem time215, current time 311, horizon 96\n", + "adding: mem time216, current time 311, horizon 95\n", + "adding: mem time217, current time 311, horizon 94\n", + "adding: mem time218, current time 311, horizon 93\n", + "adding: mem time219, current time 311, horizon 92\n", + "adding: mem time220, current time 311, horizon 91\n", + "adding: mem time221, current time 311, horizon 90\n", + "adding: mem time222, current time 311, horizon 89\n", + "adding: mem time223, current time 311, horizon 88\n", + "adding: mem time224, current time 311, horizon 87\n", + "adding: mem time225, current time 311, horizon 86\n", + "adding: mem time226, current time 311, horizon 85\n", + "adding: mem time227, current time 311, horizon 84\n", + "adding: mem time228, current time 311, horizon 83\n", + "adding: mem time229, current time 311, horizon 82\n", + "adding: mem time230, current time 311, horizon 81\n", + "adding: mem time231, current time 311, horizon 80\n", + "adding: mem time232, current time 311, horizon 79\n", + "adding: mem time233, current time 311, horizon 78\n", + "adding: mem time234, current time 311, horizon 77\n", + "adding: mem time235, current time 311, horizon 76\n", + "adding: mem time236, current time 311, horizon 75\n", + "adding: mem time237, current time 311, horizon 74\n", + "adding: mem time238, current time 311, horizon 73\n", + "adding: mem time239, current time 311, horizon 72\n", + "adding: mem time240, current time 311, horizon 71\n", + "adding: mem time241, current time 311, horizon 70\n", + "adding: mem time242, current time 311, horizon 69\n", + "adding: mem time243, current time 311, horizon 68\n", + "adding: mem time244, current time 311, horizon 67\n", + "adding: mem time245, current time 311, horizon 66\n", + "adding: mem time246, current time 311, horizon 65\n", + "adding: mem time247, current time 311, horizon 64\n", + "adding: mem time248, current time 311, horizon 63\n", + "adding: mem time249, current time 311, horizon 62\n", + "adding: mem time250, current time 311, horizon 61\n", + "adding: mem time251, current time 311, horizon 60\n", + "adding: mem time252, current time 311, horizon 59\n", + "adding: mem time253, current time 311, horizon 58\n", + "adding: mem time254, current time 311, horizon 57\n", + "adding: mem time255, current time 311, horizon 56\n", + "adding: mem time256, current time 311, horizon 55\n", + "adding: mem time257, current time 311, horizon 54\n", + "adding: mem time258, current time 311, horizon 53\n", + "adding: mem time259, current time 311, horizon 52\n", + "adding: mem time260, current time 311, horizon 51\n", + "adding: mem time261, current time 311, horizon 50\n", + "adding: mem time262, current time 311, horizon 49\n", + "adding: mem time263, current time 311, horizon 48\n", + "adding: mem time264, current time 311, horizon 47\n", + "adding: mem time265, current time 311, horizon 46\n", + "adding: mem time266, current time 311, horizon 45\n", + "adding: mem time267, current time 311, horizon 44\n", + "adding: mem time268, current time 311, horizon 43\n", + "adding: mem time269, current time 311, horizon 42\n", + "adding: mem time270, current time 311, horizon 41\n", + "adding: mem time271, current time 311, horizon 40\n", + "adding: mem time272, current time 311, horizon 39\n", + "adding: mem time273, current time 311, horizon 38\n", + "adding: mem time274, current time 311, horizon 37\n", + "adding: mem time275, current time 311, horizon 36\n", + "adding: mem time276, current time 311, horizon 35\n", + "adding: mem time277, current time 311, horizon 34\n", + "adding: mem time278, current time 311, horizon 33\n", + "adding: mem time279, current time 311, horizon 32\n", + "adding: mem time280, current time 311, horizon 31\n", + "adding: mem time281, current time 311, horizon 30\n", + "adding: mem time282, current time 311, horizon 29\n", + "adding: mem time283, current time 311, horizon 28\n", + "adding: mem time284, current time 311, horizon 27\n", + "adding: mem time285, current time 311, horizon 26\n", + "adding: mem time286, current time 311, horizon 25\n", + "adding: mem time287, current time 311, horizon 24\n", + "adding: mem time288, current time 311, horizon 23\n", + "adding: mem time289, current time 311, horizon 22\n", + "adding: mem time290, current time 311, horizon 21\n", + "adding: mem time291, current time 311, horizon 20\n", + "adding: mem time292, current time 311, horizon 19\n", + "adding: mem time293, current time 311, horizon 18\n", + "adding: mem time294, current time 311, horizon 17\n", + "adding: mem time295, current time 311, horizon 16\n", + "adding: mem time296, current time 311, horizon 15\n", + "adding: mem time297, current time 311, horizon 14\n", + "adding: mem time298, current time 311, horizon 13\n", + "adding: mem time299, current time 311, horizon 12\n", + "adding: mem time300, current time 311, horizon 11\n", + "adding: mem time301, current time 311, horizon 10\n", + "adding: mem time302, current time 311, horizon 9\n", + "adding: mem time303, current time 311, horizon 8\n", + "adding: mem time304, current time 311, horizon 7\n", + "adding: mem time305, current time 311, horizon 6\n", + "adding: mem time306, current time 311, horizon 5\n", + "adding: mem time307, current time 311, horizon 4\n", + "adding: mem time308, current time 311, horizon 3\n", + "adding: mem time309, current time 311, horizon 2\n", + "adding: mem time310, current time 311, horizon 1\n", + "adding: mem time200, current time 312, horizon 112\n", + "adding: mem time201, current time 312, horizon 111\n", + "adding: mem time202, current time 312, horizon 110\n", + "adding: mem time203, current time 312, horizon 109\n", + "adding: mem time204, current time 312, horizon 108\n", + "adding: mem time205, current time 312, horizon 107\n", + "adding: mem time206, current time 312, horizon 106\n", + "adding: mem time207, current time 312, horizon 105\n", + "adding: mem time208, current time 312, horizon 104\n", + "adding: mem time209, current time 312, horizon 103\n", + "adding: mem time210, current time 312, horizon 102\n", + "adding: mem time211, current time 312, horizon 101\n", + "adding: mem time212, current time 312, horizon 100\n", + "adding: mem time213, current time 312, horizon 99\n", + "adding: mem time214, current time 312, horizon 98\n", + "adding: mem time215, current time 312, horizon 97\n", + "adding: mem time216, current time 312, horizon 96\n", + "adding: mem time217, current time 312, horizon 95\n", + "adding: mem time218, current time 312, horizon 94\n", + "adding: mem time219, current time 312, horizon 93\n", + "adding: mem time220, current time 312, horizon 92\n", + "adding: mem time221, current time 312, horizon 91\n", + "adding: mem time222, current time 312, horizon 90\n", + "adding: mem time223, current time 312, horizon 89\n", + "adding: mem time224, current time 312, horizon 88\n", + "adding: mem time225, current time 312, horizon 87\n", + "adding: mem time226, current time 312, horizon 86\n", + "adding: mem time227, current time 312, horizon 85\n", + "adding: mem time228, current time 312, horizon 84\n", + "adding: mem time229, current time 312, horizon 83\n", + "adding: mem time230, current time 312, horizon 82\n", + "adding: mem time231, current time 312, horizon 81\n", + "adding: mem time232, current time 312, horizon 80\n", + "adding: mem time233, current time 312, horizon 79\n", + "adding: mem time234, current time 312, horizon 78\n", + "adding: mem time235, current time 312, horizon 77\n", + "adding: mem time236, current time 312, horizon 76\n", + "adding: mem time237, current time 312, horizon 75\n", + "adding: mem time238, current time 312, horizon 74\n", + "adding: mem time239, current time 312, horizon 73\n", + "adding: mem time240, current time 312, horizon 72\n", + "adding: mem time241, current time 312, horizon 71\n", + "adding: mem time242, current time 312, horizon 70\n", + "adding: mem time243, current time 312, horizon 69\n", + "adding: mem time244, current time 312, horizon 68\n", + "adding: mem time245, current time 312, horizon 67\n", + "adding: mem time246, current time 312, horizon 66\n", + "adding: mem time247, current time 312, horizon 65\n", + "adding: mem time248, current time 312, horizon 64\n", + "adding: mem time249, current time 312, horizon 63\n", + "adding: mem time250, current time 312, horizon 62\n", + "adding: mem time251, current time 312, horizon 61\n", + "adding: mem time252, current time 312, horizon 60\n", + "adding: mem time253, current time 312, horizon 59\n", + "adding: mem time254, current time 312, horizon 58\n", + "adding: mem time255, current time 312, horizon 57\n", + "adding: mem time256, current time 312, horizon 56\n", + "adding: mem time257, current time 312, horizon 55\n", + "adding: mem time258, current time 312, horizon 54\n", + "adding: mem time259, current time 312, horizon 53\n", + "adding: mem time260, current time 312, horizon 52\n", + "adding: mem time261, current time 312, horizon 51\n", + "adding: mem time262, current time 312, horizon 50\n", + "adding: mem time263, current time 312, horizon 49\n", + "adding: mem time264, current time 312, horizon 48\n", + "adding: mem time265, current time 312, horizon 47\n", + "adding: mem time266, current time 312, horizon 46\n", + "adding: mem time267, current time 312, horizon 45\n", + "adding: mem time268, current time 312, horizon 44\n", + "adding: mem time269, current time 312, horizon 43\n", + "adding: mem time270, current time 312, horizon 42\n", + "adding: mem time271, current time 312, horizon 41\n", + "adding: mem time272, current time 312, horizon 40\n", + "adding: mem time273, current time 312, horizon 39\n", + "adding: mem time274, current time 312, horizon 38\n", + "adding: mem time275, current time 312, horizon 37\n", + "adding: mem time276, current time 312, horizon 36\n", + "adding: mem time277, current time 312, horizon 35\n", + "adding: mem time278, current time 312, horizon 34\n", + "adding: mem time279, current time 312, horizon 33\n", + "adding: mem time280, current time 312, horizon 32\n", + "adding: mem time281, current time 312, horizon 31\n", + "adding: mem time282, current time 312, horizon 30\n", + "adding: mem time283, current time 312, horizon 29\n", + "adding: mem time284, current time 312, horizon 28\n", + "adding: mem time285, current time 312, horizon 27\n", + "adding: mem time286, current time 312, horizon 26\n", + "adding: mem time287, current time 312, horizon 25\n", + "adding: mem time288, current time 312, horizon 24\n", + "adding: mem time289, current time 312, horizon 23\n", + "adding: mem time290, current time 312, horizon 22\n", + "adding: mem time291, current time 312, horizon 21\n", + "adding: mem time292, current time 312, horizon 20\n", + "adding: mem time293, current time 312, horizon 19\n", + "adding: mem time294, current time 312, horizon 18\n", + "adding: mem time295, current time 312, horizon 17\n", + "adding: mem time296, current time 312, horizon 16\n", + "adding: mem time297, current time 312, horizon 15\n", + "adding: mem time298, current time 312, horizon 14\n", + "adding: mem time299, current time 312, horizon 13\n", + "adding: mem time300, current time 312, horizon 12\n", + "adding: mem time301, current time 312, horizon 11\n", + "adding: mem time302, current time 312, horizon 10\n", + "adding: mem time303, current time 312, horizon 9\n", + "adding: mem time304, current time 312, horizon 8\n", + "adding: mem time305, current time 312, horizon 7\n", + "adding: mem time306, current time 312, horizon 6\n", + "adding: mem time307, current time 312, horizon 5\n", + "adding: mem time308, current time 312, horizon 4\n", + "adding: mem time309, current time 312, horizon 3\n", + "adding: mem time310, current time 312, horizon 2\n", + "adding: mem time311, current time 312, horizon 1\n", + "adding: mem time200, current time 313, horizon 113\n", + "adding: mem time201, current time 313, horizon 112\n", + "adding: mem time202, current time 313, horizon 111\n", + "adding: mem time203, current time 313, horizon 110\n", + "adding: mem time204, current time 313, horizon 109\n", + "adding: mem time205, current time 313, horizon 108\n", + "adding: mem time206, current time 313, horizon 107\n", + "adding: mem time207, current time 313, horizon 106\n", + "adding: mem time208, current time 313, horizon 105\n", + "adding: mem time209, current time 313, horizon 104\n", + "adding: mem time210, current time 313, horizon 103\n", + "adding: mem time211, current time 313, horizon 102\n", + "adding: mem time212, current time 313, horizon 101\n", + "adding: mem time213, current time 313, horizon 100\n", + "adding: mem time214, current time 313, horizon 99\n", + "adding: mem time215, current time 313, horizon 98\n", + "adding: mem time216, current time 313, horizon 97\n", + "adding: mem time217, current time 313, horizon 96\n", + "adding: mem time218, current time 313, horizon 95\n", + "adding: mem time219, current time 313, horizon 94\n", + "adding: mem time220, current time 313, horizon 93\n", + "adding: mem time221, current time 313, horizon 92\n", + "adding: mem time222, current time 313, horizon 91\n", + "adding: mem time223, current time 313, horizon 90\n", + "adding: mem time224, current time 313, horizon 89\n", + "adding: mem time225, current time 313, horizon 88\n", + "adding: mem time226, current time 313, horizon 87\n", + "adding: mem time227, current time 313, horizon 86\n", + "adding: mem time228, current time 313, horizon 85\n", + "adding: mem time229, current time 313, horizon 84\n", + "adding: mem time230, current time 313, horizon 83\n", + "adding: mem time231, current time 313, horizon 82\n", + "adding: mem time232, current time 313, horizon 81\n", + "adding: mem time233, current time 313, horizon 80\n", + "adding: mem time234, current time 313, horizon 79\n", + "adding: mem time235, current time 313, horizon 78\n", + "adding: mem time236, current time 313, horizon 77\n", + "adding: mem time237, current time 313, horizon 76\n", + "adding: mem time238, current time 313, horizon 75\n", + "adding: mem time239, current time 313, horizon 74\n", + "adding: mem time240, current time 313, horizon 73\n", + "adding: mem time241, current time 313, horizon 72\n", + "adding: mem time242, current time 313, horizon 71\n", + "adding: mem time243, current time 313, horizon 70\n", + "adding: mem time244, current time 313, horizon 69\n", + "adding: mem time245, current time 313, horizon 68\n", + "adding: mem time246, current time 313, horizon 67\n", + "adding: mem time247, current time 313, horizon 66\n", + "adding: mem time248, current time 313, horizon 65\n", + "adding: mem time249, current time 313, horizon 64\n", + "adding: mem time250, current time 313, horizon 63\n", + "adding: mem time251, current time 313, horizon 62\n", + "adding: mem time252, current time 313, horizon 61\n", + "adding: mem time253, current time 313, horizon 60\n", + "adding: mem time254, current time 313, horizon 59\n", + "adding: mem time255, current time 313, horizon 58\n", + "adding: mem time256, current time 313, horizon 57\n", + "adding: mem time257, current time 313, horizon 56\n", + "adding: mem time258, current time 313, horizon 55\n", + "adding: mem time259, current time 313, horizon 54\n", + "adding: mem time260, current time 313, horizon 53\n", + "adding: mem time261, current time 313, horizon 52\n", + "adding: mem time262, current time 313, horizon 51\n", + "adding: mem time263, current time 313, horizon 50\n", + "adding: mem time264, current time 313, horizon 49\n", + "adding: mem time265, current time 313, horizon 48\n", + "adding: mem time266, current time 313, horizon 47\n", + "adding: mem time267, current time 313, horizon 46\n", + "adding: mem time268, current time 313, horizon 45\n", + "adding: mem time269, current time 313, horizon 44\n", + "adding: mem time270, current time 313, horizon 43\n", + "adding: mem time271, current time 313, horizon 42\n", + "adding: mem time272, current time 313, horizon 41\n", + "adding: mem time273, current time 313, horizon 40\n", + "adding: mem time274, current time 313, horizon 39\n", + "adding: mem time275, current time 313, horizon 38\n", + "adding: mem time276, current time 313, horizon 37\n", + "adding: mem time277, current time 313, horizon 36\n", + "adding: mem time278, current time 313, horizon 35\n", + "adding: mem time279, current time 313, horizon 34\n", + "adding: mem time280, current time 313, horizon 33\n", + "adding: mem time281, current time 313, horizon 32\n", + "adding: mem time282, current time 313, horizon 31\n", + "adding: mem time283, current time 313, horizon 30\n", + "adding: mem time284, current time 313, horizon 29\n", + "adding: mem time285, current time 313, horizon 28\n", + "adding: mem time286, current time 313, horizon 27\n", + "adding: mem time287, current time 313, horizon 26\n", + "adding: mem time288, current time 313, horizon 25\n", + "adding: mem time289, current time 313, horizon 24\n", + "adding: mem time290, current time 313, horizon 23\n", + "adding: mem time291, current time 313, horizon 22\n", + "adding: mem time292, current time 313, horizon 21\n", + "adding: mem time293, current time 313, horizon 20\n", + "adding: mem time294, current time 313, horizon 19\n", + "adding: mem time295, current time 313, horizon 18\n", + "adding: mem time296, current time 313, horizon 17\n", + "adding: mem time297, current time 313, horizon 16\n", + "adding: mem time298, current time 313, horizon 15\n", + "adding: mem time299, current time 313, horizon 14\n", + "adding: mem time300, current time 313, horizon 13\n", + "adding: mem time301, current time 313, horizon 12\n", + "adding: mem time302, current time 313, horizon 11\n", + "adding: mem time303, current time 313, horizon 10\n", + "adding: mem time304, current time 313, horizon 9\n", + "adding: mem time305, current time 313, horizon 8\n", + "adding: mem time306, current time 313, horizon 7\n", + "adding: mem time307, current time 313, horizon 6\n", + "adding: mem time308, current time 313, horizon 5\n", + "adding: mem time309, current time 313, horizon 4\n", + "adding: mem time310, current time 313, horizon 3\n", + "adding: mem time311, current time 313, horizon 2\n", + "adding: mem time312, current time 313, horizon 1\n", + "adding: mem time200, current time 314, horizon 114\n", + "adding: mem time201, current time 314, horizon 113\n", + "adding: mem time202, current time 314, horizon 112\n", + "adding: mem time203, current time 314, horizon 111\n", + "adding: mem time204, current time 314, horizon 110\n", + "adding: mem time205, current time 314, horizon 109\n", + "adding: mem time206, current time 314, horizon 108\n", + "adding: mem time207, current time 314, horizon 107\n", + "adding: mem time208, current time 314, horizon 106\n", + "adding: mem time209, current time 314, horizon 105\n", + "adding: mem time210, current time 314, horizon 104\n", + "adding: mem time211, current time 314, horizon 103\n", + "adding: mem time212, current time 314, horizon 102\n", + "adding: mem time213, current time 314, horizon 101\n", + "adding: mem time214, current time 314, horizon 100\n", + "adding: mem time215, current time 314, horizon 99\n", + "adding: mem time216, current time 314, horizon 98\n", + "adding: mem time217, current time 314, horizon 97\n", + "adding: mem time218, current time 314, horizon 96\n", + "adding: mem time219, current time 314, horizon 95\n", + "adding: mem time220, current time 314, horizon 94\n", + "adding: mem time221, current time 314, horizon 93\n", + "adding: mem time222, current time 314, horizon 92\n", + "adding: mem time223, current time 314, horizon 91\n", + "adding: mem time224, current time 314, horizon 90\n", + "adding: mem time225, current time 314, horizon 89\n", + "adding: mem time226, current time 314, horizon 88\n", + "adding: mem time227, current time 314, horizon 87\n", + "adding: mem time228, current time 314, horizon 86\n", + "adding: mem time229, current time 314, horizon 85\n", + "adding: mem time230, current time 314, horizon 84\n", + "adding: mem time231, current time 314, horizon 83\n", + "adding: mem time232, current time 314, horizon 82\n", + "adding: mem time233, current time 314, horizon 81\n", + "adding: mem time234, current time 314, horizon 80\n", + "adding: mem time235, current time 314, horizon 79\n", + "adding: mem time236, current time 314, horizon 78\n", + "adding: mem time237, current time 314, horizon 77\n", + "adding: mem time238, current time 314, horizon 76\n", + "adding: mem time239, current time 314, horizon 75\n", + "adding: mem time240, current time 314, horizon 74\n", + "adding: mem time241, current time 314, horizon 73\n", + "adding: mem time242, current time 314, horizon 72\n", + "adding: mem time243, current time 314, horizon 71\n", + "adding: mem time244, current time 314, horizon 70\n", + "adding: mem time245, current time 314, horizon 69\n", + "adding: mem time246, current time 314, horizon 68\n", + "adding: mem time247, current time 314, horizon 67\n", + "adding: mem time248, current time 314, horizon 66\n", + "adding: mem time249, current time 314, horizon 65\n", + "adding: mem time250, current time 314, horizon 64\n", + "adding: mem time251, current time 314, horizon 63\n", + "adding: mem time252, current time 314, horizon 62\n", + "adding: mem time253, current time 314, horizon 61\n", + "adding: mem time254, current time 314, horizon 60\n", + "adding: mem time255, current time 314, horizon 59\n", + "adding: mem time256, current time 314, horizon 58\n", + "adding: mem time257, current time 314, horizon 57\n", + "adding: mem time258, current time 314, horizon 56\n", + "adding: mem time259, current time 314, horizon 55\n", + "adding: mem time260, current time 314, horizon 54\n", + "adding: mem time261, current time 314, horizon 53\n", + "adding: mem time262, current time 314, horizon 52\n", + "adding: mem time263, current time 314, horizon 51\n", + "adding: mem time264, current time 314, horizon 50\n", + "adding: mem time265, current time 314, horizon 49\n", + "adding: mem time266, current time 314, horizon 48\n", + "adding: mem time267, current time 314, horizon 47\n", + "adding: mem time268, current time 314, horizon 46\n", + "adding: mem time269, current time 314, horizon 45\n", + "adding: mem time270, current time 314, horizon 44\n", + "adding: mem time271, current time 314, horizon 43\n", + "adding: mem time272, current time 314, horizon 42\n", + "adding: mem time273, current time 314, horizon 41\n", + "adding: mem time274, current time 314, horizon 40\n", + "adding: mem time275, current time 314, horizon 39\n", + "adding: mem time276, current time 314, horizon 38\n", + "adding: mem time277, current time 314, horizon 37\n", + "adding: mem time278, current time 314, horizon 36\n", + "adding: mem time279, current time 314, horizon 35\n", + "adding: mem time280, current time 314, horizon 34\n", + "adding: mem time281, current time 314, horizon 33\n", + "adding: mem time282, current time 314, horizon 32\n", + "adding: mem time283, current time 314, horizon 31\n", + "adding: mem time284, current time 314, horizon 30\n", + "adding: mem time285, current time 314, horizon 29\n", + "adding: mem time286, current time 314, horizon 28\n", + "adding: mem time287, current time 314, horizon 27\n", + "adding: mem time288, current time 314, horizon 26\n", + "adding: mem time289, current time 314, horizon 25\n", + "adding: mem time290, current time 314, horizon 24\n", + "adding: mem time291, current time 314, horizon 23\n", + "adding: mem time292, current time 314, horizon 22\n", + "adding: mem time293, current time 314, horizon 21\n", + "adding: mem time294, current time 314, horizon 20\n", + "adding: mem time295, current time 314, horizon 19\n", + "adding: mem time296, current time 314, horizon 18\n", + "adding: mem time297, current time 314, horizon 17\n", + "adding: mem time298, current time 314, horizon 16\n", + "adding: mem time299, current time 314, horizon 15\n", + "adding: mem time300, current time 314, horizon 14\n", + "adding: mem time301, current time 314, horizon 13\n", + "adding: mem time302, current time 314, horizon 12\n", + "adding: mem time303, current time 314, horizon 11\n", + "adding: mem time304, current time 314, horizon 10\n", + "adding: mem time305, current time 314, horizon 9\n", + "adding: mem time306, current time 314, horizon 8\n", + "adding: mem time307, current time 314, horizon 7\n", + "adding: mem time308, current time 314, horizon 6\n", + "adding: mem time309, current time 314, horizon 5\n", + "adding: mem time310, current time 314, horizon 4\n", + "adding: mem time311, current time 314, horizon 3\n", + "adding: mem time312, current time 314, horizon 2\n", + "adding: mem time313, current time 314, horizon 1\n", + "adding: mem time200, current time 315, horizon 115\n", + "adding: mem time201, current time 315, horizon 114\n", + "adding: mem time202, current time 315, horizon 113\n", + "adding: mem time203, current time 315, horizon 112\n", + "adding: mem time204, current time 315, horizon 111\n", + "adding: mem time205, current time 315, horizon 110\n", + "adding: mem time206, current time 315, horizon 109\n", + "adding: mem time207, current time 315, horizon 108\n", + "adding: mem time208, current time 315, horizon 107\n", + "adding: mem time209, current time 315, horizon 106\n", + "adding: mem time210, current time 315, horizon 105\n", + "adding: mem time211, current time 315, horizon 104\n", + "adding: mem time212, current time 315, horizon 103\n", + "adding: mem time213, current time 315, horizon 102\n", + "adding: mem time214, current time 315, horizon 101\n", + "adding: mem time215, current time 315, horizon 100\n", + "adding: mem time216, current time 315, horizon 99\n", + "adding: mem time217, current time 315, horizon 98\n", + "adding: mem time218, current time 315, horizon 97\n", + "adding: mem time219, current time 315, horizon 96\n", + "adding: mem time220, current time 315, horizon 95\n", + "adding: mem time221, current time 315, horizon 94\n", + "adding: mem time222, current time 315, horizon 93\n", + "adding: mem time223, current time 315, horizon 92\n", + "adding: mem time224, current time 315, horizon 91\n", + "adding: mem time225, current time 315, horizon 90\n", + "adding: mem time226, current time 315, horizon 89\n", + "adding: mem time227, current time 315, horizon 88\n", + "adding: mem time228, current time 315, horizon 87\n", + "adding: mem time229, current time 315, horizon 86\n", + "adding: mem time230, current time 315, horizon 85\n", + "adding: mem time231, current time 315, horizon 84\n", + "adding: mem time232, current time 315, horizon 83\n", + "adding: mem time233, current time 315, horizon 82\n", + "adding: mem time234, current time 315, horizon 81\n", + "adding: mem time235, current time 315, horizon 80\n", + "adding: mem time236, current time 315, horizon 79\n", + "adding: mem time237, current time 315, horizon 78\n", + "adding: mem time238, current time 315, horizon 77\n", + "adding: mem time239, current time 315, horizon 76\n", + "adding: mem time240, current time 315, horizon 75\n", + "adding: mem time241, current time 315, horizon 74\n", + "adding: mem time242, current time 315, horizon 73\n", + "adding: mem time243, current time 315, horizon 72\n", + "adding: mem time244, current time 315, horizon 71\n", + "adding: mem time245, current time 315, horizon 70\n", + "adding: mem time246, current time 315, horizon 69\n", + "adding: mem time247, current time 315, horizon 68\n", + "adding: mem time248, current time 315, horizon 67\n", + "adding: mem time249, current time 315, horizon 66\n", + "adding: mem time250, current time 315, horizon 65\n", + "adding: mem time251, current time 315, horizon 64\n", + "adding: mem time252, current time 315, horizon 63\n", + "adding: mem time253, current time 315, horizon 62\n", + "adding: mem time254, current time 315, horizon 61\n", + "adding: mem time255, current time 315, horizon 60\n", + "adding: mem time256, current time 315, horizon 59\n", + "adding: mem time257, current time 315, horizon 58\n", + "adding: mem time258, current time 315, horizon 57\n", + "adding: mem time259, current time 315, horizon 56\n", + "adding: mem time260, current time 315, horizon 55\n", + "adding: mem time261, current time 315, horizon 54\n", + "adding: mem time262, current time 315, horizon 53\n", + "adding: mem time263, current time 315, horizon 52\n", + "adding: mem time264, current time 315, horizon 51\n", + "adding: mem time265, current time 315, horizon 50\n", + "adding: mem time266, current time 315, horizon 49\n", + "adding: mem time267, current time 315, horizon 48\n", + "adding: mem time268, current time 315, horizon 47\n", + "adding: mem time269, current time 315, horizon 46\n", + "adding: mem time270, current time 315, horizon 45\n", + "adding: mem time271, current time 315, horizon 44\n", + "adding: mem time272, current time 315, horizon 43\n", + "adding: mem time273, current time 315, horizon 42\n", + "adding: mem time274, current time 315, horizon 41\n", + "adding: mem time275, current time 315, horizon 40\n", + "adding: mem time276, current time 315, horizon 39\n", + "adding: mem time277, current time 315, horizon 38\n", + "adding: mem time278, current time 315, horizon 37\n", + "adding: mem time279, current time 315, horizon 36\n", + "adding: mem time280, current time 315, horizon 35\n", + "adding: mem time281, current time 315, horizon 34\n", + "adding: mem time282, current time 315, horizon 33\n", + "adding: mem time283, current time 315, horizon 32\n", + "adding: mem time284, current time 315, horizon 31\n", + "adding: mem time285, current time 315, horizon 30\n", + "adding: mem time286, current time 315, horizon 29\n", + "adding: mem time287, current time 315, horizon 28\n", + "adding: mem time288, current time 315, horizon 27\n", + "adding: mem time289, current time 315, horizon 26\n", + "adding: mem time290, current time 315, horizon 25\n", + "adding: mem time291, current time 315, horizon 24\n", + "adding: mem time292, current time 315, horizon 23\n", + "adding: mem time293, current time 315, horizon 22\n", + "adding: mem time294, current time 315, horizon 21\n", + "adding: mem time295, current time 315, horizon 20\n", + "adding: mem time296, current time 315, horizon 19\n", + "adding: mem time297, current time 315, horizon 18\n", + "adding: mem time298, current time 315, horizon 17\n", + "adding: mem time299, current time 315, horizon 16\n", + "adding: mem time300, current time 315, horizon 15\n", + "adding: mem time301, current time 315, horizon 14\n", + "adding: mem time302, current time 315, horizon 13\n", + "adding: mem time303, current time 315, horizon 12\n", + "adding: mem time304, current time 315, horizon 11\n", + "adding: mem time305, current time 315, horizon 10\n", + "adding: mem time306, current time 315, horizon 9\n", + "adding: mem time307, current time 315, horizon 8\n", + "adding: mem time308, current time 315, horizon 7\n", + "adding: mem time309, current time 315, horizon 6\n", + "adding: mem time310, current time 315, horizon 5\n", + "adding: mem time311, current time 315, horizon 4\n", + "adding: mem time312, current time 315, horizon 3\n", + "adding: mem time313, current time 315, horizon 2\n", + "adding: mem time314, current time 315, horizon 1\n", + "adding: mem time200, current time 316, horizon 116\n", + "adding: mem time201, current time 316, horizon 115\n", + "adding: mem time202, current time 316, horizon 114\n", + "adding: mem time203, current time 316, horizon 113\n", + "adding: mem time204, current time 316, horizon 112\n", + "adding: mem time205, current time 316, horizon 111\n", + "adding: mem time206, current time 316, horizon 110\n", + "adding: mem time207, current time 316, horizon 109\n", + "adding: mem time208, current time 316, horizon 108\n", + "adding: mem time209, current time 316, horizon 107\n", + "adding: mem time210, current time 316, horizon 106\n", + "adding: mem time211, current time 316, horizon 105\n", + "adding: mem time212, current time 316, horizon 104\n", + "adding: mem time213, current time 316, horizon 103\n", + "adding: mem time214, current time 316, horizon 102\n", + "adding: mem time215, current time 316, horizon 101\n", + "adding: mem time216, current time 316, horizon 100\n", + "adding: mem time217, current time 316, horizon 99\n", + "adding: mem time218, current time 316, horizon 98\n", + "adding: mem time219, current time 316, horizon 97\n", + "adding: mem time220, current time 316, horizon 96\n", + "adding: mem time221, current time 316, horizon 95\n", + "adding: mem time222, current time 316, horizon 94\n", + "adding: mem time223, current time 316, horizon 93\n", + "adding: mem time224, current time 316, horizon 92\n", + "adding: mem time225, current time 316, horizon 91\n", + "adding: mem time226, current time 316, horizon 90\n", + "adding: mem time227, current time 316, horizon 89\n", + "adding: mem time228, current time 316, horizon 88\n", + "adding: mem time229, current time 316, horizon 87\n", + "adding: mem time230, current time 316, horizon 86\n", + "adding: mem time231, current time 316, horizon 85\n", + "adding: mem time232, current time 316, horizon 84\n", + "adding: mem time233, current time 316, horizon 83\n", + "adding: mem time234, current time 316, horizon 82\n", + "adding: mem time235, current time 316, horizon 81\n", + "adding: mem time236, current time 316, horizon 80\n", + "adding: mem time237, current time 316, horizon 79\n", + "adding: mem time238, current time 316, horizon 78\n", + "adding: mem time239, current time 316, horizon 77\n", + "adding: mem time240, current time 316, horizon 76\n", + "adding: mem time241, current time 316, horizon 75\n", + "adding: mem time242, current time 316, horizon 74\n", + "adding: mem time243, current time 316, horizon 73\n", + "adding: mem time244, current time 316, horizon 72\n", + "adding: mem time245, current time 316, horizon 71\n", + "adding: mem time246, current time 316, horizon 70\n", + "adding: mem time247, current time 316, horizon 69\n", + "adding: mem time248, current time 316, horizon 68\n", + "adding: mem time249, current time 316, horizon 67\n", + "adding: mem time250, current time 316, horizon 66\n", + "adding: mem time251, current time 316, horizon 65\n", + "adding: mem time252, current time 316, horizon 64\n", + "adding: mem time253, current time 316, horizon 63\n", + "adding: mem time254, current time 316, horizon 62\n", + "adding: mem time255, current time 316, horizon 61\n", + "adding: mem time256, current time 316, horizon 60\n", + "adding: mem time257, current time 316, horizon 59\n", + "adding: mem time258, current time 316, horizon 58\n", + "adding: mem time259, current time 316, horizon 57\n", + "adding: mem time260, current time 316, horizon 56\n", + "adding: mem time261, current time 316, horizon 55\n", + "adding: mem time262, current time 316, horizon 54\n", + "adding: mem time263, current time 316, horizon 53\n", + "adding: mem time264, current time 316, horizon 52\n", + "adding: mem time265, current time 316, horizon 51\n", + "adding: mem time266, current time 316, horizon 50\n", + "adding: mem time267, current time 316, horizon 49\n", + "adding: mem time268, current time 316, horizon 48\n", + "adding: mem time269, current time 316, horizon 47\n", + "adding: mem time270, current time 316, horizon 46\n", + "adding: mem time271, current time 316, horizon 45\n", + "adding: mem time272, current time 316, horizon 44\n", + "adding: mem time273, current time 316, horizon 43\n", + "adding: mem time274, current time 316, horizon 42\n", + "adding: mem time275, current time 316, horizon 41\n", + "adding: mem time276, current time 316, horizon 40\n", + "adding: mem time277, current time 316, horizon 39\n", + "adding: mem time278, current time 316, horizon 38\n", + "adding: mem time279, current time 316, horizon 37\n", + "adding: mem time280, current time 316, horizon 36\n", + "adding: mem time281, current time 316, horizon 35\n", + "adding: mem time282, current time 316, horizon 34\n", + "adding: mem time283, current time 316, horizon 33\n", + "adding: mem time284, current time 316, horizon 32\n", + "adding: mem time285, current time 316, horizon 31\n", + "adding: mem time286, current time 316, horizon 30\n", + "adding: mem time287, current time 316, horizon 29\n", + "adding: mem time288, current time 316, horizon 28\n", + "adding: mem time289, current time 316, horizon 27\n", + "adding: mem time290, current time 316, horizon 26\n", + "adding: mem time291, current time 316, horizon 25\n", + "adding: mem time292, current time 316, horizon 24\n", + "adding: mem time293, current time 316, horizon 23\n", + "adding: mem time294, current time 316, horizon 22\n", + "adding: mem time295, current time 316, horizon 21\n", + "adding: mem time296, current time 316, horizon 20\n", + "adding: mem time297, current time 316, horizon 19\n", + "adding: mem time298, current time 316, horizon 18\n", + "adding: mem time299, current time 316, horizon 17\n", + "adding: mem time300, current time 316, horizon 16\n", + "adding: mem time301, current time 316, horizon 15\n", + "adding: mem time302, current time 316, horizon 14\n", + "adding: mem time303, current time 316, horizon 13\n", + "adding: mem time304, current time 316, horizon 12\n", + "adding: mem time305, current time 316, horizon 11\n", + "adding: mem time306, current time 316, horizon 10\n", + "adding: mem time307, current time 316, horizon 9\n", + "adding: mem time308, current time 316, horizon 8\n", + "adding: mem time309, current time 316, horizon 7\n", + "adding: mem time310, current time 316, horizon 6\n", + "adding: mem time311, current time 316, horizon 5\n", + "adding: mem time312, current time 316, horizon 4\n", + "adding: mem time313, current time 316, horizon 3\n", + "adding: mem time314, current time 316, horizon 2\n", + "adding: mem time315, current time 316, horizon 1\n", + "adding: mem time200, current time 317, horizon 117\n", + "adding: mem time201, current time 317, horizon 116\n", + "adding: mem time202, current time 317, horizon 115\n", + "adding: mem time203, current time 317, horizon 114\n", + "adding: mem time204, current time 317, horizon 113\n", + "adding: mem time205, current time 317, horizon 112\n", + "adding: mem time206, current time 317, horizon 111\n", + "adding: mem time207, current time 317, horizon 110\n", + "adding: mem time208, current time 317, horizon 109\n", + "adding: mem time209, current time 317, horizon 108\n", + "adding: mem time210, current time 317, horizon 107\n", + "adding: mem time211, current time 317, horizon 106\n", + "adding: mem time212, current time 317, horizon 105\n", + "adding: mem time213, current time 317, horizon 104\n", + "adding: mem time214, current time 317, horizon 103\n", + "adding: mem time215, current time 317, horizon 102\n", + "adding: mem time216, current time 317, horizon 101\n", + "adding: mem time217, current time 317, horizon 100\n", + "adding: mem time218, current time 317, horizon 99\n", + "adding: mem time219, current time 317, horizon 98\n", + "adding: mem time220, current time 317, horizon 97\n", + "adding: mem time221, current time 317, horizon 96\n", + "adding: mem time222, current time 317, horizon 95\n", + "adding: mem time223, current time 317, horizon 94\n", + "adding: mem time224, current time 317, horizon 93\n", + "adding: mem time225, current time 317, horizon 92\n", + "adding: mem time226, current time 317, horizon 91\n", + "adding: mem time227, current time 317, horizon 90\n", + "adding: mem time228, current time 317, horizon 89\n", + "adding: mem time229, current time 317, horizon 88\n", + "adding: mem time230, current time 317, horizon 87\n", + "adding: mem time231, current time 317, horizon 86\n", + "adding: mem time232, current time 317, horizon 85\n", + "adding: mem time233, current time 317, horizon 84\n", + "adding: mem time234, current time 317, horizon 83\n", + "adding: mem time235, current time 317, horizon 82\n", + "adding: mem time236, current time 317, horizon 81\n", + "adding: mem time237, current time 317, horizon 80\n", + "adding: mem time238, current time 317, horizon 79\n", + "adding: mem time239, current time 317, horizon 78\n", + "adding: mem time240, current time 317, horizon 77\n", + "adding: mem time241, current time 317, horizon 76\n", + "adding: mem time242, current time 317, horizon 75\n", + "adding: mem time243, current time 317, horizon 74\n", + "adding: mem time244, current time 317, horizon 73\n", + "adding: mem time245, current time 317, horizon 72\n", + "adding: mem time246, current time 317, horizon 71\n", + "adding: mem time247, current time 317, horizon 70\n", + "adding: mem time248, current time 317, horizon 69\n", + "adding: mem time249, current time 317, horizon 68\n", + "adding: mem time250, current time 317, horizon 67\n", + "adding: mem time251, current time 317, horizon 66\n", + "adding: mem time252, current time 317, horizon 65\n", + "adding: mem time253, current time 317, horizon 64\n", + "adding: mem time254, current time 317, horizon 63\n", + "adding: mem time255, current time 317, horizon 62\n", + "adding: mem time256, current time 317, horizon 61\n", + "adding: mem time257, current time 317, horizon 60\n", + "adding: mem time258, current time 317, horizon 59\n", + "adding: mem time259, current time 317, horizon 58\n", + "adding: mem time260, current time 317, horizon 57\n", + "adding: mem time261, current time 317, horizon 56\n", + "adding: mem time262, current time 317, horizon 55\n", + "adding: mem time263, current time 317, horizon 54\n", + "adding: mem time264, current time 317, horizon 53\n", + "adding: mem time265, current time 317, horizon 52\n", + "adding: mem time266, current time 317, horizon 51\n", + "adding: mem time267, current time 317, horizon 50\n", + "adding: mem time268, current time 317, horizon 49\n", + "adding: mem time269, current time 317, horizon 48\n", + "adding: mem time270, current time 317, horizon 47\n", + "adding: mem time271, current time 317, horizon 46\n", + "adding: mem time272, current time 317, horizon 45\n", + "adding: mem time273, current time 317, horizon 44\n", + "adding: mem time274, current time 317, horizon 43\n", + "adding: mem time275, current time 317, horizon 42\n", + "adding: mem time276, current time 317, horizon 41\n", + "adding: mem time277, current time 317, horizon 40\n", + "adding: mem time278, current time 317, horizon 39\n", + "adding: mem time279, current time 317, horizon 38\n", + "adding: mem time280, current time 317, horizon 37\n", + "adding: mem time281, current time 317, horizon 36\n", + "adding: mem time282, current time 317, horizon 35\n", + "adding: mem time283, current time 317, horizon 34\n", + "adding: mem time284, current time 317, horizon 33\n", + "adding: mem time285, current time 317, horizon 32\n", + "adding: mem time286, current time 317, horizon 31\n", + "adding: mem time287, current time 317, horizon 30\n", + "adding: mem time288, current time 317, horizon 29\n", + "adding: mem time289, current time 317, horizon 28\n", + "adding: mem time290, current time 317, horizon 27\n", + "adding: mem time291, current time 317, horizon 26\n", + "adding: mem time292, current time 317, horizon 25\n", + "adding: mem time293, current time 317, horizon 24\n", + "adding: mem time294, current time 317, horizon 23\n", + "adding: mem time295, current time 317, horizon 22\n", + "adding: mem time296, current time 317, horizon 21\n", + "adding: mem time297, current time 317, horizon 20\n", + "adding: mem time298, current time 317, horizon 19\n", + "adding: mem time299, current time 317, horizon 18\n", + "adding: mem time300, current time 317, horizon 17\n", + "adding: mem time301, current time 317, horizon 16\n", + "adding: mem time302, current time 317, horizon 15\n", + "adding: mem time303, current time 317, horizon 14\n", + "adding: mem time304, current time 317, horizon 13\n", + "adding: mem time305, current time 317, horizon 12\n", + "adding: mem time306, current time 317, horizon 11\n", + "adding: mem time307, current time 317, horizon 10\n", + "adding: mem time308, current time 317, horizon 9\n", + "adding: mem time309, current time 317, horizon 8\n", + "adding: mem time310, current time 317, horizon 7\n", + "adding: mem time311, current time 317, horizon 6\n", + "adding: mem time312, current time 317, horizon 5\n", + "adding: mem time313, current time 317, horizon 4\n", + "adding: mem time314, current time 317, horizon 3\n", + "adding: mem time315, current time 317, horizon 2\n", + "adding: mem time316, current time 317, horizon 1\n", + "adding: mem time200, current time 318, horizon 118\n", + "adding: mem time201, current time 318, horizon 117\n", + "adding: mem time202, current time 318, horizon 116\n", + "adding: mem time203, current time 318, horizon 115\n", + "adding: mem time204, current time 318, horizon 114\n", + "adding: mem time205, current time 318, horizon 113\n", + "adding: mem time206, current time 318, horizon 112\n", + "adding: mem time207, current time 318, horizon 111\n", + "adding: mem time208, current time 318, horizon 110\n", + "adding: mem time209, current time 318, horizon 109\n", + "adding: mem time210, current time 318, horizon 108\n", + "adding: mem time211, current time 318, horizon 107\n", + "adding: mem time212, current time 318, horizon 106\n", + "adding: mem time213, current time 318, horizon 105\n", + "adding: mem time214, current time 318, horizon 104\n", + "adding: mem time215, current time 318, horizon 103\n", + "adding: mem time216, current time 318, horizon 102\n", + "adding: mem time217, current time 318, horizon 101\n", + "adding: mem time218, current time 318, horizon 100\n", + "adding: mem time219, current time 318, horizon 99\n", + "adding: mem time220, current time 318, horizon 98\n", + "adding: mem time221, current time 318, horizon 97\n", + "adding: mem time222, current time 318, horizon 96\n", + "adding: mem time223, current time 318, horizon 95\n", + "adding: mem time224, current time 318, horizon 94\n", + "adding: mem time225, current time 318, horizon 93\n", + "adding: mem time226, current time 318, horizon 92\n", + "adding: mem time227, current time 318, horizon 91\n", + "adding: mem time228, current time 318, horizon 90\n", + "adding: mem time229, current time 318, horizon 89\n", + "adding: mem time230, current time 318, horizon 88\n", + "adding: mem time231, current time 318, horizon 87\n", + "adding: mem time232, current time 318, horizon 86\n", + "adding: mem time233, current time 318, horizon 85\n", + "adding: mem time234, current time 318, horizon 84\n", + "adding: mem time235, current time 318, horizon 83\n", + "adding: mem time236, current time 318, horizon 82\n", + "adding: mem time237, current time 318, horizon 81\n", + "adding: mem time238, current time 318, horizon 80\n", + "adding: mem time239, current time 318, horizon 79\n", + "adding: mem time240, current time 318, horizon 78\n", + "adding: mem time241, current time 318, horizon 77\n", + "adding: mem time242, current time 318, horizon 76\n", + "adding: mem time243, current time 318, horizon 75\n", + "adding: mem time244, current time 318, horizon 74\n", + "adding: mem time245, current time 318, horizon 73\n", + "adding: mem time246, current time 318, horizon 72\n", + "adding: mem time247, current time 318, horizon 71\n", + "adding: mem time248, current time 318, horizon 70\n", + "adding: mem time249, current time 318, horizon 69\n", + "adding: mem time250, current time 318, horizon 68\n", + "adding: mem time251, current time 318, horizon 67\n", + "adding: mem time252, current time 318, horizon 66\n", + "adding: mem time253, current time 318, horizon 65\n", + "adding: mem time254, current time 318, horizon 64\n", + "adding: mem time255, current time 318, horizon 63\n", + "adding: mem time256, current time 318, horizon 62\n", + "adding: mem time257, current time 318, horizon 61\n", + "adding: mem time258, current time 318, horizon 60\n", + "adding: mem time259, current time 318, horizon 59\n", + "adding: mem time260, current time 318, horizon 58\n", + "adding: mem time261, current time 318, horizon 57\n", + "adding: mem time262, current time 318, horizon 56\n", + "adding: mem time263, current time 318, horizon 55\n", + "adding: mem time264, current time 318, horizon 54\n", + "adding: mem time265, current time 318, horizon 53\n", + "adding: mem time266, current time 318, horizon 52\n", + "adding: mem time267, current time 318, horizon 51\n", + "adding: mem time268, current time 318, horizon 50\n", + "adding: mem time269, current time 318, horizon 49\n", + "adding: mem time270, current time 318, horizon 48\n", + "adding: mem time271, current time 318, horizon 47\n", + "adding: mem time272, current time 318, horizon 46\n", + "adding: mem time273, current time 318, horizon 45\n", + "adding: mem time274, current time 318, horizon 44\n", + "adding: mem time275, current time 318, horizon 43\n", + "adding: mem time276, current time 318, horizon 42\n", + "adding: mem time277, current time 318, horizon 41\n", + "adding: mem time278, current time 318, horizon 40\n", + "adding: mem time279, current time 318, horizon 39\n", + "adding: mem time280, current time 318, horizon 38\n", + "adding: mem time281, current time 318, horizon 37\n", + "adding: mem time282, current time 318, horizon 36\n", + "adding: mem time283, current time 318, horizon 35\n", + "adding: mem time284, current time 318, horizon 34\n", + "adding: mem time285, current time 318, horizon 33\n", + "adding: mem time286, current time 318, horizon 32\n", + "adding: mem time287, current time 318, horizon 31\n", + "adding: mem time288, current time 318, horizon 30\n", + "adding: mem time289, current time 318, horizon 29\n", + "adding: mem time290, current time 318, horizon 28\n", + "adding: mem time291, current time 318, horizon 27\n", + "adding: mem time292, current time 318, horizon 26\n", + "adding: mem time293, current time 318, horizon 25\n", + "adding: mem time294, current time 318, horizon 24\n", + "adding: mem time295, current time 318, horizon 23\n", + "adding: mem time296, current time 318, horizon 22\n", + "adding: mem time297, current time 318, horizon 21\n", + "adding: mem time298, current time 318, horizon 20\n", + "adding: mem time299, current time 318, horizon 19\n", + "adding: mem time300, current time 318, horizon 18\n", + "adding: mem time301, current time 318, horizon 17\n", + "adding: mem time302, current time 318, horizon 16\n", + "adding: mem time303, current time 318, horizon 15\n", + "adding: mem time304, current time 318, horizon 14\n", + "adding: mem time305, current time 318, horizon 13\n", + "adding: mem time306, current time 318, horizon 12\n", + "adding: mem time307, current time 318, horizon 11\n", + "adding: mem time308, current time 318, horizon 10\n", + "adding: mem time309, current time 318, horizon 9\n", + "adding: mem time310, current time 318, horizon 8\n", + "adding: mem time311, current time 318, horizon 7\n", + "adding: mem time312, current time 318, horizon 6\n", + "adding: mem time313, current time 318, horizon 5\n", + "adding: mem time314, current time 318, horizon 4\n", + "adding: mem time315, current time 318, horizon 3\n", + "adding: mem time316, current time 318, horizon 2\n", + "adding: mem time317, current time 318, horizon 1\n", + "adding: mem time200, current time 319, horizon 119\n", + "adding: mem time201, current time 319, horizon 118\n", + "adding: mem time202, current time 319, horizon 117\n", + "adding: mem time203, current time 319, horizon 116\n", + "adding: mem time204, current time 319, horizon 115\n", + "adding: mem time205, current time 319, horizon 114\n", + "adding: mem time206, current time 319, horizon 113\n", + "adding: mem time207, current time 319, horizon 112\n", + "adding: mem time208, current time 319, horizon 111\n", + "adding: mem time209, current time 319, horizon 110\n", + "adding: mem time210, current time 319, horizon 109\n", + "adding: mem time211, current time 319, horizon 108\n", + "adding: mem time212, current time 319, horizon 107\n", + "adding: mem time213, current time 319, horizon 106\n", + "adding: mem time214, current time 319, horizon 105\n", + "adding: mem time215, current time 319, horizon 104\n", + "adding: mem time216, current time 319, horizon 103\n", + "adding: mem time217, current time 319, horizon 102\n", + "adding: mem time218, current time 319, horizon 101\n", + "adding: mem time219, current time 319, horizon 100\n", + "adding: mem time220, current time 319, horizon 99\n", + "adding: mem time221, current time 319, horizon 98\n", + "adding: mem time222, current time 319, horizon 97\n", + "adding: mem time223, current time 319, horizon 96\n", + "adding: mem time224, current time 319, horizon 95\n", + "adding: mem time225, current time 319, horizon 94\n", + "adding: mem time226, current time 319, horizon 93\n", + "adding: mem time227, current time 319, horizon 92\n", + "adding: mem time228, current time 319, horizon 91\n", + "adding: mem time229, current time 319, horizon 90\n", + "adding: mem time230, current time 319, horizon 89\n", + "adding: mem time231, current time 319, horizon 88\n", + "adding: mem time232, current time 319, horizon 87\n", + "adding: mem time233, current time 319, horizon 86\n", + "adding: mem time234, current time 319, horizon 85\n", + "adding: mem time235, current time 319, horizon 84\n", + "adding: mem time236, current time 319, horizon 83\n", + "adding: mem time237, current time 319, horizon 82\n", + "adding: mem time238, current time 319, horizon 81\n", + "adding: mem time239, current time 319, horizon 80\n", + "adding: mem time240, current time 319, horizon 79\n", + "adding: mem time241, current time 319, horizon 78\n", + "adding: mem time242, current time 319, horizon 77\n", + "adding: mem time243, current time 319, horizon 76\n", + "adding: mem time244, current time 319, horizon 75\n", + "adding: mem time245, current time 319, horizon 74\n", + "adding: mem time246, current time 319, horizon 73\n", + "adding: mem time247, current time 319, horizon 72\n", + "adding: mem time248, current time 319, horizon 71\n", + "adding: mem time249, current time 319, horizon 70\n", + "adding: mem time250, current time 319, horizon 69\n", + "adding: mem time251, current time 319, horizon 68\n", + "adding: mem time252, current time 319, horizon 67\n", + "adding: mem time253, current time 319, horizon 66\n", + "adding: mem time254, current time 319, horizon 65\n", + "adding: mem time255, current time 319, horizon 64\n", + "adding: mem time256, current time 319, horizon 63\n", + "adding: mem time257, current time 319, horizon 62\n", + "adding: mem time258, current time 319, horizon 61\n", + "adding: mem time259, current time 319, horizon 60\n", + "adding: mem time260, current time 319, horizon 59\n", + "adding: mem time261, current time 319, horizon 58\n", + "adding: mem time262, current time 319, horizon 57\n", + "adding: mem time263, current time 319, horizon 56\n", + "adding: mem time264, current time 319, horizon 55\n", + "adding: mem time265, current time 319, horizon 54\n", + "adding: mem time266, current time 319, horizon 53\n", + "adding: mem time267, current time 319, horizon 52\n", + "adding: mem time268, current time 319, horizon 51\n", + "adding: mem time269, current time 319, horizon 50\n", + "adding: mem time270, current time 319, horizon 49\n", + "adding: mem time271, current time 319, horizon 48\n", + "adding: mem time272, current time 319, horizon 47\n", + "adding: mem time273, current time 319, horizon 46\n", + "adding: mem time274, current time 319, horizon 45\n", + "adding: mem time275, current time 319, horizon 44\n", + "adding: mem time276, current time 319, horizon 43\n", + "adding: mem time277, current time 319, horizon 42\n", + "adding: mem time278, current time 319, horizon 41\n", + "adding: mem time279, current time 319, horizon 40\n", + "adding: mem time280, current time 319, horizon 39\n", + "adding: mem time281, current time 319, horizon 38\n", + "adding: mem time282, current time 319, horizon 37\n", + "adding: mem time283, current time 319, horizon 36\n", + "adding: mem time284, current time 319, horizon 35\n", + "adding: mem time285, current time 319, horizon 34\n", + "adding: mem time286, current time 319, horizon 33\n", + "adding: mem time287, current time 319, horizon 32\n", + "adding: mem time288, current time 319, horizon 31\n", + "adding: mem time289, current time 319, horizon 30\n", + "adding: mem time290, current time 319, horizon 29\n", + "adding: mem time291, current time 319, horizon 28\n", + "adding: mem time292, current time 319, horizon 27\n", + "adding: mem time293, current time 319, horizon 26\n", + "adding: mem time294, current time 319, horizon 25\n", + "adding: mem time295, current time 319, horizon 24\n", + "adding: mem time296, current time 319, horizon 23\n", + "adding: mem time297, current time 319, horizon 22\n", + "adding: mem time298, current time 319, horizon 21\n", + "adding: mem time299, current time 319, horizon 20\n", + "adding: mem time300, current time 319, horizon 19\n", + "adding: mem time301, current time 319, horizon 18\n", + "adding: mem time302, current time 319, horizon 17\n", + "adding: mem time303, current time 319, horizon 16\n", + "adding: mem time304, current time 319, horizon 15\n", + "adding: mem time305, current time 319, horizon 14\n", + "adding: mem time306, current time 319, horizon 13\n", + "adding: mem time307, current time 319, horizon 12\n", + "adding: mem time308, current time 319, horizon 11\n", + "adding: mem time309, current time 319, horizon 10\n", + "adding: mem time310, current time 319, horizon 9\n", + "adding: mem time311, current time 319, horizon 8\n", + "adding: mem time312, current time 319, horizon 7\n", + "adding: mem time313, current time 319, horizon 6\n", + "adding: mem time314, current time 319, horizon 5\n", + "adding: mem time315, current time 319, horizon 4\n", + "adding: mem time316, current time 319, horizon 3\n", + "adding: mem time317, current time 319, horizon 2\n", + "adding: mem time318, current time 319, horizon 1\n", + "adding: mem time200, current time 320, horizon 120\n", + "adding: mem time201, current time 320, horizon 119\n", + "adding: mem time202, current time 320, horizon 118\n", + "adding: mem time203, current time 320, horizon 117\n", + "adding: mem time204, current time 320, horizon 116\n", + "adding: mem time205, current time 320, horizon 115\n", + "adding: mem time206, current time 320, horizon 114\n", + "adding: mem time207, current time 320, horizon 113\n", + "adding: mem time208, current time 320, horizon 112\n", + "adding: mem time209, current time 320, horizon 111\n", + "adding: mem time210, current time 320, horizon 110\n", + "adding: mem time211, current time 320, horizon 109\n", + "adding: mem time212, current time 320, horizon 108\n", + "adding: mem time213, current time 320, horizon 107\n", + "adding: mem time214, current time 320, horizon 106\n", + "adding: mem time215, current time 320, horizon 105\n", + "adding: mem time216, current time 320, horizon 104\n", + "adding: mem time217, current time 320, horizon 103\n", + "adding: mem time218, current time 320, horizon 102\n", + "adding: mem time219, current time 320, horizon 101\n", + "adding: mem time220, current time 320, horizon 100\n", + "adding: mem time221, current time 320, horizon 99\n", + "adding: mem time222, current time 320, horizon 98\n", + "adding: mem time223, current time 320, horizon 97\n", + "adding: mem time224, current time 320, horizon 96\n", + "adding: mem time225, current time 320, horizon 95\n", + "adding: mem time226, current time 320, horizon 94\n", + "adding: mem time227, current time 320, horizon 93\n", + "adding: mem time228, current time 320, horizon 92\n", + "adding: mem time229, current time 320, horizon 91\n", + "adding: mem time230, current time 320, horizon 90\n", + "adding: mem time231, current time 320, horizon 89\n", + "adding: mem time232, current time 320, horizon 88\n", + "adding: mem time233, current time 320, horizon 87\n", + "adding: mem time234, current time 320, horizon 86\n", + "adding: mem time235, current time 320, horizon 85\n", + "adding: mem time236, current time 320, horizon 84\n", + "adding: mem time237, current time 320, horizon 83\n", + "adding: mem time238, current time 320, horizon 82\n", + "adding: mem time239, current time 320, horizon 81\n", + "adding: mem time240, current time 320, horizon 80\n", + "adding: mem time241, current time 320, horizon 79\n", + "adding: mem time242, current time 320, horizon 78\n", + "adding: mem time243, current time 320, horizon 77\n", + "adding: mem time244, current time 320, horizon 76\n", + "adding: mem time245, current time 320, horizon 75\n", + "adding: mem time246, current time 320, horizon 74\n", + "adding: mem time247, current time 320, horizon 73\n", + "adding: mem time248, current time 320, horizon 72\n", + "adding: mem time249, current time 320, horizon 71\n", + "adding: mem time250, current time 320, horizon 70\n", + "adding: mem time251, current time 320, horizon 69\n", + "adding: mem time252, current time 320, horizon 68\n", + "adding: mem time253, current time 320, horizon 67\n", + "adding: mem time254, current time 320, horizon 66\n", + "adding: mem time255, current time 320, horizon 65\n", + "adding: mem time256, current time 320, horizon 64\n", + "adding: mem time257, current time 320, horizon 63\n", + "adding: mem time258, current time 320, horizon 62\n", + "adding: mem time259, current time 320, horizon 61\n", + "adding: mem time260, current time 320, horizon 60\n", + "adding: mem time261, current time 320, horizon 59\n", + "adding: mem time262, current time 320, horizon 58\n", + "adding: mem time263, current time 320, horizon 57\n", + "adding: mem time264, current time 320, horizon 56\n", + "adding: mem time265, current time 320, horizon 55\n", + "adding: mem time266, current time 320, horizon 54\n", + "adding: mem time267, current time 320, horizon 53\n", + "adding: mem time268, current time 320, horizon 52\n", + "adding: mem time269, current time 320, horizon 51\n", + "adding: mem time270, current time 320, horizon 50\n", + "adding: mem time271, current time 320, horizon 49\n", + "adding: mem time272, current time 320, horizon 48\n", + "adding: mem time273, current time 320, horizon 47\n", + "adding: mem time274, current time 320, horizon 46\n", + "adding: mem time275, current time 320, horizon 45\n", + "adding: mem time276, current time 320, horizon 44\n", + "adding: mem time277, current time 320, horizon 43\n", + "adding: mem time278, current time 320, horizon 42\n", + "adding: mem time279, current time 320, horizon 41\n", + "adding: mem time280, current time 320, horizon 40\n", + "adding: mem time281, current time 320, horizon 39\n", + "adding: mem time282, current time 320, horizon 38\n", + "adding: mem time283, current time 320, horizon 37\n", + "adding: mem time284, current time 320, horizon 36\n", + "adding: mem time285, current time 320, horizon 35\n", + "adding: mem time286, current time 320, horizon 34\n", + "adding: mem time287, current time 320, horizon 33\n", + "adding: mem time288, current time 320, horizon 32\n", + "adding: mem time289, current time 320, horizon 31\n", + "adding: mem time290, current time 320, horizon 30\n", + "adding: mem time291, current time 320, horizon 29\n", + "adding: mem time292, current time 320, horizon 28\n", + "adding: mem time293, current time 320, horizon 27\n", + "adding: mem time294, current time 320, horizon 26\n", + "adding: mem time295, current time 320, horizon 25\n", + "adding: mem time296, current time 320, horizon 24\n", + "adding: mem time297, current time 320, horizon 23\n", + "adding: mem time298, current time 320, horizon 22\n", + "adding: mem time299, current time 320, horizon 21\n", + "adding: mem time300, current time 320, horizon 20\n", + "adding: mem time301, current time 320, horizon 19\n", + "adding: mem time302, current time 320, horizon 18\n", + "adding: mem time303, current time 320, horizon 17\n", + "adding: mem time304, current time 320, horizon 16\n", + "adding: mem time305, current time 320, horizon 15\n", + "adding: mem time306, current time 320, horizon 14\n", + "adding: mem time307, current time 320, horizon 13\n", + "adding: mem time308, current time 320, horizon 12\n", + "adding: mem time309, current time 320, horizon 11\n", + "adding: mem time310, current time 320, horizon 10\n", + "adding: mem time311, current time 320, horizon 9\n", + "adding: mem time312, current time 320, horizon 8\n", + "adding: mem time313, current time 320, horizon 7\n", + "adding: mem time314, current time 320, horizon 6\n", + "adding: mem time315, current time 320, horizon 5\n", + "adding: mem time316, current time 320, horizon 4\n", + "adding: mem time317, current time 320, horizon 3\n", + "adding: mem time318, current time 320, horizon 2\n", + "adding: mem time319, current time 320, horizon 1\n", + "adding: mem time200, current time 321, horizon 121\n", + "adding: mem time201, current time 321, horizon 120\n", + "adding: mem time202, current time 321, horizon 119\n", + "adding: mem time203, current time 321, horizon 118\n", + "adding: mem time204, current time 321, horizon 117\n", + "adding: mem time205, current time 321, horizon 116\n", + "adding: mem time206, current time 321, horizon 115\n", + "adding: mem time207, current time 321, horizon 114\n", + "adding: mem time208, current time 321, horizon 113\n", + "adding: mem time209, current time 321, horizon 112\n", + "adding: mem time210, current time 321, horizon 111\n", + "adding: mem time211, current time 321, horizon 110\n", + "adding: mem time212, current time 321, horizon 109\n", + "adding: mem time213, current time 321, horizon 108\n", + "adding: mem time214, current time 321, horizon 107\n", + "adding: mem time215, current time 321, horizon 106\n", + "adding: mem time216, current time 321, horizon 105\n", + "adding: mem time217, current time 321, horizon 104\n", + "adding: mem time218, current time 321, horizon 103\n", + "adding: mem time219, current time 321, horizon 102\n", + "adding: mem time220, current time 321, horizon 101\n", + "adding: mem time221, current time 321, horizon 100\n", + "adding: mem time222, current time 321, horizon 99\n", + "adding: mem time223, current time 321, horizon 98\n", + "adding: mem time224, current time 321, horizon 97\n", + "adding: mem time225, current time 321, horizon 96\n", + "adding: mem time226, current time 321, horizon 95\n", + "adding: mem time227, current time 321, horizon 94\n", + "adding: mem time228, current time 321, horizon 93\n", + "adding: mem time229, current time 321, horizon 92\n", + "adding: mem time230, current time 321, horizon 91\n", + "adding: mem time231, current time 321, horizon 90\n", + "adding: mem time232, current time 321, horizon 89\n", + "adding: mem time233, current time 321, horizon 88\n", + "adding: mem time234, current time 321, horizon 87\n", + "adding: mem time235, current time 321, horizon 86\n", + "adding: mem time236, current time 321, horizon 85\n", + "adding: mem time237, current time 321, horizon 84\n", + "adding: mem time238, current time 321, horizon 83\n", + "adding: mem time239, current time 321, horizon 82\n", + "adding: mem time240, current time 321, horizon 81\n", + "adding: mem time241, current time 321, horizon 80\n", + "adding: mem time242, current time 321, horizon 79\n", + "adding: mem time243, current time 321, horizon 78\n", + "adding: mem time244, current time 321, horizon 77\n", + "adding: mem time245, current time 321, horizon 76\n", + "adding: mem time246, current time 321, horizon 75\n", + "adding: mem time247, current time 321, horizon 74\n", + "adding: mem time248, current time 321, horizon 73\n", + "adding: mem time249, current time 321, horizon 72\n", + "adding: mem time250, current time 321, horizon 71\n", + "adding: mem time251, current time 321, horizon 70\n", + "adding: mem time252, current time 321, horizon 69\n", + "adding: mem time253, current time 321, horizon 68\n", + "adding: mem time254, current time 321, horizon 67\n", + "adding: mem time255, current time 321, horizon 66\n", + "adding: mem time256, current time 321, horizon 65\n", + "adding: mem time257, current time 321, horizon 64\n", + "adding: mem time258, current time 321, horizon 63\n", + "adding: mem time259, current time 321, horizon 62\n", + "adding: mem time260, current time 321, horizon 61\n", + "adding: mem time261, current time 321, horizon 60\n", + "adding: mem time262, current time 321, horizon 59\n", + "adding: mem time263, current time 321, horizon 58\n", + "adding: mem time264, current time 321, horizon 57\n", + "adding: mem time265, current time 321, horizon 56\n", + "adding: mem time266, current time 321, horizon 55\n", + "adding: mem time267, current time 321, horizon 54\n", + "adding: mem time268, current time 321, horizon 53\n", + "adding: mem time269, current time 321, horizon 52\n", + "adding: mem time270, current time 321, horizon 51\n", + "adding: mem time271, current time 321, horizon 50\n", + "adding: mem time272, current time 321, horizon 49\n", + "adding: mem time273, current time 321, horizon 48\n", + "adding: mem time274, current time 321, horizon 47\n", + "adding: mem time275, current time 321, horizon 46\n", + "adding: mem time276, current time 321, horizon 45\n", + "adding: mem time277, current time 321, horizon 44\n", + "adding: mem time278, current time 321, horizon 43\n", + "adding: mem time279, current time 321, horizon 42\n", + "adding: mem time280, current time 321, horizon 41\n", + "adding: mem time281, current time 321, horizon 40\n", + "adding: mem time282, current time 321, horizon 39\n", + "adding: mem time283, current time 321, horizon 38\n", + "adding: mem time284, current time 321, horizon 37\n", + "adding: mem time285, current time 321, horizon 36\n", + "adding: mem time286, current time 321, horizon 35\n", + "adding: mem time287, current time 321, horizon 34\n", + "adding: mem time288, current time 321, horizon 33\n", + "adding: mem time289, current time 321, horizon 32\n", + "adding: mem time290, current time 321, horizon 31\n", + "adding: mem time291, current time 321, horizon 30\n", + "adding: mem time292, current time 321, horizon 29\n", + "adding: mem time293, current time 321, horizon 28\n", + "adding: mem time294, current time 321, horizon 27\n", + "adding: mem time295, current time 321, horizon 26\n", + "adding: mem time296, current time 321, horizon 25\n", + "adding: mem time297, current time 321, horizon 24\n", + "adding: mem time298, current time 321, horizon 23\n", + "adding: mem time299, current time 321, horizon 22\n", + "adding: mem time300, current time 321, horizon 21\n", + "adding: mem time301, current time 321, horizon 20\n", + "adding: mem time302, current time 321, horizon 19\n", + "adding: mem time303, current time 321, horizon 18\n", + "adding: mem time304, current time 321, horizon 17\n", + "adding: mem time305, current time 321, horizon 16\n", + "adding: mem time306, current time 321, horizon 15\n", + "adding: mem time307, current time 321, horizon 14\n", + "adding: mem time308, current time 321, horizon 13\n", + "adding: mem time309, current time 321, horizon 12\n", + "adding: mem time310, current time 321, horizon 11\n", + "adding: mem time311, current time 321, horizon 10\n", + "adding: mem time312, current time 321, horizon 9\n", + "adding: mem time313, current time 321, horizon 8\n", + "adding: mem time314, current time 321, horizon 7\n", + "adding: mem time315, current time 321, horizon 6\n", + "adding: mem time316, current time 321, horizon 5\n", + "adding: mem time317, current time 321, horizon 4\n", + "adding: mem time318, current time 321, horizon 3\n", + "adding: mem time319, current time 321, horizon 2\n", + "adding: mem time320, current time 321, horizon 1\n", + "adding: mem time200, current time 322, horizon 122\n", + "adding: mem time201, current time 322, horizon 121\n", + "adding: mem time202, current time 322, horizon 120\n", + "adding: mem time203, current time 322, horizon 119\n", + "adding: mem time204, current time 322, horizon 118\n", + "adding: mem time205, current time 322, horizon 117\n", + "adding: mem time206, current time 322, horizon 116\n", + "adding: mem time207, current time 322, horizon 115\n", + "adding: mem time208, current time 322, horizon 114\n", + "adding: mem time209, current time 322, horizon 113\n", + "adding: mem time210, current time 322, horizon 112\n", + "adding: mem time211, current time 322, horizon 111\n", + "adding: mem time212, current time 322, horizon 110\n", + "adding: mem time213, current time 322, horizon 109\n", + "adding: mem time214, current time 322, horizon 108\n", + "adding: mem time215, current time 322, horizon 107\n", + "adding: mem time216, current time 322, horizon 106\n", + "adding: mem time217, current time 322, horizon 105\n", + "adding: mem time218, current time 322, horizon 104\n", + "adding: mem time219, current time 322, horizon 103\n", + "adding: mem time220, current time 322, horizon 102\n", + "adding: mem time221, current time 322, horizon 101\n", + "adding: mem time222, current time 322, horizon 100\n", + "adding: mem time223, current time 322, horizon 99\n", + "adding: mem time224, current time 322, horizon 98\n", + "adding: mem time225, current time 322, horizon 97\n", + "adding: mem time226, current time 322, horizon 96\n", + "adding: mem time227, current time 322, horizon 95\n", + "adding: mem time228, current time 322, horizon 94\n", + "adding: mem time229, current time 322, horizon 93\n", + "adding: mem time230, current time 322, horizon 92\n", + "adding: mem time231, current time 322, horizon 91\n", + "adding: mem time232, current time 322, horizon 90\n", + "adding: mem time233, current time 322, horizon 89\n", + "adding: mem time234, current time 322, horizon 88\n", + "adding: mem time235, current time 322, horizon 87\n", + "adding: mem time236, current time 322, horizon 86\n", + "adding: mem time237, current time 322, horizon 85\n", + "adding: mem time238, current time 322, horizon 84\n", + "adding: mem time239, current time 322, horizon 83\n", + "adding: mem time240, current time 322, horizon 82\n", + "adding: mem time241, current time 322, horizon 81\n", + "adding: mem time242, current time 322, horizon 80\n", + "adding: mem time243, current time 322, horizon 79\n", + "adding: mem time244, current time 322, horizon 78\n", + "adding: mem time245, current time 322, horizon 77\n", + "adding: mem time246, current time 322, horizon 76\n", + "adding: mem time247, current time 322, horizon 75\n", + "adding: mem time248, current time 322, horizon 74\n", + "adding: mem time249, current time 322, horizon 73\n", + "adding: mem time250, current time 322, horizon 72\n", + "adding: mem time251, current time 322, horizon 71\n", + "adding: mem time252, current time 322, horizon 70\n", + "adding: mem time253, current time 322, horizon 69\n", + "adding: mem time254, current time 322, horizon 68\n", + "adding: mem time255, current time 322, horizon 67\n", + "adding: mem time256, current time 322, horizon 66\n", + "adding: mem time257, current time 322, horizon 65\n", + "adding: mem time258, current time 322, horizon 64\n", + "adding: mem time259, current time 322, horizon 63\n", + "adding: mem time260, current time 322, horizon 62\n", + "adding: mem time261, current time 322, horizon 61\n", + "adding: mem time262, current time 322, horizon 60\n", + "adding: mem time263, current time 322, horizon 59\n", + "adding: mem time264, current time 322, horizon 58\n", + "adding: mem time265, current time 322, horizon 57\n", + "adding: mem time266, current time 322, horizon 56\n", + "adding: mem time267, current time 322, horizon 55\n", + "adding: mem time268, current time 322, horizon 54\n", + "adding: mem time269, current time 322, horizon 53\n", + "adding: mem time270, current time 322, horizon 52\n", + "adding: mem time271, current time 322, horizon 51\n", + "adding: mem time272, current time 322, horizon 50\n", + "adding: mem time273, current time 322, horizon 49\n", + "adding: mem time274, current time 322, horizon 48\n", + "adding: mem time275, current time 322, horizon 47\n", + "adding: mem time276, current time 322, horizon 46\n", + "adding: mem time277, current time 322, horizon 45\n", + "adding: mem time278, current time 322, horizon 44\n", + "adding: mem time279, current time 322, horizon 43\n", + "adding: mem time280, current time 322, horizon 42\n", + "adding: mem time281, current time 322, horizon 41\n", + "adding: mem time282, current time 322, horizon 40\n", + "adding: mem time283, current time 322, horizon 39\n", + "adding: mem time284, current time 322, horizon 38\n", + "adding: mem time285, current time 322, horizon 37\n", + "adding: mem time286, current time 322, horizon 36\n", + "adding: mem time287, current time 322, horizon 35\n", + "adding: mem time288, current time 322, horizon 34\n", + "adding: mem time289, current time 322, horizon 33\n", + "adding: mem time290, current time 322, horizon 32\n", + "adding: mem time291, current time 322, horizon 31\n", + "adding: mem time292, current time 322, horizon 30\n", + "adding: mem time293, current time 322, horizon 29\n", + "adding: mem time294, current time 322, horizon 28\n", + "adding: mem time295, current time 322, horizon 27\n", + "adding: mem time296, current time 322, horizon 26\n", + "adding: mem time297, current time 322, horizon 25\n", + "adding: mem time298, current time 322, horizon 24\n", + "adding: mem time299, current time 322, horizon 23\n", + "adding: mem time300, current time 322, horizon 22\n", + "adding: mem time301, current time 322, horizon 21\n", + "adding: mem time302, current time 322, horizon 20\n", + "adding: mem time303, current time 322, horizon 19\n", + "adding: mem time304, current time 322, horizon 18\n", + "adding: mem time305, current time 322, horizon 17\n", + "adding: mem time306, current time 322, horizon 16\n", + "adding: mem time307, current time 322, horizon 15\n", + "adding: mem time308, current time 322, horizon 14\n", + "adding: mem time309, current time 322, horizon 13\n", + "adding: mem time310, current time 322, horizon 12\n", + "adding: mem time311, current time 322, horizon 11\n", + "adding: mem time312, current time 322, horizon 10\n", + "adding: mem time313, current time 322, horizon 9\n", + "adding: mem time314, current time 322, horizon 8\n", + "adding: mem time315, current time 322, horizon 7\n", + "adding: mem time316, current time 322, horizon 6\n", + "adding: mem time317, current time 322, horizon 5\n", + "adding: mem time318, current time 322, horizon 4\n", + "adding: mem time319, current time 322, horizon 3\n", + "adding: mem time320, current time 322, horizon 2\n", + "adding: mem time321, current time 322, horizon 1\n", + "adding: mem time200, current time 323, horizon 123\n", + "adding: mem time201, current time 323, horizon 122\n", + "adding: mem time202, current time 323, horizon 121\n", + "adding: mem time203, current time 323, horizon 120\n", + "adding: mem time204, current time 323, horizon 119\n", + "adding: mem time205, current time 323, horizon 118\n", + "adding: mem time206, current time 323, horizon 117\n", + "adding: mem time207, current time 323, horizon 116\n", + "adding: mem time208, current time 323, horizon 115\n", + "adding: mem time209, current time 323, horizon 114\n", + "adding: mem time210, current time 323, horizon 113\n", + "adding: mem time211, current time 323, horizon 112\n", + "adding: mem time212, current time 323, horizon 111\n", + "adding: mem time213, current time 323, horizon 110\n", + "adding: mem time214, current time 323, horizon 109\n", + "adding: mem time215, current time 323, horizon 108\n", + "adding: mem time216, current time 323, horizon 107\n", + "adding: mem time217, current time 323, horizon 106\n", + "adding: mem time218, current time 323, horizon 105\n", + "adding: mem time219, current time 323, horizon 104\n", + "adding: mem time220, current time 323, horizon 103\n", + "adding: mem time221, current time 323, horizon 102\n", + "adding: mem time222, current time 323, horizon 101\n", + "adding: mem time223, current time 323, horizon 100\n", + "adding: mem time224, current time 323, horizon 99\n", + "adding: mem time225, current time 323, horizon 98\n", + "adding: mem time226, current time 323, horizon 97\n", + "adding: mem time227, current time 323, horizon 96\n", + "adding: mem time228, current time 323, horizon 95\n", + "adding: mem time229, current time 323, horizon 94\n", + "adding: mem time230, current time 323, horizon 93\n", + "adding: mem time231, current time 323, horizon 92\n", + "adding: mem time232, current time 323, horizon 91\n", + "adding: mem time233, current time 323, horizon 90\n", + "adding: mem time234, current time 323, horizon 89\n", + "adding: mem time235, current time 323, horizon 88\n", + "adding: mem time236, current time 323, horizon 87\n", + "adding: mem time237, current time 323, horizon 86\n", + "adding: mem time238, current time 323, horizon 85\n", + "adding: mem time239, current time 323, horizon 84\n", + "adding: mem time240, current time 323, horizon 83\n", + "adding: mem time241, current time 323, horizon 82\n", + "adding: mem time242, current time 323, horizon 81\n", + "adding: mem time243, current time 323, horizon 80\n", + "adding: mem time244, current time 323, horizon 79\n", + "adding: mem time245, current time 323, horizon 78\n", + "adding: mem time246, current time 323, horizon 77\n", + "adding: mem time247, current time 323, horizon 76\n", + "adding: mem time248, current time 323, horizon 75\n", + "adding: mem time249, current time 323, horizon 74\n", + "adding: mem time250, current time 323, horizon 73\n", + "adding: mem time251, current time 323, horizon 72\n", + "adding: mem time252, current time 323, horizon 71\n", + "adding: mem time253, current time 323, horizon 70\n", + "adding: mem time254, current time 323, horizon 69\n", + "adding: mem time255, current time 323, horizon 68\n", + "adding: mem time256, current time 323, horizon 67\n", + "adding: mem time257, current time 323, horizon 66\n", + "adding: mem time258, current time 323, horizon 65\n", + "adding: mem time259, current time 323, horizon 64\n", + "adding: mem time260, current time 323, horizon 63\n", + "adding: mem time261, current time 323, horizon 62\n", + "adding: mem time262, current time 323, horizon 61\n", + "adding: mem time263, current time 323, horizon 60\n", + "adding: mem time264, current time 323, horizon 59\n", + "adding: mem time265, current time 323, horizon 58\n", + "adding: mem time266, current time 323, horizon 57\n", + "adding: mem time267, current time 323, horizon 56\n", + "adding: mem time268, current time 323, horizon 55\n", + "adding: mem time269, current time 323, horizon 54\n", + "adding: mem time270, current time 323, horizon 53\n", + "adding: mem time271, current time 323, horizon 52\n", + "adding: mem time272, current time 323, horizon 51\n", + "adding: mem time273, current time 323, horizon 50\n", + "adding: mem time274, current time 323, horizon 49\n", + "adding: mem time275, current time 323, horizon 48\n", + "adding: mem time276, current time 323, horizon 47\n", + "adding: mem time277, current time 323, horizon 46\n", + "adding: mem time278, current time 323, horizon 45\n", + "adding: mem time279, current time 323, horizon 44\n", + "adding: mem time280, current time 323, horizon 43\n", + "adding: mem time281, current time 323, horizon 42\n", + "adding: mem time282, current time 323, horizon 41\n", + "adding: mem time283, current time 323, horizon 40\n", + "adding: mem time284, current time 323, horizon 39\n", + "adding: mem time285, current time 323, horizon 38\n", + "adding: mem time286, current time 323, horizon 37\n", + "adding: mem time287, current time 323, horizon 36\n", + "adding: mem time288, current time 323, horizon 35\n", + "adding: mem time289, current time 323, horizon 34\n", + "adding: mem time290, current time 323, horizon 33\n", + "adding: mem time291, current time 323, horizon 32\n", + "adding: mem time292, current time 323, horizon 31\n", + "adding: mem time293, current time 323, horizon 30\n", + "adding: mem time294, current time 323, horizon 29\n", + "adding: mem time295, current time 323, horizon 28\n", + "adding: mem time296, current time 323, horizon 27\n", + "adding: mem time297, current time 323, horizon 26\n", + "adding: mem time298, current time 323, horizon 25\n", + "adding: mem time299, current time 323, horizon 24\n", + "adding: mem time300, current time 323, horizon 23\n", + "adding: mem time301, current time 323, horizon 22\n", + "adding: mem time302, current time 323, horizon 21\n", + "adding: mem time303, current time 323, horizon 20\n", + "adding: mem time304, current time 323, horizon 19\n", + "adding: mem time305, current time 323, horizon 18\n", + "adding: mem time306, current time 323, horizon 17\n", + "adding: mem time307, current time 323, horizon 16\n", + "adding: mem time308, current time 323, horizon 15\n", + "adding: mem time309, current time 323, horizon 14\n", + "adding: mem time310, current time 323, horizon 13\n", + "adding: mem time311, current time 323, horizon 12\n", + "adding: mem time312, current time 323, horizon 11\n", + "adding: mem time313, current time 323, horizon 10\n", + "adding: mem time314, current time 323, horizon 9\n", + "adding: mem time315, current time 323, horizon 8\n", + "adding: mem time316, current time 323, horizon 7\n", + "adding: mem time317, current time 323, horizon 6\n", + "adding: mem time318, current time 323, horizon 5\n", + "adding: mem time319, current time 323, horizon 4\n", + "adding: mem time320, current time 323, horizon 3\n", + "adding: mem time321, current time 323, horizon 2\n", + "adding: mem time322, current time 323, horizon 1\n", + "adding: mem time200, current time 324, horizon 124\n", + "adding: mem time201, current time 324, horizon 123\n", + "adding: mem time202, current time 324, horizon 122\n", + "adding: mem time203, current time 324, horizon 121\n", + "adding: mem time204, current time 324, horizon 120\n", + "adding: mem time205, current time 324, horizon 119\n", + "adding: mem time206, current time 324, horizon 118\n", + "adding: mem time207, current time 324, horizon 117\n", + "adding: mem time208, current time 324, horizon 116\n", + "adding: mem time209, current time 324, horizon 115\n", + "adding: mem time210, current time 324, horizon 114\n", + "adding: mem time211, current time 324, horizon 113\n", + "adding: mem time212, current time 324, horizon 112\n", + "adding: mem time213, current time 324, horizon 111\n", + "adding: mem time214, current time 324, horizon 110\n", + "adding: mem time215, current time 324, horizon 109\n", + "adding: mem time216, current time 324, horizon 108\n", + "adding: mem time217, current time 324, horizon 107\n", + "adding: mem time218, current time 324, horizon 106\n", + "adding: mem time219, current time 324, horizon 105\n", + "adding: mem time220, current time 324, horizon 104\n", + "adding: mem time221, current time 324, horizon 103\n", + "adding: mem time222, current time 324, horizon 102\n", + "adding: mem time223, current time 324, horizon 101\n", + "adding: mem time224, current time 324, horizon 100\n", + "adding: mem time225, current time 324, horizon 99\n", + "adding: mem time226, current time 324, horizon 98\n", + "adding: mem time227, current time 324, horizon 97\n", + "adding: mem time228, current time 324, horizon 96\n", + "adding: mem time229, current time 324, horizon 95\n", + "adding: mem time230, current time 324, horizon 94\n", + "adding: mem time231, current time 324, horizon 93\n", + "adding: mem time232, current time 324, horizon 92\n", + "adding: mem time233, current time 324, horizon 91\n", + "adding: mem time234, current time 324, horizon 90\n", + "adding: mem time235, current time 324, horizon 89\n", + "adding: mem time236, current time 324, horizon 88\n", + "adding: mem time237, current time 324, horizon 87\n", + "adding: mem time238, current time 324, horizon 86\n", + "adding: mem time239, current time 324, horizon 85\n", + "adding: mem time240, current time 324, horizon 84\n", + "adding: mem time241, current time 324, horizon 83\n", + "adding: mem time242, current time 324, horizon 82\n", + "adding: mem time243, current time 324, horizon 81\n", + "adding: mem time244, current time 324, horizon 80\n", + "adding: mem time245, current time 324, horizon 79\n", + "adding: mem time246, current time 324, horizon 78\n", + "adding: mem time247, current time 324, horizon 77\n", + "adding: mem time248, current time 324, horizon 76\n", + "adding: mem time249, current time 324, horizon 75\n", + "adding: mem time250, current time 324, horizon 74\n", + "adding: mem time251, current time 324, horizon 73\n", + "adding: mem time252, current time 324, horizon 72\n", + "adding: mem time253, current time 324, horizon 71\n", + "adding: mem time254, current time 324, horizon 70\n", + "adding: mem time255, current time 324, horizon 69\n", + "adding: mem time256, current time 324, horizon 68\n", + "adding: mem time257, current time 324, horizon 67\n", + "adding: mem time258, current time 324, horizon 66\n", + "adding: mem time259, current time 324, horizon 65\n", + "adding: mem time260, current time 324, horizon 64\n", + "adding: mem time261, current time 324, horizon 63\n", + "adding: mem time262, current time 324, horizon 62\n", + "adding: mem time263, current time 324, horizon 61\n", + "adding: mem time264, current time 324, horizon 60\n", + "adding: mem time265, current time 324, horizon 59\n", + "adding: mem time266, current time 324, horizon 58\n", + "adding: mem time267, current time 324, horizon 57\n", + "adding: mem time268, current time 324, horizon 56\n", + "adding: mem time269, current time 324, horizon 55\n", + "adding: mem time270, current time 324, horizon 54\n", + "adding: mem time271, current time 324, horizon 53\n", + "adding: mem time272, current time 324, horizon 52\n", + "adding: mem time273, current time 324, horizon 51\n", + "adding: mem time274, current time 324, horizon 50\n", + "adding: mem time275, current time 324, horizon 49\n", + "adding: mem time276, current time 324, horizon 48\n", + "adding: mem time277, current time 324, horizon 47\n", + "adding: mem time278, current time 324, horizon 46\n", + "adding: mem time279, current time 324, horizon 45\n", + "adding: mem time280, current time 324, horizon 44\n", + "adding: mem time281, current time 324, horizon 43\n", + "adding: mem time282, current time 324, horizon 42\n", + "adding: mem time283, current time 324, horizon 41\n", + "adding: mem time284, current time 324, horizon 40\n", + "adding: mem time285, current time 324, horizon 39\n", + "adding: mem time286, current time 324, horizon 38\n", + "adding: mem time287, current time 324, horizon 37\n", + "adding: mem time288, current time 324, horizon 36\n", + "adding: mem time289, current time 324, horizon 35\n", + "adding: mem time290, current time 324, horizon 34\n", + "adding: mem time291, current time 324, horizon 33\n", + "adding: mem time292, current time 324, horizon 32\n", + "adding: mem time293, current time 324, horizon 31\n", + "adding: mem time294, current time 324, horizon 30\n", + "adding: mem time295, current time 324, horizon 29\n", + "adding: mem time296, current time 324, horizon 28\n", + "adding: mem time297, current time 324, horizon 27\n", + "adding: mem time298, current time 324, horizon 26\n", + "adding: mem time299, current time 324, horizon 25\n", + "adding: mem time300, current time 324, horizon 24\n", + "adding: mem time301, current time 324, horizon 23\n", + "adding: mem time302, current time 324, horizon 22\n", + "adding: mem time303, current time 324, horizon 21\n", + "adding: mem time304, current time 324, horizon 20\n", + "adding: mem time305, current time 324, horizon 19\n", + "adding: mem time306, current time 324, horizon 18\n", + "adding: mem time307, current time 324, horizon 17\n", + "adding: mem time308, current time 324, horizon 16\n", + "adding: mem time309, current time 324, horizon 15\n", + "adding: mem time310, current time 324, horizon 14\n", + "adding: mem time311, current time 324, horizon 13\n", + "adding: mem time312, current time 324, horizon 12\n", + "adding: mem time313, current time 324, horizon 11\n", + "adding: mem time314, current time 324, horizon 10\n", + "adding: mem time315, current time 324, horizon 9\n", + "adding: mem time316, current time 324, horizon 8\n", + "adding: mem time317, current time 324, horizon 7\n", + "adding: mem time318, current time 324, horizon 6\n", + "adding: mem time319, current time 324, horizon 5\n", + "adding: mem time320, current time 324, horizon 4\n", + "adding: mem time321, current time 324, horizon 3\n", + "adding: mem time322, current time 324, horizon 2\n", + "adding: mem time323, current time 324, horizon 1\n", + "adding: mem time200, current time 325, horizon 125\n", + "adding: mem time201, current time 325, horizon 124\n", + "adding: mem time202, current time 325, horizon 123\n", + "adding: mem time203, current time 325, horizon 122\n", + "adding: mem time204, current time 325, horizon 121\n", + "adding: mem time205, current time 325, horizon 120\n", + "adding: mem time206, current time 325, horizon 119\n", + "adding: mem time207, current time 325, horizon 118\n", + "adding: mem time208, current time 325, horizon 117\n", + "adding: mem time209, current time 325, horizon 116\n", + "adding: mem time210, current time 325, horizon 115\n", + "adding: mem time211, current time 325, horizon 114\n", + "adding: mem time212, current time 325, horizon 113\n", + "adding: mem time213, current time 325, horizon 112\n", + "adding: mem time214, current time 325, horizon 111\n", + "adding: mem time215, current time 325, horizon 110\n", + "adding: mem time216, current time 325, horizon 109\n", + "adding: mem time217, current time 325, horizon 108\n", + "adding: mem time218, current time 325, horizon 107\n", + "adding: mem time219, current time 325, horizon 106\n", + "adding: mem time220, current time 325, horizon 105\n", + "adding: mem time221, current time 325, horizon 104\n", + "adding: mem time222, current time 325, horizon 103\n", + "adding: mem time223, current time 325, horizon 102\n", + "adding: mem time224, current time 325, horizon 101\n", + "adding: mem time225, current time 325, horizon 100\n", + "adding: mem time226, current time 325, horizon 99\n", + "adding: mem time227, current time 325, horizon 98\n", + "adding: mem time228, current time 325, horizon 97\n", + "adding: mem time229, current time 325, horizon 96\n", + "adding: mem time230, current time 325, horizon 95\n", + "adding: mem time231, current time 325, horizon 94\n", + "adding: mem time232, current time 325, horizon 93\n", + "adding: mem time233, current time 325, horizon 92\n", + "adding: mem time234, current time 325, horizon 91\n", + "adding: mem time235, current time 325, horizon 90\n", + "adding: mem time236, current time 325, horizon 89\n", + "adding: mem time237, current time 325, horizon 88\n", + "adding: mem time238, current time 325, horizon 87\n", + "adding: mem time239, current time 325, horizon 86\n", + "adding: mem time240, current time 325, horizon 85\n", + "adding: mem time241, current time 325, horizon 84\n", + "adding: mem time242, current time 325, horizon 83\n", + "adding: mem time243, current time 325, horizon 82\n", + "adding: mem time244, current time 325, horizon 81\n", + "adding: mem time245, current time 325, horizon 80\n", + "adding: mem time246, current time 325, horizon 79\n", + "adding: mem time247, current time 325, horizon 78\n", + "adding: mem time248, current time 325, horizon 77\n", + "adding: mem time249, current time 325, horizon 76\n", + "adding: mem time250, current time 325, horizon 75\n", + "adding: mem time251, current time 325, horizon 74\n", + "adding: mem time252, current time 325, horizon 73\n", + "adding: mem time253, current time 325, horizon 72\n", + "adding: mem time254, current time 325, horizon 71\n", + "adding: mem time255, current time 325, horizon 70\n", + "adding: mem time256, current time 325, horizon 69\n", + "adding: mem time257, current time 325, horizon 68\n", + "adding: mem time258, current time 325, horizon 67\n", + "adding: mem time259, current time 325, horizon 66\n", + "adding: mem time260, current time 325, horizon 65\n", + "adding: mem time261, current time 325, horizon 64\n", + "adding: mem time262, current time 325, horizon 63\n", + "adding: mem time263, current time 325, horizon 62\n", + "adding: mem time264, current time 325, horizon 61\n", + "adding: mem time265, current time 325, horizon 60\n", + "adding: mem time266, current time 325, horizon 59\n", + "adding: mem time267, current time 325, horizon 58\n", + "adding: mem time268, current time 325, horizon 57\n", + "adding: mem time269, current time 325, horizon 56\n", + "adding: mem time270, current time 325, horizon 55\n", + "adding: mem time271, current time 325, horizon 54\n", + "adding: mem time272, current time 325, horizon 53\n", + "adding: mem time273, current time 325, horizon 52\n", + "adding: mem time274, current time 325, horizon 51\n", + "adding: mem time275, current time 325, horizon 50\n", + "adding: mem time276, current time 325, horizon 49\n", + "adding: mem time277, current time 325, horizon 48\n", + "adding: mem time278, current time 325, horizon 47\n", + "adding: mem time279, current time 325, horizon 46\n", + "adding: mem time280, current time 325, horizon 45\n", + "adding: mem time281, current time 325, horizon 44\n", + "adding: mem time282, current time 325, horizon 43\n", + "adding: mem time283, current time 325, horizon 42\n", + "adding: mem time284, current time 325, horizon 41\n", + "adding: mem time285, current time 325, horizon 40\n", + "adding: mem time286, current time 325, horizon 39\n", + "adding: mem time287, current time 325, horizon 38\n", + "adding: mem time288, current time 325, horizon 37\n", + "adding: mem time289, current time 325, horizon 36\n", + "adding: mem time290, current time 325, horizon 35\n", + "adding: mem time291, current time 325, horizon 34\n", + "adding: mem time292, current time 325, horizon 33\n", + "adding: mem time293, current time 325, horizon 32\n", + "adding: mem time294, current time 325, horizon 31\n", + "adding: mem time295, current time 325, horizon 30\n", + "adding: mem time296, current time 325, horizon 29\n", + "adding: mem time297, current time 325, horizon 28\n", + "adding: mem time298, current time 325, horizon 27\n", + "adding: mem time299, current time 325, horizon 26\n", + "adding: mem time300, current time 325, horizon 25\n", + "adding: mem time301, current time 325, horizon 24\n", + "adding: mem time302, current time 325, horizon 23\n", + "adding: mem time303, current time 325, horizon 22\n", + "adding: mem time304, current time 325, horizon 21\n", + "adding: mem time305, current time 325, horizon 20\n", + "adding: mem time306, current time 325, horizon 19\n", + "adding: mem time307, current time 325, horizon 18\n", + "adding: mem time308, current time 325, horizon 17\n", + "adding: mem time309, current time 325, horizon 16\n", + "adding: mem time310, current time 325, horizon 15\n", + "adding: mem time311, current time 325, horizon 14\n", + "adding: mem time312, current time 325, horizon 13\n", + "adding: mem time313, current time 325, horizon 12\n", + "adding: mem time314, current time 325, horizon 11\n", + "adding: mem time315, current time 325, horizon 10\n", + "adding: mem time316, current time 325, horizon 9\n", + "adding: mem time317, current time 325, horizon 8\n", + "adding: mem time318, current time 325, horizon 7\n", + "adding: mem time319, current time 325, horizon 6\n", + "adding: mem time320, current time 325, horizon 5\n", + "adding: mem time321, current time 325, horizon 4\n", + "adding: mem time322, current time 325, horizon 3\n", + "adding: mem time323, current time 325, horizon 2\n", + "adding: mem time324, current time 325, horizon 1\n", + "adding: mem time200, current time 326, horizon 126\n", + "adding: mem time201, current time 326, horizon 125\n", + "adding: mem time202, current time 326, horizon 124\n", + "adding: mem time203, current time 326, horizon 123\n", + "adding: mem time204, current time 326, horizon 122\n", + "adding: mem time205, current time 326, horizon 121\n", + "adding: mem time206, current time 326, horizon 120\n", + "adding: mem time207, current time 326, horizon 119\n", + "adding: mem time208, current time 326, horizon 118\n", + "adding: mem time209, current time 326, horizon 117\n", + "adding: mem time210, current time 326, horizon 116\n", + "adding: mem time211, current time 326, horizon 115\n", + "adding: mem time212, current time 326, horizon 114\n", + "adding: mem time213, current time 326, horizon 113\n", + "adding: mem time214, current time 326, horizon 112\n", + "adding: mem time215, current time 326, horizon 111\n", + "adding: mem time216, current time 326, horizon 110\n", + "adding: mem time217, current time 326, horizon 109\n", + "adding: mem time218, current time 326, horizon 108\n", + "adding: mem time219, current time 326, horizon 107\n", + "adding: mem time220, current time 326, horizon 106\n", + "adding: mem time221, current time 326, horizon 105\n", + "adding: mem time222, current time 326, horizon 104\n", + "adding: mem time223, current time 326, horizon 103\n", + "adding: mem time224, current time 326, horizon 102\n", + "adding: mem time225, current time 326, horizon 101\n", + "adding: mem time226, current time 326, horizon 100\n", + "adding: mem time227, current time 326, horizon 99\n", + "adding: mem time228, current time 326, horizon 98\n", + "adding: mem time229, current time 326, horizon 97\n", + "adding: mem time230, current time 326, horizon 96\n", + "adding: mem time231, current time 326, horizon 95\n", + "adding: mem time232, current time 326, horizon 94\n", + "adding: mem time233, current time 326, horizon 93\n", + "adding: mem time234, current time 326, horizon 92\n", + "adding: mem time235, current time 326, horizon 91\n", + "adding: mem time236, current time 326, horizon 90\n", + "adding: mem time237, current time 326, horizon 89\n", + "adding: mem time238, current time 326, horizon 88\n", + "adding: mem time239, current time 326, horizon 87\n", + "adding: mem time240, current time 326, horizon 86\n", + "adding: mem time241, current time 326, horizon 85\n", + "adding: mem time242, current time 326, horizon 84\n", + "adding: mem time243, current time 326, horizon 83\n", + "adding: mem time244, current time 326, horizon 82\n", + "adding: mem time245, current time 326, horizon 81\n", + "adding: mem time246, current time 326, horizon 80\n", + "adding: mem time247, current time 326, horizon 79\n", + "adding: mem time248, current time 326, horizon 78\n", + "adding: mem time249, current time 326, horizon 77\n", + "adding: mem time250, current time 326, horizon 76\n", + "adding: mem time251, current time 326, horizon 75\n", + "adding: mem time252, current time 326, horizon 74\n", + "adding: mem time253, current time 326, horizon 73\n", + "adding: mem time254, current time 326, horizon 72\n", + "adding: mem time255, current time 326, horizon 71\n", + "adding: mem time256, current time 326, horizon 70\n", + "adding: mem time257, current time 326, horizon 69\n", + "adding: mem time258, current time 326, horizon 68\n", + "adding: mem time259, current time 326, horizon 67\n", + "adding: mem time260, current time 326, horizon 66\n", + "adding: mem time261, current time 326, horizon 65\n", + "adding: mem time262, current time 326, horizon 64\n", + "adding: mem time263, current time 326, horizon 63\n", + "adding: mem time264, current time 326, horizon 62\n", + "adding: mem time265, current time 326, horizon 61\n", + "adding: mem time266, current time 326, horizon 60\n", + "adding: mem time267, current time 326, horizon 59\n", + "adding: mem time268, current time 326, horizon 58\n", + "adding: mem time269, current time 326, horizon 57\n", + "adding: mem time270, current time 326, horizon 56\n", + "adding: mem time271, current time 326, horizon 55\n", + "adding: mem time272, current time 326, horizon 54\n", + "adding: mem time273, current time 326, horizon 53\n", + "adding: mem time274, current time 326, horizon 52\n", + "adding: mem time275, current time 326, horizon 51\n", + "adding: mem time276, current time 326, horizon 50\n", + "adding: mem time277, current time 326, horizon 49\n", + "adding: mem time278, current time 326, horizon 48\n", + "adding: mem time279, current time 326, horizon 47\n", + "adding: mem time280, current time 326, horizon 46\n", + "adding: mem time281, current time 326, horizon 45\n", + "adding: mem time282, current time 326, horizon 44\n", + "adding: mem time283, current time 326, horizon 43\n", + "adding: mem time284, current time 326, horizon 42\n", + "adding: mem time285, current time 326, horizon 41\n", + "adding: mem time286, current time 326, horizon 40\n", + "adding: mem time287, current time 326, horizon 39\n", + "adding: mem time288, current time 326, horizon 38\n", + "adding: mem time289, current time 326, horizon 37\n", + "adding: mem time290, current time 326, horizon 36\n", + "adding: mem time291, current time 326, horizon 35\n", + "adding: mem time292, current time 326, horizon 34\n", + "adding: mem time293, current time 326, horizon 33\n", + "adding: mem time294, current time 326, horizon 32\n", + "adding: mem time295, current time 326, horizon 31\n", + "adding: mem time296, current time 326, horizon 30\n", + "adding: mem time297, current time 326, horizon 29\n", + "adding: mem time298, current time 326, horizon 28\n", + "adding: mem time299, current time 326, horizon 27\n", + "adding: mem time300, current time 326, horizon 26\n", + "adding: mem time301, current time 326, horizon 25\n", + "adding: mem time302, current time 326, horizon 24\n", + "adding: mem time303, current time 326, horizon 23\n", + "adding: mem time304, current time 326, horizon 22\n", + "adding: mem time305, current time 326, horizon 21\n", + "adding: mem time306, current time 326, horizon 20\n", + "adding: mem time307, current time 326, horizon 19\n", + "adding: mem time308, current time 326, horizon 18\n", + "adding: mem time309, current time 326, horizon 17\n", + "adding: mem time310, current time 326, horizon 16\n", + "adding: mem time311, current time 326, horizon 15\n", + "adding: mem time312, current time 326, horizon 14\n", + "adding: mem time313, current time 326, horizon 13\n", + "adding: mem time314, current time 326, horizon 12\n", + "adding: mem time315, current time 326, horizon 11\n", + "adding: mem time316, current time 326, horizon 10\n", + "adding: mem time317, current time 326, horizon 9\n", + "adding: mem time318, current time 326, horizon 8\n", + "adding: mem time319, current time 326, horizon 7\n", + "adding: mem time320, current time 326, horizon 6\n", + "adding: mem time321, current time 326, horizon 5\n", + "adding: mem time322, current time 326, horizon 4\n", + "adding: mem time323, current time 326, horizon 3\n", + "adding: mem time324, current time 326, horizon 2\n", + "adding: mem time325, current time 326, horizon 1\n", + "adding: mem time200, current time 327, horizon 127\n", + "adding: mem time201, current time 327, horizon 126\n", + "adding: mem time202, current time 327, horizon 125\n", + "adding: mem time203, current time 327, horizon 124\n", + "adding: mem time204, current time 327, horizon 123\n", + "adding: mem time205, current time 327, horizon 122\n", + "adding: mem time206, current time 327, horizon 121\n", + "adding: mem time207, current time 327, horizon 120\n", + "adding: mem time208, current time 327, horizon 119\n", + "adding: mem time209, current time 327, horizon 118\n", + "adding: mem time210, current time 327, horizon 117\n", + "adding: mem time211, current time 327, horizon 116\n", + "adding: mem time212, current time 327, horizon 115\n", + "adding: mem time213, current time 327, horizon 114\n", + "adding: mem time214, current time 327, horizon 113\n", + "adding: mem time215, current time 327, horizon 112\n", + "adding: mem time216, current time 327, horizon 111\n", + "adding: mem time217, current time 327, horizon 110\n", + "adding: mem time218, current time 327, horizon 109\n", + "adding: mem time219, current time 327, horizon 108\n", + "adding: mem time220, current time 327, horizon 107\n", + "adding: mem time221, current time 327, horizon 106\n", + "adding: mem time222, current time 327, horizon 105\n", + "adding: mem time223, current time 327, horizon 104\n", + "adding: mem time224, current time 327, horizon 103\n", + "adding: mem time225, current time 327, horizon 102\n", + "adding: mem time226, current time 327, horizon 101\n", + "adding: mem time227, current time 327, horizon 100\n", + "adding: mem time228, current time 327, horizon 99\n", + "adding: mem time229, current time 327, horizon 98\n", + "adding: mem time230, current time 327, horizon 97\n", + "adding: mem time231, current time 327, horizon 96\n", + "adding: mem time232, current time 327, horizon 95\n", + "adding: mem time233, current time 327, horizon 94\n", + "adding: mem time234, current time 327, horizon 93\n", + "adding: mem time235, current time 327, horizon 92\n", + "adding: mem time236, current time 327, horizon 91\n", + "adding: mem time237, current time 327, horizon 90\n", + "adding: mem time238, current time 327, horizon 89\n", + "adding: mem time239, current time 327, horizon 88\n", + "adding: mem time240, current time 327, horizon 87\n", + "adding: mem time241, current time 327, horizon 86\n", + "adding: mem time242, current time 327, horizon 85\n", + "adding: mem time243, current time 327, horizon 84\n", + "adding: mem time244, current time 327, horizon 83\n", + "adding: mem time245, current time 327, horizon 82\n", + "adding: mem time246, current time 327, horizon 81\n", + "adding: mem time247, current time 327, horizon 80\n", + "adding: mem time248, current time 327, horizon 79\n", + "adding: mem time249, current time 327, horizon 78\n", + "adding: mem time250, current time 327, horizon 77\n", + "adding: mem time251, current time 327, horizon 76\n", + "adding: mem time252, current time 327, horizon 75\n", + "adding: mem time253, current time 327, horizon 74\n", + "adding: mem time254, current time 327, horizon 73\n", + "adding: mem time255, current time 327, horizon 72\n", + "adding: mem time256, current time 327, horizon 71\n", + "adding: mem time257, current time 327, horizon 70\n", + "adding: mem time258, current time 327, horizon 69\n", + "adding: mem time259, current time 327, horizon 68\n", + "adding: mem time260, current time 327, horizon 67\n", + "adding: mem time261, current time 327, horizon 66\n", + "adding: mem time262, current time 327, horizon 65\n", + "adding: mem time263, current time 327, horizon 64\n", + "adding: mem time264, current time 327, horizon 63\n", + "adding: mem time265, current time 327, horizon 62\n", + "adding: mem time266, current time 327, horizon 61\n", + "adding: mem time267, current time 327, horizon 60\n", + "adding: mem time268, current time 327, horizon 59\n", + "adding: mem time269, current time 327, horizon 58\n", + "adding: mem time270, current time 327, horizon 57\n", + "adding: mem time271, current time 327, horizon 56\n", + "adding: mem time272, current time 327, horizon 55\n", + "adding: mem time273, current time 327, horizon 54\n", + "adding: mem time274, current time 327, horizon 53\n", + "adding: mem time275, current time 327, horizon 52\n", + "adding: mem time276, current time 327, horizon 51\n", + "adding: mem time277, current time 327, horizon 50\n", + "adding: mem time278, current time 327, horizon 49\n", + "adding: mem time279, current time 327, horizon 48\n", + "adding: mem time280, current time 327, horizon 47\n", + "adding: mem time281, current time 327, horizon 46\n", + "adding: mem time282, current time 327, horizon 45\n", + "adding: mem time283, current time 327, horizon 44\n", + "adding: mem time284, current time 327, horizon 43\n", + "adding: mem time285, current time 327, horizon 42\n", + "adding: mem time286, current time 327, horizon 41\n", + "adding: mem time287, current time 327, horizon 40\n", + "adding: mem time288, current time 327, horizon 39\n", + "adding: mem time289, current time 327, horizon 38\n", + "adding: mem time290, current time 327, horizon 37\n", + "adding: mem time291, current time 327, horizon 36\n", + "adding: mem time292, current time 327, horizon 35\n", + "adding: mem time293, current time 327, horizon 34\n", + "adding: mem time294, current time 327, horizon 33\n", + "adding: mem time295, current time 327, horizon 32\n", + "adding: mem time296, current time 327, horizon 31\n", + "adding: mem time297, current time 327, horizon 30\n", + "adding: mem time298, current time 327, horizon 29\n", + "adding: mem time299, current time 327, horizon 28\n", + "adding: mem time300, current time 327, horizon 27\n", + "adding: mem time301, current time 327, horizon 26\n", + "adding: mem time302, current time 327, horizon 25\n", + "adding: mem time303, current time 327, horizon 24\n", + "adding: mem time304, current time 327, horizon 23\n", + "adding: mem time305, current time 327, horizon 22\n", + "adding: mem time306, current time 327, horizon 21\n", + "adding: mem time307, current time 327, horizon 20\n", + "adding: mem time308, current time 327, horizon 19\n", + "adding: mem time309, current time 327, horizon 18\n", + "adding: mem time310, current time 327, horizon 17\n", + "adding: mem time311, current time 327, horizon 16\n", + "adding: mem time312, current time 327, horizon 15\n", + "adding: mem time313, current time 327, horizon 14\n", + "adding: mem time314, current time 327, horizon 13\n", + "adding: mem time315, current time 327, horizon 12\n", + "adding: mem time316, current time 327, horizon 11\n", + "adding: mem time317, current time 327, horizon 10\n", + "adding: mem time318, current time 327, horizon 9\n", + "adding: mem time319, current time 327, horizon 8\n", + "adding: mem time320, current time 327, horizon 7\n", + "adding: mem time321, current time 327, horizon 6\n", + "adding: mem time322, current time 327, horizon 5\n", + "adding: mem time323, current time 327, horizon 4\n", + "adding: mem time324, current time 327, horizon 3\n", + "adding: mem time325, current time 327, horizon 2\n", + "adding: mem time326, current time 327, horizon 1\n", + "adding: mem time200, current time 328, horizon 128\n", + "adding: mem time201, current time 328, horizon 127\n", + "adding: mem time202, current time 328, horizon 126\n", + "adding: mem time203, current time 328, horizon 125\n", + "adding: mem time204, current time 328, horizon 124\n", + "adding: mem time205, current time 328, horizon 123\n", + "adding: mem time206, current time 328, horizon 122\n", + "adding: mem time207, current time 328, horizon 121\n", + "adding: mem time208, current time 328, horizon 120\n", + "adding: mem time209, current time 328, horizon 119\n", + "adding: mem time210, current time 328, horizon 118\n", + "adding: mem time211, current time 328, horizon 117\n", + "adding: mem time212, current time 328, horizon 116\n", + "adding: mem time213, current time 328, horizon 115\n", + "adding: mem time214, current time 328, horizon 114\n", + "adding: mem time215, current time 328, horizon 113\n", + "adding: mem time216, current time 328, horizon 112\n", + "adding: mem time217, current time 328, horizon 111\n", + "adding: mem time218, current time 328, horizon 110\n", + "adding: mem time219, current time 328, horizon 109\n", + "adding: mem time220, current time 328, horizon 108\n", + "adding: mem time221, current time 328, horizon 107\n", + "adding: mem time222, current time 328, horizon 106\n", + "adding: mem time223, current time 328, horizon 105\n", + "adding: mem time224, current time 328, horizon 104\n", + "adding: mem time225, current time 328, horizon 103\n", + "adding: mem time226, current time 328, horizon 102\n", + "adding: mem time227, current time 328, horizon 101\n", + "adding: mem time228, current time 328, horizon 100\n", + "adding: mem time229, current time 328, horizon 99\n", + "adding: mem time230, current time 328, horizon 98\n", + "adding: mem time231, current time 328, horizon 97\n", + "adding: mem time232, current time 328, horizon 96\n", + "adding: mem time233, current time 328, horizon 95\n", + "adding: mem time234, current time 328, horizon 94\n", + "adding: mem time235, current time 328, horizon 93\n", + "adding: mem time236, current time 328, horizon 92\n", + "adding: mem time237, current time 328, horizon 91\n", + "adding: mem time238, current time 328, horizon 90\n", + "adding: mem time239, current time 328, horizon 89\n", + "adding: mem time240, current time 328, horizon 88\n", + "adding: mem time241, current time 328, horizon 87\n", + "adding: mem time242, current time 328, horizon 86\n", + "adding: mem time243, current time 328, horizon 85\n", + "adding: mem time244, current time 328, horizon 84\n", + "adding: mem time245, current time 328, horizon 83\n", + "adding: mem time246, current time 328, horizon 82\n", + "adding: mem time247, current time 328, horizon 81\n", + "adding: mem time248, current time 328, horizon 80\n", + "adding: mem time249, current time 328, horizon 79\n", + "adding: mem time250, current time 328, horizon 78\n", + "adding: mem time251, current time 328, horizon 77\n", + "adding: mem time252, current time 328, horizon 76\n", + "adding: mem time253, current time 328, horizon 75\n", + "adding: mem time254, current time 328, horizon 74\n", + "adding: mem time255, current time 328, horizon 73\n", + "adding: mem time256, current time 328, horizon 72\n", + "adding: mem time257, current time 328, horizon 71\n", + "adding: mem time258, current time 328, horizon 70\n", + "adding: mem time259, current time 328, horizon 69\n", + "adding: mem time260, current time 328, horizon 68\n", + "adding: mem time261, current time 328, horizon 67\n", + "adding: mem time262, current time 328, horizon 66\n", + "adding: mem time263, current time 328, horizon 65\n", + "adding: mem time264, current time 328, horizon 64\n", + "adding: mem time265, current time 328, horizon 63\n", + "adding: mem time266, current time 328, horizon 62\n", + "adding: mem time267, current time 328, horizon 61\n", + "adding: mem time268, current time 328, horizon 60\n", + "adding: mem time269, current time 328, horizon 59\n", + "adding: mem time270, current time 328, horizon 58\n", + "adding: mem time271, current time 328, horizon 57\n", + "adding: mem time272, current time 328, horizon 56\n", + "adding: mem time273, current time 328, horizon 55\n", + "adding: mem time274, current time 328, horizon 54\n", + "adding: mem time275, current time 328, horizon 53\n", + "adding: mem time276, current time 328, horizon 52\n", + "adding: mem time277, current time 328, horizon 51\n", + "adding: mem time278, current time 328, horizon 50\n", + "adding: mem time279, current time 328, horizon 49\n", + "adding: mem time280, current time 328, horizon 48\n", + "adding: mem time281, current time 328, horizon 47\n", + "adding: mem time282, current time 328, horizon 46\n", + "adding: mem time283, current time 328, horizon 45\n", + "adding: mem time284, current time 328, horizon 44\n", + "adding: mem time285, current time 328, horizon 43\n", + "adding: mem time286, current time 328, horizon 42\n", + "adding: mem time287, current time 328, horizon 41\n", + "adding: mem time288, current time 328, horizon 40\n", + "adding: mem time289, current time 328, horizon 39\n", + "adding: mem time290, current time 328, horizon 38\n", + "adding: mem time291, current time 328, horizon 37\n", + "adding: mem time292, current time 328, horizon 36\n", + "adding: mem time293, current time 328, horizon 35\n", + "adding: mem time294, current time 328, horizon 34\n", + "adding: mem time295, current time 328, horizon 33\n", + "adding: mem time296, current time 328, horizon 32\n", + "adding: mem time297, current time 328, horizon 31\n", + "adding: mem time298, current time 328, horizon 30\n", + "adding: mem time299, current time 328, horizon 29\n", + "adding: mem time300, current time 328, horizon 28\n", + "adding: mem time301, current time 328, horizon 27\n", + "adding: mem time302, current time 328, horizon 26\n", + "adding: mem time303, current time 328, horizon 25\n", + "adding: mem time304, current time 328, horizon 24\n", + "adding: mem time305, current time 328, horizon 23\n", + "adding: mem time306, current time 328, horizon 22\n", + "adding: mem time307, current time 328, horizon 21\n", + "adding: mem time308, current time 328, horizon 20\n", + "adding: mem time309, current time 328, horizon 19\n", + "adding: mem time310, current time 328, horizon 18\n", + "adding: mem time311, current time 328, horizon 17\n", + "adding: mem time312, current time 328, horizon 16\n", + "adding: mem time313, current time 328, horizon 15\n", + "adding: mem time314, current time 328, horizon 14\n", + "adding: mem time315, current time 328, horizon 13\n", + "adding: mem time316, current time 328, horizon 12\n", + "adding: mem time317, current time 328, horizon 11\n", + "adding: mem time318, current time 328, horizon 10\n", + "adding: mem time319, current time 328, horizon 9\n", + "adding: mem time320, current time 328, horizon 8\n", + "adding: mem time321, current time 328, horizon 7\n", + "adding: mem time322, current time 328, horizon 6\n", + "adding: mem time323, current time 328, horizon 5\n", + "adding: mem time324, current time 328, horizon 4\n", + "adding: mem time325, current time 328, horizon 3\n", + "adding: mem time326, current time 328, horizon 2\n", + "adding: mem time327, current time 328, horizon 1\n", + "adding: mem time200, current time 329, horizon 129\n", + "adding: mem time201, current time 329, horizon 128\n", + "adding: mem time202, current time 329, horizon 127\n", + "adding: mem time203, current time 329, horizon 126\n", + "adding: mem time204, current time 329, horizon 125\n", + "adding: mem time205, current time 329, horizon 124\n", + "adding: mem time206, current time 329, horizon 123\n", + "adding: mem time207, current time 329, horizon 122\n", + "adding: mem time208, current time 329, horizon 121\n", + "adding: mem time209, current time 329, horizon 120\n", + "adding: mem time210, current time 329, horizon 119\n", + "adding: mem time211, current time 329, horizon 118\n", + "adding: mem time212, current time 329, horizon 117\n", + "adding: mem time213, current time 329, horizon 116\n", + "adding: mem time214, current time 329, horizon 115\n", + "adding: mem time215, current time 329, horizon 114\n", + "adding: mem time216, current time 329, horizon 113\n", + "adding: mem time217, current time 329, horizon 112\n", + "adding: mem time218, current time 329, horizon 111\n", + "adding: mem time219, current time 329, horizon 110\n", + "adding: mem time220, current time 329, horizon 109\n", + "adding: mem time221, current time 329, horizon 108\n", + "adding: mem time222, current time 329, horizon 107\n", + "adding: mem time223, current time 329, horizon 106\n", + "adding: mem time224, current time 329, horizon 105\n", + "adding: mem time225, current time 329, horizon 104\n", + "adding: mem time226, current time 329, horizon 103\n", + "adding: mem time227, current time 329, horizon 102\n", + "adding: mem time228, current time 329, horizon 101\n", + "adding: mem time229, current time 329, horizon 100\n", + "adding: mem time230, current time 329, horizon 99\n", + "adding: mem time231, current time 329, horizon 98\n", + "adding: mem time232, current time 329, horizon 97\n", + "adding: mem time233, current time 329, horizon 96\n", + "adding: mem time234, current time 329, horizon 95\n", + "adding: mem time235, current time 329, horizon 94\n", + "adding: mem time236, current time 329, horizon 93\n", + "adding: mem time237, current time 329, horizon 92\n", + "adding: mem time238, current time 329, horizon 91\n", + "adding: mem time239, current time 329, horizon 90\n", + "adding: mem time240, current time 329, horizon 89\n", + "adding: mem time241, current time 329, horizon 88\n", + "adding: mem time242, current time 329, horizon 87\n", + "adding: mem time243, current time 329, horizon 86\n", + "adding: mem time244, current time 329, horizon 85\n", + "adding: mem time245, current time 329, horizon 84\n", + "adding: mem time246, current time 329, horizon 83\n", + "adding: mem time247, current time 329, horizon 82\n", + "adding: mem time248, current time 329, horizon 81\n", + "adding: mem time249, current time 329, horizon 80\n", + "adding: mem time250, current time 329, horizon 79\n", + "adding: mem time251, current time 329, horizon 78\n", + "adding: mem time252, current time 329, horizon 77\n", + "adding: mem time253, current time 329, horizon 76\n", + "adding: mem time254, current time 329, horizon 75\n", + "adding: mem time255, current time 329, horizon 74\n", + "adding: mem time256, current time 329, horizon 73\n", + "adding: mem time257, current time 329, horizon 72\n", + "adding: mem time258, current time 329, horizon 71\n", + "adding: mem time259, current time 329, horizon 70\n", + "adding: mem time260, current time 329, horizon 69\n", + "adding: mem time261, current time 329, horizon 68\n", + "adding: mem time262, current time 329, horizon 67\n", + "adding: mem time263, current time 329, horizon 66\n", + "adding: mem time264, current time 329, horizon 65\n", + "adding: mem time265, current time 329, horizon 64\n", + "adding: mem time266, current time 329, horizon 63\n", + "adding: mem time267, current time 329, horizon 62\n", + "adding: mem time268, current time 329, horizon 61\n", + "adding: mem time269, current time 329, horizon 60\n", + "adding: mem time270, current time 329, horizon 59\n", + "adding: mem time271, current time 329, horizon 58\n", + "adding: mem time272, current time 329, horizon 57\n", + "adding: mem time273, current time 329, horizon 56\n", + "adding: mem time274, current time 329, horizon 55\n", + "adding: mem time275, current time 329, horizon 54\n", + "adding: mem time276, current time 329, horizon 53\n", + "adding: mem time277, current time 329, horizon 52\n", + "adding: mem time278, current time 329, horizon 51\n", + "adding: mem time279, current time 329, horizon 50\n", + "adding: mem time280, current time 329, horizon 49\n", + "adding: mem time281, current time 329, horizon 48\n", + "adding: mem time282, current time 329, horizon 47\n", + "adding: mem time283, current time 329, horizon 46\n", + "adding: mem time284, current time 329, horizon 45\n", + "adding: mem time285, current time 329, horizon 44\n", + "adding: mem time286, current time 329, horizon 43\n", + "adding: mem time287, current time 329, horizon 42\n", + "adding: mem time288, current time 329, horizon 41\n", + "adding: mem time289, current time 329, horizon 40\n", + "adding: mem time290, current time 329, horizon 39\n", + "adding: mem time291, current time 329, horizon 38\n", + "adding: mem time292, current time 329, horizon 37\n", + "adding: mem time293, current time 329, horizon 36\n", + "adding: mem time294, current time 329, horizon 35\n", + "adding: mem time295, current time 329, horizon 34\n", + "adding: mem time296, current time 329, horizon 33\n", + "adding: mem time297, current time 329, horizon 32\n", + "adding: mem time298, current time 329, horizon 31\n", + "adding: mem time299, current time 329, horizon 30\n", + "adding: mem time300, current time 329, horizon 29\n", + "adding: mem time301, current time 329, horizon 28\n", + "adding: mem time302, current time 329, horizon 27\n", + "adding: mem time303, current time 329, horizon 26\n", + "adding: mem time304, current time 329, horizon 25\n", + "adding: mem time305, current time 329, horizon 24\n", + "adding: mem time306, current time 329, horizon 23\n", + "adding: mem time307, current time 329, horizon 22\n", + "adding: mem time308, current time 329, horizon 21\n", + "adding: mem time309, current time 329, horizon 20\n", + "adding: mem time310, current time 329, horizon 19\n", + "adding: mem time311, current time 329, horizon 18\n", + "adding: mem time312, current time 329, horizon 17\n", + "adding: mem time313, current time 329, horizon 16\n", + "adding: mem time314, current time 329, horizon 15\n", + "adding: mem time315, current time 329, horizon 14\n", + "adding: mem time316, current time 329, horizon 13\n", + "adding: mem time317, current time 329, horizon 12\n", + "adding: mem time318, current time 329, horizon 11\n", + "adding: mem time319, current time 329, horizon 10\n", + "adding: mem time320, current time 329, horizon 9\n", + "adding: mem time321, current time 329, horizon 8\n", + "adding: mem time322, current time 329, horizon 7\n", + "adding: mem time323, current time 329, horizon 6\n", + "adding: mem time324, current time 329, horizon 5\n", + "adding: mem time325, current time 329, horizon 4\n", + "adding: mem time326, current time 329, horizon 3\n", + "adding: mem time327, current time 329, horizon 2\n", + "adding: mem time328, current time 329, horizon 1\n", + "adding: mem time200, current time 330, horizon 130\n", + "adding: mem time201, current time 330, horizon 129\n", + "adding: mem time202, current time 330, horizon 128\n", + "adding: mem time203, current time 330, horizon 127\n", + "adding: mem time204, current time 330, horizon 126\n", + "adding: mem time205, current time 330, horizon 125\n", + "adding: mem time206, current time 330, horizon 124\n", + "adding: mem time207, current time 330, horizon 123\n", + "adding: mem time208, current time 330, horizon 122\n", + "adding: mem time209, current time 330, horizon 121\n", + "adding: mem time210, current time 330, horizon 120\n", + "adding: mem time211, current time 330, horizon 119\n", + "adding: mem time212, current time 330, horizon 118\n", + "adding: mem time213, current time 330, horizon 117\n", + "adding: mem time214, current time 330, horizon 116\n", + "adding: mem time215, current time 330, horizon 115\n", + "adding: mem time216, current time 330, horizon 114\n", + "adding: mem time217, current time 330, horizon 113\n", + "adding: mem time218, current time 330, horizon 112\n", + "adding: mem time219, current time 330, horizon 111\n", + "adding: mem time220, current time 330, horizon 110\n", + "adding: mem time221, current time 330, horizon 109\n", + "adding: mem time222, current time 330, horizon 108\n", + "adding: mem time223, current time 330, horizon 107\n", + "adding: mem time224, current time 330, horizon 106\n", + "adding: mem time225, current time 330, horizon 105\n", + "adding: mem time226, current time 330, horizon 104\n", + "adding: mem time227, current time 330, horizon 103\n", + "adding: mem time228, current time 330, horizon 102\n", + "adding: mem time229, current time 330, horizon 101\n", + "adding: mem time230, current time 330, horizon 100\n", + "adding: mem time231, current time 330, horizon 99\n", + "adding: mem time232, current time 330, horizon 98\n", + "adding: mem time233, current time 330, horizon 97\n", + "adding: mem time234, current time 330, horizon 96\n", + "adding: mem time235, current time 330, horizon 95\n", + "adding: mem time236, current time 330, horizon 94\n", + "adding: mem time237, current time 330, horizon 93\n", + "adding: mem time238, current time 330, horizon 92\n", + "adding: mem time239, current time 330, horizon 91\n", + "adding: mem time240, current time 330, horizon 90\n", + "adding: mem time241, current time 330, horizon 89\n", + "adding: mem time242, current time 330, horizon 88\n", + "adding: mem time243, current time 330, horizon 87\n", + "adding: mem time244, current time 330, horizon 86\n", + "adding: mem time245, current time 330, horizon 85\n", + "adding: mem time246, current time 330, horizon 84\n", + "adding: mem time247, current time 330, horizon 83\n", + "adding: mem time248, current time 330, horizon 82\n", + "adding: mem time249, current time 330, horizon 81\n", + "adding: mem time250, current time 330, horizon 80\n", + "adding: mem time251, current time 330, horizon 79\n", + "adding: mem time252, current time 330, horizon 78\n", + "adding: mem time253, current time 330, horizon 77\n", + "adding: mem time254, current time 330, horizon 76\n", + "adding: mem time255, current time 330, horizon 75\n", + "adding: mem time256, current time 330, horizon 74\n", + "adding: mem time257, current time 330, horizon 73\n", + "adding: mem time258, current time 330, horizon 72\n", + "adding: mem time259, current time 330, horizon 71\n", + "adding: mem time260, current time 330, horizon 70\n", + "adding: mem time261, current time 330, horizon 69\n", + "adding: mem time262, current time 330, horizon 68\n", + "adding: mem time263, current time 330, horizon 67\n", + "adding: mem time264, current time 330, horizon 66\n", + "adding: mem time265, current time 330, horizon 65\n", + "adding: mem time266, current time 330, horizon 64\n", + "adding: mem time267, current time 330, horizon 63\n", + "adding: mem time268, current time 330, horizon 62\n", + "adding: mem time269, current time 330, horizon 61\n", + "adding: mem time270, current time 330, horizon 60\n", + "adding: mem time271, current time 330, horizon 59\n", + "adding: mem time272, current time 330, horizon 58\n", + "adding: mem time273, current time 330, horizon 57\n", + "adding: mem time274, current time 330, horizon 56\n", + "adding: mem time275, current time 330, horizon 55\n", + "adding: mem time276, current time 330, horizon 54\n", + "adding: mem time277, current time 330, horizon 53\n", + "adding: mem time278, current time 330, horizon 52\n", + "adding: mem time279, current time 330, horizon 51\n", + "adding: mem time280, current time 330, horizon 50\n", + "adding: mem time281, current time 330, horizon 49\n", + "adding: mem time282, current time 330, horizon 48\n", + "adding: mem time283, current time 330, horizon 47\n", + "adding: mem time284, current time 330, horizon 46\n", + "adding: mem time285, current time 330, horizon 45\n", + "adding: mem time286, current time 330, horizon 44\n", + "adding: mem time287, current time 330, horizon 43\n", + "adding: mem time288, current time 330, horizon 42\n", + "adding: mem time289, current time 330, horizon 41\n", + "adding: mem time290, current time 330, horizon 40\n", + "adding: mem time291, current time 330, horizon 39\n", + "adding: mem time292, current time 330, horizon 38\n", + "adding: mem time293, current time 330, horizon 37\n", + "adding: mem time294, current time 330, horizon 36\n", + "adding: mem time295, current time 330, horizon 35\n", + "adding: mem time296, current time 330, horizon 34\n", + "adding: mem time297, current time 330, horizon 33\n", + "adding: mem time298, current time 330, horizon 32\n", + "adding: mem time299, current time 330, horizon 31\n", + "adding: mem time300, current time 330, horizon 30\n", + "adding: mem time301, current time 330, horizon 29\n", + "adding: mem time302, current time 330, horizon 28\n", + "adding: mem time303, current time 330, horizon 27\n", + "adding: mem time304, current time 330, horizon 26\n", + "adding: mem time305, current time 330, horizon 25\n", + "adding: mem time306, current time 330, horizon 24\n", + "adding: mem time307, current time 330, horizon 23\n", + "adding: mem time308, current time 330, horizon 22\n", + "adding: mem time309, current time 330, horizon 21\n", + "adding: mem time310, current time 330, horizon 20\n", + "adding: mem time311, current time 330, horizon 19\n", + "adding: mem time312, current time 330, horizon 18\n", + "adding: mem time313, current time 330, horizon 17\n", + "adding: mem time314, current time 330, horizon 16\n", + "adding: mem time315, current time 330, horizon 15\n", + "adding: mem time316, current time 330, horizon 14\n", + "adding: mem time317, current time 330, horizon 13\n", + "adding: mem time318, current time 330, horizon 12\n", + "adding: mem time319, current time 330, horizon 11\n", + "adding: mem time320, current time 330, horizon 10\n", + "adding: mem time321, current time 330, horizon 9\n", + "adding: mem time322, current time 330, horizon 8\n", + "adding: mem time323, current time 330, horizon 7\n", + "adding: mem time324, current time 330, horizon 6\n", + "adding: mem time325, current time 330, horizon 5\n", + "adding: mem time326, current time 330, horizon 4\n", + "adding: mem time327, current time 330, horizon 3\n", + "adding: mem time328, current time 330, horizon 2\n", + "adding: mem time329, current time 330, horizon 1\n", + "adding: mem time200, current time 331, horizon 131\n", + "adding: mem time201, current time 331, horizon 130\n", + "adding: mem time202, current time 331, horizon 129\n", + "adding: mem time203, current time 331, horizon 128\n", + "adding: mem time204, current time 331, horizon 127\n", + "adding: mem time205, current time 331, horizon 126\n", + "adding: mem time206, current time 331, horizon 125\n", + "adding: mem time207, current time 331, horizon 124\n", + "adding: mem time208, current time 331, horizon 123\n", + "adding: mem time209, current time 331, horizon 122\n", + "adding: mem time210, current time 331, horizon 121\n", + "adding: mem time211, current time 331, horizon 120\n", + "adding: mem time212, current time 331, horizon 119\n", + "adding: mem time213, current time 331, horizon 118\n", + "adding: mem time214, current time 331, horizon 117\n", + "adding: mem time215, current time 331, horizon 116\n", + "adding: mem time216, current time 331, horizon 115\n", + "adding: mem time217, current time 331, horizon 114\n", + "adding: mem time218, current time 331, horizon 113\n", + "adding: mem time219, current time 331, horizon 112\n", + "adding: mem time220, current time 331, horizon 111\n", + "adding: mem time221, current time 331, horizon 110\n", + "adding: mem time222, current time 331, horizon 109\n", + "adding: mem time223, current time 331, horizon 108\n", + "adding: mem time224, current time 331, horizon 107\n", + "adding: mem time225, current time 331, horizon 106\n", + "adding: mem time226, current time 331, horizon 105\n", + "adding: mem time227, current time 331, horizon 104\n", + "adding: mem time228, current time 331, horizon 103\n", + "adding: mem time229, current time 331, horizon 102\n", + "adding: mem time230, current time 331, horizon 101\n", + "adding: mem time231, current time 331, horizon 100\n", + "adding: mem time232, current time 331, horizon 99\n", + "adding: mem time233, current time 331, horizon 98\n", + "adding: mem time234, current time 331, horizon 97\n", + "adding: mem time235, current time 331, horizon 96\n", + "adding: mem time236, current time 331, horizon 95\n", + "adding: mem time237, current time 331, horizon 94\n", + "adding: mem time238, current time 331, horizon 93\n", + "adding: mem time239, current time 331, horizon 92\n", + "adding: mem time240, current time 331, horizon 91\n", + "adding: mem time241, current time 331, horizon 90\n", + "adding: mem time242, current time 331, horizon 89\n", + "adding: mem time243, current time 331, horizon 88\n", + "adding: mem time244, current time 331, horizon 87\n", + "adding: mem time245, current time 331, horizon 86\n", + "adding: mem time246, current time 331, horizon 85\n", + "adding: mem time247, current time 331, horizon 84\n", + "adding: mem time248, current time 331, horizon 83\n", + "adding: mem time249, current time 331, horizon 82\n", + "adding: mem time250, current time 331, horizon 81\n", + "adding: mem time251, current time 331, horizon 80\n", + "adding: mem time252, current time 331, horizon 79\n", + "adding: mem time253, current time 331, horizon 78\n", + "adding: mem time254, current time 331, horizon 77\n", + "adding: mem time255, current time 331, horizon 76\n", + "adding: mem time256, current time 331, horizon 75\n", + "adding: mem time257, current time 331, horizon 74\n", + "adding: mem time258, current time 331, horizon 73\n", + "adding: mem time259, current time 331, horizon 72\n", + "adding: mem time260, current time 331, horizon 71\n", + "adding: mem time261, current time 331, horizon 70\n", + "adding: mem time262, current time 331, horizon 69\n", + "adding: mem time263, current time 331, horizon 68\n", + "adding: mem time264, current time 331, horizon 67\n", + "adding: mem time265, current time 331, horizon 66\n", + "adding: mem time266, current time 331, horizon 65\n", + "adding: mem time267, current time 331, horizon 64\n", + "adding: mem time268, current time 331, horizon 63\n", + "adding: mem time269, current time 331, horizon 62\n", + "adding: mem time270, current time 331, horizon 61\n", + "adding: mem time271, current time 331, horizon 60\n", + "adding: mem time272, current time 331, horizon 59\n", + "adding: mem time273, current time 331, horizon 58\n", + "adding: mem time274, current time 331, horizon 57\n", + "adding: mem time275, current time 331, horizon 56\n", + "adding: mem time276, current time 331, horizon 55\n", + "adding: mem time277, current time 331, horizon 54\n", + "adding: mem time278, current time 331, horizon 53\n", + "adding: mem time279, current time 331, horizon 52\n", + "adding: mem time280, current time 331, horizon 51\n", + "adding: mem time281, current time 331, horizon 50\n", + "adding: mem time282, current time 331, horizon 49\n", + "adding: mem time283, current time 331, horizon 48\n", + "adding: mem time284, current time 331, horizon 47\n", + "adding: mem time285, current time 331, horizon 46\n", + "adding: mem time286, current time 331, horizon 45\n", + "adding: mem time287, current time 331, horizon 44\n", + "adding: mem time288, current time 331, horizon 43\n", + "adding: mem time289, current time 331, horizon 42\n", + "adding: mem time290, current time 331, horizon 41\n", + "adding: mem time291, current time 331, horizon 40\n", + "adding: mem time292, current time 331, horizon 39\n", + "adding: mem time293, current time 331, horizon 38\n", + "adding: mem time294, current time 331, horizon 37\n", + "adding: mem time295, current time 331, horizon 36\n", + "adding: mem time296, current time 331, horizon 35\n", + "adding: mem time297, current time 331, horizon 34\n", + "adding: mem time298, current time 331, horizon 33\n", + "adding: mem time299, current time 331, horizon 32\n", + "adding: mem time300, current time 331, horizon 31\n", + "adding: mem time301, current time 331, horizon 30\n", + "adding: mem time302, current time 331, horizon 29\n", + "adding: mem time303, current time 331, horizon 28\n", + "adding: mem time304, current time 331, horizon 27\n", + "adding: mem time305, current time 331, horizon 26\n", + "adding: mem time306, current time 331, horizon 25\n", + "adding: mem time307, current time 331, horizon 24\n", + "adding: mem time308, current time 331, horizon 23\n", + "adding: mem time309, current time 331, horizon 22\n", + "adding: mem time310, current time 331, horizon 21\n", + "adding: mem time311, current time 331, horizon 20\n", + "adding: mem time312, current time 331, horizon 19\n", + "adding: mem time313, current time 331, horizon 18\n", + "adding: mem time314, current time 331, horizon 17\n", + "adding: mem time315, current time 331, horizon 16\n", + "adding: mem time316, current time 331, horizon 15\n", + "adding: mem time317, current time 331, horizon 14\n", + "adding: mem time318, current time 331, horizon 13\n", + "adding: mem time319, current time 331, horizon 12\n", + "adding: mem time320, current time 331, horizon 11\n", + "adding: mem time321, current time 331, horizon 10\n", + "adding: mem time322, current time 331, horizon 9\n", + "adding: mem time323, current time 331, horizon 8\n", + "adding: mem time324, current time 331, horizon 7\n", + "adding: mem time325, current time 331, horizon 6\n", + "adding: mem time326, current time 331, horizon 5\n", + "adding: mem time327, current time 331, horizon 4\n", + "adding: mem time328, current time 331, horizon 3\n", + "adding: mem time329, current time 331, horizon 2\n", + "adding: mem time330, current time 331, horizon 1\n", + "adding: mem time200, current time 332, horizon 132\n", + "adding: mem time201, current time 332, horizon 131\n", + "adding: mem time202, current time 332, horizon 130\n", + "adding: mem time203, current time 332, horizon 129\n", + "adding: mem time204, current time 332, horizon 128\n", + "adding: mem time205, current time 332, horizon 127\n", + "adding: mem time206, current time 332, horizon 126\n", + "adding: mem time207, current time 332, horizon 125\n", + "adding: mem time208, current time 332, horizon 124\n", + "adding: mem time209, current time 332, horizon 123\n", + "adding: mem time210, current time 332, horizon 122\n", + "adding: mem time211, current time 332, horizon 121\n", + "adding: mem time212, current time 332, horizon 120\n", + "adding: mem time213, current time 332, horizon 119\n", + "adding: mem time214, current time 332, horizon 118\n", + "adding: mem time215, current time 332, horizon 117\n", + "adding: mem time216, current time 332, horizon 116\n", + "adding: mem time217, current time 332, horizon 115\n", + "adding: mem time218, current time 332, horizon 114\n", + "adding: mem time219, current time 332, horizon 113\n", + "adding: mem time220, current time 332, horizon 112\n", + "adding: mem time221, current time 332, horizon 111\n", + "adding: mem time222, current time 332, horizon 110\n", + "adding: mem time223, current time 332, horizon 109\n", + "adding: mem time224, current time 332, horizon 108\n", + "adding: mem time225, current time 332, horizon 107\n", + "adding: mem time226, current time 332, horizon 106\n", + "adding: mem time227, current time 332, horizon 105\n", + "adding: mem time228, current time 332, horizon 104\n", + "adding: mem time229, current time 332, horizon 103\n", + "adding: mem time230, current time 332, horizon 102\n", + "adding: mem time231, current time 332, horizon 101\n", + "adding: mem time232, current time 332, horizon 100\n", + "adding: mem time233, current time 332, horizon 99\n", + "adding: mem time234, current time 332, horizon 98\n", + "adding: mem time235, current time 332, horizon 97\n", + "adding: mem time236, current time 332, horizon 96\n", + "adding: mem time237, current time 332, horizon 95\n", + "adding: mem time238, current time 332, horizon 94\n", + "adding: mem time239, current time 332, horizon 93\n", + "adding: mem time240, current time 332, horizon 92\n", + "adding: mem time241, current time 332, horizon 91\n", + "adding: mem time242, current time 332, horizon 90\n", + "adding: mem time243, current time 332, horizon 89\n", + "adding: mem time244, current time 332, horizon 88\n", + "adding: mem time245, current time 332, horizon 87\n", + "adding: mem time246, current time 332, horizon 86\n", + "adding: mem time247, current time 332, horizon 85\n", + "adding: mem time248, current time 332, horizon 84\n", + "adding: mem time249, current time 332, horizon 83\n", + "adding: mem time250, current time 332, horizon 82\n", + "adding: mem time251, current time 332, horizon 81\n", + "adding: mem time252, current time 332, horizon 80\n", + "adding: mem time253, current time 332, horizon 79\n", + "adding: mem time254, current time 332, horizon 78\n", + "adding: mem time255, current time 332, horizon 77\n", + "adding: mem time256, current time 332, horizon 76\n", + "adding: mem time257, current time 332, horizon 75\n", + "adding: mem time258, current time 332, horizon 74\n", + "adding: mem time259, current time 332, horizon 73\n", + "adding: mem time260, current time 332, horizon 72\n", + "adding: mem time261, current time 332, horizon 71\n", + "adding: mem time262, current time 332, horizon 70\n", + "adding: mem time263, current time 332, horizon 69\n", + "adding: mem time264, current time 332, horizon 68\n", + "adding: mem time265, current time 332, horizon 67\n", + "adding: mem time266, current time 332, horizon 66\n", + "adding: mem time267, current time 332, horizon 65\n", + "adding: mem time268, current time 332, horizon 64\n", + "adding: mem time269, current time 332, horizon 63\n", + "adding: mem time270, current time 332, horizon 62\n", + "adding: mem time271, current time 332, horizon 61\n", + "adding: mem time272, current time 332, horizon 60\n", + "adding: mem time273, current time 332, horizon 59\n", + "adding: mem time274, current time 332, horizon 58\n", + "adding: mem time275, current time 332, horizon 57\n", + "adding: mem time276, current time 332, horizon 56\n", + "adding: mem time277, current time 332, horizon 55\n", + "adding: mem time278, current time 332, horizon 54\n", + "adding: mem time279, current time 332, horizon 53\n", + "adding: mem time280, current time 332, horizon 52\n", + "adding: mem time281, current time 332, horizon 51\n", + "adding: mem time282, current time 332, horizon 50\n", + "adding: mem time283, current time 332, horizon 49\n", + "adding: mem time284, current time 332, horizon 48\n", + "adding: mem time285, current time 332, horizon 47\n", + "adding: mem time286, current time 332, horizon 46\n", + "adding: mem time287, current time 332, horizon 45\n", + "adding: mem time288, current time 332, horizon 44\n", + "adding: mem time289, current time 332, horizon 43\n", + "adding: mem time290, current time 332, horizon 42\n", + "adding: mem time291, current time 332, horizon 41\n", + "adding: mem time292, current time 332, horizon 40\n", + "adding: mem time293, current time 332, horizon 39\n", + "adding: mem time294, current time 332, horizon 38\n", + "adding: mem time295, current time 332, horizon 37\n", + "adding: mem time296, current time 332, horizon 36\n", + "adding: mem time297, current time 332, horizon 35\n", + "adding: mem time298, current time 332, horizon 34\n", + "adding: mem time299, current time 332, horizon 33\n", + "adding: mem time300, current time 332, horizon 32\n", + "adding: mem time301, current time 332, horizon 31\n", + "adding: mem time302, current time 332, horizon 30\n", + "adding: mem time303, current time 332, horizon 29\n", + "adding: mem time304, current time 332, horizon 28\n", + "adding: mem time305, current time 332, horizon 27\n", + "adding: mem time306, current time 332, horizon 26\n", + "adding: mem time307, current time 332, horizon 25\n", + "adding: mem time308, current time 332, horizon 24\n", + "adding: mem time309, current time 332, horizon 23\n", + "adding: mem time310, current time 332, horizon 22\n", + "adding: mem time311, current time 332, horizon 21\n", + "adding: mem time312, current time 332, horizon 20\n", + "adding: mem time313, current time 332, horizon 19\n", + "adding: mem time314, current time 332, horizon 18\n", + "adding: mem time315, current time 332, horizon 17\n", + "adding: mem time316, current time 332, horizon 16\n", + "adding: mem time317, current time 332, horizon 15\n", + "adding: mem time318, current time 332, horizon 14\n", + "adding: mem time319, current time 332, horizon 13\n", + "adding: mem time320, current time 332, horizon 12\n", + "adding: mem time321, current time 332, horizon 11\n", + "adding: mem time322, current time 332, horizon 10\n", + "adding: mem time323, current time 332, horizon 9\n", + "adding: mem time324, current time 332, horizon 8\n", + "adding: mem time325, current time 332, horizon 7\n", + "adding: mem time326, current time 332, horizon 6\n", + "adding: mem time327, current time 332, horizon 5\n", + "adding: mem time328, current time 332, horizon 4\n", + "adding: mem time329, current time 332, horizon 3\n", + "adding: mem time330, current time 332, horizon 2\n", + "adding: mem time331, current time 332, horizon 1\n", + "adding: mem time200, current time 333, horizon 133\n", + "adding: mem time201, current time 333, horizon 132\n", + "adding: mem time202, current time 333, horizon 131\n", + "adding: mem time203, current time 333, horizon 130\n", + "adding: mem time204, current time 333, horizon 129\n", + "adding: mem time205, current time 333, horizon 128\n", + "adding: mem time206, current time 333, horizon 127\n", + "adding: mem time207, current time 333, horizon 126\n", + "adding: mem time208, current time 333, horizon 125\n", + "adding: mem time209, current time 333, horizon 124\n", + "adding: mem time210, current time 333, horizon 123\n", + "adding: mem time211, current time 333, horizon 122\n", + "adding: mem time212, current time 333, horizon 121\n", + "adding: mem time213, current time 333, horizon 120\n", + "adding: mem time214, current time 333, horizon 119\n", + "adding: mem time215, current time 333, horizon 118\n", + "adding: mem time216, current time 333, horizon 117\n", + "adding: mem time217, current time 333, horizon 116\n", + "adding: mem time218, current time 333, horizon 115\n", + "adding: mem time219, current time 333, horizon 114\n", + "adding: mem time220, current time 333, horizon 113\n", + "adding: mem time221, current time 333, horizon 112\n", + "adding: mem time222, current time 333, horizon 111\n", + "adding: mem time223, current time 333, horizon 110\n", + "adding: mem time224, current time 333, horizon 109\n", + "adding: mem time225, current time 333, horizon 108\n", + "adding: mem time226, current time 333, horizon 107\n", + "adding: mem time227, current time 333, horizon 106\n", + "adding: mem time228, current time 333, horizon 105\n", + "adding: mem time229, current time 333, horizon 104\n", + "adding: mem time230, current time 333, horizon 103\n", + "adding: mem time231, current time 333, horizon 102\n", + "adding: mem time232, current time 333, horizon 101\n", + "adding: mem time233, current time 333, horizon 100\n", + "adding: mem time234, current time 333, horizon 99\n", + "adding: mem time235, current time 333, horizon 98\n", + "adding: mem time236, current time 333, horizon 97\n", + "adding: mem time237, current time 333, horizon 96\n", + "adding: mem time238, current time 333, horizon 95\n", + "adding: mem time239, current time 333, horizon 94\n", + "adding: mem time240, current time 333, horizon 93\n", + "adding: mem time241, current time 333, horizon 92\n", + "adding: mem time242, current time 333, horizon 91\n", + "adding: mem time243, current time 333, horizon 90\n", + "adding: mem time244, current time 333, horizon 89\n", + "adding: mem time245, current time 333, horizon 88\n", + "adding: mem time246, current time 333, horizon 87\n", + "adding: mem time247, current time 333, horizon 86\n", + "adding: mem time248, current time 333, horizon 85\n", + "adding: mem time249, current time 333, horizon 84\n", + "adding: mem time250, current time 333, horizon 83\n", + "adding: mem time251, current time 333, horizon 82\n", + "adding: mem time252, current time 333, horizon 81\n", + "adding: mem time253, current time 333, horizon 80\n", + "adding: mem time254, current time 333, horizon 79\n", + "adding: mem time255, current time 333, horizon 78\n", + "adding: mem time256, current time 333, horizon 77\n", + "adding: mem time257, current time 333, horizon 76\n", + "adding: mem time258, current time 333, horizon 75\n", + "adding: mem time259, current time 333, horizon 74\n", + "adding: mem time260, current time 333, horizon 73\n", + "adding: mem time261, current time 333, horizon 72\n", + "adding: mem time262, current time 333, horizon 71\n", + "adding: mem time263, current time 333, horizon 70\n", + "adding: mem time264, current time 333, horizon 69\n", + "adding: mem time265, current time 333, horizon 68\n", + "adding: mem time266, current time 333, horizon 67\n", + "adding: mem time267, current time 333, horizon 66\n", + "adding: mem time268, current time 333, horizon 65\n", + "adding: mem time269, current time 333, horizon 64\n", + "adding: mem time270, current time 333, horizon 63\n", + "adding: mem time271, current time 333, horizon 62\n", + "adding: mem time272, current time 333, horizon 61\n", + "adding: mem time273, current time 333, horizon 60\n", + "adding: mem time274, current time 333, horizon 59\n", + "adding: mem time275, current time 333, horizon 58\n", + "adding: mem time276, current time 333, horizon 57\n", + "adding: mem time277, current time 333, horizon 56\n", + "adding: mem time278, current time 333, horizon 55\n", + "adding: mem time279, current time 333, horizon 54\n", + "adding: mem time280, current time 333, horizon 53\n", + "adding: mem time281, current time 333, horizon 52\n", + "adding: mem time282, current time 333, horizon 51\n", + "adding: mem time283, current time 333, horizon 50\n", + "adding: mem time284, current time 333, horizon 49\n", + "adding: mem time285, current time 333, horizon 48\n", + "adding: mem time286, current time 333, horizon 47\n", + "adding: mem time287, current time 333, horizon 46\n", + "adding: mem time288, current time 333, horizon 45\n", + "adding: mem time289, current time 333, horizon 44\n", + "adding: mem time290, current time 333, horizon 43\n", + "adding: mem time291, current time 333, horizon 42\n", + "adding: mem time292, current time 333, horizon 41\n", + "adding: mem time293, current time 333, horizon 40\n", + "adding: mem time294, current time 333, horizon 39\n", + "adding: mem time295, current time 333, horizon 38\n", + "adding: mem time296, current time 333, horizon 37\n", + "adding: mem time297, current time 333, horizon 36\n", + "adding: mem time298, current time 333, horizon 35\n", + "adding: mem time299, current time 333, horizon 34\n", + "adding: mem time300, current time 333, horizon 33\n", + "adding: mem time301, current time 333, horizon 32\n", + "adding: mem time302, current time 333, horizon 31\n", + "adding: mem time303, current time 333, horizon 30\n", + "adding: mem time304, current time 333, horizon 29\n", + "adding: mem time305, current time 333, horizon 28\n", + "adding: mem time306, current time 333, horizon 27\n", + "adding: mem time307, current time 333, horizon 26\n", + "adding: mem time308, current time 333, horizon 25\n", + "adding: mem time309, current time 333, horizon 24\n", + "adding: mem time310, current time 333, horizon 23\n", + "adding: mem time311, current time 333, horizon 22\n", + "adding: mem time312, current time 333, horizon 21\n", + "adding: mem time313, current time 333, horizon 20\n", + "adding: mem time314, current time 333, horizon 19\n", + "adding: mem time315, current time 333, horizon 18\n", + "adding: mem time316, current time 333, horizon 17\n", + "adding: mem time317, current time 333, horizon 16\n", + "adding: mem time318, current time 333, horizon 15\n", + "adding: mem time319, current time 333, horizon 14\n", + "adding: mem time320, current time 333, horizon 13\n", + "adding: mem time321, current time 333, horizon 12\n", + "adding: mem time322, current time 333, horizon 11\n", + "adding: mem time323, current time 333, horizon 10\n", + "adding: mem time324, current time 333, horizon 9\n", + "adding: mem time325, current time 333, horizon 8\n", + "adding: mem time326, current time 333, horizon 7\n", + "adding: mem time327, current time 333, horizon 6\n", + "adding: mem time328, current time 333, horizon 5\n", + "adding: mem time329, current time 333, horizon 4\n", + "adding: mem time330, current time 333, horizon 3\n", + "adding: mem time331, current time 333, horizon 2\n", + "adding: mem time332, current time 333, horizon 1\n", + "adding: mem time200, current time 334, horizon 134\n", + "adding: mem time201, current time 334, horizon 133\n", + "adding: mem time202, current time 334, horizon 132\n", + "adding: mem time203, current time 334, horizon 131\n", + "adding: mem time204, current time 334, horizon 130\n", + "adding: mem time205, current time 334, horizon 129\n", + "adding: mem time206, current time 334, horizon 128\n", + "adding: mem time207, current time 334, horizon 127\n", + "adding: mem time208, current time 334, horizon 126\n", + "adding: mem time209, current time 334, horizon 125\n", + "adding: mem time210, current time 334, horizon 124\n", + "adding: mem time211, current time 334, horizon 123\n", + "adding: mem time212, current time 334, horizon 122\n", + "adding: mem time213, current time 334, horizon 121\n", + "adding: mem time214, current time 334, horizon 120\n", + "adding: mem time215, current time 334, horizon 119\n", + "adding: mem time216, current time 334, horizon 118\n", + "adding: mem time217, current time 334, horizon 117\n", + "adding: mem time218, current time 334, horizon 116\n", + "adding: mem time219, current time 334, horizon 115\n", + "adding: mem time220, current time 334, horizon 114\n", + "adding: mem time221, current time 334, horizon 113\n", + "adding: mem time222, current time 334, horizon 112\n", + "adding: mem time223, current time 334, horizon 111\n", + "adding: mem time224, current time 334, horizon 110\n", + "adding: mem time225, current time 334, horizon 109\n", + "adding: mem time226, current time 334, horizon 108\n", + "adding: mem time227, current time 334, horizon 107\n", + "adding: mem time228, current time 334, horizon 106\n", + "adding: mem time229, current time 334, horizon 105\n", + "adding: mem time230, current time 334, horizon 104\n", + "adding: mem time231, current time 334, horizon 103\n", + "adding: mem time232, current time 334, horizon 102\n", + "adding: mem time233, current time 334, horizon 101\n", + "adding: mem time234, current time 334, horizon 100\n", + "adding: mem time235, current time 334, horizon 99\n", + "adding: mem time236, current time 334, horizon 98\n", + "adding: mem time237, current time 334, horizon 97\n", + "adding: mem time238, current time 334, horizon 96\n", + "adding: mem time239, current time 334, horizon 95\n", + "adding: mem time240, current time 334, horizon 94\n", + "adding: mem time241, current time 334, horizon 93\n", + "adding: mem time242, current time 334, horizon 92\n", + "adding: mem time243, current time 334, horizon 91\n", + "adding: mem time244, current time 334, horizon 90\n", + "adding: mem time245, current time 334, horizon 89\n", + "adding: mem time246, current time 334, horizon 88\n", + "adding: mem time247, current time 334, horizon 87\n", + "adding: mem time248, current time 334, horizon 86\n", + "adding: mem time249, current time 334, horizon 85\n", + "adding: mem time250, current time 334, horizon 84\n", + "adding: mem time251, current time 334, horizon 83\n", + "adding: mem time252, current time 334, horizon 82\n", + "adding: mem time253, current time 334, horizon 81\n", + "adding: mem time254, current time 334, horizon 80\n", + "adding: mem time255, current time 334, horizon 79\n", + "adding: mem time256, current time 334, horizon 78\n", + "adding: mem time257, current time 334, horizon 77\n", + "adding: mem time258, current time 334, horizon 76\n", + "adding: mem time259, current time 334, horizon 75\n", + "adding: mem time260, current time 334, horizon 74\n", + "adding: mem time261, current time 334, horizon 73\n", + "adding: mem time262, current time 334, horizon 72\n", + "adding: mem time263, current time 334, horizon 71\n", + "adding: mem time264, current time 334, horizon 70\n", + "adding: mem time265, current time 334, horizon 69\n", + "adding: mem time266, current time 334, horizon 68\n", + "adding: mem time267, current time 334, horizon 67\n", + "adding: mem time268, current time 334, horizon 66\n", + "adding: mem time269, current time 334, horizon 65\n", + "adding: mem time270, current time 334, horizon 64\n", + "adding: mem time271, current time 334, horizon 63\n", + "adding: mem time272, current time 334, horizon 62\n", + "adding: mem time273, current time 334, horizon 61\n", + "adding: mem time274, current time 334, horizon 60\n", + "adding: mem time275, current time 334, horizon 59\n", + "adding: mem time276, current time 334, horizon 58\n", + "adding: mem time277, current time 334, horizon 57\n", + "adding: mem time278, current time 334, horizon 56\n", + "adding: mem time279, current time 334, horizon 55\n", + "adding: mem time280, current time 334, horizon 54\n", + "adding: mem time281, current time 334, horizon 53\n", + "adding: mem time282, current time 334, horizon 52\n", + "adding: mem time283, current time 334, horizon 51\n", + "adding: mem time284, current time 334, horizon 50\n", + "adding: mem time285, current time 334, horizon 49\n", + "adding: mem time286, current time 334, horizon 48\n", + "adding: mem time287, current time 334, horizon 47\n", + "adding: mem time288, current time 334, horizon 46\n", + "adding: mem time289, current time 334, horizon 45\n", + "adding: mem time290, current time 334, horizon 44\n", + "adding: mem time291, current time 334, horizon 43\n", + "adding: mem time292, current time 334, horizon 42\n", + "adding: mem time293, current time 334, horizon 41\n", + "adding: mem time294, current time 334, horizon 40\n", + "adding: mem time295, current time 334, horizon 39\n", + "adding: mem time296, current time 334, horizon 38\n", + "adding: mem time297, current time 334, horizon 37\n", + "adding: mem time298, current time 334, horizon 36\n", + "adding: mem time299, current time 334, horizon 35\n", + "adding: mem time300, current time 334, horizon 34\n", + "adding: mem time301, current time 334, horizon 33\n", + "adding: mem time302, current time 334, horizon 32\n", + "adding: mem time303, current time 334, horizon 31\n", + "adding: mem time304, current time 334, horizon 30\n", + "adding: mem time305, current time 334, horizon 29\n", + "adding: mem time306, current time 334, horizon 28\n", + "adding: mem time307, current time 334, horizon 27\n", + "adding: mem time308, current time 334, horizon 26\n", + "adding: mem time309, current time 334, horizon 25\n", + "adding: mem time310, current time 334, horizon 24\n", + "adding: mem time311, current time 334, horizon 23\n", + "adding: mem time312, current time 334, horizon 22\n", + "adding: mem time313, current time 334, horizon 21\n", + "adding: mem time314, current time 334, horizon 20\n", + "adding: mem time315, current time 334, horizon 19\n", + "adding: mem time316, current time 334, horizon 18\n", + "adding: mem time317, current time 334, horizon 17\n", + "adding: mem time318, current time 334, horizon 16\n", + "adding: mem time319, current time 334, horizon 15\n", + "adding: mem time320, current time 334, horizon 14\n", + "adding: mem time321, current time 334, horizon 13\n", + "adding: mem time322, current time 334, horizon 12\n", + "adding: mem time323, current time 334, horizon 11\n", + "adding: mem time324, current time 334, horizon 10\n", + "adding: mem time325, current time 334, horizon 9\n", + "adding: mem time326, current time 334, horizon 8\n", + "adding: mem time327, current time 334, horizon 7\n", + "adding: mem time328, current time 334, horizon 6\n", + "adding: mem time329, current time 334, horizon 5\n", + "adding: mem time330, current time 334, horizon 4\n", + "adding: mem time331, current time 334, horizon 3\n", + "adding: mem time332, current time 334, horizon 2\n", + "adding: mem time333, current time 334, horizon 1\n", + "adding: mem time200, current time 335, horizon 135\n", + "adding: mem time201, current time 335, horizon 134\n", + "adding: mem time202, current time 335, horizon 133\n", + "adding: mem time203, current time 335, horizon 132\n", + "adding: mem time204, current time 335, horizon 131\n", + "adding: mem time205, current time 335, horizon 130\n", + "adding: mem time206, current time 335, horizon 129\n", + "adding: mem time207, current time 335, horizon 128\n", + "adding: mem time208, current time 335, horizon 127\n", + "adding: mem time209, current time 335, horizon 126\n", + "adding: mem time210, current time 335, horizon 125\n", + "adding: mem time211, current time 335, horizon 124\n", + "adding: mem time212, current time 335, horizon 123\n", + "adding: mem time213, current time 335, horizon 122\n", + "adding: mem time214, current time 335, horizon 121\n", + "adding: mem time215, current time 335, horizon 120\n", + "adding: mem time216, current time 335, horizon 119\n", + "adding: mem time217, current time 335, horizon 118\n", + "adding: mem time218, current time 335, horizon 117\n", + "adding: mem time219, current time 335, horizon 116\n", + "adding: mem time220, current time 335, horizon 115\n", + "adding: mem time221, current time 335, horizon 114\n", + "adding: mem time222, current time 335, horizon 113\n", + "adding: mem time223, current time 335, horizon 112\n", + "adding: mem time224, current time 335, horizon 111\n", + "adding: mem time225, current time 335, horizon 110\n", + "adding: mem time226, current time 335, horizon 109\n", + "adding: mem time227, current time 335, horizon 108\n", + "adding: mem time228, current time 335, horizon 107\n", + "adding: mem time229, current time 335, horizon 106\n", + "adding: mem time230, current time 335, horizon 105\n", + "adding: mem time231, current time 335, horizon 104\n", + "adding: mem time232, current time 335, horizon 103\n", + "adding: mem time233, current time 335, horizon 102\n", + "adding: mem time234, current time 335, horizon 101\n", + "adding: mem time235, current time 335, horizon 100\n", + "adding: mem time236, current time 335, horizon 99\n", + "adding: mem time237, current time 335, horizon 98\n", + "adding: mem time238, current time 335, horizon 97\n", + "adding: mem time239, current time 335, horizon 96\n", + "adding: mem time240, current time 335, horizon 95\n", + "adding: mem time241, current time 335, horizon 94\n", + "adding: mem time242, current time 335, horizon 93\n", + "adding: mem time243, current time 335, horizon 92\n", + "adding: mem time244, current time 335, horizon 91\n", + "adding: mem time245, current time 335, horizon 90\n", + "adding: mem time246, current time 335, horizon 89\n", + "adding: mem time247, current time 335, horizon 88\n", + "adding: mem time248, current time 335, horizon 87\n", + "adding: mem time249, current time 335, horizon 86\n", + "adding: mem time250, current time 335, horizon 85\n", + "adding: mem time251, current time 335, horizon 84\n", + "adding: mem time252, current time 335, horizon 83\n", + "adding: mem time253, current time 335, horizon 82\n", + "adding: mem time254, current time 335, horizon 81\n", + "adding: mem time255, current time 335, horizon 80\n", + "adding: mem time256, current time 335, horizon 79\n", + "adding: mem time257, current time 335, horizon 78\n", + "adding: mem time258, current time 335, horizon 77\n", + "adding: mem time259, current time 335, horizon 76\n", + "adding: mem time260, current time 335, horizon 75\n", + "adding: mem time261, current time 335, horizon 74\n", + "adding: mem time262, current time 335, horizon 73\n", + "adding: mem time263, current time 335, horizon 72\n", + "adding: mem time264, current time 335, horizon 71\n", + "adding: mem time265, current time 335, horizon 70\n", + "adding: mem time266, current time 335, horizon 69\n", + "adding: mem time267, current time 335, horizon 68\n", + "adding: mem time268, current time 335, horizon 67\n", + "adding: mem time269, current time 335, horizon 66\n", + "adding: mem time270, current time 335, horizon 65\n", + "adding: mem time271, current time 335, horizon 64\n", + "adding: mem time272, current time 335, horizon 63\n", + "adding: mem time273, current time 335, horizon 62\n", + "adding: mem time274, current time 335, horizon 61\n", + "adding: mem time275, current time 335, horizon 60\n", + "adding: mem time276, current time 335, horizon 59\n", + "adding: mem time277, current time 335, horizon 58\n", + "adding: mem time278, current time 335, horizon 57\n", + "adding: mem time279, current time 335, horizon 56\n", + "adding: mem time280, current time 335, horizon 55\n", + "adding: mem time281, current time 335, horizon 54\n", + "adding: mem time282, current time 335, horizon 53\n", + "adding: mem time283, current time 335, horizon 52\n", + "adding: mem time284, current time 335, horizon 51\n", + "adding: mem time285, current time 335, horizon 50\n", + "adding: mem time286, current time 335, horizon 49\n", + "adding: mem time287, current time 335, horizon 48\n", + "adding: mem time288, current time 335, horizon 47\n", + "adding: mem time289, current time 335, horizon 46\n", + "adding: mem time290, current time 335, horizon 45\n", + "adding: mem time291, current time 335, horizon 44\n", + "adding: mem time292, current time 335, horizon 43\n", + "adding: mem time293, current time 335, horizon 42\n", + "adding: mem time294, current time 335, horizon 41\n", + "adding: mem time295, current time 335, horizon 40\n", + "adding: mem time296, current time 335, horizon 39\n", + "adding: mem time297, current time 335, horizon 38\n", + "adding: mem time298, current time 335, horizon 37\n", + "adding: mem time299, current time 335, horizon 36\n", + "adding: mem time300, current time 335, horizon 35\n", + "adding: mem time301, current time 335, horizon 34\n", + "adding: mem time302, current time 335, horizon 33\n", + "adding: mem time303, current time 335, horizon 32\n", + "adding: mem time304, current time 335, horizon 31\n", + "adding: mem time305, current time 335, horizon 30\n", + "adding: mem time306, current time 335, horizon 29\n", + "adding: mem time307, current time 335, horizon 28\n", + "adding: mem time308, current time 335, horizon 27\n", + "adding: mem time309, current time 335, horizon 26\n", + "adding: mem time310, current time 335, horizon 25\n", + "adding: mem time311, current time 335, horizon 24\n", + "adding: mem time312, current time 335, horizon 23\n", + "adding: mem time313, current time 335, horizon 22\n", + "adding: mem time314, current time 335, horizon 21\n", + "adding: mem time315, current time 335, horizon 20\n", + "adding: mem time316, current time 335, horizon 19\n", + "adding: mem time317, current time 335, horizon 18\n", + "adding: mem time318, current time 335, horizon 17\n", + "adding: mem time319, current time 335, horizon 16\n", + "adding: mem time320, current time 335, horizon 15\n", + "adding: mem time321, current time 335, horizon 14\n", + "adding: mem time322, current time 335, horizon 13\n", + "adding: mem time323, current time 335, horizon 12\n", + "adding: mem time324, current time 335, horizon 11\n", + "adding: mem time325, current time 335, horizon 10\n", + "adding: mem time326, current time 335, horizon 9\n", + "adding: mem time327, current time 335, horizon 8\n", + "adding: mem time328, current time 335, horizon 7\n", + "adding: mem time329, current time 335, horizon 6\n", + "adding: mem time330, current time 335, horizon 5\n", + "adding: mem time331, current time 335, horizon 4\n", + "adding: mem time332, current time 335, horizon 3\n", + "adding: mem time333, current time 335, horizon 2\n", + "adding: mem time334, current time 335, horizon 1\n", + "adding: mem time200, current time 336, horizon 136\n", + "adding: mem time201, current time 336, horizon 135\n", + "adding: mem time202, current time 336, horizon 134\n", + "adding: mem time203, current time 336, horizon 133\n", + "adding: mem time204, current time 336, horizon 132\n", + "adding: mem time205, current time 336, horizon 131\n", + "adding: mem time206, current time 336, horizon 130\n", + "adding: mem time207, current time 336, horizon 129\n", + "adding: mem time208, current time 336, horizon 128\n", + "adding: mem time209, current time 336, horizon 127\n", + "adding: mem time210, current time 336, horizon 126\n", + "adding: mem time211, current time 336, horizon 125\n", + "adding: mem time212, current time 336, horizon 124\n", + "adding: mem time213, current time 336, horizon 123\n", + "adding: mem time214, current time 336, horizon 122\n", + "adding: mem time215, current time 336, horizon 121\n", + "adding: mem time216, current time 336, horizon 120\n", + "adding: mem time217, current time 336, horizon 119\n", + "adding: mem time218, current time 336, horizon 118\n", + "adding: mem time219, current time 336, horizon 117\n", + "adding: mem time220, current time 336, horizon 116\n", + "adding: mem time221, current time 336, horizon 115\n", + "adding: mem time222, current time 336, horizon 114\n", + "adding: mem time223, current time 336, horizon 113\n", + "adding: mem time224, current time 336, horizon 112\n", + "adding: mem time225, current time 336, horizon 111\n", + "adding: mem time226, current time 336, horizon 110\n", + "adding: mem time227, current time 336, horizon 109\n", + "adding: mem time228, current time 336, horizon 108\n", + "adding: mem time229, current time 336, horizon 107\n", + "adding: mem time230, current time 336, horizon 106\n", + "adding: mem time231, current time 336, horizon 105\n", + "adding: mem time232, current time 336, horizon 104\n", + "adding: mem time233, current time 336, horizon 103\n", + "adding: mem time234, current time 336, horizon 102\n", + "adding: mem time235, current time 336, horizon 101\n", + "adding: mem time236, current time 336, horizon 100\n", + "adding: mem time237, current time 336, horizon 99\n", + "adding: mem time238, current time 336, horizon 98\n", + "adding: mem time239, current time 336, horizon 97\n", + "adding: mem time240, current time 336, horizon 96\n", + "adding: mem time241, current time 336, horizon 95\n", + "adding: mem time242, current time 336, horizon 94\n", + "adding: mem time243, current time 336, horizon 93\n", + "adding: mem time244, current time 336, horizon 92\n", + "adding: mem time245, current time 336, horizon 91\n", + "adding: mem time246, current time 336, horizon 90\n", + "adding: mem time247, current time 336, horizon 89\n", + "adding: mem time248, current time 336, horizon 88\n", + "adding: mem time249, current time 336, horizon 87\n", + "adding: mem time250, current time 336, horizon 86\n", + "adding: mem time251, current time 336, horizon 85\n", + "adding: mem time252, current time 336, horizon 84\n", + "adding: mem time253, current time 336, horizon 83\n", + "adding: mem time254, current time 336, horizon 82\n", + "adding: mem time255, current time 336, horizon 81\n", + "adding: mem time256, current time 336, horizon 80\n", + "adding: mem time257, current time 336, horizon 79\n", + "adding: mem time258, current time 336, horizon 78\n", + "adding: mem time259, current time 336, horizon 77\n", + "adding: mem time260, current time 336, horizon 76\n", + "adding: mem time261, current time 336, horizon 75\n", + "adding: mem time262, current time 336, horizon 74\n", + "adding: mem time263, current time 336, horizon 73\n", + "adding: mem time264, current time 336, horizon 72\n", + "adding: mem time265, current time 336, horizon 71\n", + "adding: mem time266, current time 336, horizon 70\n", + "adding: mem time267, current time 336, horizon 69\n", + "adding: mem time268, current time 336, horizon 68\n", + "adding: mem time269, current time 336, horizon 67\n", + "adding: mem time270, current time 336, horizon 66\n", + "adding: mem time271, current time 336, horizon 65\n", + "adding: mem time272, current time 336, horizon 64\n", + "adding: mem time273, current time 336, horizon 63\n", + "adding: mem time274, current time 336, horizon 62\n", + "adding: mem time275, current time 336, horizon 61\n", + "adding: mem time276, current time 336, horizon 60\n", + "adding: mem time277, current time 336, horizon 59\n", + "adding: mem time278, current time 336, horizon 58\n", + "adding: mem time279, current time 336, horizon 57\n", + "adding: mem time280, current time 336, horizon 56\n", + "adding: mem time281, current time 336, horizon 55\n", + "adding: mem time282, current time 336, horizon 54\n", + "adding: mem time283, current time 336, horizon 53\n", + "adding: mem time284, current time 336, horizon 52\n", + "adding: mem time285, current time 336, horizon 51\n", + "adding: mem time286, current time 336, horizon 50\n", + "adding: mem time287, current time 336, horizon 49\n", + "adding: mem time288, current time 336, horizon 48\n", + "adding: mem time289, current time 336, horizon 47\n", + "adding: mem time290, current time 336, horizon 46\n", + "adding: mem time291, current time 336, horizon 45\n", + "adding: mem time292, current time 336, horizon 44\n", + "adding: mem time293, current time 336, horizon 43\n", + "adding: mem time294, current time 336, horizon 42\n", + "adding: mem time295, current time 336, horizon 41\n", + "adding: mem time296, current time 336, horizon 40\n", + "adding: mem time297, current time 336, horizon 39\n", + "adding: mem time298, current time 336, horizon 38\n", + "adding: mem time299, current time 336, horizon 37\n", + "adding: mem time300, current time 336, horizon 36\n", + "adding: mem time301, current time 336, horizon 35\n", + "adding: mem time302, current time 336, horizon 34\n", + "adding: mem time303, current time 336, horizon 33\n", + "adding: mem time304, current time 336, horizon 32\n", + "adding: mem time305, current time 336, horizon 31\n", + "adding: mem time306, current time 336, horizon 30\n", + "adding: mem time307, current time 336, horizon 29\n", + "adding: mem time308, current time 336, horizon 28\n", + "adding: mem time309, current time 336, horizon 27\n", + "adding: mem time310, current time 336, horizon 26\n", + "adding: mem time311, current time 336, horizon 25\n", + "adding: mem time312, current time 336, horizon 24\n", + "adding: mem time313, current time 336, horizon 23\n", + "adding: mem time314, current time 336, horizon 22\n", + "adding: mem time315, current time 336, horizon 21\n", + "adding: mem time316, current time 336, horizon 20\n", + "adding: mem time317, current time 336, horizon 19\n", + "adding: mem time318, current time 336, horizon 18\n", + "adding: mem time319, current time 336, horizon 17\n", + "adding: mem time320, current time 336, horizon 16\n", + "adding: mem time321, current time 336, horizon 15\n", + "adding: mem time322, current time 336, horizon 14\n", + "adding: mem time323, current time 336, horizon 13\n", + "adding: mem time324, current time 336, horizon 12\n", + "adding: mem time325, current time 336, horizon 11\n", + "adding: mem time326, current time 336, horizon 10\n", + "adding: mem time327, current time 336, horizon 9\n", + "adding: mem time328, current time 336, horizon 8\n", + "adding: mem time329, current time 336, horizon 7\n", + "adding: mem time330, current time 336, horizon 6\n", + "adding: mem time331, current time 336, horizon 5\n", + "adding: mem time332, current time 336, horizon 4\n", + "adding: mem time333, current time 336, horizon 3\n", + "adding: mem time334, current time 336, horizon 2\n", + "adding: mem time335, current time 336, horizon 1\n", + "adding: mem time200, current time 337, horizon 137\n", + "adding: mem time201, current time 337, horizon 136\n", + "adding: mem time202, current time 337, horizon 135\n", + "adding: mem time203, current time 337, horizon 134\n", + "adding: mem time204, current time 337, horizon 133\n", + "adding: mem time205, current time 337, horizon 132\n", + "adding: mem time206, current time 337, horizon 131\n", + "adding: mem time207, current time 337, horizon 130\n", + "adding: mem time208, current time 337, horizon 129\n", + "adding: mem time209, current time 337, horizon 128\n", + "adding: mem time210, current time 337, horizon 127\n", + "adding: mem time211, current time 337, horizon 126\n", + "adding: mem time212, current time 337, horizon 125\n", + "adding: mem time213, current time 337, horizon 124\n", + "adding: mem time214, current time 337, horizon 123\n", + "adding: mem time215, current time 337, horizon 122\n", + "adding: mem time216, current time 337, horizon 121\n", + "adding: mem time217, current time 337, horizon 120\n", + "adding: mem time218, current time 337, horizon 119\n", + "adding: mem time219, current time 337, horizon 118\n", + "adding: mem time220, current time 337, horizon 117\n", + "adding: mem time221, current time 337, horizon 116\n", + "adding: mem time222, current time 337, horizon 115\n", + "adding: mem time223, current time 337, horizon 114\n", + "adding: mem time224, current time 337, horizon 113\n", + "adding: mem time225, current time 337, horizon 112\n", + "adding: mem time226, current time 337, horizon 111\n", + "adding: mem time227, current time 337, horizon 110\n", + "adding: mem time228, current time 337, horizon 109\n", + "adding: mem time229, current time 337, horizon 108\n", + "adding: mem time230, current time 337, horizon 107\n", + "adding: mem time231, current time 337, horizon 106\n", + "adding: mem time232, current time 337, horizon 105\n", + "adding: mem time233, current time 337, horizon 104\n", + "adding: mem time234, current time 337, horizon 103\n", + "adding: mem time235, current time 337, horizon 102\n", + "adding: mem time236, current time 337, horizon 101\n", + "adding: mem time237, current time 337, horizon 100\n", + "adding: mem time238, current time 337, horizon 99\n", + "adding: mem time239, current time 337, horizon 98\n", + "adding: mem time240, current time 337, horizon 97\n", + "adding: mem time241, current time 337, horizon 96\n", + "adding: mem time242, current time 337, horizon 95\n", + "adding: mem time243, current time 337, horizon 94\n", + "adding: mem time244, current time 337, horizon 93\n", + "adding: mem time245, current time 337, horizon 92\n", + "adding: mem time246, current time 337, horizon 91\n", + "adding: mem time247, current time 337, horizon 90\n", + "adding: mem time248, current time 337, horizon 89\n", + "adding: mem time249, current time 337, horizon 88\n", + "adding: mem time250, current time 337, horizon 87\n", + "adding: mem time251, current time 337, horizon 86\n", + "adding: mem time252, current time 337, horizon 85\n", + "adding: mem time253, current time 337, horizon 84\n", + "adding: mem time254, current time 337, horizon 83\n", + "adding: mem time255, current time 337, horizon 82\n", + "adding: mem time256, current time 337, horizon 81\n", + "adding: mem time257, current time 337, horizon 80\n", + "adding: mem time258, current time 337, horizon 79\n", + "adding: mem time259, current time 337, horizon 78\n", + "adding: mem time260, current time 337, horizon 77\n", + "adding: mem time261, current time 337, horizon 76\n", + "adding: mem time262, current time 337, horizon 75\n", + "adding: mem time263, current time 337, horizon 74\n", + "adding: mem time264, current time 337, horizon 73\n", + "adding: mem time265, current time 337, horizon 72\n", + "adding: mem time266, current time 337, horizon 71\n", + "adding: mem time267, current time 337, horizon 70\n", + "adding: mem time268, current time 337, horizon 69\n", + "adding: mem time269, current time 337, horizon 68\n", + "adding: mem time270, current time 337, horizon 67\n", + "adding: mem time271, current time 337, horizon 66\n", + "adding: mem time272, current time 337, horizon 65\n", + "adding: mem time273, current time 337, horizon 64\n", + "adding: mem time274, current time 337, horizon 63\n", + "adding: mem time275, current time 337, horizon 62\n", + "adding: mem time276, current time 337, horizon 61\n", + "adding: mem time277, current time 337, horizon 60\n", + "adding: mem time278, current time 337, horizon 59\n", + "adding: mem time279, current time 337, horizon 58\n", + "adding: mem time280, current time 337, horizon 57\n", + "adding: mem time281, current time 337, horizon 56\n", + "adding: mem time282, current time 337, horizon 55\n", + "adding: mem time283, current time 337, horizon 54\n", + "adding: mem time284, current time 337, horizon 53\n", + "adding: mem time285, current time 337, horizon 52\n", + "adding: mem time286, current time 337, horizon 51\n", + "adding: mem time287, current time 337, horizon 50\n", + "adding: mem time288, current time 337, horizon 49\n", + "adding: mem time289, current time 337, horizon 48\n", + "adding: mem time290, current time 337, horizon 47\n", + "adding: mem time291, current time 337, horizon 46\n", + "adding: mem time292, current time 337, horizon 45\n", + "adding: mem time293, current time 337, horizon 44\n", + "adding: mem time294, current time 337, horizon 43\n", + "adding: mem time295, current time 337, horizon 42\n", + "adding: mem time296, current time 337, horizon 41\n", + "adding: mem time297, current time 337, horizon 40\n", + "adding: mem time298, current time 337, horizon 39\n", + "adding: mem time299, current time 337, horizon 38\n", + "adding: mem time300, current time 337, horizon 37\n", + "adding: mem time301, current time 337, horizon 36\n", + "adding: mem time302, current time 337, horizon 35\n", + "adding: mem time303, current time 337, horizon 34\n", + "adding: mem time304, current time 337, horizon 33\n", + "adding: mem time305, current time 337, horizon 32\n", + "adding: mem time306, current time 337, horizon 31\n", + "adding: mem time307, current time 337, horizon 30\n", + "adding: mem time308, current time 337, horizon 29\n", + "adding: mem time309, current time 337, horizon 28\n", + "adding: mem time310, current time 337, horizon 27\n", + "adding: mem time311, current time 337, horizon 26\n", + "adding: mem time312, current time 337, horizon 25\n", + "adding: mem time313, current time 337, horizon 24\n", + "adding: mem time314, current time 337, horizon 23\n", + "adding: mem time315, current time 337, horizon 22\n", + "adding: mem time316, current time 337, horizon 21\n", + "adding: mem time317, current time 337, horizon 20\n", + "adding: mem time318, current time 337, horizon 19\n", + "adding: mem time319, current time 337, horizon 18\n", + "adding: mem time320, current time 337, horizon 17\n", + "adding: mem time321, current time 337, horizon 16\n", + "adding: mem time322, current time 337, horizon 15\n", + "adding: mem time323, current time 337, horizon 14\n", + "adding: mem time324, current time 337, horizon 13\n", + "adding: mem time325, current time 337, horizon 12\n", + "adding: mem time326, current time 337, horizon 11\n", + "adding: mem time327, current time 337, horizon 10\n", + "adding: mem time328, current time 337, horizon 9\n", + "adding: mem time329, current time 337, horizon 8\n", + "adding: mem time330, current time 337, horizon 7\n", + "adding: mem time331, current time 337, horizon 6\n", + "adding: mem time332, current time 337, horizon 5\n", + "adding: mem time333, current time 337, horizon 4\n", + "adding: mem time334, current time 337, horizon 3\n", + "adding: mem time335, current time 337, horizon 2\n", + "adding: mem time336, current time 337, horizon 1\n", + "adding: mem time200, current time 338, horizon 138\n", + "adding: mem time201, current time 338, horizon 137\n", + "adding: mem time202, current time 338, horizon 136\n", + "adding: mem time203, current time 338, horizon 135\n", + "adding: mem time204, current time 338, horizon 134\n", + "adding: mem time205, current time 338, horizon 133\n", + "adding: mem time206, current time 338, horizon 132\n", + "adding: mem time207, current time 338, horizon 131\n", + "adding: mem time208, current time 338, horizon 130\n", + "adding: mem time209, current time 338, horizon 129\n", + "adding: mem time210, current time 338, horizon 128\n", + "adding: mem time211, current time 338, horizon 127\n", + "adding: mem time212, current time 338, horizon 126\n", + "adding: mem time213, current time 338, horizon 125\n", + "adding: mem time214, current time 338, horizon 124\n", + "adding: mem time215, current time 338, horizon 123\n", + "adding: mem time216, current time 338, horizon 122\n", + "adding: mem time217, current time 338, horizon 121\n", + "adding: mem time218, current time 338, horizon 120\n", + "adding: mem time219, current time 338, horizon 119\n", + "adding: mem time220, current time 338, horizon 118\n", + "adding: mem time221, current time 338, horizon 117\n", + "adding: mem time222, current time 338, horizon 116\n", + "adding: mem time223, current time 338, horizon 115\n", + "adding: mem time224, current time 338, horizon 114\n", + "adding: mem time225, current time 338, horizon 113\n", + "adding: mem time226, current time 338, horizon 112\n", + "adding: mem time227, current time 338, horizon 111\n", + "adding: mem time228, current time 338, horizon 110\n", + "adding: mem time229, current time 338, horizon 109\n", + "adding: mem time230, current time 338, horizon 108\n", + "adding: mem time231, current time 338, horizon 107\n", + "adding: mem time232, current time 338, horizon 106\n", + "adding: mem time233, current time 338, horizon 105\n", + "adding: mem time234, current time 338, horizon 104\n", + "adding: mem time235, current time 338, horizon 103\n", + "adding: mem time236, current time 338, horizon 102\n", + "adding: mem time237, current time 338, horizon 101\n", + "adding: mem time238, current time 338, horizon 100\n", + "adding: mem time239, current time 338, horizon 99\n", + "adding: mem time240, current time 338, horizon 98\n", + "adding: mem time241, current time 338, horizon 97\n", + "adding: mem time242, current time 338, horizon 96\n", + "adding: mem time243, current time 338, horizon 95\n", + "adding: mem time244, current time 338, horizon 94\n", + "adding: mem time245, current time 338, horizon 93\n", + "adding: mem time246, current time 338, horizon 92\n", + "adding: mem time247, current time 338, horizon 91\n", + "adding: mem time248, current time 338, horizon 90\n", + "adding: mem time249, current time 338, horizon 89\n", + "adding: mem time250, current time 338, horizon 88\n", + "adding: mem time251, current time 338, horizon 87\n", + "adding: mem time252, current time 338, horizon 86\n", + "adding: mem time253, current time 338, horizon 85\n", + "adding: mem time254, current time 338, horizon 84\n", + "adding: mem time255, current time 338, horizon 83\n", + "adding: mem time256, current time 338, horizon 82\n", + "adding: mem time257, current time 338, horizon 81\n", + "adding: mem time258, current time 338, horizon 80\n", + "adding: mem time259, current time 338, horizon 79\n", + "adding: mem time260, current time 338, horizon 78\n", + "adding: mem time261, current time 338, horizon 77\n", + "adding: mem time262, current time 338, horizon 76\n", + "adding: mem time263, current time 338, horizon 75\n", + "adding: mem time264, current time 338, horizon 74\n", + "adding: mem time265, current time 338, horizon 73\n", + "adding: mem time266, current time 338, horizon 72\n", + "adding: mem time267, current time 338, horizon 71\n", + "adding: mem time268, current time 338, horizon 70\n", + "adding: mem time269, current time 338, horizon 69\n", + "adding: mem time270, current time 338, horizon 68\n", + "adding: mem time271, current time 338, horizon 67\n", + "adding: mem time272, current time 338, horizon 66\n", + "adding: mem time273, current time 338, horizon 65\n", + "adding: mem time274, current time 338, horizon 64\n", + "adding: mem time275, current time 338, horizon 63\n", + "adding: mem time276, current time 338, horizon 62\n", + "adding: mem time277, current time 338, horizon 61\n", + "adding: mem time278, current time 338, horizon 60\n", + "adding: mem time279, current time 338, horizon 59\n", + "adding: mem time280, current time 338, horizon 58\n", + "adding: mem time281, current time 338, horizon 57\n", + "adding: mem time282, current time 338, horizon 56\n", + "adding: mem time283, current time 338, horizon 55\n", + "adding: mem time284, current time 338, horizon 54\n", + "adding: mem time285, current time 338, horizon 53\n", + "adding: mem time286, current time 338, horizon 52\n", + "adding: mem time287, current time 338, horizon 51\n", + "adding: mem time288, current time 338, horizon 50\n", + "adding: mem time289, current time 338, horizon 49\n", + "adding: mem time290, current time 338, horizon 48\n", + "adding: mem time291, current time 338, horizon 47\n", + "adding: mem time292, current time 338, horizon 46\n", + "adding: mem time293, current time 338, horizon 45\n", + "adding: mem time294, current time 338, horizon 44\n", + "adding: mem time295, current time 338, horizon 43\n", + "adding: mem time296, current time 338, horizon 42\n", + "adding: mem time297, current time 338, horizon 41\n", + "adding: mem time298, current time 338, horizon 40\n", + "adding: mem time299, current time 338, horizon 39\n", + "adding: mem time300, current time 338, horizon 38\n", + "adding: mem time301, current time 338, horizon 37\n", + "adding: mem time302, current time 338, horizon 36\n", + "adding: mem time303, current time 338, horizon 35\n", + "adding: mem time304, current time 338, horizon 34\n", + "adding: mem time305, current time 338, horizon 33\n", + "adding: mem time306, current time 338, horizon 32\n", + "adding: mem time307, current time 338, horizon 31\n", + "adding: mem time308, current time 338, horizon 30\n", + "adding: mem time309, current time 338, horizon 29\n", + "adding: mem time310, current time 338, horizon 28\n", + "adding: mem time311, current time 338, horizon 27\n", + "adding: mem time312, current time 338, horizon 26\n", + "adding: mem time313, current time 338, horizon 25\n", + "adding: mem time314, current time 338, horizon 24\n", + "adding: mem time315, current time 338, horizon 23\n", + "adding: mem time316, current time 338, horizon 22\n", + "adding: mem time317, current time 338, horizon 21\n", + "adding: mem time318, current time 338, horizon 20\n", + "adding: mem time319, current time 338, horizon 19\n", + "adding: mem time320, current time 338, horizon 18\n", + "adding: mem time321, current time 338, horizon 17\n", + "adding: mem time322, current time 338, horizon 16\n", + "adding: mem time323, current time 338, horizon 15\n", + "adding: mem time324, current time 338, horizon 14\n", + "adding: mem time325, current time 338, horizon 13\n", + "adding: mem time326, current time 338, horizon 12\n", + "adding: mem time327, current time 338, horizon 11\n", + "adding: mem time328, current time 338, horizon 10\n", + "adding: mem time329, current time 338, horizon 9\n", + "adding: mem time330, current time 338, horizon 8\n", + "adding: mem time331, current time 338, horizon 7\n", + "adding: mem time332, current time 338, horizon 6\n", + "adding: mem time333, current time 338, horizon 5\n", + "adding: mem time334, current time 338, horizon 4\n", + "adding: mem time335, current time 338, horizon 3\n", + "adding: mem time336, current time 338, horizon 2\n", + "adding: mem time337, current time 338, horizon 1\n", + "adding: mem time200, current time 339, horizon 139\n", + "adding: mem time201, current time 339, horizon 138\n", + "adding: mem time202, current time 339, horizon 137\n", + "adding: mem time203, current time 339, horizon 136\n", + "adding: mem time204, current time 339, horizon 135\n", + "adding: mem time205, current time 339, horizon 134\n", + "adding: mem time206, current time 339, horizon 133\n", + "adding: mem time207, current time 339, horizon 132\n", + "adding: mem time208, current time 339, horizon 131\n", + "adding: mem time209, current time 339, horizon 130\n", + "adding: mem time210, current time 339, horizon 129\n", + "adding: mem time211, current time 339, horizon 128\n", + "adding: mem time212, current time 339, horizon 127\n", + "adding: mem time213, current time 339, horizon 126\n", + "adding: mem time214, current time 339, horizon 125\n", + "adding: mem time215, current time 339, horizon 124\n", + "adding: mem time216, current time 339, horizon 123\n", + "adding: mem time217, current time 339, horizon 122\n", + "adding: mem time218, current time 339, horizon 121\n", + "adding: mem time219, current time 339, horizon 120\n", + "adding: mem time220, current time 339, horizon 119\n", + "adding: mem time221, current time 339, horizon 118\n", + "adding: mem time222, current time 339, horizon 117\n", + "adding: mem time223, current time 339, horizon 116\n", + "adding: mem time224, current time 339, horizon 115\n", + "adding: mem time225, current time 339, horizon 114\n", + "adding: mem time226, current time 339, horizon 113\n", + "adding: mem time227, current time 339, horizon 112\n", + "adding: mem time228, current time 339, horizon 111\n", + "adding: mem time229, current time 339, horizon 110\n", + "adding: mem time230, current time 339, horizon 109\n", + "adding: mem time231, current time 339, horizon 108\n", + "adding: mem time232, current time 339, horizon 107\n", + "adding: mem time233, current time 339, horizon 106\n", + "adding: mem time234, current time 339, horizon 105\n", + "adding: mem time235, current time 339, horizon 104\n", + "adding: mem time236, current time 339, horizon 103\n", + "adding: mem time237, current time 339, horizon 102\n", + "adding: mem time238, current time 339, horizon 101\n", + "adding: mem time239, current time 339, horizon 100\n", + "adding: mem time240, current time 339, horizon 99\n", + "adding: mem time241, current time 339, horizon 98\n", + "adding: mem time242, current time 339, horizon 97\n", + "adding: mem time243, current time 339, horizon 96\n", + "adding: mem time244, current time 339, horizon 95\n", + "adding: mem time245, current time 339, horizon 94\n", + "adding: mem time246, current time 339, horizon 93\n", + "adding: mem time247, current time 339, horizon 92\n", + "adding: mem time248, current time 339, horizon 91\n", + "adding: mem time249, current time 339, horizon 90\n", + "adding: mem time250, current time 339, horizon 89\n", + "adding: mem time251, current time 339, horizon 88\n", + "adding: mem time252, current time 339, horizon 87\n", + "adding: mem time253, current time 339, horizon 86\n", + "adding: mem time254, current time 339, horizon 85\n", + "adding: mem time255, current time 339, horizon 84\n", + "adding: mem time256, current time 339, horizon 83\n", + "adding: mem time257, current time 339, horizon 82\n", + "adding: mem time258, current time 339, horizon 81\n", + "adding: mem time259, current time 339, horizon 80\n", + "adding: mem time260, current time 339, horizon 79\n", + "adding: mem time261, current time 339, horizon 78\n", + "adding: mem time262, current time 339, horizon 77\n", + "adding: mem time263, current time 339, horizon 76\n", + "adding: mem time264, current time 339, horizon 75\n", + "adding: mem time265, current time 339, horizon 74\n", + "adding: mem time266, current time 339, horizon 73\n", + "adding: mem time267, current time 339, horizon 72\n", + "adding: mem time268, current time 339, horizon 71\n", + "adding: mem time269, current time 339, horizon 70\n", + "adding: mem time270, current time 339, horizon 69\n", + "adding: mem time271, current time 339, horizon 68\n", + "adding: mem time272, current time 339, horizon 67\n", + "adding: mem time273, current time 339, horizon 66\n", + "adding: mem time274, current time 339, horizon 65\n", + "adding: mem time275, current time 339, horizon 64\n", + "adding: mem time276, current time 339, horizon 63\n", + "adding: mem time277, current time 339, horizon 62\n", + "adding: mem time278, current time 339, horizon 61\n", + "adding: mem time279, current time 339, horizon 60\n", + "adding: mem time280, current time 339, horizon 59\n", + "adding: mem time281, current time 339, horizon 58\n", + "adding: mem time282, current time 339, horizon 57\n", + "adding: mem time283, current time 339, horizon 56\n", + "adding: mem time284, current time 339, horizon 55\n", + "adding: mem time285, current time 339, horizon 54\n", + "adding: mem time286, current time 339, horizon 53\n", + "adding: mem time287, current time 339, horizon 52\n", + "adding: mem time288, current time 339, horizon 51\n", + "adding: mem time289, current time 339, horizon 50\n", + "adding: mem time290, current time 339, horizon 49\n", + "adding: mem time291, current time 339, horizon 48\n", + "adding: mem time292, current time 339, horizon 47\n", + "adding: mem time293, current time 339, horizon 46\n", + "adding: mem time294, current time 339, horizon 45\n", + "adding: mem time295, current time 339, horizon 44\n", + "adding: mem time296, current time 339, horizon 43\n", + "adding: mem time297, current time 339, horizon 42\n", + "adding: mem time298, current time 339, horizon 41\n", + "adding: mem time299, current time 339, horizon 40\n", + "adding: mem time300, current time 339, horizon 39\n", + "adding: mem time301, current time 339, horizon 38\n", + "adding: mem time302, current time 339, horizon 37\n", + "adding: mem time303, current time 339, horizon 36\n", + "adding: mem time304, current time 339, horizon 35\n", + "adding: mem time305, current time 339, horizon 34\n", + "adding: mem time306, current time 339, horizon 33\n", + "adding: mem time307, current time 339, horizon 32\n", + "adding: mem time308, current time 339, horizon 31\n", + "adding: mem time309, current time 339, horizon 30\n", + "adding: mem time310, current time 339, horizon 29\n", + "adding: mem time311, current time 339, horizon 28\n", + "adding: mem time312, current time 339, horizon 27\n", + "adding: mem time313, current time 339, horizon 26\n", + "adding: mem time314, current time 339, horizon 25\n", + "adding: mem time315, current time 339, horizon 24\n", + "adding: mem time316, current time 339, horizon 23\n", + "adding: mem time317, current time 339, horizon 22\n", + "adding: mem time318, current time 339, horizon 21\n", + "adding: mem time319, current time 339, horizon 20\n", + "adding: mem time320, current time 339, horizon 19\n", + "adding: mem time321, current time 339, horizon 18\n", + "adding: mem time322, current time 339, horizon 17\n", + "adding: mem time323, current time 339, horizon 16\n", + "adding: mem time324, current time 339, horizon 15\n", + "adding: mem time325, current time 339, horizon 14\n", + "adding: mem time326, current time 339, horizon 13\n", + "adding: mem time327, current time 339, horizon 12\n", + "adding: mem time328, current time 339, horizon 11\n", + "adding: mem time329, current time 339, horizon 10\n", + "adding: mem time330, current time 339, horizon 9\n", + "adding: mem time331, current time 339, horizon 8\n", + "adding: mem time332, current time 339, horizon 7\n", + "adding: mem time333, current time 339, horizon 6\n", + "adding: mem time334, current time 339, horizon 5\n", + "adding: mem time335, current time 339, horizon 4\n", + "adding: mem time336, current time 339, horizon 3\n", + "adding: mem time337, current time 339, horizon 2\n", + "adding: mem time338, current time 339, horizon 1\n", + "adding: mem time200, current time 340, horizon 140\n", + "adding: mem time201, current time 340, horizon 139\n", + "adding: mem time202, current time 340, horizon 138\n", + "adding: mem time203, current time 340, horizon 137\n", + "adding: mem time204, current time 340, horizon 136\n", + "adding: mem time205, current time 340, horizon 135\n", + "adding: mem time206, current time 340, horizon 134\n", + "adding: mem time207, current time 340, horizon 133\n", + "adding: mem time208, current time 340, horizon 132\n", + "adding: mem time209, current time 340, horizon 131\n", + "adding: mem time210, current time 340, horizon 130\n", + "adding: mem time211, current time 340, horizon 129\n", + "adding: mem time212, current time 340, horizon 128\n", + "adding: mem time213, current time 340, horizon 127\n", + "adding: mem time214, current time 340, horizon 126\n", + "adding: mem time215, current time 340, horizon 125\n", + "adding: mem time216, current time 340, horizon 124\n", + "adding: mem time217, current time 340, horizon 123\n", + "adding: mem time218, current time 340, horizon 122\n", + "adding: mem time219, current time 340, horizon 121\n", + "adding: mem time220, current time 340, horizon 120\n", + "adding: mem time221, current time 340, horizon 119\n", + "adding: mem time222, current time 340, horizon 118\n", + "adding: mem time223, current time 340, horizon 117\n", + "adding: mem time224, current time 340, horizon 116\n", + "adding: mem time225, current time 340, horizon 115\n", + "adding: mem time226, current time 340, horizon 114\n", + "adding: mem time227, current time 340, horizon 113\n", + "adding: mem time228, current time 340, horizon 112\n", + "adding: mem time229, current time 340, horizon 111\n", + "adding: mem time230, current time 340, horizon 110\n", + "adding: mem time231, current time 340, horizon 109\n", + "adding: mem time232, current time 340, horizon 108\n", + "adding: mem time233, current time 340, horizon 107\n", + "adding: mem time234, current time 340, horizon 106\n", + "adding: mem time235, current time 340, horizon 105\n", + "adding: mem time236, current time 340, horizon 104\n", + "adding: mem time237, current time 340, horizon 103\n", + "adding: mem time238, current time 340, horizon 102\n", + "adding: mem time239, current time 340, horizon 101\n", + "adding: mem time240, current time 340, horizon 100\n", + "adding: mem time241, current time 340, horizon 99\n", + "adding: mem time242, current time 340, horizon 98\n", + "adding: mem time243, current time 340, horizon 97\n", + "adding: mem time244, current time 340, horizon 96\n", + "adding: mem time245, current time 340, horizon 95\n", + "adding: mem time246, current time 340, horizon 94\n", + "adding: mem time247, current time 340, horizon 93\n", + "adding: mem time248, current time 340, horizon 92\n", + "adding: mem time249, current time 340, horizon 91\n", + "adding: mem time250, current time 340, horizon 90\n", + "adding: mem time251, current time 340, horizon 89\n", + "adding: mem time252, current time 340, horizon 88\n", + "adding: mem time253, current time 340, horizon 87\n", + "adding: mem time254, current time 340, horizon 86\n", + "adding: mem time255, current time 340, horizon 85\n", + "adding: mem time256, current time 340, horizon 84\n", + "adding: mem time257, current time 340, horizon 83\n", + "adding: mem time258, current time 340, horizon 82\n", + "adding: mem time259, current time 340, horizon 81\n", + "adding: mem time260, current time 340, horizon 80\n", + "adding: mem time261, current time 340, horizon 79\n", + "adding: mem time262, current time 340, horizon 78\n", + "adding: mem time263, current time 340, horizon 77\n", + "adding: mem time264, current time 340, horizon 76\n", + "adding: mem time265, current time 340, horizon 75\n", + "adding: mem time266, current time 340, horizon 74\n", + "adding: mem time267, current time 340, horizon 73\n", + "adding: mem time268, current time 340, horizon 72\n", + "adding: mem time269, current time 340, horizon 71\n", + "adding: mem time270, current time 340, horizon 70\n", + "adding: mem time271, current time 340, horizon 69\n", + "adding: mem time272, current time 340, horizon 68\n", + "adding: mem time273, current time 340, horizon 67\n", + "adding: mem time274, current time 340, horizon 66\n", + "adding: mem time275, current time 340, horizon 65\n", + "adding: mem time276, current time 340, horizon 64\n", + "adding: mem time277, current time 340, horizon 63\n", + "adding: mem time278, current time 340, horizon 62\n", + "adding: mem time279, current time 340, horizon 61\n", + "adding: mem time280, current time 340, horizon 60\n", + "adding: mem time281, current time 340, horizon 59\n", + "adding: mem time282, current time 340, horizon 58\n", + "adding: mem time283, current time 340, horizon 57\n", + "adding: mem time284, current time 340, horizon 56\n", + "adding: mem time285, current time 340, horizon 55\n", + "adding: mem time286, current time 340, horizon 54\n", + "adding: mem time287, current time 340, horizon 53\n", + "adding: mem time288, current time 340, horizon 52\n", + "adding: mem time289, current time 340, horizon 51\n", + "adding: mem time290, current time 340, horizon 50\n", + "adding: mem time291, current time 340, horizon 49\n", + "adding: mem time292, current time 340, horizon 48\n", + "adding: mem time293, current time 340, horizon 47\n", + "adding: mem time294, current time 340, horizon 46\n", + "adding: mem time295, current time 340, horizon 45\n", + "adding: mem time296, current time 340, horizon 44\n", + "adding: mem time297, current time 340, horizon 43\n", + "adding: mem time298, current time 340, horizon 42\n", + "adding: mem time299, current time 340, horizon 41\n", + "adding: mem time300, current time 340, horizon 40\n", + "adding: mem time301, current time 340, horizon 39\n", + "adding: mem time302, current time 340, horizon 38\n", + "adding: mem time303, current time 340, horizon 37\n", + "adding: mem time304, current time 340, horizon 36\n", + "adding: mem time305, current time 340, horizon 35\n", + "adding: mem time306, current time 340, horizon 34\n", + "adding: mem time307, current time 340, horizon 33\n", + "adding: mem time308, current time 340, horizon 32\n", + "adding: mem time309, current time 340, horizon 31\n", + "adding: mem time310, current time 340, horizon 30\n", + "adding: mem time311, current time 340, horizon 29\n", + "adding: mem time312, current time 340, horizon 28\n", + "adding: mem time313, current time 340, horizon 27\n", + "adding: mem time314, current time 340, horizon 26\n", + "adding: mem time315, current time 340, horizon 25\n", + "adding: mem time316, current time 340, horizon 24\n", + "adding: mem time317, current time 340, horizon 23\n", + "adding: mem time318, current time 340, horizon 22\n", + "adding: mem time319, current time 340, horizon 21\n", + "adding: mem time320, current time 340, horizon 20\n", + "adding: mem time321, current time 340, horizon 19\n", + "adding: mem time322, current time 340, horizon 18\n", + "adding: mem time323, current time 340, horizon 17\n", + "adding: mem time324, current time 340, horizon 16\n", + "adding: mem time325, current time 340, horizon 15\n", + "adding: mem time326, current time 340, horizon 14\n", + "adding: mem time327, current time 340, horizon 13\n", + "adding: mem time328, current time 340, horizon 12\n", + "adding: mem time329, current time 340, horizon 11\n", + "adding: mem time330, current time 340, horizon 10\n", + "adding: mem time331, current time 340, horizon 9\n", + "adding: mem time332, current time 340, horizon 8\n", + "adding: mem time333, current time 340, horizon 7\n", + "adding: mem time334, current time 340, horizon 6\n", + "adding: mem time335, current time 340, horizon 5\n", + "adding: mem time336, current time 340, horizon 4\n", + "adding: mem time337, current time 340, horizon 3\n", + "adding: mem time338, current time 340, horizon 2\n", + "adding: mem time339, current time 340, horizon 1\n", + "adding: mem time200, current time 341, horizon 141\n", + "adding: mem time201, current time 341, horizon 140\n", + "adding: mem time202, current time 341, horizon 139\n", + "adding: mem time203, current time 341, horizon 138\n", + "adding: mem time204, current time 341, horizon 137\n", + "adding: mem time205, current time 341, horizon 136\n", + "adding: mem time206, current time 341, horizon 135\n", + "adding: mem time207, current time 341, horizon 134\n", + "adding: mem time208, current time 341, horizon 133\n", + "adding: mem time209, current time 341, horizon 132\n", + "adding: mem time210, current time 341, horizon 131\n", + "adding: mem time211, current time 341, horizon 130\n", + "adding: mem time212, current time 341, horizon 129\n", + "adding: mem time213, current time 341, horizon 128\n", + "adding: mem time214, current time 341, horizon 127\n", + "adding: mem time215, current time 341, horizon 126\n", + "adding: mem time216, current time 341, horizon 125\n", + "adding: mem time217, current time 341, horizon 124\n", + "adding: mem time218, current time 341, horizon 123\n", + "adding: mem time219, current time 341, horizon 122\n", + "adding: mem time220, current time 341, horizon 121\n", + "adding: mem time221, current time 341, horizon 120\n", + "adding: mem time222, current time 341, horizon 119\n", + "adding: mem time223, current time 341, horizon 118\n", + "adding: mem time224, current time 341, horizon 117\n", + "adding: mem time225, current time 341, horizon 116\n", + "adding: mem time226, current time 341, horizon 115\n", + "adding: mem time227, current time 341, horizon 114\n", + "adding: mem time228, current time 341, horizon 113\n", + "adding: mem time229, current time 341, horizon 112\n", + "adding: mem time230, current time 341, horizon 111\n", + "adding: mem time231, current time 341, horizon 110\n", + "adding: mem time232, current time 341, horizon 109\n", + "adding: mem time233, current time 341, horizon 108\n", + "adding: mem time234, current time 341, horizon 107\n", + "adding: mem time235, current time 341, horizon 106\n", + "adding: mem time236, current time 341, horizon 105\n", + "adding: mem time237, current time 341, horizon 104\n", + "adding: mem time238, current time 341, horizon 103\n", + "adding: mem time239, current time 341, horizon 102\n", + "adding: mem time240, current time 341, horizon 101\n", + "adding: mem time241, current time 341, horizon 100\n", + "adding: mem time242, current time 341, horizon 99\n", + "adding: mem time243, current time 341, horizon 98\n", + "adding: mem time244, current time 341, horizon 97\n", + "adding: mem time245, current time 341, horizon 96\n", + "adding: mem time246, current time 341, horizon 95\n", + "adding: mem time247, current time 341, horizon 94\n", + "adding: mem time248, current time 341, horizon 93\n", + "adding: mem time249, current time 341, horizon 92\n", + "adding: mem time250, current time 341, horizon 91\n", + "adding: mem time251, current time 341, horizon 90\n", + "adding: mem time252, current time 341, horizon 89\n", + "adding: mem time253, current time 341, horizon 88\n", + "adding: mem time254, current time 341, horizon 87\n", + "adding: mem time255, current time 341, horizon 86\n", + "adding: mem time256, current time 341, horizon 85\n", + "adding: mem time257, current time 341, horizon 84\n", + "adding: mem time258, current time 341, horizon 83\n", + "adding: mem time259, current time 341, horizon 82\n", + "adding: mem time260, current time 341, horizon 81\n", + "adding: mem time261, current time 341, horizon 80\n", + "adding: mem time262, current time 341, horizon 79\n", + "adding: mem time263, current time 341, horizon 78\n", + "adding: mem time264, current time 341, horizon 77\n", + "adding: mem time265, current time 341, horizon 76\n", + "adding: mem time266, current time 341, horizon 75\n", + "adding: mem time267, current time 341, horizon 74\n", + "adding: mem time268, current time 341, horizon 73\n", + "adding: mem time269, current time 341, horizon 72\n", + "adding: mem time270, current time 341, horizon 71\n", + "adding: mem time271, current time 341, horizon 70\n", + "adding: mem time272, current time 341, horizon 69\n", + "adding: mem time273, current time 341, horizon 68\n", + "adding: mem time274, current time 341, horizon 67\n", + "adding: mem time275, current time 341, horizon 66\n", + "adding: mem time276, current time 341, horizon 65\n", + "adding: mem time277, current time 341, horizon 64\n", + "adding: mem time278, current time 341, horizon 63\n", + "adding: mem time279, current time 341, horizon 62\n", + "adding: mem time280, current time 341, horizon 61\n", + "adding: mem time281, current time 341, horizon 60\n", + "adding: mem time282, current time 341, horizon 59\n", + "adding: mem time283, current time 341, horizon 58\n", + "adding: mem time284, current time 341, horizon 57\n", + "adding: mem time285, current time 341, horizon 56\n", + "adding: mem time286, current time 341, horizon 55\n", + "adding: mem time287, current time 341, horizon 54\n", + "adding: mem time288, current time 341, horizon 53\n", + "adding: mem time289, current time 341, horizon 52\n", + "adding: mem time290, current time 341, horizon 51\n", + "adding: mem time291, current time 341, horizon 50\n", + "adding: mem time292, current time 341, horizon 49\n", + "adding: mem time293, current time 341, horizon 48\n", + "adding: mem time294, current time 341, horizon 47\n", + "adding: mem time295, current time 341, horizon 46\n", + "adding: mem time296, current time 341, horizon 45\n", + "adding: mem time297, current time 341, horizon 44\n", + "adding: mem time298, current time 341, horizon 43\n", + "adding: mem time299, current time 341, horizon 42\n", + "adding: mem time300, current time 341, horizon 41\n", + "adding: mem time301, current time 341, horizon 40\n", + "adding: mem time302, current time 341, horizon 39\n", + "adding: mem time303, current time 341, horizon 38\n", + "adding: mem time304, current time 341, horizon 37\n", + "adding: mem time305, current time 341, horizon 36\n", + "adding: mem time306, current time 341, horizon 35\n", + "adding: mem time307, current time 341, horizon 34\n", + "adding: mem time308, current time 341, horizon 33\n", + "adding: mem time309, current time 341, horizon 32\n", + "adding: mem time310, current time 341, horizon 31\n", + "adding: mem time311, current time 341, horizon 30\n", + "adding: mem time312, current time 341, horizon 29\n", + "adding: mem time313, current time 341, horizon 28\n", + "adding: mem time314, current time 341, horizon 27\n", + "adding: mem time315, current time 341, horizon 26\n", + "adding: mem time316, current time 341, horizon 25\n", + "adding: mem time317, current time 341, horizon 24\n", + "adding: mem time318, current time 341, horizon 23\n", + "adding: mem time319, current time 341, horizon 22\n", + "adding: mem time320, current time 341, horizon 21\n", + "adding: mem time321, current time 341, horizon 20\n", + "adding: mem time322, current time 341, horizon 19\n", + "adding: mem time323, current time 341, horizon 18\n", + "adding: mem time324, current time 341, horizon 17\n", + "adding: mem time325, current time 341, horizon 16\n", + "adding: mem time326, current time 341, horizon 15\n", + "adding: mem time327, current time 341, horizon 14\n", + "adding: mem time328, current time 341, horizon 13\n", + "adding: mem time329, current time 341, horizon 12\n", + "adding: mem time330, current time 341, horizon 11\n", + "adding: mem time331, current time 341, horizon 10\n", + "adding: mem time332, current time 341, horizon 9\n", + "adding: mem time333, current time 341, horizon 8\n", + "adding: mem time334, current time 341, horizon 7\n", + "adding: mem time335, current time 341, horizon 6\n", + "adding: mem time336, current time 341, horizon 5\n", + "adding: mem time337, current time 341, horizon 4\n", + "adding: mem time338, current time 341, horizon 3\n", + "adding: mem time339, current time 341, horizon 2\n", + "adding: mem time340, current time 341, horizon 1\n", + "adding: mem time200, current time 342, horizon 142\n", + "adding: mem time201, current time 342, horizon 141\n", + "adding: mem time202, current time 342, horizon 140\n", + "adding: mem time203, current time 342, horizon 139\n", + "adding: mem time204, current time 342, horizon 138\n", + "adding: mem time205, current time 342, horizon 137\n", + "adding: mem time206, current time 342, horizon 136\n", + "adding: mem time207, current time 342, horizon 135\n", + "adding: mem time208, current time 342, horizon 134\n", + "adding: mem time209, current time 342, horizon 133\n", + "adding: mem time210, current time 342, horizon 132\n", + "adding: mem time211, current time 342, horizon 131\n", + "adding: mem time212, current time 342, horizon 130\n", + "adding: mem time213, current time 342, horizon 129\n", + "adding: mem time214, current time 342, horizon 128\n", + "adding: mem time215, current time 342, horizon 127\n", + "adding: mem time216, current time 342, horizon 126\n", + "adding: mem time217, current time 342, horizon 125\n", + "adding: mem time218, current time 342, horizon 124\n", + "adding: mem time219, current time 342, horizon 123\n", + "adding: mem time220, current time 342, horizon 122\n", + "adding: mem time221, current time 342, horizon 121\n", + "adding: mem time222, current time 342, horizon 120\n", + "adding: mem time223, current time 342, horizon 119\n", + "adding: mem time224, current time 342, horizon 118\n", + "adding: mem time225, current time 342, horizon 117\n", + "adding: mem time226, current time 342, horizon 116\n", + "adding: mem time227, current time 342, horizon 115\n", + "adding: mem time228, current time 342, horizon 114\n", + "adding: mem time229, current time 342, horizon 113\n", + "adding: mem time230, current time 342, horizon 112\n", + "adding: mem time231, current time 342, horizon 111\n", + "adding: mem time232, current time 342, horizon 110\n", + "adding: mem time233, current time 342, horizon 109\n", + "adding: mem time234, current time 342, horizon 108\n", + "adding: mem time235, current time 342, horizon 107\n", + "adding: mem time236, current time 342, horizon 106\n", + "adding: mem time237, current time 342, horizon 105\n", + "adding: mem time238, current time 342, horizon 104\n", + "adding: mem time239, current time 342, horizon 103\n", + "adding: mem time240, current time 342, horizon 102\n", + "adding: mem time241, current time 342, horizon 101\n", + "adding: mem time242, current time 342, horizon 100\n", + "adding: mem time243, current time 342, horizon 99\n", + "adding: mem time244, current time 342, horizon 98\n", + "adding: mem time245, current time 342, horizon 97\n", + "adding: mem time246, current time 342, horizon 96\n", + "adding: mem time247, current time 342, horizon 95\n", + "adding: mem time248, current time 342, horizon 94\n", + "adding: mem time249, current time 342, horizon 93\n", + "adding: mem time250, current time 342, horizon 92\n", + "adding: mem time251, current time 342, horizon 91\n", + "adding: mem time252, current time 342, horizon 90\n", + "adding: mem time253, current time 342, horizon 89\n", + "adding: mem time254, current time 342, horizon 88\n", + "adding: mem time255, current time 342, horizon 87\n", + "adding: mem time256, current time 342, horizon 86\n", + "adding: mem time257, current time 342, horizon 85\n", + "adding: mem time258, current time 342, horizon 84\n", + "adding: mem time259, current time 342, horizon 83\n", + "adding: mem time260, current time 342, horizon 82\n", + "adding: mem time261, current time 342, horizon 81\n", + "adding: mem time262, current time 342, horizon 80\n", + "adding: mem time263, current time 342, horizon 79\n", + "adding: mem time264, current time 342, horizon 78\n", + "adding: mem time265, current time 342, horizon 77\n", + "adding: mem time266, current time 342, horizon 76\n", + "adding: mem time267, current time 342, horizon 75\n", + "adding: mem time268, current time 342, horizon 74\n", + "adding: mem time269, current time 342, horizon 73\n", + "adding: mem time270, current time 342, horizon 72\n", + "adding: mem time271, current time 342, horizon 71\n", + "adding: mem time272, current time 342, horizon 70\n", + "adding: mem time273, current time 342, horizon 69\n", + "adding: mem time274, current time 342, horizon 68\n", + "adding: mem time275, current time 342, horizon 67\n", + "adding: mem time276, current time 342, horizon 66\n", + "adding: mem time277, current time 342, horizon 65\n", + "adding: mem time278, current time 342, horizon 64\n", + "adding: mem time279, current time 342, horizon 63\n", + "adding: mem time280, current time 342, horizon 62\n", + "adding: mem time281, current time 342, horizon 61\n", + "adding: mem time282, current time 342, horizon 60\n", + "adding: mem time283, current time 342, horizon 59\n", + "adding: mem time284, current time 342, horizon 58\n", + "adding: mem time285, current time 342, horizon 57\n", + "adding: mem time286, current time 342, horizon 56\n", + "adding: mem time287, current time 342, horizon 55\n", + "adding: mem time288, current time 342, horizon 54\n", + "adding: mem time289, current time 342, horizon 53\n", + "adding: mem time290, current time 342, horizon 52\n", + "adding: mem time291, current time 342, horizon 51\n", + "adding: mem time292, current time 342, horizon 50\n", + "adding: mem time293, current time 342, horizon 49\n", + "adding: mem time294, current time 342, horizon 48\n", + "adding: mem time295, current time 342, horizon 47\n", + "adding: mem time296, current time 342, horizon 46\n", + "adding: mem time297, current time 342, horizon 45\n", + "adding: mem time298, current time 342, horizon 44\n", + "adding: mem time299, current time 342, horizon 43\n", + "adding: mem time300, current time 342, horizon 42\n", + "adding: mem time301, current time 342, horizon 41\n", + "adding: mem time302, current time 342, horizon 40\n", + "adding: mem time303, current time 342, horizon 39\n", + "adding: mem time304, current time 342, horizon 38\n", + "adding: mem time305, current time 342, horizon 37\n", + "adding: mem time306, current time 342, horizon 36\n", + "adding: mem time307, current time 342, horizon 35\n", + "adding: mem time308, current time 342, horizon 34\n", + "adding: mem time309, current time 342, horizon 33\n", + "adding: mem time310, current time 342, horizon 32\n", + "adding: mem time311, current time 342, horizon 31\n", + "adding: mem time312, current time 342, horizon 30\n", + "adding: mem time313, current time 342, horizon 29\n", + "adding: mem time314, current time 342, horizon 28\n", + "adding: mem time315, current time 342, horizon 27\n", + "adding: mem time316, current time 342, horizon 26\n", + "adding: mem time317, current time 342, horizon 25\n", + "adding: mem time318, current time 342, horizon 24\n", + "adding: mem time319, current time 342, horizon 23\n", + "adding: mem time320, current time 342, horizon 22\n", + "adding: mem time321, current time 342, horizon 21\n", + "adding: mem time322, current time 342, horizon 20\n", + "adding: mem time323, current time 342, horizon 19\n", + "adding: mem time324, current time 342, horizon 18\n", + "adding: mem time325, current time 342, horizon 17\n", + "adding: mem time326, current time 342, horizon 16\n", + "adding: mem time327, current time 342, horizon 15\n", + "adding: mem time328, current time 342, horizon 14\n", + "adding: mem time329, current time 342, horizon 13\n", + "adding: mem time330, current time 342, horizon 12\n", + "adding: mem time331, current time 342, horizon 11\n", + "adding: mem time332, current time 342, horizon 10\n", + "adding: mem time333, current time 342, horizon 9\n", + "adding: mem time334, current time 342, horizon 8\n", + "adding: mem time335, current time 342, horizon 7\n", + "adding: mem time336, current time 342, horizon 6\n", + "adding: mem time337, current time 342, horizon 5\n", + "adding: mem time338, current time 342, horizon 4\n", + "adding: mem time339, current time 342, horizon 3\n", + "adding: mem time340, current time 342, horizon 2\n", + "adding: mem time341, current time 342, horizon 1\n", + "adding: mem time200, current time 343, horizon 143\n", + "adding: mem time201, current time 343, horizon 142\n", + "adding: mem time202, current time 343, horizon 141\n", + "adding: mem time203, current time 343, horizon 140\n", + "adding: mem time204, current time 343, horizon 139\n", + "adding: mem time205, current time 343, horizon 138\n", + "adding: mem time206, current time 343, horizon 137\n", + "adding: mem time207, current time 343, horizon 136\n", + "adding: mem time208, current time 343, horizon 135\n", + "adding: mem time209, current time 343, horizon 134\n", + "adding: mem time210, current time 343, horizon 133\n", + "adding: mem time211, current time 343, horizon 132\n", + "adding: mem time212, current time 343, horizon 131\n", + "adding: mem time213, current time 343, horizon 130\n", + "adding: mem time214, current time 343, horizon 129\n", + "adding: mem time215, current time 343, horizon 128\n", + "adding: mem time216, current time 343, horizon 127\n", + "adding: mem time217, current time 343, horizon 126\n", + "adding: mem time218, current time 343, horizon 125\n", + "adding: mem time219, current time 343, horizon 124\n", + "adding: mem time220, current time 343, horizon 123\n", + "adding: mem time221, current time 343, horizon 122\n", + "adding: mem time222, current time 343, horizon 121\n", + "adding: mem time223, current time 343, horizon 120\n", + "adding: mem time224, current time 343, horizon 119\n", + "adding: mem time225, current time 343, horizon 118\n", + "adding: mem time226, current time 343, horizon 117\n", + "adding: mem time227, current time 343, horizon 116\n", + "adding: mem time228, current time 343, horizon 115\n", + "adding: mem time229, current time 343, horizon 114\n", + "adding: mem time230, current time 343, horizon 113\n", + "adding: mem time231, current time 343, horizon 112\n", + "adding: mem time232, current time 343, horizon 111\n", + "adding: mem time233, current time 343, horizon 110\n", + "adding: mem time234, current time 343, horizon 109\n", + "adding: mem time235, current time 343, horizon 108\n", + "adding: mem time236, current time 343, horizon 107\n", + "adding: mem time237, current time 343, horizon 106\n", + "adding: mem time238, current time 343, horizon 105\n", + "adding: mem time239, current time 343, horizon 104\n", + "adding: mem time240, current time 343, horizon 103\n", + "adding: mem time241, current time 343, horizon 102\n", + "adding: mem time242, current time 343, horizon 101\n", + "adding: mem time243, current time 343, horizon 100\n", + "adding: mem time244, current time 343, horizon 99\n", + "adding: mem time245, current time 343, horizon 98\n", + "adding: mem time246, current time 343, horizon 97\n", + "adding: mem time247, current time 343, horizon 96\n", + "adding: mem time248, current time 343, horizon 95\n", + "adding: mem time249, current time 343, horizon 94\n", + "adding: mem time250, current time 343, horizon 93\n", + "adding: mem time251, current time 343, horizon 92\n", + "adding: mem time252, current time 343, horizon 91\n", + "adding: mem time253, current time 343, horizon 90\n", + "adding: mem time254, current time 343, horizon 89\n", + "adding: mem time255, current time 343, horizon 88\n", + "adding: mem time256, current time 343, horizon 87\n", + "adding: mem time257, current time 343, horizon 86\n", + "adding: mem time258, current time 343, horizon 85\n", + "adding: mem time259, current time 343, horizon 84\n", + "adding: mem time260, current time 343, horizon 83\n", + "adding: mem time261, current time 343, horizon 82\n", + "adding: mem time262, current time 343, horizon 81\n", + "adding: mem time263, current time 343, horizon 80\n", + "adding: mem time264, current time 343, horizon 79\n", + "adding: mem time265, current time 343, horizon 78\n", + "adding: mem time266, current time 343, horizon 77\n", + "adding: mem time267, current time 343, horizon 76\n", + "adding: mem time268, current time 343, horizon 75\n", + "adding: mem time269, current time 343, horizon 74\n", + "adding: mem time270, current time 343, horizon 73\n", + "adding: mem time271, current time 343, horizon 72\n", + "adding: mem time272, current time 343, horizon 71\n", + "adding: mem time273, current time 343, horizon 70\n", + "adding: mem time274, current time 343, horizon 69\n", + "adding: mem time275, current time 343, horizon 68\n", + "adding: mem time276, current time 343, horizon 67\n", + "adding: mem time277, current time 343, horizon 66\n", + "adding: mem time278, current time 343, horizon 65\n", + "adding: mem time279, current time 343, horizon 64\n", + "adding: mem time280, current time 343, horizon 63\n", + "adding: mem time281, current time 343, horizon 62\n", + "adding: mem time282, current time 343, horizon 61\n", + "adding: mem time283, current time 343, horizon 60\n", + "adding: mem time284, current time 343, horizon 59\n", + "adding: mem time285, current time 343, horizon 58\n", + "adding: mem time286, current time 343, horizon 57\n", + "adding: mem time287, current time 343, horizon 56\n", + "adding: mem time288, current time 343, horizon 55\n", + "adding: mem time289, current time 343, horizon 54\n", + "adding: mem time290, current time 343, horizon 53\n", + "adding: mem time291, current time 343, horizon 52\n", + "adding: mem time292, current time 343, horizon 51\n", + "adding: mem time293, current time 343, horizon 50\n", + "adding: mem time294, current time 343, horizon 49\n", + "adding: mem time295, current time 343, horizon 48\n", + "adding: mem time296, current time 343, horizon 47\n", + "adding: mem time297, current time 343, horizon 46\n", + "adding: mem time298, current time 343, horizon 45\n", + "adding: mem time299, current time 343, horizon 44\n", + "adding: mem time300, current time 343, horizon 43\n", + "adding: mem time301, current time 343, horizon 42\n", + "adding: mem time302, current time 343, horizon 41\n", + "adding: mem time303, current time 343, horizon 40\n", + "adding: mem time304, current time 343, horizon 39\n", + "adding: mem time305, current time 343, horizon 38\n", + "adding: mem time306, current time 343, horizon 37\n", + "adding: mem time307, current time 343, horizon 36\n", + "adding: mem time308, current time 343, horizon 35\n", + "adding: mem time309, current time 343, horizon 34\n", + "adding: mem time310, current time 343, horizon 33\n", + "adding: mem time311, current time 343, horizon 32\n", + "adding: mem time312, current time 343, horizon 31\n", + "adding: mem time313, current time 343, horizon 30\n", + "adding: mem time314, current time 343, horizon 29\n", + "adding: mem time315, current time 343, horizon 28\n", + "adding: mem time316, current time 343, horizon 27\n", + "adding: mem time317, current time 343, horizon 26\n", + "adding: mem time318, current time 343, horizon 25\n", + "adding: mem time319, current time 343, horizon 24\n", + "adding: mem time320, current time 343, horizon 23\n", + "adding: mem time321, current time 343, horizon 22\n", + "adding: mem time322, current time 343, horizon 21\n", + "adding: mem time323, current time 343, horizon 20\n", + "adding: mem time324, current time 343, horizon 19\n", + "adding: mem time325, current time 343, horizon 18\n", + "adding: mem time326, current time 343, horizon 17\n", + "adding: mem time327, current time 343, horizon 16\n", + "adding: mem time328, current time 343, horizon 15\n", + "adding: mem time329, current time 343, horizon 14\n", + "adding: mem time330, current time 343, horizon 13\n", + "adding: mem time331, current time 343, horizon 12\n", + "adding: mem time332, current time 343, horizon 11\n", + "adding: mem time333, current time 343, horizon 10\n", + "adding: mem time334, current time 343, horizon 9\n", + "adding: mem time335, current time 343, horizon 8\n", + "adding: mem time336, current time 343, horizon 7\n", + "adding: mem time337, current time 343, horizon 6\n", + "adding: mem time338, current time 343, horizon 5\n", + "adding: mem time339, current time 343, horizon 4\n", + "adding: mem time340, current time 343, horizon 3\n", + "adding: mem time341, current time 343, horizon 2\n", + "adding: mem time342, current time 343, horizon 1\n", + "adding: mem time200, current time 344, horizon 144\n", + "adding: mem time201, current time 344, horizon 143\n", + "adding: mem time202, current time 344, horizon 142\n", + "adding: mem time203, current time 344, horizon 141\n", + "adding: mem time204, current time 344, horizon 140\n", + "adding: mem time205, current time 344, horizon 139\n", + "adding: mem time206, current time 344, horizon 138\n", + "adding: mem time207, current time 344, horizon 137\n", + "adding: mem time208, current time 344, horizon 136\n", + "adding: mem time209, current time 344, horizon 135\n", + "adding: mem time210, current time 344, horizon 134\n", + "adding: mem time211, current time 344, horizon 133\n", + "adding: mem time212, current time 344, horizon 132\n", + "adding: mem time213, current time 344, horizon 131\n", + "adding: mem time214, current time 344, horizon 130\n", + "adding: mem time215, current time 344, horizon 129\n", + "adding: mem time216, current time 344, horizon 128\n", + "adding: mem time217, current time 344, horizon 127\n", + "adding: mem time218, current time 344, horizon 126\n", + "adding: mem time219, current time 344, horizon 125\n", + "adding: mem time220, current time 344, horizon 124\n", + "adding: mem time221, current time 344, horizon 123\n", + "adding: mem time222, current time 344, horizon 122\n", + "adding: mem time223, current time 344, horizon 121\n", + "adding: mem time224, current time 344, horizon 120\n", + "adding: mem time225, current time 344, horizon 119\n", + "adding: mem time226, current time 344, horizon 118\n", + "adding: mem time227, current time 344, horizon 117\n", + "adding: mem time228, current time 344, horizon 116\n", + "adding: mem time229, current time 344, horizon 115\n", + "adding: mem time230, current time 344, horizon 114\n", + "adding: mem time231, current time 344, horizon 113\n", + "adding: mem time232, current time 344, horizon 112\n", + "adding: mem time233, current time 344, horizon 111\n", + "adding: mem time234, current time 344, horizon 110\n", + "adding: mem time235, current time 344, horizon 109\n", + "adding: mem time236, current time 344, horizon 108\n", + "adding: mem time237, current time 344, horizon 107\n", + "adding: mem time238, current time 344, horizon 106\n", + "adding: mem time239, current time 344, horizon 105\n", + "adding: mem time240, current time 344, horizon 104\n", + "adding: mem time241, current time 344, horizon 103\n", + "adding: mem time242, current time 344, horizon 102\n", + "adding: mem time243, current time 344, horizon 101\n", + "adding: mem time244, current time 344, horizon 100\n", + "adding: mem time245, current time 344, horizon 99\n", + "adding: mem time246, current time 344, horizon 98\n", + "adding: mem time247, current time 344, horizon 97\n", + "adding: mem time248, current time 344, horizon 96\n", + "adding: mem time249, current time 344, horizon 95\n", + "adding: mem time250, current time 344, horizon 94\n", + "adding: mem time251, current time 344, horizon 93\n", + "adding: mem time252, current time 344, horizon 92\n", + "adding: mem time253, current time 344, horizon 91\n", + "adding: mem time254, current time 344, horizon 90\n", + "adding: mem time255, current time 344, horizon 89\n", + "adding: mem time256, current time 344, horizon 88\n", + "adding: mem time257, current time 344, horizon 87\n", + "adding: mem time258, current time 344, horizon 86\n", + "adding: mem time259, current time 344, horizon 85\n", + "adding: mem time260, current time 344, horizon 84\n", + "adding: mem time261, current time 344, horizon 83\n", + "adding: mem time262, current time 344, horizon 82\n", + "adding: mem time263, current time 344, horizon 81\n", + "adding: mem time264, current time 344, horizon 80\n", + "adding: mem time265, current time 344, horizon 79\n", + "adding: mem time266, current time 344, horizon 78\n", + "adding: mem time267, current time 344, horizon 77\n", + "adding: mem time268, current time 344, horizon 76\n", + "adding: mem time269, current time 344, horizon 75\n", + "adding: mem time270, current time 344, horizon 74\n", + "adding: mem time271, current time 344, horizon 73\n", + "adding: mem time272, current time 344, horizon 72\n", + "adding: mem time273, current time 344, horizon 71\n", + "adding: mem time274, current time 344, horizon 70\n", + "adding: mem time275, current time 344, horizon 69\n", + "adding: mem time276, current time 344, horizon 68\n", + "adding: mem time277, current time 344, horizon 67\n", + "adding: mem time278, current time 344, horizon 66\n", + "adding: mem time279, current time 344, horizon 65\n", + "adding: mem time280, current time 344, horizon 64\n", + "adding: mem time281, current time 344, horizon 63\n", + "adding: mem time282, current time 344, horizon 62\n", + "adding: mem time283, current time 344, horizon 61\n", + "adding: mem time284, current time 344, horizon 60\n", + "adding: mem time285, current time 344, horizon 59\n", + "adding: mem time286, current time 344, horizon 58\n", + "adding: mem time287, current time 344, horizon 57\n", + "adding: mem time288, current time 344, horizon 56\n", + "adding: mem time289, current time 344, horizon 55\n", + "adding: mem time290, current time 344, horizon 54\n", + "adding: mem time291, current time 344, horizon 53\n", + "adding: mem time292, current time 344, horizon 52\n", + "adding: mem time293, current time 344, horizon 51\n", + "adding: mem time294, current time 344, horizon 50\n", + "adding: mem time295, current time 344, horizon 49\n", + "adding: mem time296, current time 344, horizon 48\n", + "adding: mem time297, current time 344, horizon 47\n", + "adding: mem time298, current time 344, horizon 46\n", + "adding: mem time299, current time 344, horizon 45\n", + "adding: mem time300, current time 344, horizon 44\n", + "adding: mem time301, current time 344, horizon 43\n", + "adding: mem time302, current time 344, horizon 42\n", + "adding: mem time303, current time 344, horizon 41\n", + "adding: mem time304, current time 344, horizon 40\n", + "adding: mem time305, current time 344, horizon 39\n", + "adding: mem time306, current time 344, horizon 38\n", + "adding: mem time307, current time 344, horizon 37\n", + "adding: mem time308, current time 344, horizon 36\n", + "adding: mem time309, current time 344, horizon 35\n", + "adding: mem time310, current time 344, horizon 34\n", + "adding: mem time311, current time 344, horizon 33\n", + "adding: mem time312, current time 344, horizon 32\n", + "adding: mem time313, current time 344, horizon 31\n", + "adding: mem time314, current time 344, horizon 30\n", + "adding: mem time315, current time 344, horizon 29\n", + "adding: mem time316, current time 344, horizon 28\n", + "adding: mem time317, current time 344, horizon 27\n", + "adding: mem time318, current time 344, horizon 26\n", + "adding: mem time319, current time 344, horizon 25\n", + "adding: mem time320, current time 344, horizon 24\n", + "adding: mem time321, current time 344, horizon 23\n", + "adding: mem time322, current time 344, horizon 22\n", + "adding: mem time323, current time 344, horizon 21\n", + "adding: mem time324, current time 344, horizon 20\n", + "adding: mem time325, current time 344, horizon 19\n", + "adding: mem time326, current time 344, horizon 18\n", + "adding: mem time327, current time 344, horizon 17\n", + "adding: mem time328, current time 344, horizon 16\n", + "adding: mem time329, current time 344, horizon 15\n", + "adding: mem time330, current time 344, horizon 14\n", + "adding: mem time331, current time 344, horizon 13\n", + "adding: mem time332, current time 344, horizon 12\n", + "adding: mem time333, current time 344, horizon 11\n", + "adding: mem time334, current time 344, horizon 10\n", + "adding: mem time335, current time 344, horizon 9\n", + "adding: mem time336, current time 344, horizon 8\n", + "adding: mem time337, current time 344, horizon 7\n", + "adding: mem time338, current time 344, horizon 6\n", + "adding: mem time339, current time 344, horizon 5\n", + "adding: mem time340, current time 344, horizon 4\n", + "adding: mem time341, current time 344, horizon 3\n", + "adding: mem time342, current time 344, horizon 2\n", + "adding: mem time343, current time 344, horizon 1\n", + "adding: mem time200, current time 345, horizon 145\n", + "adding: mem time201, current time 345, horizon 144\n", + "adding: mem time202, current time 345, horizon 143\n", + "adding: mem time203, current time 345, horizon 142\n", + "adding: mem time204, current time 345, horizon 141\n", + "adding: mem time205, current time 345, horizon 140\n", + "adding: mem time206, current time 345, horizon 139\n", + "adding: mem time207, current time 345, horizon 138\n", + "adding: mem time208, current time 345, horizon 137\n", + "adding: mem time209, current time 345, horizon 136\n", + "adding: mem time210, current time 345, horizon 135\n", + "adding: mem time211, current time 345, horizon 134\n", + "adding: mem time212, current time 345, horizon 133\n", + "adding: mem time213, current time 345, horizon 132\n", + "adding: mem time214, current time 345, horizon 131\n", + "adding: mem time215, current time 345, horizon 130\n", + "adding: mem time216, current time 345, horizon 129\n", + "adding: mem time217, current time 345, horizon 128\n", + "adding: mem time218, current time 345, horizon 127\n", + "adding: mem time219, current time 345, horizon 126\n", + "adding: mem time220, current time 345, horizon 125\n", + "adding: mem time221, current time 345, horizon 124\n", + "adding: mem time222, current time 345, horizon 123\n", + "adding: mem time223, current time 345, horizon 122\n", + "adding: mem time224, current time 345, horizon 121\n", + "adding: mem time225, current time 345, horizon 120\n", + "adding: mem time226, current time 345, horizon 119\n", + "adding: mem time227, current time 345, horizon 118\n", + "adding: mem time228, current time 345, horizon 117\n", + "adding: mem time229, current time 345, horizon 116\n", + "adding: mem time230, current time 345, horizon 115\n", + "adding: mem time231, current time 345, horizon 114\n", + "adding: mem time232, current time 345, horizon 113\n", + "adding: mem time233, current time 345, horizon 112\n", + "adding: mem time234, current time 345, horizon 111\n", + "adding: mem time235, current time 345, horizon 110\n", + "adding: mem time236, current time 345, horizon 109\n", + "adding: mem time237, current time 345, horizon 108\n", + "adding: mem time238, current time 345, horizon 107\n", + "adding: mem time239, current time 345, horizon 106\n", + "adding: mem time240, current time 345, horizon 105\n", + "adding: mem time241, current time 345, horizon 104\n", + "adding: mem time242, current time 345, horizon 103\n", + "adding: mem time243, current time 345, horizon 102\n", + "adding: mem time244, current time 345, horizon 101\n", + "adding: mem time245, current time 345, horizon 100\n", + "adding: mem time246, current time 345, horizon 99\n", + "adding: mem time247, current time 345, horizon 98\n", + "adding: mem time248, current time 345, horizon 97\n", + "adding: mem time249, current time 345, horizon 96\n", + "adding: mem time250, current time 345, horizon 95\n", + "adding: mem time251, current time 345, horizon 94\n", + "adding: mem time252, current time 345, horizon 93\n", + "adding: mem time253, current time 345, horizon 92\n", + "adding: mem time254, current time 345, horizon 91\n", + "adding: mem time255, current time 345, horizon 90\n", + "adding: mem time256, current time 345, horizon 89\n", + "adding: mem time257, current time 345, horizon 88\n", + "adding: mem time258, current time 345, horizon 87\n", + "adding: mem time259, current time 345, horizon 86\n", + "adding: mem time260, current time 345, horizon 85\n", + "adding: mem time261, current time 345, horizon 84\n", + "adding: mem time262, current time 345, horizon 83\n", + "adding: mem time263, current time 345, horizon 82\n", + "adding: mem time264, current time 345, horizon 81\n", + "adding: mem time265, current time 345, horizon 80\n", + "adding: mem time266, current time 345, horizon 79\n", + "adding: mem time267, current time 345, horizon 78\n", + "adding: mem time268, current time 345, horizon 77\n", + "adding: mem time269, current time 345, horizon 76\n", + "adding: mem time270, current time 345, horizon 75\n", + "adding: mem time271, current time 345, horizon 74\n", + "adding: mem time272, current time 345, horizon 73\n", + "adding: mem time273, current time 345, horizon 72\n", + "adding: mem time274, current time 345, horizon 71\n", + "adding: mem time275, current time 345, horizon 70\n", + "adding: mem time276, current time 345, horizon 69\n", + "adding: mem time277, current time 345, horizon 68\n", + "adding: mem time278, current time 345, horizon 67\n", + "adding: mem time279, current time 345, horizon 66\n", + "adding: mem time280, current time 345, horizon 65\n", + "adding: mem time281, current time 345, horizon 64\n", + "adding: mem time282, current time 345, horizon 63\n", + "adding: mem time283, current time 345, horizon 62\n", + "adding: mem time284, current time 345, horizon 61\n", + "adding: mem time285, current time 345, horizon 60\n", + "adding: mem time286, current time 345, horizon 59\n", + "adding: mem time287, current time 345, horizon 58\n", + "adding: mem time288, current time 345, horizon 57\n", + "adding: mem time289, current time 345, horizon 56\n", + "adding: mem time290, current time 345, horizon 55\n", + "adding: mem time291, current time 345, horizon 54\n", + "adding: mem time292, current time 345, horizon 53\n", + "adding: mem time293, current time 345, horizon 52\n", + "adding: mem time294, current time 345, horizon 51\n", + "adding: mem time295, current time 345, horizon 50\n", + "adding: mem time296, current time 345, horizon 49\n", + "adding: mem time297, current time 345, horizon 48\n", + "adding: mem time298, current time 345, horizon 47\n", + "adding: mem time299, current time 345, horizon 46\n", + "adding: mem time300, current time 345, horizon 45\n", + "adding: mem time301, current time 345, horizon 44\n", + "adding: mem time302, current time 345, horizon 43\n", + "adding: mem time303, current time 345, horizon 42\n", + "adding: mem time304, current time 345, horizon 41\n", + "adding: mem time305, current time 345, horizon 40\n", + "adding: mem time306, current time 345, horizon 39\n", + "adding: mem time307, current time 345, horizon 38\n", + "adding: mem time308, current time 345, horizon 37\n", + "adding: mem time309, current time 345, horizon 36\n", + "adding: mem time310, current time 345, horizon 35\n", + "adding: mem time311, current time 345, horizon 34\n", + "adding: mem time312, current time 345, horizon 33\n", + "adding: mem time313, current time 345, horizon 32\n", + "adding: mem time314, current time 345, horizon 31\n", + "adding: mem time315, current time 345, horizon 30\n", + "adding: mem time316, current time 345, horizon 29\n", + "adding: mem time317, current time 345, horizon 28\n", + "adding: mem time318, current time 345, horizon 27\n", + "adding: mem time319, current time 345, horizon 26\n", + "adding: mem time320, current time 345, horizon 25\n", + "adding: mem time321, current time 345, horizon 24\n", + "adding: mem time322, current time 345, horizon 23\n", + "adding: mem time323, current time 345, horizon 22\n", + "adding: mem time324, current time 345, horizon 21\n", + "adding: mem time325, current time 345, horizon 20\n", + "adding: mem time326, current time 345, horizon 19\n", + "adding: mem time327, current time 345, horizon 18\n", + "adding: mem time328, current time 345, horizon 17\n", + "adding: mem time329, current time 345, horizon 16\n", + "adding: mem time330, current time 345, horizon 15\n", + "adding: mem time331, current time 345, horizon 14\n", + "adding: mem time332, current time 345, horizon 13\n", + "adding: mem time333, current time 345, horizon 12\n", + "adding: mem time334, current time 345, horizon 11\n", + "adding: mem time335, current time 345, horizon 10\n", + "adding: mem time336, current time 345, horizon 9\n", + "adding: mem time337, current time 345, horizon 8\n", + "adding: mem time338, current time 345, horizon 7\n", + "adding: mem time339, current time 345, horizon 6\n", + "adding: mem time340, current time 345, horizon 5\n", + "adding: mem time341, current time 345, horizon 4\n", + "adding: mem time342, current time 345, horizon 3\n", + "adding: mem time343, current time 345, horizon 2\n", + "adding: mem time344, current time 345, horizon 1\n", + "adding: mem time200, current time 346, horizon 146\n", + "adding: mem time201, current time 346, horizon 145\n", + "adding: mem time202, current time 346, horizon 144\n", + "adding: mem time203, current time 346, horizon 143\n", + "adding: mem time204, current time 346, horizon 142\n", + "adding: mem time205, current time 346, horizon 141\n", + "adding: mem time206, current time 346, horizon 140\n", + "adding: mem time207, current time 346, horizon 139\n", + "adding: mem time208, current time 346, horizon 138\n", + "adding: mem time209, current time 346, horizon 137\n", + "adding: mem time210, current time 346, horizon 136\n", + "adding: mem time211, current time 346, horizon 135\n", + "adding: mem time212, current time 346, horizon 134\n", + "adding: mem time213, current time 346, horizon 133\n", + "adding: mem time214, current time 346, horizon 132\n", + "adding: mem time215, current time 346, horizon 131\n", + "adding: mem time216, current time 346, horizon 130\n", + "adding: mem time217, current time 346, horizon 129\n", + "adding: mem time218, current time 346, horizon 128\n", + "adding: mem time219, current time 346, horizon 127\n", + "adding: mem time220, current time 346, horizon 126\n", + "adding: mem time221, current time 346, horizon 125\n", + "adding: mem time222, current time 346, horizon 124\n", + "adding: mem time223, current time 346, horizon 123\n", + "adding: mem time224, current time 346, horizon 122\n", + "adding: mem time225, current time 346, horizon 121\n", + "adding: mem time226, current time 346, horizon 120\n", + "adding: mem time227, current time 346, horizon 119\n", + "adding: mem time228, current time 346, horizon 118\n", + "adding: mem time229, current time 346, horizon 117\n", + "adding: mem time230, current time 346, horizon 116\n", + "adding: mem time231, current time 346, horizon 115\n", + "adding: mem time232, current time 346, horizon 114\n", + "adding: mem time233, current time 346, horizon 113\n", + "adding: mem time234, current time 346, horizon 112\n", + "adding: mem time235, current time 346, horizon 111\n", + "adding: mem time236, current time 346, horizon 110\n", + "adding: mem time237, current time 346, horizon 109\n", + "adding: mem time238, current time 346, horizon 108\n", + "adding: mem time239, current time 346, horizon 107\n", + "adding: mem time240, current time 346, horizon 106\n", + "adding: mem time241, current time 346, horizon 105\n", + "adding: mem time242, current time 346, horizon 104\n", + "adding: mem time243, current time 346, horizon 103\n", + "adding: mem time244, current time 346, horizon 102\n", + "adding: mem time245, current time 346, horizon 101\n", + "adding: mem time246, current time 346, horizon 100\n", + "adding: mem time247, current time 346, horizon 99\n", + "adding: mem time248, current time 346, horizon 98\n", + "adding: mem time249, current time 346, horizon 97\n", + "adding: mem time250, current time 346, horizon 96\n", + "adding: mem time251, current time 346, horizon 95\n", + "adding: mem time252, current time 346, horizon 94\n", + "adding: mem time253, current time 346, horizon 93\n", + "adding: mem time254, current time 346, horizon 92\n", + "adding: mem time255, current time 346, horizon 91\n", + "adding: mem time256, current time 346, horizon 90\n", + "adding: mem time257, current time 346, horizon 89\n", + "adding: mem time258, current time 346, horizon 88\n", + "adding: mem time259, current time 346, horizon 87\n", + "adding: mem time260, current time 346, horizon 86\n", + "adding: mem time261, current time 346, horizon 85\n", + "adding: mem time262, current time 346, horizon 84\n", + "adding: mem time263, current time 346, horizon 83\n", + "adding: mem time264, current time 346, horizon 82\n", + "adding: mem time265, current time 346, horizon 81\n", + "adding: mem time266, current time 346, horizon 80\n", + "adding: mem time267, current time 346, horizon 79\n", + "adding: mem time268, current time 346, horizon 78\n", + "adding: mem time269, current time 346, horizon 77\n", + "adding: mem time270, current time 346, horizon 76\n", + "adding: mem time271, current time 346, horizon 75\n", + "adding: mem time272, current time 346, horizon 74\n", + "adding: mem time273, current time 346, horizon 73\n", + "adding: mem time274, current time 346, horizon 72\n", + "adding: mem time275, current time 346, horizon 71\n", + "adding: mem time276, current time 346, horizon 70\n", + "adding: mem time277, current time 346, horizon 69\n", + "adding: mem time278, current time 346, horizon 68\n", + "adding: mem time279, current time 346, horizon 67\n", + "adding: mem time280, current time 346, horizon 66\n", + "adding: mem time281, current time 346, horizon 65\n", + "adding: mem time282, current time 346, horizon 64\n", + "adding: mem time283, current time 346, horizon 63\n", + "adding: mem time284, current time 346, horizon 62\n", + "adding: mem time285, current time 346, horizon 61\n", + "adding: mem time286, current time 346, horizon 60\n", + "adding: mem time287, current time 346, horizon 59\n", + "adding: mem time288, current time 346, horizon 58\n", + "adding: mem time289, current time 346, horizon 57\n", + "adding: mem time290, current time 346, horizon 56\n", + "adding: mem time291, current time 346, horizon 55\n", + "adding: mem time292, current time 346, horizon 54\n", + "adding: mem time293, current time 346, horizon 53\n", + "adding: mem time294, current time 346, horizon 52\n", + "adding: mem time295, current time 346, horizon 51\n", + "adding: mem time296, current time 346, horizon 50\n", + "adding: mem time297, current time 346, horizon 49\n", + "adding: mem time298, current time 346, horizon 48\n", + "adding: mem time299, current time 346, horizon 47\n", + "adding: mem time300, current time 346, horizon 46\n", + "adding: mem time301, current time 346, horizon 45\n", + "adding: mem time302, current time 346, horizon 44\n", + "adding: mem time303, current time 346, horizon 43\n", + "adding: mem time304, current time 346, horizon 42\n", + "adding: mem time305, current time 346, horizon 41\n", + "adding: mem time306, current time 346, horizon 40\n", + "adding: mem time307, current time 346, horizon 39\n", + "adding: mem time308, current time 346, horizon 38\n", + "adding: mem time309, current time 346, horizon 37\n", + "adding: mem time310, current time 346, horizon 36\n", + "adding: mem time311, current time 346, horizon 35\n", + "adding: mem time312, current time 346, horizon 34\n", + "adding: mem time313, current time 346, horizon 33\n", + "adding: mem time314, current time 346, horizon 32\n", + "adding: mem time315, current time 346, horizon 31\n", + "adding: mem time316, current time 346, horizon 30\n", + "adding: mem time317, current time 346, horizon 29\n", + "adding: mem time318, current time 346, horizon 28\n", + "adding: mem time319, current time 346, horizon 27\n", + "adding: mem time320, current time 346, horizon 26\n", + "adding: mem time321, current time 346, horizon 25\n", + "adding: mem time322, current time 346, horizon 24\n", + "adding: mem time323, current time 346, horizon 23\n", + "adding: mem time324, current time 346, horizon 22\n", + "adding: mem time325, current time 346, horizon 21\n", + "adding: mem time326, current time 346, horizon 20\n", + "adding: mem time327, current time 346, horizon 19\n", + "adding: mem time328, current time 346, horizon 18\n", + "adding: mem time329, current time 346, horizon 17\n", + "adding: mem time330, current time 346, horizon 16\n", + "adding: mem time331, current time 346, horizon 15\n", + "adding: mem time332, current time 346, horizon 14\n", + "adding: mem time333, current time 346, horizon 13\n", + "adding: mem time334, current time 346, horizon 12\n", + "adding: mem time335, current time 346, horizon 11\n", + "adding: mem time336, current time 346, horizon 10\n", + "adding: mem time337, current time 346, horizon 9\n", + "adding: mem time338, current time 346, horizon 8\n", + "adding: mem time339, current time 346, horizon 7\n", + "adding: mem time340, current time 346, horizon 6\n", + "adding: mem time341, current time 346, horizon 5\n", + "adding: mem time342, current time 346, horizon 4\n", + "adding: mem time343, current time 346, horizon 3\n", + "adding: mem time344, current time 346, horizon 2\n", + "adding: mem time345, current time 346, horizon 1\n", + "adding: mem time200, current time 347, horizon 147\n", + "adding: mem time201, current time 347, horizon 146\n", + "adding: mem time202, current time 347, horizon 145\n", + "adding: mem time203, current time 347, horizon 144\n", + "adding: mem time204, current time 347, horizon 143\n", + "adding: mem time205, current time 347, horizon 142\n", + "adding: mem time206, current time 347, horizon 141\n", + "adding: mem time207, current time 347, horizon 140\n", + "adding: mem time208, current time 347, horizon 139\n", + "adding: mem time209, current time 347, horizon 138\n", + "adding: mem time210, current time 347, horizon 137\n", + "adding: mem time211, current time 347, horizon 136\n", + "adding: mem time212, current time 347, horizon 135\n", + "adding: mem time213, current time 347, horizon 134\n", + "adding: mem time214, current time 347, horizon 133\n", + "adding: mem time215, current time 347, horizon 132\n", + "adding: mem time216, current time 347, horizon 131\n", + "adding: mem time217, current time 347, horizon 130\n", + "adding: mem time218, current time 347, horizon 129\n", + "adding: mem time219, current time 347, horizon 128\n", + "adding: mem time220, current time 347, horizon 127\n", + "adding: mem time221, current time 347, horizon 126\n", + "adding: mem time222, current time 347, horizon 125\n", + "adding: mem time223, current time 347, horizon 124\n", + "adding: mem time224, current time 347, horizon 123\n", + "adding: mem time225, current time 347, horizon 122\n", + "adding: mem time226, current time 347, horizon 121\n", + "adding: mem time227, current time 347, horizon 120\n", + "adding: mem time228, current time 347, horizon 119\n", + "adding: mem time229, current time 347, horizon 118\n", + "adding: mem time230, current time 347, horizon 117\n", + "adding: mem time231, current time 347, horizon 116\n", + "adding: mem time232, current time 347, horizon 115\n", + "adding: mem time233, current time 347, horizon 114\n", + "adding: mem time234, current time 347, horizon 113\n", + "adding: mem time235, current time 347, horizon 112\n", + "adding: mem time236, current time 347, horizon 111\n", + "adding: mem time237, current time 347, horizon 110\n", + "adding: mem time238, current time 347, horizon 109\n", + "adding: mem time239, current time 347, horizon 108\n", + "adding: mem time240, current time 347, horizon 107\n", + "adding: mem time241, current time 347, horizon 106\n", + "adding: mem time242, current time 347, horizon 105\n", + "adding: mem time243, current time 347, horizon 104\n", + "adding: mem time244, current time 347, horizon 103\n", + "adding: mem time245, current time 347, horizon 102\n", + "adding: mem time246, current time 347, horizon 101\n", + "adding: mem time247, current time 347, horizon 100\n", + "adding: mem time248, current time 347, horizon 99\n", + "adding: mem time249, current time 347, horizon 98\n", + "adding: mem time250, current time 347, horizon 97\n", + "adding: mem time251, current time 347, horizon 96\n", + "adding: mem time252, current time 347, horizon 95\n", + "adding: mem time253, current time 347, horizon 94\n", + "adding: mem time254, current time 347, horizon 93\n", + "adding: mem time255, current time 347, horizon 92\n", + "adding: mem time256, current time 347, horizon 91\n", + "adding: mem time257, current time 347, horizon 90\n", + "adding: mem time258, current time 347, horizon 89\n", + "adding: mem time259, current time 347, horizon 88\n", + "adding: mem time260, current time 347, horizon 87\n", + "adding: mem time261, current time 347, horizon 86\n", + "adding: mem time262, current time 347, horizon 85\n", + "adding: mem time263, current time 347, horizon 84\n", + "adding: mem time264, current time 347, horizon 83\n", + "adding: mem time265, current time 347, horizon 82\n", + "adding: mem time266, current time 347, horizon 81\n", + "adding: mem time267, current time 347, horizon 80\n", + "adding: mem time268, current time 347, horizon 79\n", + "adding: mem time269, current time 347, horizon 78\n", + "adding: mem time270, current time 347, horizon 77\n", + "adding: mem time271, current time 347, horizon 76\n", + "adding: mem time272, current time 347, horizon 75\n", + "adding: mem time273, current time 347, horizon 74\n", + "adding: mem time274, current time 347, horizon 73\n", + "adding: mem time275, current time 347, horizon 72\n", + "adding: mem time276, current time 347, horizon 71\n", + "adding: mem time277, current time 347, horizon 70\n", + "adding: mem time278, current time 347, horizon 69\n", + "adding: mem time279, current time 347, horizon 68\n", + "adding: mem time280, current time 347, horizon 67\n", + "adding: mem time281, current time 347, horizon 66\n", + "adding: mem time282, current time 347, horizon 65\n", + "adding: mem time283, current time 347, horizon 64\n", + "adding: mem time284, current time 347, horizon 63\n", + "adding: mem time285, current time 347, horizon 62\n", + "adding: mem time286, current time 347, horizon 61\n", + "adding: mem time287, current time 347, horizon 60\n", + "adding: mem time288, current time 347, horizon 59\n", + "adding: mem time289, current time 347, horizon 58\n", + "adding: mem time290, current time 347, horizon 57\n", + "adding: mem time291, current time 347, horizon 56\n", + "adding: mem time292, current time 347, horizon 55\n", + "adding: mem time293, current time 347, horizon 54\n", + "adding: mem time294, current time 347, horizon 53\n", + "adding: mem time295, current time 347, horizon 52\n", + "adding: mem time296, current time 347, horizon 51\n", + "adding: mem time297, current time 347, horizon 50\n", + "adding: mem time298, current time 347, horizon 49\n", + "adding: mem time299, current time 347, horizon 48\n", + "adding: mem time300, current time 347, horizon 47\n", + "adding: mem time301, current time 347, horizon 46\n", + "adding: mem time302, current time 347, horizon 45\n", + "adding: mem time303, current time 347, horizon 44\n", + "adding: mem time304, current time 347, horizon 43\n", + "adding: mem time305, current time 347, horizon 42\n", + "adding: mem time306, current time 347, horizon 41\n", + "adding: mem time307, current time 347, horizon 40\n", + "adding: mem time308, current time 347, horizon 39\n", + "adding: mem time309, current time 347, horizon 38\n", + "adding: mem time310, current time 347, horizon 37\n", + "adding: mem time311, current time 347, horizon 36\n", + "adding: mem time312, current time 347, horizon 35\n", + "adding: mem time313, current time 347, horizon 34\n", + "adding: mem time314, current time 347, horizon 33\n", + "adding: mem time315, current time 347, horizon 32\n", + "adding: mem time316, current time 347, horizon 31\n", + "adding: mem time317, current time 347, horizon 30\n", + "adding: mem time318, current time 347, horizon 29\n", + "adding: mem time319, current time 347, horizon 28\n", + "adding: mem time320, current time 347, horizon 27\n", + "adding: mem time321, current time 347, horizon 26\n", + "adding: mem time322, current time 347, horizon 25\n", + "adding: mem time323, current time 347, horizon 24\n", + "adding: mem time324, current time 347, horizon 23\n", + "adding: mem time325, current time 347, horizon 22\n", + "adding: mem time326, current time 347, horizon 21\n", + "adding: mem time327, current time 347, horizon 20\n", + "adding: mem time328, current time 347, horizon 19\n", + "adding: mem time329, current time 347, horizon 18\n", + "adding: mem time330, current time 347, horizon 17\n", + "adding: mem time331, current time 347, horizon 16\n", + "adding: mem time332, current time 347, horizon 15\n", + "adding: mem time333, current time 347, horizon 14\n", + "adding: mem time334, current time 347, horizon 13\n", + "adding: mem time335, current time 347, horizon 12\n", + "adding: mem time336, current time 347, horizon 11\n", + "adding: mem time337, current time 347, horizon 10\n", + "adding: mem time338, current time 347, horizon 9\n", + "adding: mem time339, current time 347, horizon 8\n", + "adding: mem time340, current time 347, horizon 7\n", + "adding: mem time341, current time 347, horizon 6\n", + "adding: mem time342, current time 347, horizon 5\n", + "adding: mem time343, current time 347, horizon 4\n", + "adding: mem time344, current time 347, horizon 3\n", + "adding: mem time345, current time 347, horizon 2\n", + "adding: mem time346, current time 347, horizon 1\n", + "adding: mem time200, current time 348, horizon 148\n", + "adding: mem time201, current time 348, horizon 147\n", + "adding: mem time202, current time 348, horizon 146\n", + "adding: mem time203, current time 348, horizon 145\n", + "adding: mem time204, current time 348, horizon 144\n", + "adding: mem time205, current time 348, horizon 143\n", + "adding: mem time206, current time 348, horizon 142\n", + "adding: mem time207, current time 348, horizon 141\n", + "adding: mem time208, current time 348, horizon 140\n", + "adding: mem time209, current time 348, horizon 139\n", + "adding: mem time210, current time 348, horizon 138\n", + "adding: mem time211, current time 348, horizon 137\n", + "adding: mem time212, current time 348, horizon 136\n", + "adding: mem time213, current time 348, horizon 135\n", + "adding: mem time214, current time 348, horizon 134\n", + "adding: mem time215, current time 348, horizon 133\n", + "adding: mem time216, current time 348, horizon 132\n", + "adding: mem time217, current time 348, horizon 131\n", + "adding: mem time218, current time 348, horizon 130\n", + "adding: mem time219, current time 348, horizon 129\n", + "adding: mem time220, current time 348, horizon 128\n", + "adding: mem time221, current time 348, horizon 127\n", + "adding: mem time222, current time 348, horizon 126\n", + "adding: mem time223, current time 348, horizon 125\n", + "adding: mem time224, current time 348, horizon 124\n", + "adding: mem time225, current time 348, horizon 123\n", + "adding: mem time226, current time 348, horizon 122\n", + "adding: mem time227, current time 348, horizon 121\n", + "adding: mem time228, current time 348, horizon 120\n", + "adding: mem time229, current time 348, horizon 119\n", + "adding: mem time230, current time 348, horizon 118\n", + "adding: mem time231, current time 348, horizon 117\n", + "adding: mem time232, current time 348, horizon 116\n", + "adding: mem time233, current time 348, horizon 115\n", + "adding: mem time234, current time 348, horizon 114\n", + "adding: mem time235, current time 348, horizon 113\n", + "adding: mem time236, current time 348, horizon 112\n", + "adding: mem time237, current time 348, horizon 111\n", + "adding: mem time238, current time 348, horizon 110\n", + "adding: mem time239, current time 348, horizon 109\n", + "adding: mem time240, current time 348, horizon 108\n", + "adding: mem time241, current time 348, horizon 107\n", + "adding: mem time242, current time 348, horizon 106\n", + "adding: mem time243, current time 348, horizon 105\n", + "adding: mem time244, current time 348, horizon 104\n", + "adding: mem time245, current time 348, horizon 103\n", + "adding: mem time246, current time 348, horizon 102\n", + "adding: mem time247, current time 348, horizon 101\n", + "adding: mem time248, current time 348, horizon 100\n", + "adding: mem time249, current time 348, horizon 99\n", + "adding: mem time250, current time 348, horizon 98\n", + "adding: mem time251, current time 348, horizon 97\n", + "adding: mem time252, current time 348, horizon 96\n", + "adding: mem time253, current time 348, horizon 95\n", + "adding: mem time254, current time 348, horizon 94\n", + "adding: mem time255, current time 348, horizon 93\n", + "adding: mem time256, current time 348, horizon 92\n", + "adding: mem time257, current time 348, horizon 91\n", + "adding: mem time258, current time 348, horizon 90\n", + "adding: mem time259, current time 348, horizon 89\n", + "adding: mem time260, current time 348, horizon 88\n", + "adding: mem time261, current time 348, horizon 87\n", + "adding: mem time262, current time 348, horizon 86\n", + "adding: mem time263, current time 348, horizon 85\n", + "adding: mem time264, current time 348, horizon 84\n", + "adding: mem time265, current time 348, horizon 83\n", + "adding: mem time266, current time 348, horizon 82\n", + "adding: mem time267, current time 348, horizon 81\n", + "adding: mem time268, current time 348, horizon 80\n", + "adding: mem time269, current time 348, horizon 79\n", + "adding: mem time270, current time 348, horizon 78\n", + "adding: mem time271, current time 348, horizon 77\n", + "adding: mem time272, current time 348, horizon 76\n", + "adding: mem time273, current time 348, horizon 75\n", + "adding: mem time274, current time 348, horizon 74\n", + "adding: mem time275, current time 348, horizon 73\n", + "adding: mem time276, current time 348, horizon 72\n", + "adding: mem time277, current time 348, horizon 71\n", + "adding: mem time278, current time 348, horizon 70\n", + "adding: mem time279, current time 348, horizon 69\n", + "adding: mem time280, current time 348, horizon 68\n", + "adding: mem time281, current time 348, horizon 67\n", + "adding: mem time282, current time 348, horizon 66\n", + "adding: mem time283, current time 348, horizon 65\n", + "adding: mem time284, current time 348, horizon 64\n", + "adding: mem time285, current time 348, horizon 63\n", + "adding: mem time286, current time 348, horizon 62\n", + "adding: mem time287, current time 348, horizon 61\n", + "adding: mem time288, current time 348, horizon 60\n", + "adding: mem time289, current time 348, horizon 59\n", + "adding: mem time290, current time 348, horizon 58\n", + "adding: mem time291, current time 348, horizon 57\n", + "adding: mem time292, current time 348, horizon 56\n", + "adding: mem time293, current time 348, horizon 55\n", + "adding: mem time294, current time 348, horizon 54\n", + "adding: mem time295, current time 348, horizon 53\n", + "adding: mem time296, current time 348, horizon 52\n", + "adding: mem time297, current time 348, horizon 51\n", + "adding: mem time298, current time 348, horizon 50\n", + "adding: mem time299, current time 348, horizon 49\n", + "adding: mem time300, current time 348, horizon 48\n", + "adding: mem time301, current time 348, horizon 47\n", + "adding: mem time302, current time 348, horizon 46\n", + "adding: mem time303, current time 348, horizon 45\n", + "adding: mem time304, current time 348, horizon 44\n", + "adding: mem time305, current time 348, horizon 43\n", + "adding: mem time306, current time 348, horizon 42\n", + "adding: mem time307, current time 348, horizon 41\n", + "adding: mem time308, current time 348, horizon 40\n", + "adding: mem time309, current time 348, horizon 39\n", + "adding: mem time310, current time 348, horizon 38\n", + "adding: mem time311, current time 348, horizon 37\n", + "adding: mem time312, current time 348, horizon 36\n", + "adding: mem time313, current time 348, horizon 35\n", + "adding: mem time314, current time 348, horizon 34\n", + "adding: mem time315, current time 348, horizon 33\n", + "adding: mem time316, current time 348, horizon 32\n", + "adding: mem time317, current time 348, horizon 31\n", + "adding: mem time318, current time 348, horizon 30\n", + "adding: mem time319, current time 348, horizon 29\n", + "adding: mem time320, current time 348, horizon 28\n", + "adding: mem time321, current time 348, horizon 27\n", + "adding: mem time322, current time 348, horizon 26\n", + "adding: mem time323, current time 348, horizon 25\n", + "adding: mem time324, current time 348, horizon 24\n", + "adding: mem time325, current time 348, horizon 23\n", + "adding: mem time326, current time 348, horizon 22\n", + "adding: mem time327, current time 348, horizon 21\n", + "adding: mem time328, current time 348, horizon 20\n", + "adding: mem time329, current time 348, horizon 19\n", + "adding: mem time330, current time 348, horizon 18\n", + "adding: mem time331, current time 348, horizon 17\n", + "adding: mem time332, current time 348, horizon 16\n", + "adding: mem time333, current time 348, horizon 15\n", + "adding: mem time334, current time 348, horizon 14\n", + "adding: mem time335, current time 348, horizon 13\n", + "adding: mem time336, current time 348, horizon 12\n", + "adding: mem time337, current time 348, horizon 11\n", + "adding: mem time338, current time 348, horizon 10\n", + "adding: mem time339, current time 348, horizon 9\n", + "adding: mem time340, current time 348, horizon 8\n", + "adding: mem time341, current time 348, horizon 7\n", + "adding: mem time342, current time 348, horizon 6\n", + "adding: mem time343, current time 348, horizon 5\n", + "adding: mem time344, current time 348, horizon 4\n", + "adding: mem time345, current time 348, horizon 3\n", + "adding: mem time346, current time 348, horizon 2\n", + "adding: mem time347, current time 348, horizon 1\n", + "adding: mem time200, current time 349, horizon 149\n", + "adding: mem time201, current time 349, horizon 148\n", + "adding: mem time202, current time 349, horizon 147\n", + "adding: mem time203, current time 349, horizon 146\n", + "adding: mem time204, current time 349, horizon 145\n", + "adding: mem time205, current time 349, horizon 144\n", + "adding: mem time206, current time 349, horizon 143\n", + "adding: mem time207, current time 349, horizon 142\n", + "adding: mem time208, current time 349, horizon 141\n", + "adding: mem time209, current time 349, horizon 140\n", + "adding: mem time210, current time 349, horizon 139\n", + "adding: mem time211, current time 349, horizon 138\n", + "adding: mem time212, current time 349, horizon 137\n", + "adding: mem time213, current time 349, horizon 136\n", + "adding: mem time214, current time 349, horizon 135\n", + "adding: mem time215, current time 349, horizon 134\n", + "adding: mem time216, current time 349, horizon 133\n", + "adding: mem time217, current time 349, horizon 132\n", + "adding: mem time218, current time 349, horizon 131\n", + "adding: mem time219, current time 349, horizon 130\n", + "adding: mem time220, current time 349, horizon 129\n", + "adding: mem time221, current time 349, horizon 128\n", + "adding: mem time222, current time 349, horizon 127\n", + "adding: mem time223, current time 349, horizon 126\n", + "adding: mem time224, current time 349, horizon 125\n", + "adding: mem time225, current time 349, horizon 124\n", + "adding: mem time226, current time 349, horizon 123\n", + "adding: mem time227, current time 349, horizon 122\n", + "adding: mem time228, current time 349, horizon 121\n", + "adding: mem time229, current time 349, horizon 120\n", + "adding: mem time230, current time 349, horizon 119\n", + "adding: mem time231, current time 349, horizon 118\n", + "adding: mem time232, current time 349, horizon 117\n", + "adding: mem time233, current time 349, horizon 116\n", + "adding: mem time234, current time 349, horizon 115\n", + "adding: mem time235, current time 349, horizon 114\n", + "adding: mem time236, current time 349, horizon 113\n", + "adding: mem time237, current time 349, horizon 112\n", + "adding: mem time238, current time 349, horizon 111\n", + "adding: mem time239, current time 349, horizon 110\n", + "adding: mem time240, current time 349, horizon 109\n", + "adding: mem time241, current time 349, horizon 108\n", + "adding: mem time242, current time 349, horizon 107\n", + "adding: mem time243, current time 349, horizon 106\n", + "adding: mem time244, current time 349, horizon 105\n", + "adding: mem time245, current time 349, horizon 104\n", + "adding: mem time246, current time 349, horizon 103\n", + "adding: mem time247, current time 349, horizon 102\n", + "adding: mem time248, current time 349, horizon 101\n", + "adding: mem time249, current time 349, horizon 100\n", + "adding: mem time250, current time 349, horizon 99\n", + "adding: mem time251, current time 349, horizon 98\n", + "adding: mem time252, current time 349, horizon 97\n", + "adding: mem time253, current time 349, horizon 96\n", + "adding: mem time254, current time 349, horizon 95\n", + "adding: mem time255, current time 349, horizon 94\n", + "adding: mem time256, current time 349, horizon 93\n", + "adding: mem time257, current time 349, horizon 92\n", + "adding: mem time258, current time 349, horizon 91\n", + "adding: mem time259, current time 349, horizon 90\n", + "adding: mem time260, current time 349, horizon 89\n", + "adding: mem time261, current time 349, horizon 88\n", + "adding: mem time262, current time 349, horizon 87\n", + "adding: mem time263, current time 349, horizon 86\n", + "adding: mem time264, current time 349, horizon 85\n", + "adding: mem time265, current time 349, horizon 84\n", + "adding: mem time266, current time 349, horizon 83\n", + "adding: mem time267, current time 349, horizon 82\n", + "adding: mem time268, current time 349, horizon 81\n", + "adding: mem time269, current time 349, horizon 80\n", + "adding: mem time270, current time 349, horizon 79\n", + "adding: mem time271, current time 349, horizon 78\n", + "adding: mem time272, current time 349, horizon 77\n", + "adding: mem time273, current time 349, horizon 76\n", + "adding: mem time274, current time 349, horizon 75\n", + "adding: mem time275, current time 349, horizon 74\n", + "adding: mem time276, current time 349, horizon 73\n", + "adding: mem time277, current time 349, horizon 72\n", + "adding: mem time278, current time 349, horizon 71\n", + "adding: mem time279, current time 349, horizon 70\n", + "adding: mem time280, current time 349, horizon 69\n", + "adding: mem time281, current time 349, horizon 68\n", + "adding: mem time282, current time 349, horizon 67\n", + "adding: mem time283, current time 349, horizon 66\n", + "adding: mem time284, current time 349, horizon 65\n", + "adding: mem time285, current time 349, horizon 64\n", + "adding: mem time286, current time 349, horizon 63\n", + "adding: mem time287, current time 349, horizon 62\n", + "adding: mem time288, current time 349, horizon 61\n", + "adding: mem time289, current time 349, horizon 60\n", + "adding: mem time290, current time 349, horizon 59\n", + "adding: mem time291, current time 349, horizon 58\n", + "adding: mem time292, current time 349, horizon 57\n", + "adding: mem time293, current time 349, horizon 56\n", + "adding: mem time294, current time 349, horizon 55\n", + "adding: mem time295, current time 349, horizon 54\n", + "adding: mem time296, current time 349, horizon 53\n", + "adding: mem time297, current time 349, horizon 52\n", + "adding: mem time298, current time 349, horizon 51\n", + "adding: mem time299, current time 349, horizon 50\n", + "adding: mem time300, current time 349, horizon 49\n", + "adding: mem time301, current time 349, horizon 48\n", + "adding: mem time302, current time 349, horizon 47\n", + "adding: mem time303, current time 349, horizon 46\n", + "adding: mem time304, current time 349, horizon 45\n", + "adding: mem time305, current time 349, horizon 44\n", + "adding: mem time306, current time 349, horizon 43\n", + "adding: mem time307, current time 349, horizon 42\n", + "adding: mem time308, current time 349, horizon 41\n", + "adding: mem time309, current time 349, horizon 40\n", + "adding: mem time310, current time 349, horizon 39\n", + "adding: mem time311, current time 349, horizon 38\n", + "adding: mem time312, current time 349, horizon 37\n", + "adding: mem time313, current time 349, horizon 36\n", + "adding: mem time314, current time 349, horizon 35\n", + "adding: mem time315, current time 349, horizon 34\n", + "adding: mem time316, current time 349, horizon 33\n", + "adding: mem time317, current time 349, horizon 32\n", + "adding: mem time318, current time 349, horizon 31\n", + "adding: mem time319, current time 349, horizon 30\n", + "adding: mem time320, current time 349, horizon 29\n", + "adding: mem time321, current time 349, horizon 28\n", + "adding: mem time322, current time 349, horizon 27\n", + "adding: mem time323, current time 349, horizon 26\n", + "adding: mem time324, current time 349, horizon 25\n", + "adding: mem time325, current time 349, horizon 24\n", + "adding: mem time326, current time 349, horizon 23\n", + "adding: mem time327, current time 349, horizon 22\n", + "adding: mem time328, current time 349, horizon 21\n", + "adding: mem time329, current time 349, horizon 20\n", + "adding: mem time330, current time 349, horizon 19\n", + "adding: mem time331, current time 349, horizon 18\n", + "adding: mem time332, current time 349, horizon 17\n", + "adding: mem time333, current time 349, horizon 16\n", + "adding: mem time334, current time 349, horizon 15\n", + "adding: mem time335, current time 349, horizon 14\n", + "adding: mem time336, current time 349, horizon 13\n", + "adding: mem time337, current time 349, horizon 12\n", + "adding: mem time338, current time 349, horizon 11\n", + "adding: mem time339, current time 349, horizon 10\n", + "adding: mem time340, current time 349, horizon 9\n", + "adding: mem time341, current time 349, horizon 8\n", + "adding: mem time342, current time 349, horizon 7\n", + "adding: mem time343, current time 349, horizon 6\n", + "adding: mem time344, current time 349, horizon 5\n", + "adding: mem time345, current time 349, horizon 4\n", + "adding: mem time346, current time 349, horizon 3\n", + "adding: mem time347, current time 349, horizon 2\n", + "adding: mem time348, current time 349, horizon 1\n", + "adding: mem time200, current time 350, horizon 150\n", + "adding: mem time201, current time 350, horizon 149\n", + "adding: mem time202, current time 350, horizon 148\n", + "adding: mem time203, current time 350, horizon 147\n", + "adding: mem time204, current time 350, horizon 146\n", + "adding: mem time205, current time 350, horizon 145\n", + "adding: mem time206, current time 350, horizon 144\n", + "adding: mem time207, current time 350, horizon 143\n", + "adding: mem time208, current time 350, horizon 142\n", + "adding: mem time209, current time 350, horizon 141\n", + "adding: mem time210, current time 350, horizon 140\n", + "adding: mem time211, current time 350, horizon 139\n", + "adding: mem time212, current time 350, horizon 138\n", + "adding: mem time213, current time 350, horizon 137\n", + "adding: mem time214, current time 350, horizon 136\n", + "adding: mem time215, current time 350, horizon 135\n", + "adding: mem time216, current time 350, horizon 134\n", + "adding: mem time217, current time 350, horizon 133\n", + "adding: mem time218, current time 350, horizon 132\n", + "adding: mem time219, current time 350, horizon 131\n", + "adding: mem time220, current time 350, horizon 130\n", + "adding: mem time221, current time 350, horizon 129\n", + "adding: mem time222, current time 350, horizon 128\n", + "adding: mem time223, current time 350, horizon 127\n", + "adding: mem time224, current time 350, horizon 126\n", + "adding: mem time225, current time 350, horizon 125\n", + "adding: mem time226, current time 350, horizon 124\n", + "adding: mem time227, current time 350, horizon 123\n", + "adding: mem time228, current time 350, horizon 122\n", + "adding: mem time229, current time 350, horizon 121\n", + "adding: mem time230, current time 350, horizon 120\n", + "adding: mem time231, current time 350, horizon 119\n", + "adding: mem time232, current time 350, horizon 118\n", + "adding: mem time233, current time 350, horizon 117\n", + "adding: mem time234, current time 350, horizon 116\n", + "adding: mem time235, current time 350, horizon 115\n", + "adding: mem time236, current time 350, horizon 114\n", + "adding: mem time237, current time 350, horizon 113\n", + "adding: mem time238, current time 350, horizon 112\n", + "adding: mem time239, current time 350, horizon 111\n", + "adding: mem time240, current time 350, horizon 110\n", + "adding: mem time241, current time 350, horizon 109\n", + "adding: mem time242, current time 350, horizon 108\n", + "adding: mem time243, current time 350, horizon 107\n", + "adding: mem time244, current time 350, horizon 106\n", + "adding: mem time245, current time 350, horizon 105\n", + "adding: mem time246, current time 350, horizon 104\n", + "adding: mem time247, current time 350, horizon 103\n", + "adding: mem time248, current time 350, horizon 102\n", + "adding: mem time249, current time 350, horizon 101\n", + "adding: mem time250, current time 350, horizon 100\n", + "adding: mem time251, current time 350, horizon 99\n", + "adding: mem time252, current time 350, horizon 98\n", + "adding: mem time253, current time 350, horizon 97\n", + "adding: mem time254, current time 350, horizon 96\n", + "adding: mem time255, current time 350, horizon 95\n", + "adding: mem time256, current time 350, horizon 94\n", + "adding: mem time257, current time 350, horizon 93\n", + "adding: mem time258, current time 350, horizon 92\n", + "adding: mem time259, current time 350, horizon 91\n", + "adding: mem time260, current time 350, horizon 90\n", + "adding: mem time261, current time 350, horizon 89\n", + "adding: mem time262, current time 350, horizon 88\n", + "adding: mem time263, current time 350, horizon 87\n", + "adding: mem time264, current time 350, horizon 86\n", + "adding: mem time265, current time 350, horizon 85\n", + "adding: mem time266, current time 350, horizon 84\n", + "adding: mem time267, current time 350, horizon 83\n", + "adding: mem time268, current time 350, horizon 82\n", + "adding: mem time269, current time 350, horizon 81\n", + "adding: mem time270, current time 350, horizon 80\n", + "adding: mem time271, current time 350, horizon 79\n", + "adding: mem time272, current time 350, horizon 78\n", + "adding: mem time273, current time 350, horizon 77\n", + "adding: mem time274, current time 350, horizon 76\n", + "adding: mem time275, current time 350, horizon 75\n", + "adding: mem time276, current time 350, horizon 74\n", + "adding: mem time277, current time 350, horizon 73\n", + "adding: mem time278, current time 350, horizon 72\n", + "adding: mem time279, current time 350, horizon 71\n", + "adding: mem time280, current time 350, horizon 70\n", + "adding: mem time281, current time 350, horizon 69\n", + "adding: mem time282, current time 350, horizon 68\n", + "adding: mem time283, current time 350, horizon 67\n", + "adding: mem time284, current time 350, horizon 66\n", + "adding: mem time285, current time 350, horizon 65\n", + "adding: mem time286, current time 350, horizon 64\n", + "adding: mem time287, current time 350, horizon 63\n", + "adding: mem time288, current time 350, horizon 62\n", + "adding: mem time289, current time 350, horizon 61\n", + "adding: mem time290, current time 350, horizon 60\n", + "adding: mem time291, current time 350, horizon 59\n", + "adding: mem time292, current time 350, horizon 58\n", + "adding: mem time293, current time 350, horizon 57\n", + "adding: mem time294, current time 350, horizon 56\n", + "adding: mem time295, current time 350, horizon 55\n", + "adding: mem time296, current time 350, horizon 54\n", + "adding: mem time297, current time 350, horizon 53\n", + "adding: mem time298, current time 350, horizon 52\n", + "adding: mem time299, current time 350, horizon 51\n", + "adding: mem time300, current time 350, horizon 50\n", + "adding: mem time301, current time 350, horizon 49\n", + "adding: mem time302, current time 350, horizon 48\n", + "adding: mem time303, current time 350, horizon 47\n", + "adding: mem time304, current time 350, horizon 46\n", + "adding: mem time305, current time 350, horizon 45\n", + "adding: mem time306, current time 350, horizon 44\n", + "adding: mem time307, current time 350, horizon 43\n", + "adding: mem time308, current time 350, horizon 42\n", + "adding: mem time309, current time 350, horizon 41\n", + "adding: mem time310, current time 350, horizon 40\n", + "adding: mem time311, current time 350, horizon 39\n", + "adding: mem time312, current time 350, horizon 38\n", + "adding: mem time313, current time 350, horizon 37\n", + "adding: mem time314, current time 350, horizon 36\n", + "adding: mem time315, current time 350, horizon 35\n", + "adding: mem time316, current time 350, horizon 34\n", + "adding: mem time317, current time 350, horizon 33\n", + "adding: mem time318, current time 350, horizon 32\n", + "adding: mem time319, current time 350, horizon 31\n", + "adding: mem time320, current time 350, horizon 30\n", + "adding: mem time321, current time 350, horizon 29\n", + "adding: mem time322, current time 350, horizon 28\n", + "adding: mem time323, current time 350, horizon 27\n", + "adding: mem time324, current time 350, horizon 26\n", + "adding: mem time325, current time 350, horizon 25\n", + "adding: mem time326, current time 350, horizon 24\n", + "adding: mem time327, current time 350, horizon 23\n", + "adding: mem time328, current time 350, horizon 22\n", + "adding: mem time329, current time 350, horizon 21\n", + "adding: mem time330, current time 350, horizon 20\n", + "adding: mem time331, current time 350, horizon 19\n", + "adding: mem time332, current time 350, horizon 18\n", + "adding: mem time333, current time 350, horizon 17\n", + "adding: mem time334, current time 350, horizon 16\n", + "adding: mem time335, current time 350, horizon 15\n", + "adding: mem time336, current time 350, horizon 14\n", + "adding: mem time337, current time 350, horizon 13\n", + "adding: mem time338, current time 350, horizon 12\n", + "adding: mem time339, current time 350, horizon 11\n", + "adding: mem time340, current time 350, horizon 10\n", + "adding: mem time341, current time 350, horizon 9\n", + "adding: mem time342, current time 350, horizon 8\n", + "adding: mem time343, current time 350, horizon 7\n", + "adding: mem time344, current time 350, horizon 6\n", + "adding: mem time345, current time 350, horizon 5\n", + "adding: mem time346, current time 350, horizon 4\n", + "adding: mem time347, current time 350, horizon 3\n", + "adding: mem time348, current time 350, horizon 2\n", + "adding: mem time349, current time 350, horizon 1\n", + "adding: mem time200, current time 351, horizon 151\n", + "adding: mem time201, current time 351, horizon 150\n", + "adding: mem time202, current time 351, horizon 149\n", + "adding: mem time203, current time 351, horizon 148\n", + "adding: mem time204, current time 351, horizon 147\n", + "adding: mem time205, current time 351, horizon 146\n", + "adding: mem time206, current time 351, horizon 145\n", + "adding: mem time207, current time 351, horizon 144\n", + "adding: mem time208, current time 351, horizon 143\n", + "adding: mem time209, current time 351, horizon 142\n", + "adding: mem time210, current time 351, horizon 141\n", + "adding: mem time211, current time 351, horizon 140\n", + "adding: mem time212, current time 351, horizon 139\n", + "adding: mem time213, current time 351, horizon 138\n", + "adding: mem time214, current time 351, horizon 137\n", + "adding: mem time215, current time 351, horizon 136\n", + "adding: mem time216, current time 351, horizon 135\n", + "adding: mem time217, current time 351, horizon 134\n", + "adding: mem time218, current time 351, horizon 133\n", + "adding: mem time219, current time 351, horizon 132\n", + "adding: mem time220, current time 351, horizon 131\n", + "adding: mem time221, current time 351, horizon 130\n", + "adding: mem time222, current time 351, horizon 129\n", + "adding: mem time223, current time 351, horizon 128\n", + "adding: mem time224, current time 351, horizon 127\n", + "adding: mem time225, current time 351, horizon 126\n", + "adding: mem time226, current time 351, horizon 125\n", + "adding: mem time227, current time 351, horizon 124\n", + "adding: mem time228, current time 351, horizon 123\n", + "adding: mem time229, current time 351, horizon 122\n", + "adding: mem time230, current time 351, horizon 121\n", + "adding: mem time231, current time 351, horizon 120\n", + "adding: mem time232, current time 351, horizon 119\n", + "adding: mem time233, current time 351, horizon 118\n", + "adding: mem time234, current time 351, horizon 117\n", + "adding: mem time235, current time 351, horizon 116\n", + "adding: mem time236, current time 351, horizon 115\n", + "adding: mem time237, current time 351, horizon 114\n", + "adding: mem time238, current time 351, horizon 113\n", + "adding: mem time239, current time 351, horizon 112\n", + "adding: mem time240, current time 351, horizon 111\n", + "adding: mem time241, current time 351, horizon 110\n", + "adding: mem time242, current time 351, horizon 109\n", + "adding: mem time243, current time 351, horizon 108\n", + "adding: mem time244, current time 351, horizon 107\n", + "adding: mem time245, current time 351, horizon 106\n", + "adding: mem time246, current time 351, horizon 105\n", + "adding: mem time247, current time 351, horizon 104\n", + "adding: mem time248, current time 351, horizon 103\n", + "adding: mem time249, current time 351, horizon 102\n", + "adding: mem time250, current time 351, horizon 101\n", + "adding: mem time251, current time 351, horizon 100\n", + "adding: mem time252, current time 351, horizon 99\n", + "adding: mem time253, current time 351, horizon 98\n", + "adding: mem time254, current time 351, horizon 97\n", + "adding: mem time255, current time 351, horizon 96\n", + "adding: mem time256, current time 351, horizon 95\n", + "adding: mem time257, current time 351, horizon 94\n", + "adding: mem time258, current time 351, horizon 93\n", + "adding: mem time259, current time 351, horizon 92\n", + "adding: mem time260, current time 351, horizon 91\n", + "adding: mem time261, current time 351, horizon 90\n", + "adding: mem time262, current time 351, horizon 89\n", + "adding: mem time263, current time 351, horizon 88\n", + "adding: mem time264, current time 351, horizon 87\n", + "adding: mem time265, current time 351, horizon 86\n", + "adding: mem time266, current time 351, horizon 85\n", + "adding: mem time267, current time 351, horizon 84\n", + "adding: mem time268, current time 351, horizon 83\n", + "adding: mem time269, current time 351, horizon 82\n", + "adding: mem time270, current time 351, horizon 81\n", + "adding: mem time271, current time 351, horizon 80\n", + "adding: mem time272, current time 351, horizon 79\n", + "adding: mem time273, current time 351, horizon 78\n", + "adding: mem time274, current time 351, horizon 77\n", + "adding: mem time275, current time 351, horizon 76\n", + "adding: mem time276, current time 351, horizon 75\n", + "adding: mem time277, current time 351, horizon 74\n", + "adding: mem time278, current time 351, horizon 73\n", + "adding: mem time279, current time 351, horizon 72\n", + "adding: mem time280, current time 351, horizon 71\n", + "adding: mem time281, current time 351, horizon 70\n", + "adding: mem time282, current time 351, horizon 69\n", + "adding: mem time283, current time 351, horizon 68\n", + "adding: mem time284, current time 351, horizon 67\n", + "adding: mem time285, current time 351, horizon 66\n", + "adding: mem time286, current time 351, horizon 65\n", + "adding: mem time287, current time 351, horizon 64\n", + "adding: mem time288, current time 351, horizon 63\n", + "adding: mem time289, current time 351, horizon 62\n", + "adding: mem time290, current time 351, horizon 61\n", + "adding: mem time291, current time 351, horizon 60\n", + "adding: mem time292, current time 351, horizon 59\n", + "adding: mem time293, current time 351, horizon 58\n", + "adding: mem time294, current time 351, horizon 57\n", + "adding: mem time295, current time 351, horizon 56\n", + "adding: mem time296, current time 351, horizon 55\n", + "adding: mem time297, current time 351, horizon 54\n", + "adding: mem time298, current time 351, horizon 53\n", + "adding: mem time299, current time 351, horizon 52\n", + "adding: mem time300, current time 351, horizon 51\n", + "adding: mem time301, current time 351, horizon 50\n", + "adding: mem time302, current time 351, horizon 49\n", + "adding: mem time303, current time 351, horizon 48\n", + "adding: mem time304, current time 351, horizon 47\n", + "adding: mem time305, current time 351, horizon 46\n", + "adding: mem time306, current time 351, horizon 45\n", + "adding: mem time307, current time 351, horizon 44\n", + "adding: mem time308, current time 351, horizon 43\n", + "adding: mem time309, current time 351, horizon 42\n", + "adding: mem time310, current time 351, horizon 41\n", + "adding: mem time311, current time 351, horizon 40\n", + "adding: mem time312, current time 351, horizon 39\n", + "adding: mem time313, current time 351, horizon 38\n", + "adding: mem time314, current time 351, horizon 37\n", + "adding: mem time315, current time 351, horizon 36\n", + "adding: mem time316, current time 351, horizon 35\n", + "adding: mem time317, current time 351, horizon 34\n", + "adding: mem time318, current time 351, horizon 33\n", + "adding: mem time319, current time 351, horizon 32\n", + "adding: mem time320, current time 351, horizon 31\n", + "adding: mem time321, current time 351, horizon 30\n", + "adding: mem time322, current time 351, horizon 29\n", + "adding: mem time323, current time 351, horizon 28\n", + "adding: mem time324, current time 351, horizon 27\n", + "adding: mem time325, current time 351, horizon 26\n", + "adding: mem time326, current time 351, horizon 25\n", + "adding: mem time327, current time 351, horizon 24\n", + "adding: mem time328, current time 351, horizon 23\n", + "adding: mem time329, current time 351, horizon 22\n", + "adding: mem time330, current time 351, horizon 21\n", + "adding: mem time331, current time 351, horizon 20\n", + "adding: mem time332, current time 351, horizon 19\n", + "adding: mem time333, current time 351, horizon 18\n", + "adding: mem time334, current time 351, horizon 17\n", + "adding: mem time335, current time 351, horizon 16\n", + "adding: mem time336, current time 351, horizon 15\n", + "adding: mem time337, current time 351, horizon 14\n", + "adding: mem time338, current time 351, horizon 13\n", + "adding: mem time339, current time 351, horizon 12\n", + "adding: mem time340, current time 351, horizon 11\n", + "adding: mem time341, current time 351, horizon 10\n", + "adding: mem time342, current time 351, horizon 9\n", + "adding: mem time343, current time 351, horizon 8\n", + "adding: mem time344, current time 351, horizon 7\n", + "adding: mem time345, current time 351, horizon 6\n", + "adding: mem time346, current time 351, horizon 5\n", + "adding: mem time347, current time 351, horizon 4\n", + "adding: mem time348, current time 351, horizon 3\n", + "adding: mem time349, current time 351, horizon 2\n", + "adding: mem time350, current time 351, horizon 1\n", + "adding: mem time200, current time 352, horizon 152\n", + "adding: mem time201, current time 352, horizon 151\n", + "adding: mem time202, current time 352, horizon 150\n", + "adding: mem time203, current time 352, horizon 149\n", + "adding: mem time204, current time 352, horizon 148\n", + "adding: mem time205, current time 352, horizon 147\n", + "adding: mem time206, current time 352, horizon 146\n", + "adding: mem time207, current time 352, horizon 145\n", + "adding: mem time208, current time 352, horizon 144\n", + "adding: mem time209, current time 352, horizon 143\n", + "adding: mem time210, current time 352, horizon 142\n", + "adding: mem time211, current time 352, horizon 141\n", + "adding: mem time212, current time 352, horizon 140\n", + "adding: mem time213, current time 352, horizon 139\n", + "adding: mem time214, current time 352, horizon 138\n", + "adding: mem time215, current time 352, horizon 137\n", + "adding: mem time216, current time 352, horizon 136\n", + "adding: mem time217, current time 352, horizon 135\n", + "adding: mem time218, current time 352, horizon 134\n", + "adding: mem time219, current time 352, horizon 133\n", + "adding: mem time220, current time 352, horizon 132\n", + "adding: mem time221, current time 352, horizon 131\n", + "adding: mem time222, current time 352, horizon 130\n", + "adding: mem time223, current time 352, horizon 129\n", + "adding: mem time224, current time 352, horizon 128\n", + "adding: mem time225, current time 352, horizon 127\n", + "adding: mem time226, current time 352, horizon 126\n", + "adding: mem time227, current time 352, horizon 125\n", + "adding: mem time228, current time 352, horizon 124\n", + "adding: mem time229, current time 352, horizon 123\n", + "adding: mem time230, current time 352, horizon 122\n", + "adding: mem time231, current time 352, horizon 121\n", + "adding: mem time232, current time 352, horizon 120\n", + "adding: mem time233, current time 352, horizon 119\n", + "adding: mem time234, current time 352, horizon 118\n", + "adding: mem time235, current time 352, horizon 117\n", + "adding: mem time236, current time 352, horizon 116\n", + "adding: mem time237, current time 352, horizon 115\n", + "adding: mem time238, current time 352, horizon 114\n", + "adding: mem time239, current time 352, horizon 113\n", + "adding: mem time240, current time 352, horizon 112\n", + "adding: mem time241, current time 352, horizon 111\n", + "adding: mem time242, current time 352, horizon 110\n", + "adding: mem time243, current time 352, horizon 109\n", + "adding: mem time244, current time 352, horizon 108\n", + "adding: mem time245, current time 352, horizon 107\n", + "adding: mem time246, current time 352, horizon 106\n", + "adding: mem time247, current time 352, horizon 105\n", + "adding: mem time248, current time 352, horizon 104\n", + "adding: mem time249, current time 352, horizon 103\n", + "adding: mem time250, current time 352, horizon 102\n", + "adding: mem time251, current time 352, horizon 101\n", + "adding: mem time252, current time 352, horizon 100\n", + "adding: mem time253, current time 352, horizon 99\n", + "adding: mem time254, current time 352, horizon 98\n", + "adding: mem time255, current time 352, horizon 97\n", + "adding: mem time256, current time 352, horizon 96\n", + "adding: mem time257, current time 352, horizon 95\n", + "adding: mem time258, current time 352, horizon 94\n", + "adding: mem time259, current time 352, horizon 93\n", + "adding: mem time260, current time 352, horizon 92\n", + "adding: mem time261, current time 352, horizon 91\n", + "adding: mem time262, current time 352, horizon 90\n", + "adding: mem time263, current time 352, horizon 89\n", + "adding: mem time264, current time 352, horizon 88\n", + "adding: mem time265, current time 352, horizon 87\n", + "adding: mem time266, current time 352, horizon 86\n", + "adding: mem time267, current time 352, horizon 85\n", + "adding: mem time268, current time 352, horizon 84\n", + "adding: mem time269, current time 352, horizon 83\n", + "adding: mem time270, current time 352, horizon 82\n", + "adding: mem time271, current time 352, horizon 81\n", + "adding: mem time272, current time 352, horizon 80\n", + "adding: mem time273, current time 352, horizon 79\n", + "adding: mem time274, current time 352, horizon 78\n", + "adding: mem time275, current time 352, horizon 77\n", + "adding: mem time276, current time 352, horizon 76\n", + "adding: mem time277, current time 352, horizon 75\n", + "adding: mem time278, current time 352, horizon 74\n", + "adding: mem time279, current time 352, horizon 73\n", + "adding: mem time280, current time 352, horizon 72\n", + "adding: mem time281, current time 352, horizon 71\n", + "adding: mem time282, current time 352, horizon 70\n", + "adding: mem time283, current time 352, horizon 69\n", + "adding: mem time284, current time 352, horizon 68\n", + "adding: mem time285, current time 352, horizon 67\n", + "adding: mem time286, current time 352, horizon 66\n", + "adding: mem time287, current time 352, horizon 65\n", + "adding: mem time288, current time 352, horizon 64\n", + "adding: mem time289, current time 352, horizon 63\n", + "adding: mem time290, current time 352, horizon 62\n", + "adding: mem time291, current time 352, horizon 61\n", + "adding: mem time292, current time 352, horizon 60\n", + "adding: mem time293, current time 352, horizon 59\n", + "adding: mem time294, current time 352, horizon 58\n", + "adding: mem time295, current time 352, horizon 57\n", + "adding: mem time296, current time 352, horizon 56\n", + "adding: mem time297, current time 352, horizon 55\n", + "adding: mem time298, current time 352, horizon 54\n", + "adding: mem time299, current time 352, horizon 53\n", + "adding: mem time300, current time 352, horizon 52\n", + "adding: mem time301, current time 352, horizon 51\n", + "adding: mem time302, current time 352, horizon 50\n", + "adding: mem time303, current time 352, horizon 49\n", + "adding: mem time304, current time 352, horizon 48\n", + "adding: mem time305, current time 352, horizon 47\n", + "adding: mem time306, current time 352, horizon 46\n", + "adding: mem time307, current time 352, horizon 45\n", + "adding: mem time308, current time 352, horizon 44\n", + "adding: mem time309, current time 352, horizon 43\n", + "adding: mem time310, current time 352, horizon 42\n", + "adding: mem time311, current time 352, horizon 41\n", + "adding: mem time312, current time 352, horizon 40\n", + "adding: mem time313, current time 352, horizon 39\n", + "adding: mem time314, current time 352, horizon 38\n", + "adding: mem time315, current time 352, horizon 37\n", + "adding: mem time316, current time 352, horizon 36\n", + "adding: mem time317, current time 352, horizon 35\n", + "adding: mem time318, current time 352, horizon 34\n", + "adding: mem time319, current time 352, horizon 33\n", + "adding: mem time320, current time 352, horizon 32\n", + "adding: mem time321, current time 352, horizon 31\n", + "adding: mem time322, current time 352, horizon 30\n", + "adding: mem time323, current time 352, horizon 29\n", + "adding: mem time324, current time 352, horizon 28\n", + "adding: mem time325, current time 352, horizon 27\n", + "adding: mem time326, current time 352, horizon 26\n", + "adding: mem time327, current time 352, horizon 25\n", + "adding: mem time328, current time 352, horizon 24\n", + "adding: mem time329, current time 352, horizon 23\n", + "adding: mem time330, current time 352, horizon 22\n", + "adding: mem time331, current time 352, horizon 21\n", + "adding: mem time332, current time 352, horizon 20\n", + "adding: mem time333, current time 352, horizon 19\n", + "adding: mem time334, current time 352, horizon 18\n", + "adding: mem time335, current time 352, horizon 17\n", + "adding: mem time336, current time 352, horizon 16\n", + "adding: mem time337, current time 352, horizon 15\n", + "adding: mem time338, current time 352, horizon 14\n", + "adding: mem time339, current time 352, horizon 13\n", + "adding: mem time340, current time 352, horizon 12\n", + "adding: mem time341, current time 352, horizon 11\n", + "adding: mem time342, current time 352, horizon 10\n", + "adding: mem time343, current time 352, horizon 9\n", + "adding: mem time344, current time 352, horizon 8\n", + "adding: mem time345, current time 352, horizon 7\n", + "adding: mem time346, current time 352, horizon 6\n", + "adding: mem time347, current time 352, horizon 5\n", + "adding: mem time348, current time 352, horizon 4\n", + "adding: mem time349, current time 352, horizon 3\n", + "adding: mem time350, current time 352, horizon 2\n", + "adding: mem time351, current time 352, horizon 1\n", + "adding: mem time200, current time 353, horizon 153\n", + "adding: mem time201, current time 353, horizon 152\n", + "adding: mem time202, current time 353, horizon 151\n", + "adding: mem time203, current time 353, horizon 150\n", + "adding: mem time204, current time 353, horizon 149\n", + "adding: mem time205, current time 353, horizon 148\n", + "adding: mem time206, current time 353, horizon 147\n", + "adding: mem time207, current time 353, horizon 146\n", + "adding: mem time208, current time 353, horizon 145\n", + "adding: mem time209, current time 353, horizon 144\n", + "adding: mem time210, current time 353, horizon 143\n", + "adding: mem time211, current time 353, horizon 142\n", + "adding: mem time212, current time 353, horizon 141\n", + "adding: mem time213, current time 353, horizon 140\n", + "adding: mem time214, current time 353, horizon 139\n", + "adding: mem time215, current time 353, horizon 138\n", + "adding: mem time216, current time 353, horizon 137\n", + "adding: mem time217, current time 353, horizon 136\n", + "adding: mem time218, current time 353, horizon 135\n", + "adding: mem time219, current time 353, horizon 134\n", + "adding: mem time220, current time 353, horizon 133\n", + "adding: mem time221, current time 353, horizon 132\n", + "adding: mem time222, current time 353, horizon 131\n", + "adding: mem time223, current time 353, horizon 130\n", + "adding: mem time224, current time 353, horizon 129\n", + "adding: mem time225, current time 353, horizon 128\n", + "adding: mem time226, current time 353, horizon 127\n", + "adding: mem time227, current time 353, horizon 126\n", + "adding: mem time228, current time 353, horizon 125\n", + "adding: mem time229, current time 353, horizon 124\n", + "adding: mem time230, current time 353, horizon 123\n", + "adding: mem time231, current time 353, horizon 122\n", + "adding: mem time232, current time 353, horizon 121\n", + "adding: mem time233, current time 353, horizon 120\n", + "adding: mem time234, current time 353, horizon 119\n", + "adding: mem time235, current time 353, horizon 118\n", + "adding: mem time236, current time 353, horizon 117\n", + "adding: mem time237, current time 353, horizon 116\n", + "adding: mem time238, current time 353, horizon 115\n", + "adding: mem time239, current time 353, horizon 114\n", + "adding: mem time240, current time 353, horizon 113\n", + "adding: mem time241, current time 353, horizon 112\n", + "adding: mem time242, current time 353, horizon 111\n", + "adding: mem time243, current time 353, horizon 110\n", + "adding: mem time244, current time 353, horizon 109\n", + "adding: mem time245, current time 353, horizon 108\n", + "adding: mem time246, current time 353, horizon 107\n", + "adding: mem time247, current time 353, horizon 106\n", + "adding: mem time248, current time 353, horizon 105\n", + "adding: mem time249, current time 353, horizon 104\n", + "adding: mem time250, current time 353, horizon 103\n", + "adding: mem time251, current time 353, horizon 102\n", + "adding: mem time252, current time 353, horizon 101\n", + "adding: mem time253, current time 353, horizon 100\n", + "adding: mem time254, current time 353, horizon 99\n", + "adding: mem time255, current time 353, horizon 98\n", + "adding: mem time256, current time 353, horizon 97\n", + "adding: mem time257, current time 353, horizon 96\n", + "adding: mem time258, current time 353, horizon 95\n", + "adding: mem time259, current time 353, horizon 94\n", + "adding: mem time260, current time 353, horizon 93\n", + "adding: mem time261, current time 353, horizon 92\n", + "adding: mem time262, current time 353, horizon 91\n", + "adding: mem time263, current time 353, horizon 90\n", + "adding: mem time264, current time 353, horizon 89\n", + "adding: mem time265, current time 353, horizon 88\n", + "adding: mem time266, current time 353, horizon 87\n", + "adding: mem time267, current time 353, horizon 86\n", + "adding: mem time268, current time 353, horizon 85\n", + "adding: mem time269, current time 353, horizon 84\n", + "adding: mem time270, current time 353, horizon 83\n", + "adding: mem time271, current time 353, horizon 82\n", + "adding: mem time272, current time 353, horizon 81\n", + "adding: mem time273, current time 353, horizon 80\n", + "adding: mem time274, current time 353, horizon 79\n", + "adding: mem time275, current time 353, horizon 78\n", + "adding: mem time276, current time 353, horizon 77\n", + "adding: mem time277, current time 353, horizon 76\n", + "adding: mem time278, current time 353, horizon 75\n", + "adding: mem time279, current time 353, horizon 74\n", + "adding: mem time280, current time 353, horizon 73\n", + "adding: mem time281, current time 353, horizon 72\n", + "adding: mem time282, current time 353, horizon 71\n", + "adding: mem time283, current time 353, horizon 70\n", + "adding: mem time284, current time 353, horizon 69\n", + "adding: mem time285, current time 353, horizon 68\n", + "adding: mem time286, current time 353, horizon 67\n", + "adding: mem time287, current time 353, horizon 66\n", + "adding: mem time288, current time 353, horizon 65\n", + "adding: mem time289, current time 353, horizon 64\n", + "adding: mem time290, current time 353, horizon 63\n", + "adding: mem time291, current time 353, horizon 62\n", + "adding: mem time292, current time 353, horizon 61\n", + "adding: mem time293, current time 353, horizon 60\n", + "adding: mem time294, current time 353, horizon 59\n", + "adding: mem time295, current time 353, horizon 58\n", + "adding: mem time296, current time 353, horizon 57\n", + "adding: mem time297, current time 353, horizon 56\n", + "adding: mem time298, current time 353, horizon 55\n", + "adding: mem time299, current time 353, horizon 54\n", + "adding: mem time300, current time 353, horizon 53\n", + "adding: mem time301, current time 353, horizon 52\n", + "adding: mem time302, current time 353, horizon 51\n", + "adding: mem time303, current time 353, horizon 50\n", + "adding: mem time304, current time 353, horizon 49\n", + "adding: mem time305, current time 353, horizon 48\n", + "adding: mem time306, current time 353, horizon 47\n", + "adding: mem time307, current time 353, horizon 46\n", + "adding: mem time308, current time 353, horizon 45\n", + "adding: mem time309, current time 353, horizon 44\n", + "adding: mem time310, current time 353, horizon 43\n", + "adding: mem time311, current time 353, horizon 42\n", + "adding: mem time312, current time 353, horizon 41\n", + "adding: mem time313, current time 353, horizon 40\n", + "adding: mem time314, current time 353, horizon 39\n", + "adding: mem time315, current time 353, horizon 38\n", + "adding: mem time316, current time 353, horizon 37\n", + "adding: mem time317, current time 353, horizon 36\n", + "adding: mem time318, current time 353, horizon 35\n", + "adding: mem time319, current time 353, horizon 34\n", + "adding: mem time320, current time 353, horizon 33\n", + "adding: mem time321, current time 353, horizon 32\n", + "adding: mem time322, current time 353, horizon 31\n", + "adding: mem time323, current time 353, horizon 30\n", + "adding: mem time324, current time 353, horizon 29\n", + "adding: mem time325, current time 353, horizon 28\n", + "adding: mem time326, current time 353, horizon 27\n", + "adding: mem time327, current time 353, horizon 26\n", + "adding: mem time328, current time 353, horizon 25\n", + "adding: mem time329, current time 353, horizon 24\n", + "adding: mem time330, current time 353, horizon 23\n", + "adding: mem time331, current time 353, horizon 22\n", + "adding: mem time332, current time 353, horizon 21\n", + "adding: mem time333, current time 353, horizon 20\n", + "adding: mem time334, current time 353, horizon 19\n", + "adding: mem time335, current time 353, horizon 18\n", + "adding: mem time336, current time 353, horizon 17\n", + "adding: mem time337, current time 353, horizon 16\n", + "adding: mem time338, current time 353, horizon 15\n", + "adding: mem time339, current time 353, horizon 14\n", + "adding: mem time340, current time 353, horizon 13\n", + "adding: mem time341, current time 353, horizon 12\n", + "adding: mem time342, current time 353, horizon 11\n", + "adding: mem time343, current time 353, horizon 10\n", + "adding: mem time344, current time 353, horizon 9\n", + "adding: mem time345, current time 353, horizon 8\n", + "adding: mem time346, current time 353, horizon 7\n", + "adding: mem time347, current time 353, horizon 6\n", + "adding: mem time348, current time 353, horizon 5\n", + "adding: mem time349, current time 353, horizon 4\n", + "adding: mem time350, current time 353, horizon 3\n", + "adding: mem time351, current time 353, horizon 2\n", + "adding: mem time352, current time 353, horizon 1\n", + "adding: mem time200, current time 354, horizon 154\n", + "adding: mem time201, current time 354, horizon 153\n", + "adding: mem time202, current time 354, horizon 152\n", + "adding: mem time203, current time 354, horizon 151\n", + "adding: mem time204, current time 354, horizon 150\n", + "adding: mem time205, current time 354, horizon 149\n", + "adding: mem time206, current time 354, horizon 148\n", + "adding: mem time207, current time 354, horizon 147\n", + "adding: mem time208, current time 354, horizon 146\n", + "adding: mem time209, current time 354, horizon 145\n", + "adding: mem time210, current time 354, horizon 144\n", + "adding: mem time211, current time 354, horizon 143\n", + "adding: mem time212, current time 354, horizon 142\n", + "adding: mem time213, current time 354, horizon 141\n", + "adding: mem time214, current time 354, horizon 140\n", + "adding: mem time215, current time 354, horizon 139\n", + "adding: mem time216, current time 354, horizon 138\n", + "adding: mem time217, current time 354, horizon 137\n", + "adding: mem time218, current time 354, horizon 136\n", + "adding: mem time219, current time 354, horizon 135\n", + "adding: mem time220, current time 354, horizon 134\n", + "adding: mem time221, current time 354, horizon 133\n", + "adding: mem time222, current time 354, horizon 132\n", + "adding: mem time223, current time 354, horizon 131\n", + "adding: mem time224, current time 354, horizon 130\n", + "adding: mem time225, current time 354, horizon 129\n", + "adding: mem time226, current time 354, horizon 128\n", + "adding: mem time227, current time 354, horizon 127\n", + "adding: mem time228, current time 354, horizon 126\n", + "adding: mem time229, current time 354, horizon 125\n", + "adding: mem time230, current time 354, horizon 124\n", + "adding: mem time231, current time 354, horizon 123\n", + "adding: mem time232, current time 354, horizon 122\n", + "adding: mem time233, current time 354, horizon 121\n", + "adding: mem time234, current time 354, horizon 120\n", + "adding: mem time235, current time 354, horizon 119\n", + "adding: mem time236, current time 354, horizon 118\n", + "adding: mem time237, current time 354, horizon 117\n", + "adding: mem time238, current time 354, horizon 116\n", + "adding: mem time239, current time 354, horizon 115\n", + "adding: mem time240, current time 354, horizon 114\n", + "adding: mem time241, current time 354, horizon 113\n", + "adding: mem time242, current time 354, horizon 112\n", + "adding: mem time243, current time 354, horizon 111\n", + "adding: mem time244, current time 354, horizon 110\n", + "adding: mem time245, current time 354, horizon 109\n", + "adding: mem time246, current time 354, horizon 108\n", + "adding: mem time247, current time 354, horizon 107\n", + "adding: mem time248, current time 354, horizon 106\n", + "adding: mem time249, current time 354, horizon 105\n", + "adding: mem time250, current time 354, horizon 104\n", + "adding: mem time251, current time 354, horizon 103\n", + "adding: mem time252, current time 354, horizon 102\n", + "adding: mem time253, current time 354, horizon 101\n", + "adding: mem time254, current time 354, horizon 100\n", + "adding: mem time255, current time 354, horizon 99\n", + "adding: mem time256, current time 354, horizon 98\n", + "adding: mem time257, current time 354, horizon 97\n", + "adding: mem time258, current time 354, horizon 96\n", + "adding: mem time259, current time 354, horizon 95\n", + "adding: mem time260, current time 354, horizon 94\n", + "adding: mem time261, current time 354, horizon 93\n", + "adding: mem time262, current time 354, horizon 92\n", + "adding: mem time263, current time 354, horizon 91\n", + "adding: mem time264, current time 354, horizon 90\n", + "adding: mem time265, current time 354, horizon 89\n", + "adding: mem time266, current time 354, horizon 88\n", + "adding: mem time267, current time 354, horizon 87\n", + "adding: mem time268, current time 354, horizon 86\n", + "adding: mem time269, current time 354, horizon 85\n", + "adding: mem time270, current time 354, horizon 84\n", + "adding: mem time271, current time 354, horizon 83\n", + "adding: mem time272, current time 354, horizon 82\n", + "adding: mem time273, current time 354, horizon 81\n", + "adding: mem time274, current time 354, horizon 80\n", + "adding: mem time275, current time 354, horizon 79\n", + "adding: mem time276, current time 354, horizon 78\n", + "adding: mem time277, current time 354, horizon 77\n", + "adding: mem time278, current time 354, horizon 76\n", + "adding: mem time279, current time 354, horizon 75\n", + "adding: mem time280, current time 354, horizon 74\n", + "adding: mem time281, current time 354, horizon 73\n", + "adding: mem time282, current time 354, horizon 72\n", + "adding: mem time283, current time 354, horizon 71\n", + "adding: mem time284, current time 354, horizon 70\n", + "adding: mem time285, current time 354, horizon 69\n", + "adding: mem time286, current time 354, horizon 68\n", + "adding: mem time287, current time 354, horizon 67\n", + "adding: mem time288, current time 354, horizon 66\n", + "adding: mem time289, current time 354, horizon 65\n", + "adding: mem time290, current time 354, horizon 64\n", + "adding: mem time291, current time 354, horizon 63\n", + "adding: mem time292, current time 354, horizon 62\n", + "adding: mem time293, current time 354, horizon 61\n", + "adding: mem time294, current time 354, horizon 60\n", + "adding: mem time295, current time 354, horizon 59\n", + "adding: mem time296, current time 354, horizon 58\n", + "adding: mem time297, current time 354, horizon 57\n", + "adding: mem time298, current time 354, horizon 56\n", + "adding: mem time299, current time 354, horizon 55\n", + "adding: mem time300, current time 354, horizon 54\n", + "adding: mem time301, current time 354, horizon 53\n", + "adding: mem time302, current time 354, horizon 52\n", + "adding: mem time303, current time 354, horizon 51\n", + "adding: mem time304, current time 354, horizon 50\n", + "adding: mem time305, current time 354, horizon 49\n", + "adding: mem time306, current time 354, horizon 48\n", + "adding: mem time307, current time 354, horizon 47\n", + "adding: mem time308, current time 354, horizon 46\n", + "adding: mem time309, current time 354, horizon 45\n", + "adding: mem time310, current time 354, horizon 44\n", + "adding: mem time311, current time 354, horizon 43\n", + "adding: mem time312, current time 354, horizon 42\n", + "adding: mem time313, current time 354, horizon 41\n", + "adding: mem time314, current time 354, horizon 40\n", + "adding: mem time315, current time 354, horizon 39\n", + "adding: mem time316, current time 354, horizon 38\n", + "adding: mem time317, current time 354, horizon 37\n", + "adding: mem time318, current time 354, horizon 36\n", + "adding: mem time319, current time 354, horizon 35\n", + "adding: mem time320, current time 354, horizon 34\n", + "adding: mem time321, current time 354, horizon 33\n", + "adding: mem time322, current time 354, horizon 32\n", + "adding: mem time323, current time 354, horizon 31\n", + "adding: mem time324, current time 354, horizon 30\n", + "adding: mem time325, current time 354, horizon 29\n", + "adding: mem time326, current time 354, horizon 28\n", + "adding: mem time327, current time 354, horizon 27\n", + "adding: mem time328, current time 354, horizon 26\n", + "adding: mem time329, current time 354, horizon 25\n", + "adding: mem time330, current time 354, horizon 24\n", + "adding: mem time331, current time 354, horizon 23\n", + "adding: mem time332, current time 354, horizon 22\n", + "adding: mem time333, current time 354, horizon 21\n", + "adding: mem time334, current time 354, horizon 20\n", + "adding: mem time335, current time 354, horizon 19\n", + "adding: mem time336, current time 354, horizon 18\n", + "adding: mem time337, current time 354, horizon 17\n", + "adding: mem time338, current time 354, horizon 16\n", + "adding: mem time339, current time 354, horizon 15\n", + "adding: mem time340, current time 354, horizon 14\n", + "adding: mem time341, current time 354, horizon 13\n", + "adding: mem time342, current time 354, horizon 12\n", + "adding: mem time343, current time 354, horizon 11\n", + "adding: mem time344, current time 354, horizon 10\n", + "adding: mem time345, current time 354, horizon 9\n", + "adding: mem time346, current time 354, horizon 8\n", + "adding: mem time347, current time 354, horizon 7\n", + "adding: mem time348, current time 354, horizon 6\n", + "adding: mem time349, current time 354, horizon 5\n", + "adding: mem time350, current time 354, horizon 4\n", + "adding: mem time351, current time 354, horizon 3\n", + "adding: mem time352, current time 354, horizon 2\n", + "adding: mem time353, current time 354, horizon 1\n", + "adding: mem time200, current time 355, horizon 155\n", + "adding: mem time201, current time 355, horizon 154\n", + "adding: mem time202, current time 355, horizon 153\n", + "adding: mem time203, current time 355, horizon 152\n", + "adding: mem time204, current time 355, horizon 151\n", + "adding: mem time205, current time 355, horizon 150\n", + "adding: mem time206, current time 355, horizon 149\n", + "adding: mem time207, current time 355, horizon 148\n", + "adding: mem time208, current time 355, horizon 147\n", + "adding: mem time209, current time 355, horizon 146\n", + "adding: mem time210, current time 355, horizon 145\n", + "adding: mem time211, current time 355, horizon 144\n", + "adding: mem time212, current time 355, horizon 143\n", + "adding: mem time213, current time 355, horizon 142\n", + "adding: mem time214, current time 355, horizon 141\n", + "adding: mem time215, current time 355, horizon 140\n", + "adding: mem time216, current time 355, horizon 139\n", + "adding: mem time217, current time 355, horizon 138\n", + "adding: mem time218, current time 355, horizon 137\n", + "adding: mem time219, current time 355, horizon 136\n", + "adding: mem time220, current time 355, horizon 135\n", + "adding: mem time221, current time 355, horizon 134\n", + "adding: mem time222, current time 355, horizon 133\n", + "adding: mem time223, current time 355, horizon 132\n", + "adding: mem time224, current time 355, horizon 131\n", + "adding: mem time225, current time 355, horizon 130\n", + "adding: mem time226, current time 355, horizon 129\n", + "adding: mem time227, current time 355, horizon 128\n", + "adding: mem time228, current time 355, horizon 127\n", + "adding: mem time229, current time 355, horizon 126\n", + "adding: mem time230, current time 355, horizon 125\n", + "adding: mem time231, current time 355, horizon 124\n", + "adding: mem time232, current time 355, horizon 123\n", + "adding: mem time233, current time 355, horizon 122\n", + "adding: mem time234, current time 355, horizon 121\n", + "adding: mem time235, current time 355, horizon 120\n", + "adding: mem time236, current time 355, horizon 119\n", + "adding: mem time237, current time 355, horizon 118\n", + "adding: mem time238, current time 355, horizon 117\n", + "adding: mem time239, current time 355, horizon 116\n", + "adding: mem time240, current time 355, horizon 115\n", + "adding: mem time241, current time 355, horizon 114\n", + "adding: mem time242, current time 355, horizon 113\n", + "adding: mem time243, current time 355, horizon 112\n", + "adding: mem time244, current time 355, horizon 111\n", + "adding: mem time245, current time 355, horizon 110\n", + "adding: mem time246, current time 355, horizon 109\n", + "adding: mem time247, current time 355, horizon 108\n", + "adding: mem time248, current time 355, horizon 107\n", + "adding: mem time249, current time 355, horizon 106\n", + "adding: mem time250, current time 355, horizon 105\n", + "adding: mem time251, current time 355, horizon 104\n", + "adding: mem time252, current time 355, horizon 103\n", + "adding: mem time253, current time 355, horizon 102\n", + "adding: mem time254, current time 355, horizon 101\n", + "adding: mem time255, current time 355, horizon 100\n", + "adding: mem time256, current time 355, horizon 99\n", + "adding: mem time257, current time 355, horizon 98\n", + "adding: mem time258, current time 355, horizon 97\n", + "adding: mem time259, current time 355, horizon 96\n", + "adding: mem time260, current time 355, horizon 95\n", + "adding: mem time261, current time 355, horizon 94\n", + "adding: mem time262, current time 355, horizon 93\n", + "adding: mem time263, current time 355, horizon 92\n", + "adding: mem time264, current time 355, horizon 91\n", + "adding: mem time265, current time 355, horizon 90\n", + "adding: mem time266, current time 355, horizon 89\n", + "adding: mem time267, current time 355, horizon 88\n", + "adding: mem time268, current time 355, horizon 87\n", + "adding: mem time269, current time 355, horizon 86\n", + "adding: mem time270, current time 355, horizon 85\n", + "adding: mem time271, current time 355, horizon 84\n", + "adding: mem time272, current time 355, horizon 83\n", + "adding: mem time273, current time 355, horizon 82\n", + "adding: mem time274, current time 355, horizon 81\n", + "adding: mem time275, current time 355, horizon 80\n", + "adding: mem time276, current time 355, horizon 79\n", + "adding: mem time277, current time 355, horizon 78\n", + "adding: mem time278, current time 355, horizon 77\n", + "adding: mem time279, current time 355, horizon 76\n", + "adding: mem time280, current time 355, horizon 75\n", + "adding: mem time281, current time 355, horizon 74\n", + "adding: mem time282, current time 355, horizon 73\n", + "adding: mem time283, current time 355, horizon 72\n", + "adding: mem time284, current time 355, horizon 71\n", + "adding: mem time285, current time 355, horizon 70\n", + "adding: mem time286, current time 355, horizon 69\n", + "adding: mem time287, current time 355, horizon 68\n", + "adding: mem time288, current time 355, horizon 67\n", + "adding: mem time289, current time 355, horizon 66\n", + "adding: mem time290, current time 355, horizon 65\n", + "adding: mem time291, current time 355, horizon 64\n", + "adding: mem time292, current time 355, horizon 63\n", + "adding: mem time293, current time 355, horizon 62\n", + "adding: mem time294, current time 355, horizon 61\n", + "adding: mem time295, current time 355, horizon 60\n", + "adding: mem time296, current time 355, horizon 59\n", + "adding: mem time297, current time 355, horizon 58\n", + "adding: mem time298, current time 355, horizon 57\n", + "adding: mem time299, current time 355, horizon 56\n", + "adding: mem time300, current time 355, horizon 55\n", + "adding: mem time301, current time 355, horizon 54\n", + "adding: mem time302, current time 355, horizon 53\n", + "adding: mem time303, current time 355, horizon 52\n", + "adding: mem time304, current time 355, horizon 51\n", + "adding: mem time305, current time 355, horizon 50\n", + "adding: mem time306, current time 355, horizon 49\n", + "adding: mem time307, current time 355, horizon 48\n", + "adding: mem time308, current time 355, horizon 47\n", + "adding: mem time309, current time 355, horizon 46\n", + "adding: mem time310, current time 355, horizon 45\n", + "adding: mem time311, current time 355, horizon 44\n", + "adding: mem time312, current time 355, horizon 43\n", + "adding: mem time313, current time 355, horizon 42\n", + "adding: mem time314, current time 355, horizon 41\n", + "adding: mem time315, current time 355, horizon 40\n", + "adding: mem time316, current time 355, horizon 39\n", + "adding: mem time317, current time 355, horizon 38\n", + "adding: mem time318, current time 355, horizon 37\n", + "adding: mem time319, current time 355, horizon 36\n", + "adding: mem time320, current time 355, horizon 35\n", + "adding: mem time321, current time 355, horizon 34\n", + "adding: mem time322, current time 355, horizon 33\n", + "adding: mem time323, current time 355, horizon 32\n", + "adding: mem time324, current time 355, horizon 31\n", + "adding: mem time325, current time 355, horizon 30\n", + "adding: mem time326, current time 355, horizon 29\n", + "adding: mem time327, current time 355, horizon 28\n", + "adding: mem time328, current time 355, horizon 27\n", + "adding: mem time329, current time 355, horizon 26\n", + "adding: mem time330, current time 355, horizon 25\n", + "adding: mem time331, current time 355, horizon 24\n", + "adding: mem time332, current time 355, horizon 23\n", + "adding: mem time333, current time 355, horizon 22\n", + "adding: mem time334, current time 355, horizon 21\n", + "adding: mem time335, current time 355, horizon 20\n", + "adding: mem time336, current time 355, horizon 19\n", + "adding: mem time337, current time 355, horizon 18\n", + "adding: mem time338, current time 355, horizon 17\n", + "adding: mem time339, current time 355, horizon 16\n", + "adding: mem time340, current time 355, horizon 15\n", + "adding: mem time341, current time 355, horizon 14\n", + "adding: mem time342, current time 355, horizon 13\n", + "adding: mem time343, current time 355, horizon 12\n", + "adding: mem time344, current time 355, horizon 11\n", + "adding: mem time345, current time 355, horizon 10\n", + "adding: mem time346, current time 355, horizon 9\n", + "adding: mem time347, current time 355, horizon 8\n", + "adding: mem time348, current time 355, horizon 7\n", + "adding: mem time349, current time 355, horizon 6\n", + "adding: mem time350, current time 355, horizon 5\n", + "adding: mem time351, current time 355, horizon 4\n", + "adding: mem time352, current time 355, horizon 3\n", + "adding: mem time353, current time 355, horizon 2\n", + "adding: mem time354, current time 355, horizon 1\n", + "adding: mem time200, current time 356, horizon 156\n", + "adding: mem time201, current time 356, horizon 155\n", + "adding: mem time202, current time 356, horizon 154\n", + "adding: mem time203, current time 356, horizon 153\n", + "adding: mem time204, current time 356, horizon 152\n", + "adding: mem time205, current time 356, horizon 151\n", + "adding: mem time206, current time 356, horizon 150\n", + "adding: mem time207, current time 356, horizon 149\n", + "adding: mem time208, current time 356, horizon 148\n", + "adding: mem time209, current time 356, horizon 147\n", + "adding: mem time210, current time 356, horizon 146\n", + "adding: mem time211, current time 356, horizon 145\n", + "adding: mem time212, current time 356, horizon 144\n", + "adding: mem time213, current time 356, horizon 143\n", + "adding: mem time214, current time 356, horizon 142\n", + "adding: mem time215, current time 356, horizon 141\n", + "adding: mem time216, current time 356, horizon 140\n", + "adding: mem time217, current time 356, horizon 139\n", + "adding: mem time218, current time 356, horizon 138\n", + "adding: mem time219, current time 356, horizon 137\n", + "adding: mem time220, current time 356, horizon 136\n", + "adding: mem time221, current time 356, horizon 135\n", + "adding: mem time222, current time 356, horizon 134\n", + "adding: mem time223, current time 356, horizon 133\n", + "adding: mem time224, current time 356, horizon 132\n", + "adding: mem time225, current time 356, horizon 131\n", + "adding: mem time226, current time 356, horizon 130\n", + "adding: mem time227, current time 356, horizon 129\n", + "adding: mem time228, current time 356, horizon 128\n", + "adding: mem time229, current time 356, horizon 127\n", + "adding: mem time230, current time 356, horizon 126\n", + "adding: mem time231, current time 356, horizon 125\n", + "adding: mem time232, current time 356, horizon 124\n", + "adding: mem time233, current time 356, horizon 123\n", + "adding: mem time234, current time 356, horizon 122\n", + "adding: mem time235, current time 356, horizon 121\n", + "adding: mem time236, current time 356, horizon 120\n", + "adding: mem time237, current time 356, horizon 119\n", + "adding: mem time238, current time 356, horizon 118\n", + "adding: mem time239, current time 356, horizon 117\n", + "adding: mem time240, current time 356, horizon 116\n", + "adding: mem time241, current time 356, horizon 115\n", + "adding: mem time242, current time 356, horizon 114\n", + "adding: mem time243, current time 356, horizon 113\n", + "adding: mem time244, current time 356, horizon 112\n", + "adding: mem time245, current time 356, horizon 111\n", + "adding: mem time246, current time 356, horizon 110\n", + "adding: mem time247, current time 356, horizon 109\n", + "adding: mem time248, current time 356, horizon 108\n", + "adding: mem time249, current time 356, horizon 107\n", + "adding: mem time250, current time 356, horizon 106\n", + "adding: mem time251, current time 356, horizon 105\n", + "adding: mem time252, current time 356, horizon 104\n", + "adding: mem time253, current time 356, horizon 103\n", + "adding: mem time254, current time 356, horizon 102\n", + "adding: mem time255, current time 356, horizon 101\n", + "adding: mem time256, current time 356, horizon 100\n", + "adding: mem time257, current time 356, horizon 99\n", + "adding: mem time258, current time 356, horizon 98\n", + "adding: mem time259, current time 356, horizon 97\n", + "adding: mem time260, current time 356, horizon 96\n", + "adding: mem time261, current time 356, horizon 95\n", + "adding: mem time262, current time 356, horizon 94\n", + "adding: mem time263, current time 356, horizon 93\n", + "adding: mem time264, current time 356, horizon 92\n", + "adding: mem time265, current time 356, horizon 91\n", + "adding: mem time266, current time 356, horizon 90\n", + "adding: mem time267, current time 356, horizon 89\n", + "adding: mem time268, current time 356, horizon 88\n", + "adding: mem time269, current time 356, horizon 87\n", + "adding: mem time270, current time 356, horizon 86\n", + "adding: mem time271, current time 356, horizon 85\n", + "adding: mem time272, current time 356, horizon 84\n", + "adding: mem time273, current time 356, horizon 83\n", + "adding: mem time274, current time 356, horizon 82\n", + "adding: mem time275, current time 356, horizon 81\n", + "adding: mem time276, current time 356, horizon 80\n", + "adding: mem time277, current time 356, horizon 79\n", + "adding: mem time278, current time 356, horizon 78\n", + "adding: mem time279, current time 356, horizon 77\n", + "adding: mem time280, current time 356, horizon 76\n", + "adding: mem time281, current time 356, horizon 75\n", + "adding: mem time282, current time 356, horizon 74\n", + "adding: mem time283, current time 356, horizon 73\n", + "adding: mem time284, current time 356, horizon 72\n", + "adding: mem time285, current time 356, horizon 71\n", + "adding: mem time286, current time 356, horizon 70\n", + "adding: mem time287, current time 356, horizon 69\n", + "adding: mem time288, current time 356, horizon 68\n", + "adding: mem time289, current time 356, horizon 67\n", + "adding: mem time290, current time 356, horizon 66\n", + "adding: mem time291, current time 356, horizon 65\n", + "adding: mem time292, current time 356, horizon 64\n", + "adding: mem time293, current time 356, horizon 63\n", + "adding: mem time294, current time 356, horizon 62\n", + "adding: mem time295, current time 356, horizon 61\n", + "adding: mem time296, current time 356, horizon 60\n", + "adding: mem time297, current time 356, horizon 59\n", + "adding: mem time298, current time 356, horizon 58\n", + "adding: mem time299, current time 356, horizon 57\n", + "adding: mem time300, current time 356, horizon 56\n", + "adding: mem time301, current time 356, horizon 55\n", + "adding: mem time302, current time 356, horizon 54\n", + "adding: mem time303, current time 356, horizon 53\n", + "adding: mem time304, current time 356, horizon 52\n", + "adding: mem time305, current time 356, horizon 51\n", + "adding: mem time306, current time 356, horizon 50\n", + "adding: mem time307, current time 356, horizon 49\n", + "adding: mem time308, current time 356, horizon 48\n", + "adding: mem time309, current time 356, horizon 47\n", + "adding: mem time310, current time 356, horizon 46\n", + "adding: mem time311, current time 356, horizon 45\n", + "adding: mem time312, current time 356, horizon 44\n", + "adding: mem time313, current time 356, horizon 43\n", + "adding: mem time314, current time 356, horizon 42\n", + "adding: mem time315, current time 356, horizon 41\n", + "adding: mem time316, current time 356, horizon 40\n", + "adding: mem time317, current time 356, horizon 39\n", + "adding: mem time318, current time 356, horizon 38\n", + "adding: mem time319, current time 356, horizon 37\n", + "adding: mem time320, current time 356, horizon 36\n", + "adding: mem time321, current time 356, horizon 35\n", + "adding: mem time322, current time 356, horizon 34\n", + "adding: mem time323, current time 356, horizon 33\n", + "adding: mem time324, current time 356, horizon 32\n", + "adding: mem time325, current time 356, horizon 31\n", + "adding: mem time326, current time 356, horizon 30\n", + "adding: mem time327, current time 356, horizon 29\n", + "adding: mem time328, current time 356, horizon 28\n", + "adding: mem time329, current time 356, horizon 27\n", + "adding: mem time330, current time 356, horizon 26\n", + "adding: mem time331, current time 356, horizon 25\n", + "adding: mem time332, current time 356, horizon 24\n", + "adding: mem time333, current time 356, horizon 23\n", + "adding: mem time334, current time 356, horizon 22\n", + "adding: mem time335, current time 356, horizon 21\n", + "adding: mem time336, current time 356, horizon 20\n", + "adding: mem time337, current time 356, horizon 19\n", + "adding: mem time338, current time 356, horizon 18\n", + "adding: mem time339, current time 356, horizon 17\n", + "adding: mem time340, current time 356, horizon 16\n", + "adding: mem time341, current time 356, horizon 15\n", + "adding: mem time342, current time 356, horizon 14\n", + "adding: mem time343, current time 356, horizon 13\n", + "adding: mem time344, current time 356, horizon 12\n", + "adding: mem time345, current time 356, horizon 11\n", + "adding: mem time346, current time 356, horizon 10\n", + "adding: mem time347, current time 356, horizon 9\n", + "adding: mem time348, current time 356, horizon 8\n", + "adding: mem time349, current time 356, horizon 7\n", + "adding: mem time350, current time 356, horizon 6\n", + "adding: mem time351, current time 356, horizon 5\n", + "adding: mem time352, current time 356, horizon 4\n", + "adding: mem time353, current time 356, horizon 3\n", + "adding: mem time354, current time 356, horizon 2\n", + "adding: mem time355, current time 356, horizon 1\n", + "adding: mem time200, current time 357, horizon 157\n", + "adding: mem time201, current time 357, horizon 156\n", + "adding: mem time202, current time 357, horizon 155\n", + "adding: mem time203, current time 357, horizon 154\n", + "adding: mem time204, current time 357, horizon 153\n", + "adding: mem time205, current time 357, horizon 152\n", + "adding: mem time206, current time 357, horizon 151\n", + "adding: mem time207, current time 357, horizon 150\n", + "adding: mem time208, current time 357, horizon 149\n", + "adding: mem time209, current time 357, horizon 148\n", + "adding: mem time210, current time 357, horizon 147\n", + "adding: mem time211, current time 357, horizon 146\n", + "adding: mem time212, current time 357, horizon 145\n", + "adding: mem time213, current time 357, horizon 144\n", + "adding: mem time214, current time 357, horizon 143\n", + "adding: mem time215, current time 357, horizon 142\n", + "adding: mem time216, current time 357, horizon 141\n", + "adding: mem time217, current time 357, horizon 140\n", + "adding: mem time218, current time 357, horizon 139\n", + "adding: mem time219, current time 357, horizon 138\n", + "adding: mem time220, current time 357, horizon 137\n", + "adding: mem time221, current time 357, horizon 136\n", + "adding: mem time222, current time 357, horizon 135\n", + "adding: mem time223, current time 357, horizon 134\n", + "adding: mem time224, current time 357, horizon 133\n", + "adding: mem time225, current time 357, horizon 132\n", + "adding: mem time226, current time 357, horizon 131\n", + "adding: mem time227, current time 357, horizon 130\n", + "adding: mem time228, current time 357, horizon 129\n", + "adding: mem time229, current time 357, horizon 128\n", + "adding: mem time230, current time 357, horizon 127\n", + "adding: mem time231, current time 357, horizon 126\n", + "adding: mem time232, current time 357, horizon 125\n", + "adding: mem time233, current time 357, horizon 124\n", + "adding: mem time234, current time 357, horizon 123\n", + "adding: mem time235, current time 357, horizon 122\n", + "adding: mem time236, current time 357, horizon 121\n", + "adding: mem time237, current time 357, horizon 120\n", + "adding: mem time238, current time 357, horizon 119\n", + "adding: mem time239, current time 357, horizon 118\n", + "adding: mem time240, current time 357, horizon 117\n", + "adding: mem time241, current time 357, horizon 116\n", + "adding: mem time242, current time 357, horizon 115\n", + "adding: mem time243, current time 357, horizon 114\n", + "adding: mem time244, current time 357, horizon 113\n", + "adding: mem time245, current time 357, horizon 112\n", + "adding: mem time246, current time 357, horizon 111\n", + "adding: mem time247, current time 357, horizon 110\n", + "adding: mem time248, current time 357, horizon 109\n", + "adding: mem time249, current time 357, horizon 108\n", + "adding: mem time250, current time 357, horizon 107\n", + "adding: mem time251, current time 357, horizon 106\n", + "adding: mem time252, current time 357, horizon 105\n", + "adding: mem time253, current time 357, horizon 104\n", + "adding: mem time254, current time 357, horizon 103\n", + "adding: mem time255, current time 357, horizon 102\n", + "adding: mem time256, current time 357, horizon 101\n", + "adding: mem time257, current time 357, horizon 100\n", + "adding: mem time258, current time 357, horizon 99\n", + "adding: mem time259, current time 357, horizon 98\n", + "adding: mem time260, current time 357, horizon 97\n", + "adding: mem time261, current time 357, horizon 96\n", + "adding: mem time262, current time 357, horizon 95\n", + "adding: mem time263, current time 357, horizon 94\n", + "adding: mem time264, current time 357, horizon 93\n", + "adding: mem time265, current time 357, horizon 92\n", + "adding: mem time266, current time 357, horizon 91\n", + "adding: mem time267, current time 357, horizon 90\n", + "adding: mem time268, current time 357, horizon 89\n", + "adding: mem time269, current time 357, horizon 88\n", + "adding: mem time270, current time 357, horizon 87\n", + "adding: mem time271, current time 357, horizon 86\n", + "adding: mem time272, current time 357, horizon 85\n", + "adding: mem time273, current time 357, horizon 84\n", + "adding: mem time274, current time 357, horizon 83\n", + "adding: mem time275, current time 357, horizon 82\n", + "adding: mem time276, current time 357, horizon 81\n", + "adding: mem time277, current time 357, horizon 80\n", + "adding: mem time278, current time 357, horizon 79\n", + "adding: mem time279, current time 357, horizon 78\n", + "adding: mem time280, current time 357, horizon 77\n", + "adding: mem time281, current time 357, horizon 76\n", + "adding: mem time282, current time 357, horizon 75\n", + "adding: mem time283, current time 357, horizon 74\n", + "adding: mem time284, current time 357, horizon 73\n", + "adding: mem time285, current time 357, horizon 72\n", + "adding: mem time286, current time 357, horizon 71\n", + "adding: mem time287, current time 357, horizon 70\n", + "adding: mem time288, current time 357, horizon 69\n", + "adding: mem time289, current time 357, horizon 68\n", + "adding: mem time290, current time 357, horizon 67\n", + "adding: mem time291, current time 357, horizon 66\n", + "adding: mem time292, current time 357, horizon 65\n", + "adding: mem time293, current time 357, horizon 64\n", + "adding: mem time294, current time 357, horizon 63\n", + "adding: mem time295, current time 357, horizon 62\n", + "adding: mem time296, current time 357, horizon 61\n", + "adding: mem time297, current time 357, horizon 60\n", + "adding: mem time298, current time 357, horizon 59\n", + "adding: mem time299, current time 357, horizon 58\n", + "adding: mem time300, current time 357, horizon 57\n", + "adding: mem time301, current time 357, horizon 56\n", + "adding: mem time302, current time 357, horizon 55\n", + "adding: mem time303, current time 357, horizon 54\n", + "adding: mem time304, current time 357, horizon 53\n", + "adding: mem time305, current time 357, horizon 52\n", + "adding: mem time306, current time 357, horizon 51\n", + "adding: mem time307, current time 357, horizon 50\n", + "adding: mem time308, current time 357, horizon 49\n", + "adding: mem time309, current time 357, horizon 48\n", + "adding: mem time310, current time 357, horizon 47\n", + "adding: mem time311, current time 357, horizon 46\n", + "adding: mem time312, current time 357, horizon 45\n", + "adding: mem time313, current time 357, horizon 44\n", + "adding: mem time314, current time 357, horizon 43\n", + "adding: mem time315, current time 357, horizon 42\n", + "adding: mem time316, current time 357, horizon 41\n", + "adding: mem time317, current time 357, horizon 40\n", + "adding: mem time318, current time 357, horizon 39\n", + "adding: mem time319, current time 357, horizon 38\n", + "adding: mem time320, current time 357, horizon 37\n", + "adding: mem time321, current time 357, horizon 36\n", + "adding: mem time322, current time 357, horizon 35\n", + "adding: mem time323, current time 357, horizon 34\n", + "adding: mem time324, current time 357, horizon 33\n", + "adding: mem time325, current time 357, horizon 32\n", + "adding: mem time326, current time 357, horizon 31\n", + "adding: mem time327, current time 357, horizon 30\n", + "adding: mem time328, current time 357, horizon 29\n", + "adding: mem time329, current time 357, horizon 28\n", + "adding: mem time330, current time 357, horizon 27\n", + "adding: mem time331, current time 357, horizon 26\n", + "adding: mem time332, current time 357, horizon 25\n", + "adding: mem time333, current time 357, horizon 24\n", + "adding: mem time334, current time 357, horizon 23\n", + "adding: mem time335, current time 357, horizon 22\n", + "adding: mem time336, current time 357, horizon 21\n", + "adding: mem time337, current time 357, horizon 20\n", + "adding: mem time338, current time 357, horizon 19\n", + "adding: mem time339, current time 357, horizon 18\n", + "adding: mem time340, current time 357, horizon 17\n", + "adding: mem time341, current time 357, horizon 16\n", + "adding: mem time342, current time 357, horizon 15\n", + "adding: mem time343, current time 357, horizon 14\n", + "adding: mem time344, current time 357, horizon 13\n", + "adding: mem time345, current time 357, horizon 12\n", + "adding: mem time346, current time 357, horizon 11\n", + "adding: mem time347, current time 357, horizon 10\n", + "adding: mem time348, current time 357, horizon 9\n", + "adding: mem time349, current time 357, horizon 8\n", + "adding: mem time350, current time 357, horizon 7\n", + "adding: mem time351, current time 357, horizon 6\n", + "adding: mem time352, current time 357, horizon 5\n", + "adding: mem time353, current time 357, horizon 4\n", + "adding: mem time354, current time 357, horizon 3\n", + "adding: mem time355, current time 357, horizon 2\n", + "adding: mem time356, current time 357, horizon 1\n", + "adding: mem time200, current time 358, horizon 158\n", + "adding: mem time201, current time 358, horizon 157\n", + "adding: mem time202, current time 358, horizon 156\n", + "adding: mem time203, current time 358, horizon 155\n", + "adding: mem time204, current time 358, horizon 154\n", + "adding: mem time205, current time 358, horizon 153\n", + "adding: mem time206, current time 358, horizon 152\n", + "adding: mem time207, current time 358, horizon 151\n", + "adding: mem time208, current time 358, horizon 150\n", + "adding: mem time209, current time 358, horizon 149\n", + "adding: mem time210, current time 358, horizon 148\n", + "adding: mem time211, current time 358, horizon 147\n", + "adding: mem time212, current time 358, horizon 146\n", + "adding: mem time213, current time 358, horizon 145\n", + "adding: mem time214, current time 358, horizon 144\n", + "adding: mem time215, current time 358, horizon 143\n", + "adding: mem time216, current time 358, horizon 142\n", + "adding: mem time217, current time 358, horizon 141\n", + "adding: mem time218, current time 358, horizon 140\n", + "adding: mem time219, current time 358, horizon 139\n", + "adding: mem time220, current time 358, horizon 138\n", + "adding: mem time221, current time 358, horizon 137\n", + "adding: mem time222, current time 358, horizon 136\n", + "adding: mem time223, current time 358, horizon 135\n", + "adding: mem time224, current time 358, horizon 134\n", + "adding: mem time225, current time 358, horizon 133\n", + "adding: mem time226, current time 358, horizon 132\n", + "adding: mem time227, current time 358, horizon 131\n", + "adding: mem time228, current time 358, horizon 130\n", + "adding: mem time229, current time 358, horizon 129\n", + "adding: mem time230, current time 358, horizon 128\n", + "adding: mem time231, current time 358, horizon 127\n", + "adding: mem time232, current time 358, horizon 126\n", + "adding: mem time233, current time 358, horizon 125\n", + "adding: mem time234, current time 358, horizon 124\n", + "adding: mem time235, current time 358, horizon 123\n", + "adding: mem time236, current time 358, horizon 122\n", + "adding: mem time237, current time 358, horizon 121\n", + "adding: mem time238, current time 358, horizon 120\n", + "adding: mem time239, current time 358, horizon 119\n", + "adding: mem time240, current time 358, horizon 118\n", + "adding: mem time241, current time 358, horizon 117\n", + "adding: mem time242, current time 358, horizon 116\n", + "adding: mem time243, current time 358, horizon 115\n", + "adding: mem time244, current time 358, horizon 114\n", + "adding: mem time245, current time 358, horizon 113\n", + "adding: mem time246, current time 358, horizon 112\n", + "adding: mem time247, current time 358, horizon 111\n", + "adding: mem time248, current time 358, horizon 110\n", + "adding: mem time249, current time 358, horizon 109\n", + "adding: mem time250, current time 358, horizon 108\n", + "adding: mem time251, current time 358, horizon 107\n", + "adding: mem time252, current time 358, horizon 106\n", + "adding: mem time253, current time 358, horizon 105\n", + "adding: mem time254, current time 358, horizon 104\n", + "adding: mem time255, current time 358, horizon 103\n", + "adding: mem time256, current time 358, horizon 102\n", + "adding: mem time257, current time 358, horizon 101\n", + "adding: mem time258, current time 358, horizon 100\n", + "adding: mem time259, current time 358, horizon 99\n", + "adding: mem time260, current time 358, horizon 98\n", + "adding: mem time261, current time 358, horizon 97\n", + "adding: mem time262, current time 358, horizon 96\n", + "adding: mem time263, current time 358, horizon 95\n", + "adding: mem time264, current time 358, horizon 94\n", + "adding: mem time265, current time 358, horizon 93\n", + "adding: mem time266, current time 358, horizon 92\n", + "adding: mem time267, current time 358, horizon 91\n", + "adding: mem time268, current time 358, horizon 90\n", + "adding: mem time269, current time 358, horizon 89\n", + "adding: mem time270, current time 358, horizon 88\n", + "adding: mem time271, current time 358, horizon 87\n", + "adding: mem time272, current time 358, horizon 86\n", + "adding: mem time273, current time 358, horizon 85\n", + "adding: mem time274, current time 358, horizon 84\n", + "adding: mem time275, current time 358, horizon 83\n", + "adding: mem time276, current time 358, horizon 82\n", + "adding: mem time277, current time 358, horizon 81\n", + "adding: mem time278, current time 358, horizon 80\n", + "adding: mem time279, current time 358, horizon 79\n", + "adding: mem time280, current time 358, horizon 78\n", + "adding: mem time281, current time 358, horizon 77\n", + "adding: mem time282, current time 358, horizon 76\n", + "adding: mem time283, current time 358, horizon 75\n", + "adding: mem time284, current time 358, horizon 74\n", + "adding: mem time285, current time 358, horizon 73\n", + "adding: mem time286, current time 358, horizon 72\n", + "adding: mem time287, current time 358, horizon 71\n", + "adding: mem time288, current time 358, horizon 70\n", + "adding: mem time289, current time 358, horizon 69\n", + "adding: mem time290, current time 358, horizon 68\n", + "adding: mem time291, current time 358, horizon 67\n", + "adding: mem time292, current time 358, horizon 66\n", + "adding: mem time293, current time 358, horizon 65\n", + "adding: mem time294, current time 358, horizon 64\n", + "adding: mem time295, current time 358, horizon 63\n", + "adding: mem time296, current time 358, horizon 62\n", + "adding: mem time297, current time 358, horizon 61\n", + "adding: mem time298, current time 358, horizon 60\n", + "adding: mem time299, current time 358, horizon 59\n", + "adding: mem time300, current time 358, horizon 58\n", + "adding: mem time301, current time 358, horizon 57\n", + "adding: mem time302, current time 358, horizon 56\n", + "adding: mem time303, current time 358, horizon 55\n", + "adding: mem time304, current time 358, horizon 54\n", + "adding: mem time305, current time 358, horizon 53\n", + "adding: mem time306, current time 358, horizon 52\n", + "adding: mem time307, current time 358, horizon 51\n", + "adding: mem time308, current time 358, horizon 50\n", + "adding: mem time309, current time 358, horizon 49\n", + "adding: mem time310, current time 358, horizon 48\n", + "adding: mem time311, current time 358, horizon 47\n", + "adding: mem time312, current time 358, horizon 46\n", + "adding: mem time313, current time 358, horizon 45\n", + "adding: mem time314, current time 358, horizon 44\n", + "adding: mem time315, current time 358, horizon 43\n", + "adding: mem time316, current time 358, horizon 42\n", + "adding: mem time317, current time 358, horizon 41\n", + "adding: mem time318, current time 358, horizon 40\n", + "adding: mem time319, current time 358, horizon 39\n", + "adding: mem time320, current time 358, horizon 38\n", + "adding: mem time321, current time 358, horizon 37\n", + "adding: mem time322, current time 358, horizon 36\n", + "adding: mem time323, current time 358, horizon 35\n", + "adding: mem time324, current time 358, horizon 34\n", + "adding: mem time325, current time 358, horizon 33\n", + "adding: mem time326, current time 358, horizon 32\n", + "adding: mem time327, current time 358, horizon 31\n", + "adding: mem time328, current time 358, horizon 30\n", + "adding: mem time329, current time 358, horizon 29\n", + "adding: mem time330, current time 358, horizon 28\n", + "adding: mem time331, current time 358, horizon 27\n", + "adding: mem time332, current time 358, horizon 26\n", + "adding: mem time333, current time 358, horizon 25\n", + "adding: mem time334, current time 358, horizon 24\n", + "adding: mem time335, current time 358, horizon 23\n", + "adding: mem time336, current time 358, horizon 22\n", + "adding: mem time337, current time 358, horizon 21\n", + "adding: mem time338, current time 358, horizon 20\n", + "adding: mem time339, current time 358, horizon 19\n", + "adding: mem time340, current time 358, horizon 18\n", + "adding: mem time341, current time 358, horizon 17\n", + "adding: mem time342, current time 358, horizon 16\n", + "adding: mem time343, current time 358, horizon 15\n", + "adding: mem time344, current time 358, horizon 14\n", + "adding: mem time345, current time 358, horizon 13\n", + "adding: mem time346, current time 358, horizon 12\n", + "adding: mem time347, current time 358, horizon 11\n", + "adding: mem time348, current time 358, horizon 10\n", + "adding: mem time349, current time 358, horizon 9\n", + "adding: mem time350, current time 358, horizon 8\n", + "adding: mem time351, current time 358, horizon 7\n", + "adding: mem time352, current time 358, horizon 6\n", + "adding: mem time353, current time 358, horizon 5\n", + "adding: mem time354, current time 358, horizon 4\n", + "adding: mem time355, current time 358, horizon 3\n", + "adding: mem time356, current time 358, horizon 2\n", + "adding: mem time357, current time 358, horizon 1\n", + "adding: mem time200, current time 359, horizon 159\n", + "adding: mem time201, current time 359, horizon 158\n", + "adding: mem time202, current time 359, horizon 157\n", + "adding: mem time203, current time 359, horizon 156\n", + "adding: mem time204, current time 359, horizon 155\n", + "adding: mem time205, current time 359, horizon 154\n", + "adding: mem time206, current time 359, horizon 153\n", + "adding: mem time207, current time 359, horizon 152\n", + "adding: mem time208, current time 359, horizon 151\n", + "adding: mem time209, current time 359, horizon 150\n", + "adding: mem time210, current time 359, horizon 149\n", + "adding: mem time211, current time 359, horizon 148\n", + "adding: mem time212, current time 359, horizon 147\n", + "adding: mem time213, current time 359, horizon 146\n", + "adding: mem time214, current time 359, horizon 145\n", + "adding: mem time215, current time 359, horizon 144\n", + "adding: mem time216, current time 359, horizon 143\n", + "adding: mem time217, current time 359, horizon 142\n", + "adding: mem time218, current time 359, horizon 141\n", + "adding: mem time219, current time 359, horizon 140\n", + "adding: mem time220, current time 359, horizon 139\n", + "adding: mem time221, current time 359, horizon 138\n", + "adding: mem time222, current time 359, horizon 137\n", + "adding: mem time223, current time 359, horizon 136\n", + "adding: mem time224, current time 359, horizon 135\n", + "adding: mem time225, current time 359, horizon 134\n", + "adding: mem time226, current time 359, horizon 133\n", + "adding: mem time227, current time 359, horizon 132\n", + "adding: mem time228, current time 359, horizon 131\n", + "adding: mem time229, current time 359, horizon 130\n", + "adding: mem time230, current time 359, horizon 129\n", + "adding: mem time231, current time 359, horizon 128\n", + "adding: mem time232, current time 359, horizon 127\n", + "adding: mem time233, current time 359, horizon 126\n", + "adding: mem time234, current time 359, horizon 125\n", + "adding: mem time235, current time 359, horizon 124\n", + "adding: mem time236, current time 359, horizon 123\n", + "adding: mem time237, current time 359, horizon 122\n", + "adding: mem time238, current time 359, horizon 121\n", + "adding: mem time239, current time 359, horizon 120\n", + "adding: mem time240, current time 359, horizon 119\n", + "adding: mem time241, current time 359, horizon 118\n", + "adding: mem time242, current time 359, horizon 117\n", + "adding: mem time243, current time 359, horizon 116\n", + "adding: mem time244, current time 359, horizon 115\n", + "adding: mem time245, current time 359, horizon 114\n", + "adding: mem time246, current time 359, horizon 113\n", + "adding: mem time247, current time 359, horizon 112\n", + "adding: mem time248, current time 359, horizon 111\n", + "adding: mem time249, current time 359, horizon 110\n", + "adding: mem time250, current time 359, horizon 109\n", + "adding: mem time251, current time 359, horizon 108\n", + "adding: mem time252, current time 359, horizon 107\n", + "adding: mem time253, current time 359, horizon 106\n", + "adding: mem time254, current time 359, horizon 105\n", + "adding: mem time255, current time 359, horizon 104\n", + "adding: mem time256, current time 359, horizon 103\n", + "adding: mem time257, current time 359, horizon 102\n", + "adding: mem time258, current time 359, horizon 101\n", + "adding: mem time259, current time 359, horizon 100\n", + "adding: mem time260, current time 359, horizon 99\n", + "adding: mem time261, current time 359, horizon 98\n", + "adding: mem time262, current time 359, horizon 97\n", + "adding: mem time263, current time 359, horizon 96\n", + "adding: mem time264, current time 359, horizon 95\n", + "adding: mem time265, current time 359, horizon 94\n", + "adding: mem time266, current time 359, horizon 93\n", + "adding: mem time267, current time 359, horizon 92\n", + "adding: mem time268, current time 359, horizon 91\n", + "adding: mem time269, current time 359, horizon 90\n", + "adding: mem time270, current time 359, horizon 89\n", + "adding: mem time271, current time 359, horizon 88\n", + "adding: mem time272, current time 359, horizon 87\n", + "adding: mem time273, current time 359, horizon 86\n", + "adding: mem time274, current time 359, horizon 85\n", + "adding: mem time275, current time 359, horizon 84\n", + "adding: mem time276, current time 359, horizon 83\n", + "adding: mem time277, current time 359, horizon 82\n", + "adding: mem time278, current time 359, horizon 81\n", + "adding: mem time279, current time 359, horizon 80\n", + "adding: mem time280, current time 359, horizon 79\n", + "adding: mem time281, current time 359, horizon 78\n", + "adding: mem time282, current time 359, horizon 77\n", + "adding: mem time283, current time 359, horizon 76\n", + "adding: mem time284, current time 359, horizon 75\n", + "adding: mem time285, current time 359, horizon 74\n", + "adding: mem time286, current time 359, horizon 73\n", + "adding: mem time287, current time 359, horizon 72\n", + "adding: mem time288, current time 359, horizon 71\n", + "adding: mem time289, current time 359, horizon 70\n", + "adding: mem time290, current time 359, horizon 69\n", + "adding: mem time291, current time 359, horizon 68\n", + "adding: mem time292, current time 359, horizon 67\n", + "adding: mem time293, current time 359, horizon 66\n", + "adding: mem time294, current time 359, horizon 65\n", + "adding: mem time295, current time 359, horizon 64\n", + "adding: mem time296, current time 359, horizon 63\n", + "adding: mem time297, current time 359, horizon 62\n", + "adding: mem time298, current time 359, horizon 61\n", + "adding: mem time299, current time 359, horizon 60\n", + "adding: mem time300, current time 359, horizon 59\n", + "adding: mem time301, current time 359, horizon 58\n", + "adding: mem time302, current time 359, horizon 57\n", + "adding: mem time303, current time 359, horizon 56\n", + "adding: mem time304, current time 359, horizon 55\n", + "adding: mem time305, current time 359, horizon 54\n", + "adding: mem time306, current time 359, horizon 53\n", + "adding: mem time307, current time 359, horizon 52\n", + "adding: mem time308, current time 359, horizon 51\n", + "adding: mem time309, current time 359, horizon 50\n", + "adding: mem time310, current time 359, horizon 49\n", + "adding: mem time311, current time 359, horizon 48\n", + "adding: mem time312, current time 359, horizon 47\n", + "adding: mem time313, current time 359, horizon 46\n", + "adding: mem time314, current time 359, horizon 45\n", + "adding: mem time315, current time 359, horizon 44\n", + "adding: mem time316, current time 359, horizon 43\n", + "adding: mem time317, current time 359, horizon 42\n", + "adding: mem time318, current time 359, horizon 41\n", + "adding: mem time319, current time 359, horizon 40\n", + "adding: mem time320, current time 359, horizon 39\n", + "adding: mem time321, current time 359, horizon 38\n", + "adding: mem time322, current time 359, horizon 37\n", + "adding: mem time323, current time 359, horizon 36\n", + "adding: mem time324, current time 359, horizon 35\n", + "adding: mem time325, current time 359, horizon 34\n", + "adding: mem time326, current time 359, horizon 33\n", + "adding: mem time327, current time 359, horizon 32\n", + "adding: mem time328, current time 359, horizon 31\n", + "adding: mem time329, current time 359, horizon 30\n", + "adding: mem time330, current time 359, horizon 29\n", + "adding: mem time331, current time 359, horizon 28\n", + "adding: mem time332, current time 359, horizon 27\n", + "adding: mem time333, current time 359, horizon 26\n", + "adding: mem time334, current time 359, horizon 25\n", + "adding: mem time335, current time 359, horizon 24\n", + "adding: mem time336, current time 359, horizon 23\n", + "adding: mem time337, current time 359, horizon 22\n", + "adding: mem time338, current time 359, horizon 21\n", + "adding: mem time339, current time 359, horizon 20\n", + "adding: mem time340, current time 359, horizon 19\n", + "adding: mem time341, current time 359, horizon 18\n", + "adding: mem time342, current time 359, horizon 17\n", + "adding: mem time343, current time 359, horizon 16\n", + "adding: mem time344, current time 359, horizon 15\n", + "adding: mem time345, current time 359, horizon 14\n", + "adding: mem time346, current time 359, horizon 13\n", + "adding: mem time347, current time 359, horizon 12\n", + "adding: mem time348, current time 359, horizon 11\n", + "adding: mem time349, current time 359, horizon 10\n", + "adding: mem time350, current time 359, horizon 9\n", + "adding: mem time351, current time 359, horizon 8\n", + "adding: mem time352, current time 359, horizon 7\n", + "adding: mem time353, current time 359, horizon 6\n", + "adding: mem time354, current time 359, horizon 5\n", + "adding: mem time355, current time 359, horizon 4\n", + "adding: mem time356, current time 359, horizon 3\n", + "adding: mem time357, current time 359, horizon 2\n", + "adding: mem time358, current time 359, horizon 1\n", + "adding: mem time200, current time 360, horizon 160\n", + "adding: mem time201, current time 360, horizon 159\n", + "adding: mem time202, current time 360, horizon 158\n", + "adding: mem time203, current time 360, horizon 157\n", + "adding: mem time204, current time 360, horizon 156\n", + "adding: mem time205, current time 360, horizon 155\n", + "adding: mem time206, current time 360, horizon 154\n", + "adding: mem time207, current time 360, horizon 153\n", + "adding: mem time208, current time 360, horizon 152\n", + "adding: mem time209, current time 360, horizon 151\n", + "adding: mem time210, current time 360, horizon 150\n", + "adding: mem time211, current time 360, horizon 149\n", + "adding: mem time212, current time 360, horizon 148\n", + "adding: mem time213, current time 360, horizon 147\n", + "adding: mem time214, current time 360, horizon 146\n", + "adding: mem time215, current time 360, horizon 145\n", + "adding: mem time216, current time 360, horizon 144\n", + "adding: mem time217, current time 360, horizon 143\n", + "adding: mem time218, current time 360, horizon 142\n", + "adding: mem time219, current time 360, horizon 141\n", + "adding: mem time220, current time 360, horizon 140\n", + "adding: mem time221, current time 360, horizon 139\n", + "adding: mem time222, current time 360, horizon 138\n", + "adding: mem time223, current time 360, horizon 137\n", + "adding: mem time224, current time 360, horizon 136\n", + "adding: mem time225, current time 360, horizon 135\n", + "adding: mem time226, current time 360, horizon 134\n", + "adding: mem time227, current time 360, horizon 133\n", + "adding: mem time228, current time 360, horizon 132\n", + "adding: mem time229, current time 360, horizon 131\n", + "adding: mem time230, current time 360, horizon 130\n", + "adding: mem time231, current time 360, horizon 129\n", + "adding: mem time232, current time 360, horizon 128\n", + "adding: mem time233, current time 360, horizon 127\n", + "adding: mem time234, current time 360, horizon 126\n", + "adding: mem time235, current time 360, horizon 125\n", + "adding: mem time236, current time 360, horizon 124\n", + "adding: mem time237, current time 360, horizon 123\n", + "adding: mem time238, current time 360, horizon 122\n", + "adding: mem time239, current time 360, horizon 121\n", + "adding: mem time240, current time 360, horizon 120\n", + "adding: mem time241, current time 360, horizon 119\n", + "adding: mem time242, current time 360, horizon 118\n", + "adding: mem time243, current time 360, horizon 117\n", + "adding: mem time244, current time 360, horizon 116\n", + "adding: mem time245, current time 360, horizon 115\n", + "adding: mem time246, current time 360, horizon 114\n", + "adding: mem time247, current time 360, horizon 113\n", + "adding: mem time248, current time 360, horizon 112\n", + "adding: mem time249, current time 360, horizon 111\n", + "adding: mem time250, current time 360, horizon 110\n", + "adding: mem time251, current time 360, horizon 109\n", + "adding: mem time252, current time 360, horizon 108\n", + "adding: mem time253, current time 360, horizon 107\n", + "adding: mem time254, current time 360, horizon 106\n", + "adding: mem time255, current time 360, horizon 105\n", + "adding: mem time256, current time 360, horizon 104\n", + "adding: mem time257, current time 360, horizon 103\n", + "adding: mem time258, current time 360, horizon 102\n", + "adding: mem time259, current time 360, horizon 101\n", + "adding: mem time260, current time 360, horizon 100\n", + "adding: mem time261, current time 360, horizon 99\n", + "adding: mem time262, current time 360, horizon 98\n", + "adding: mem time263, current time 360, horizon 97\n", + "adding: mem time264, current time 360, horizon 96\n", + "adding: mem time265, current time 360, horizon 95\n", + "adding: mem time266, current time 360, horizon 94\n", + "adding: mem time267, current time 360, horizon 93\n", + "adding: mem time268, current time 360, horizon 92\n", + "adding: mem time269, current time 360, horizon 91\n", + "adding: mem time270, current time 360, horizon 90\n", + "adding: mem time271, current time 360, horizon 89\n", + "adding: mem time272, current time 360, horizon 88\n", + "adding: mem time273, current time 360, horizon 87\n", + "adding: mem time274, current time 360, horizon 86\n", + "adding: mem time275, current time 360, horizon 85\n", + "adding: mem time276, current time 360, horizon 84\n", + "adding: mem time277, current time 360, horizon 83\n", + "adding: mem time278, current time 360, horizon 82\n", + "adding: mem time279, current time 360, horizon 81\n", + "adding: mem time280, current time 360, horizon 80\n", + "adding: mem time281, current time 360, horizon 79\n", + "adding: mem time282, current time 360, horizon 78\n", + "adding: mem time283, current time 360, horizon 77\n", + "adding: mem time284, current time 360, horizon 76\n", + "adding: mem time285, current time 360, horizon 75\n", + "adding: mem time286, current time 360, horizon 74\n", + "adding: mem time287, current time 360, horizon 73\n", + "adding: mem time288, current time 360, horizon 72\n", + "adding: mem time289, current time 360, horizon 71\n", + "adding: mem time290, current time 360, horizon 70\n", + "adding: mem time291, current time 360, horizon 69\n", + "adding: mem time292, current time 360, horizon 68\n", + "adding: mem time293, current time 360, horizon 67\n", + "adding: mem time294, current time 360, horizon 66\n", + "adding: mem time295, current time 360, horizon 65\n", + "adding: mem time296, current time 360, horizon 64\n", + "adding: mem time297, current time 360, horizon 63\n", + "adding: mem time298, current time 360, horizon 62\n", + "adding: mem time299, current time 360, horizon 61\n", + "adding: mem time300, current time 360, horizon 60\n", + "adding: mem time301, current time 360, horizon 59\n", + "adding: mem time302, current time 360, horizon 58\n", + "adding: mem time303, current time 360, horizon 57\n", + "adding: mem time304, current time 360, horizon 56\n", + "adding: mem time305, current time 360, horizon 55\n", + "adding: mem time306, current time 360, horizon 54\n", + "adding: mem time307, current time 360, horizon 53\n", + "adding: mem time308, current time 360, horizon 52\n", + "adding: mem time309, current time 360, horizon 51\n", + "adding: mem time310, current time 360, horizon 50\n", + "adding: mem time311, current time 360, horizon 49\n", + "adding: mem time312, current time 360, horizon 48\n", + "adding: mem time313, current time 360, horizon 47\n", + "adding: mem time314, current time 360, horizon 46\n", + "adding: mem time315, current time 360, horizon 45\n", + "adding: mem time316, current time 360, horizon 44\n", + "adding: mem time317, current time 360, horizon 43\n", + "adding: mem time318, current time 360, horizon 42\n", + "adding: mem time319, current time 360, horizon 41\n", + "adding: mem time320, current time 360, horizon 40\n", + "adding: mem time321, current time 360, horizon 39\n", + "adding: mem time322, current time 360, horizon 38\n", + "adding: mem time323, current time 360, horizon 37\n", + "adding: mem time324, current time 360, horizon 36\n", + "adding: mem time325, current time 360, horizon 35\n", + "adding: mem time326, current time 360, horizon 34\n", + "adding: mem time327, current time 360, horizon 33\n", + "adding: mem time328, current time 360, horizon 32\n", + "adding: mem time329, current time 360, horizon 31\n", + "adding: mem time330, current time 360, horizon 30\n", + "adding: mem time331, current time 360, horizon 29\n", + "adding: mem time332, current time 360, horizon 28\n", + "adding: mem time333, current time 360, horizon 27\n", + "adding: mem time334, current time 360, horizon 26\n", + "adding: mem time335, current time 360, horizon 25\n", + "adding: mem time336, current time 360, horizon 24\n", + "adding: mem time337, current time 360, horizon 23\n", + "adding: mem time338, current time 360, horizon 22\n", + "adding: mem time339, current time 360, horizon 21\n", + "adding: mem time340, current time 360, horizon 20\n", + "adding: mem time341, current time 360, horizon 19\n", + "adding: mem time342, current time 360, horizon 18\n", + "adding: mem time343, current time 360, horizon 17\n", + "adding: mem time344, current time 360, horizon 16\n", + "adding: mem time345, current time 360, horizon 15\n", + "adding: mem time346, current time 360, horizon 14\n", + "adding: mem time347, current time 360, horizon 13\n", + "adding: mem time348, current time 360, horizon 12\n", + "adding: mem time349, current time 360, horizon 11\n", + "adding: mem time350, current time 360, horizon 10\n", + "adding: mem time351, current time 360, horizon 9\n", + "adding: mem time352, current time 360, horizon 8\n", + "adding: mem time353, current time 360, horizon 7\n", + "adding: mem time354, current time 360, horizon 6\n", + "adding: mem time355, current time 360, horizon 5\n", + "adding: mem time356, current time 360, horizon 4\n", + "adding: mem time357, current time 360, horizon 3\n", + "adding: mem time358, current time 360, horizon 2\n", + "adding: mem time359, current time 360, horizon 1\n", + "adding: mem time200, current time 361, horizon 161\n", + "adding: mem time201, current time 361, horizon 160\n", + "adding: mem time202, current time 361, horizon 159\n", + "adding: mem time203, current time 361, horizon 158\n", + "adding: mem time204, current time 361, horizon 157\n", + "adding: mem time205, current time 361, horizon 156\n", + "adding: mem time206, current time 361, horizon 155\n", + "adding: mem time207, current time 361, horizon 154\n", + "adding: mem time208, current time 361, horizon 153\n", + "adding: mem time209, current time 361, horizon 152\n", + "adding: mem time210, current time 361, horizon 151\n", + "adding: mem time211, current time 361, horizon 150\n", + "adding: mem time212, current time 361, horizon 149\n", + "adding: mem time213, current time 361, horizon 148\n", + "adding: mem time214, current time 361, horizon 147\n", + "adding: mem time215, current time 361, horizon 146\n", + "adding: mem time216, current time 361, horizon 145\n", + "adding: mem time217, current time 361, horizon 144\n", + "adding: mem time218, current time 361, horizon 143\n", + "adding: mem time219, current time 361, horizon 142\n", + "adding: mem time220, current time 361, horizon 141\n", + "adding: mem time221, current time 361, horizon 140\n", + "adding: mem time222, current time 361, horizon 139\n", + "adding: mem time223, current time 361, horizon 138\n", + "adding: mem time224, current time 361, horizon 137\n", + "adding: mem time225, current time 361, horizon 136\n", + "adding: mem time226, current time 361, horizon 135\n", + "adding: mem time227, current time 361, horizon 134\n", + "adding: mem time228, current time 361, horizon 133\n", + "adding: mem time229, current time 361, horizon 132\n", + "adding: mem time230, current time 361, horizon 131\n", + "adding: mem time231, current time 361, horizon 130\n", + "adding: mem time232, current time 361, horizon 129\n", + "adding: mem time233, current time 361, horizon 128\n", + "adding: mem time234, current time 361, horizon 127\n", + "adding: mem time235, current time 361, horizon 126\n", + "adding: mem time236, current time 361, horizon 125\n", + "adding: mem time237, current time 361, horizon 124\n", + "adding: mem time238, current time 361, horizon 123\n", + "adding: mem time239, current time 361, horizon 122\n", + "adding: mem time240, current time 361, horizon 121\n", + "adding: mem time241, current time 361, horizon 120\n", + "adding: mem time242, current time 361, horizon 119\n", + "adding: mem time243, current time 361, horizon 118\n", + "adding: mem time244, current time 361, horizon 117\n", + "adding: mem time245, current time 361, horizon 116\n", + "adding: mem time246, current time 361, horizon 115\n", + "adding: mem time247, current time 361, horizon 114\n", + "adding: mem time248, current time 361, horizon 113\n", + "adding: mem time249, current time 361, horizon 112\n", + "adding: mem time250, current time 361, horizon 111\n", + "adding: mem time251, current time 361, horizon 110\n", + "adding: mem time252, current time 361, horizon 109\n", + "adding: mem time253, current time 361, horizon 108\n", + "adding: mem time254, current time 361, horizon 107\n", + "adding: mem time255, current time 361, horizon 106\n", + "adding: mem time256, current time 361, horizon 105\n", + "adding: mem time257, current time 361, horizon 104\n", + "adding: mem time258, current time 361, horizon 103\n", + "adding: mem time259, current time 361, horizon 102\n", + "adding: mem time260, current time 361, horizon 101\n", + "adding: mem time261, current time 361, horizon 100\n", + "adding: mem time262, current time 361, horizon 99\n", + "adding: mem time263, current time 361, horizon 98\n", + "adding: mem time264, current time 361, horizon 97\n", + "adding: mem time265, current time 361, horizon 96\n", + "adding: mem time266, current time 361, horizon 95\n", + "adding: mem time267, current time 361, horizon 94\n", + "adding: mem time268, current time 361, horizon 93\n", + "adding: mem time269, current time 361, horizon 92\n", + "adding: mem time270, current time 361, horizon 91\n", + "adding: mem time271, current time 361, horizon 90\n", + "adding: mem time272, current time 361, horizon 89\n", + "adding: mem time273, current time 361, horizon 88\n", + "adding: mem time274, current time 361, horizon 87\n", + "adding: mem time275, current time 361, horizon 86\n", + "adding: mem time276, current time 361, horizon 85\n", + "adding: mem time277, current time 361, horizon 84\n", + "adding: mem time278, current time 361, horizon 83\n", + "adding: mem time279, current time 361, horizon 82\n", + "adding: mem time280, current time 361, horizon 81\n", + "adding: mem time281, current time 361, horizon 80\n", + "adding: mem time282, current time 361, horizon 79\n", + "adding: mem time283, current time 361, horizon 78\n", + "adding: mem time284, current time 361, horizon 77\n", + "adding: mem time285, current time 361, horizon 76\n", + "adding: mem time286, current time 361, horizon 75\n", + "adding: mem time287, current time 361, horizon 74\n", + "adding: mem time288, current time 361, horizon 73\n", + "adding: mem time289, current time 361, horizon 72\n", + "adding: mem time290, current time 361, horizon 71\n", + "adding: mem time291, current time 361, horizon 70\n", + "adding: mem time292, current time 361, horizon 69\n", + "adding: mem time293, current time 361, horizon 68\n", + "adding: mem time294, current time 361, horizon 67\n", + "adding: mem time295, current time 361, horizon 66\n", + "adding: mem time296, current time 361, horizon 65\n", + "adding: mem time297, current time 361, horizon 64\n", + "adding: mem time298, current time 361, horizon 63\n", + "adding: mem time299, current time 361, horizon 62\n", + "adding: mem time300, current time 361, horizon 61\n", + "adding: mem time301, current time 361, horizon 60\n", + "adding: mem time302, current time 361, horizon 59\n", + "adding: mem time303, current time 361, horizon 58\n", + "adding: mem time304, current time 361, horizon 57\n", + "adding: mem time305, current time 361, horizon 56\n", + "adding: mem time306, current time 361, horizon 55\n", + "adding: mem time307, current time 361, horizon 54\n", + "adding: mem time308, current time 361, horizon 53\n", + "adding: mem time309, current time 361, horizon 52\n", + "adding: mem time310, current time 361, horizon 51\n", + "adding: mem time311, current time 361, horizon 50\n", + "adding: mem time312, current time 361, horizon 49\n", + "adding: mem time313, current time 361, horizon 48\n", + "adding: mem time314, current time 361, horizon 47\n", + "adding: mem time315, current time 361, horizon 46\n", + "adding: mem time316, current time 361, horizon 45\n", + "adding: mem time317, current time 361, horizon 44\n", + "adding: mem time318, current time 361, horizon 43\n", + "adding: mem time319, current time 361, horizon 42\n", + "adding: mem time320, current time 361, horizon 41\n", + "adding: mem time321, current time 361, horizon 40\n", + "adding: mem time322, current time 361, horizon 39\n", + "adding: mem time323, current time 361, horizon 38\n", + "adding: mem time324, current time 361, horizon 37\n", + "adding: mem time325, current time 361, horizon 36\n", + "adding: mem time326, current time 361, horizon 35\n", + "adding: mem time327, current time 361, horizon 34\n", + "adding: mem time328, current time 361, horizon 33\n", + "adding: mem time329, current time 361, horizon 32\n", + "adding: mem time330, current time 361, horizon 31\n", + "adding: mem time331, current time 361, horizon 30\n", + "adding: mem time332, current time 361, horizon 29\n", + "adding: mem time333, current time 361, horizon 28\n", + "adding: mem time334, current time 361, horizon 27\n", + "adding: mem time335, current time 361, horizon 26\n", + "adding: mem time336, current time 361, horizon 25\n", + "adding: mem time337, current time 361, horizon 24\n", + "adding: mem time338, current time 361, horizon 23\n", + "adding: mem time339, current time 361, horizon 22\n", + "adding: mem time340, current time 361, horizon 21\n", + "adding: mem time341, current time 361, horizon 20\n", + "adding: mem time342, current time 361, horizon 19\n", + "adding: mem time343, current time 361, horizon 18\n", + "adding: mem time344, current time 361, horizon 17\n", + "adding: mem time345, current time 361, horizon 16\n", + "adding: mem time346, current time 361, horizon 15\n", + "adding: mem time347, current time 361, horizon 14\n", + "adding: mem time348, current time 361, horizon 13\n", + "adding: mem time349, current time 361, horizon 12\n", + "adding: mem time350, current time 361, horizon 11\n", + "adding: mem time351, current time 361, horizon 10\n", + "adding: mem time352, current time 361, horizon 9\n", + "adding: mem time353, current time 361, horizon 8\n", + "adding: mem time354, current time 361, horizon 7\n", + "adding: mem time355, current time 361, horizon 6\n", + "adding: mem time356, current time 361, horizon 5\n", + "adding: mem time357, current time 361, horizon 4\n", + "adding: mem time358, current time 361, horizon 3\n", + "adding: mem time359, current time 361, horizon 2\n", + "adding: mem time360, current time 361, horizon 1\n", + "adding: mem time200, current time 362, horizon 162\n", + "adding: mem time201, current time 362, horizon 161\n", + "adding: mem time202, current time 362, horizon 160\n", + "adding: mem time203, current time 362, horizon 159\n", + "adding: mem time204, current time 362, horizon 158\n", + "adding: mem time205, current time 362, horizon 157\n", + "adding: mem time206, current time 362, horizon 156\n", + "adding: mem time207, current time 362, horizon 155\n", + "adding: mem time208, current time 362, horizon 154\n", + "adding: mem time209, current time 362, horizon 153\n", + "adding: mem time210, current time 362, horizon 152\n", + "adding: mem time211, current time 362, horizon 151\n", + "adding: mem time212, current time 362, horizon 150\n", + "adding: mem time213, current time 362, horizon 149\n", + "adding: mem time214, current time 362, horizon 148\n", + "adding: mem time215, current time 362, horizon 147\n", + "adding: mem time216, current time 362, horizon 146\n", + "adding: mem time217, current time 362, horizon 145\n", + "adding: mem time218, current time 362, horizon 144\n", + "adding: mem time219, current time 362, horizon 143\n", + "adding: mem time220, current time 362, horizon 142\n", + "adding: mem time221, current time 362, horizon 141\n", + "adding: mem time222, current time 362, horizon 140\n", + "adding: mem time223, current time 362, horizon 139\n", + "adding: mem time224, current time 362, horizon 138\n", + "adding: mem time225, current time 362, horizon 137\n", + "adding: mem time226, current time 362, horizon 136\n", + "adding: mem time227, current time 362, horizon 135\n", + "adding: mem time228, current time 362, horizon 134\n", + "adding: mem time229, current time 362, horizon 133\n", + "adding: mem time230, current time 362, horizon 132\n", + "adding: mem time231, current time 362, horizon 131\n", + "adding: mem time232, current time 362, horizon 130\n", + "adding: mem time233, current time 362, horizon 129\n", + "adding: mem time234, current time 362, horizon 128\n", + "adding: mem time235, current time 362, horizon 127\n", + "adding: mem time236, current time 362, horizon 126\n", + "adding: mem time237, current time 362, horizon 125\n", + "adding: mem time238, current time 362, horizon 124\n", + "adding: mem time239, current time 362, horizon 123\n", + "adding: mem time240, current time 362, horizon 122\n", + "adding: mem time241, current time 362, horizon 121\n", + "adding: mem time242, current time 362, horizon 120\n", + "adding: mem time243, current time 362, horizon 119\n", + "adding: mem time244, current time 362, horizon 118\n", + "adding: mem time245, current time 362, horizon 117\n", + "adding: mem time246, current time 362, horizon 116\n", + "adding: mem time247, current time 362, horizon 115\n", + "adding: mem time248, current time 362, horizon 114\n", + "adding: mem time249, current time 362, horizon 113\n", + "adding: mem time250, current time 362, horizon 112\n", + "adding: mem time251, current time 362, horizon 111\n", + "adding: mem time252, current time 362, horizon 110\n", + "adding: mem time253, current time 362, horizon 109\n", + "adding: mem time254, current time 362, horizon 108\n", + "adding: mem time255, current time 362, horizon 107\n", + "adding: mem time256, current time 362, horizon 106\n", + "adding: mem time257, current time 362, horizon 105\n", + "adding: mem time258, current time 362, horizon 104\n", + "adding: mem time259, current time 362, horizon 103\n", + "adding: mem time260, current time 362, horizon 102\n", + "adding: mem time261, current time 362, horizon 101\n", + "adding: mem time262, current time 362, horizon 100\n", + "adding: mem time263, current time 362, horizon 99\n", + "adding: mem time264, current time 362, horizon 98\n", + "adding: mem time265, current time 362, horizon 97\n", + "adding: mem time266, current time 362, horizon 96\n", + "adding: mem time267, current time 362, horizon 95\n", + "adding: mem time268, current time 362, horizon 94\n", + "adding: mem time269, current time 362, horizon 93\n", + "adding: mem time270, current time 362, horizon 92\n", + "adding: mem time271, current time 362, horizon 91\n", + "adding: mem time272, current time 362, horizon 90\n", + "adding: mem time273, current time 362, horizon 89\n", + "adding: mem time274, current time 362, horizon 88\n", + "adding: mem time275, current time 362, horizon 87\n", + "adding: mem time276, current time 362, horizon 86\n", + "adding: mem time277, current time 362, horizon 85\n", + "adding: mem time278, current time 362, horizon 84\n", + "adding: mem time279, current time 362, horizon 83\n", + "adding: mem time280, current time 362, horizon 82\n", + "adding: mem time281, current time 362, horizon 81\n", + "adding: mem time282, current time 362, horizon 80\n", + "adding: mem time283, current time 362, horizon 79\n", + "adding: mem time284, current time 362, horizon 78\n", + "adding: mem time285, current time 362, horizon 77\n", + "adding: mem time286, current time 362, horizon 76\n", + "adding: mem time287, current time 362, horizon 75\n", + "adding: mem time288, current time 362, horizon 74\n", + "adding: mem time289, current time 362, horizon 73\n", + "adding: mem time290, current time 362, horizon 72\n", + "adding: mem time291, current time 362, horizon 71\n", + "adding: mem time292, current time 362, horizon 70\n", + "adding: mem time293, current time 362, horizon 69\n", + "adding: mem time294, current time 362, horizon 68\n", + "adding: mem time295, current time 362, horizon 67\n", + "adding: mem time296, current time 362, horizon 66\n", + "adding: mem time297, current time 362, horizon 65\n", + "adding: mem time298, current time 362, horizon 64\n", + "adding: mem time299, current time 362, horizon 63\n", + "adding: mem time300, current time 362, horizon 62\n", + "adding: mem time301, current time 362, horizon 61\n", + "adding: mem time302, current time 362, horizon 60\n", + "adding: mem time303, current time 362, horizon 59\n", + "adding: mem time304, current time 362, horizon 58\n", + "adding: mem time305, current time 362, horizon 57\n", + "adding: mem time306, current time 362, horizon 56\n", + "adding: mem time307, current time 362, horizon 55\n", + "adding: mem time308, current time 362, horizon 54\n", + "adding: mem time309, current time 362, horizon 53\n", + "adding: mem time310, current time 362, horizon 52\n", + "adding: mem time311, current time 362, horizon 51\n", + "adding: mem time312, current time 362, horizon 50\n", + "adding: mem time313, current time 362, horizon 49\n", + "adding: mem time314, current time 362, horizon 48\n", + "adding: mem time315, current time 362, horizon 47\n", + "adding: mem time316, current time 362, horizon 46\n", + "adding: mem time317, current time 362, horizon 45\n", + "adding: mem time318, current time 362, horizon 44\n", + "adding: mem time319, current time 362, horizon 43\n", + "adding: mem time320, current time 362, horizon 42\n", + "adding: mem time321, current time 362, horizon 41\n", + "adding: mem time322, current time 362, horizon 40\n", + "adding: mem time323, current time 362, horizon 39\n", + "adding: mem time324, current time 362, horizon 38\n", + "adding: mem time325, current time 362, horizon 37\n", + "adding: mem time326, current time 362, horizon 36\n", + "adding: mem time327, current time 362, horizon 35\n", + "adding: mem time328, current time 362, horizon 34\n", + "adding: mem time329, current time 362, horizon 33\n", + "adding: mem time330, current time 362, horizon 32\n", + "adding: mem time331, current time 362, horizon 31\n", + "adding: mem time332, current time 362, horizon 30\n", + "adding: mem time333, current time 362, horizon 29\n", + "adding: mem time334, current time 362, horizon 28\n", + "adding: mem time335, current time 362, horizon 27\n", + "adding: mem time336, current time 362, horizon 26\n", + "adding: mem time337, current time 362, horizon 25\n", + "adding: mem time338, current time 362, horizon 24\n", + "adding: mem time339, current time 362, horizon 23\n", + "adding: mem time340, current time 362, horizon 22\n", + "adding: mem time341, current time 362, horizon 21\n", + "adding: mem time342, current time 362, horizon 20\n", + "adding: mem time343, current time 362, horizon 19\n", + "adding: mem time344, current time 362, horizon 18\n", + "adding: mem time345, current time 362, horizon 17\n", + "adding: mem time346, current time 362, horizon 16\n", + "adding: mem time347, current time 362, horizon 15\n", + "adding: mem time348, current time 362, horizon 14\n", + "adding: mem time349, current time 362, horizon 13\n", + "adding: mem time350, current time 362, horizon 12\n", + "adding: mem time351, current time 362, horizon 11\n", + "adding: mem time352, current time 362, horizon 10\n", + "adding: mem time353, current time 362, horizon 9\n", + "adding: mem time354, current time 362, horizon 8\n", + "adding: mem time355, current time 362, horizon 7\n", + "adding: mem time356, current time 362, horizon 6\n", + "adding: mem time357, current time 362, horizon 5\n", + "adding: mem time358, current time 362, horizon 4\n", + "adding: mem time359, current time 362, horizon 3\n", + "adding: mem time360, current time 362, horizon 2\n", + "adding: mem time361, current time 362, horizon 1\n", + "adding: mem time200, current time 363, horizon 163\n", + "adding: mem time201, current time 363, horizon 162\n", + "adding: mem time202, current time 363, horizon 161\n", + "adding: mem time203, current time 363, horizon 160\n", + "adding: mem time204, current time 363, horizon 159\n", + "adding: mem time205, current time 363, horizon 158\n", + "adding: mem time206, current time 363, horizon 157\n", + "adding: mem time207, current time 363, horizon 156\n", + "adding: mem time208, current time 363, horizon 155\n", + "adding: mem time209, current time 363, horizon 154\n", + "adding: mem time210, current time 363, horizon 153\n", + "adding: mem time211, current time 363, horizon 152\n", + "adding: mem time212, current time 363, horizon 151\n", + "adding: mem time213, current time 363, horizon 150\n", + "adding: mem time214, current time 363, horizon 149\n", + "adding: mem time215, current time 363, horizon 148\n", + "adding: mem time216, current time 363, horizon 147\n", + "adding: mem time217, current time 363, horizon 146\n", + "adding: mem time218, current time 363, horizon 145\n", + "adding: mem time219, current time 363, horizon 144\n", + "adding: mem time220, current time 363, horizon 143\n", + "adding: mem time221, current time 363, horizon 142\n", + "adding: mem time222, current time 363, horizon 141\n", + "adding: mem time223, current time 363, horizon 140\n", + "adding: mem time224, current time 363, horizon 139\n", + "adding: mem time225, current time 363, horizon 138\n", + "adding: mem time226, current time 363, horizon 137\n", + "adding: mem time227, current time 363, horizon 136\n", + "adding: mem time228, current time 363, horizon 135\n", + "adding: mem time229, current time 363, horizon 134\n", + "adding: mem time230, current time 363, horizon 133\n", + "adding: mem time231, current time 363, horizon 132\n", + "adding: mem time232, current time 363, horizon 131\n", + "adding: mem time233, current time 363, horizon 130\n", + "adding: mem time234, current time 363, horizon 129\n", + "adding: mem time235, current time 363, horizon 128\n", + "adding: mem time236, current time 363, horizon 127\n", + "adding: mem time237, current time 363, horizon 126\n", + "adding: mem time238, current time 363, horizon 125\n", + "adding: mem time239, current time 363, horizon 124\n", + "adding: mem time240, current time 363, horizon 123\n", + "adding: mem time241, current time 363, horizon 122\n", + "adding: mem time242, current time 363, horizon 121\n", + "adding: mem time243, current time 363, horizon 120\n", + "adding: mem time244, current time 363, horizon 119\n", + "adding: mem time245, current time 363, horizon 118\n", + "adding: mem time246, current time 363, horizon 117\n", + "adding: mem time247, current time 363, horizon 116\n", + "adding: mem time248, current time 363, horizon 115\n", + "adding: mem time249, current time 363, horizon 114\n", + "adding: mem time250, current time 363, horizon 113\n", + "adding: mem time251, current time 363, horizon 112\n", + "adding: mem time252, current time 363, horizon 111\n", + "adding: mem time253, current time 363, horizon 110\n", + "adding: mem time254, current time 363, horizon 109\n", + "adding: mem time255, current time 363, horizon 108\n", + "adding: mem time256, current time 363, horizon 107\n", + "adding: mem time257, current time 363, horizon 106\n", + "adding: mem time258, current time 363, horizon 105\n", + "adding: mem time259, current time 363, horizon 104\n", + "adding: mem time260, current time 363, horizon 103\n", + "adding: mem time261, current time 363, horizon 102\n", + "adding: mem time262, current time 363, horizon 101\n", + "adding: mem time263, current time 363, horizon 100\n", + "adding: mem time264, current time 363, horizon 99\n", + "adding: mem time265, current time 363, horizon 98\n", + "adding: mem time266, current time 363, horizon 97\n", + "adding: mem time267, current time 363, horizon 96\n", + "adding: mem time268, current time 363, horizon 95\n", + "adding: mem time269, current time 363, horizon 94\n", + "adding: mem time270, current time 363, horizon 93\n", + "adding: mem time271, current time 363, horizon 92\n", + "adding: mem time272, current time 363, horizon 91\n", + "adding: mem time273, current time 363, horizon 90\n", + "adding: mem time274, current time 363, horizon 89\n", + "adding: mem time275, current time 363, horizon 88\n", + "adding: mem time276, current time 363, horizon 87\n", + "adding: mem time277, current time 363, horizon 86\n", + "adding: mem time278, current time 363, horizon 85\n", + "adding: mem time279, current time 363, horizon 84\n", + "adding: mem time280, current time 363, horizon 83\n", + "adding: mem time281, current time 363, horizon 82\n", + "adding: mem time282, current time 363, horizon 81\n", + "adding: mem time283, current time 363, horizon 80\n", + "adding: mem time284, current time 363, horizon 79\n", + "adding: mem time285, current time 363, horizon 78\n", + "adding: mem time286, current time 363, horizon 77\n", + "adding: mem time287, current time 363, horizon 76\n", + "adding: mem time288, current time 363, horizon 75\n", + "adding: mem time289, current time 363, horizon 74\n", + "adding: mem time290, current time 363, horizon 73\n", + "adding: mem time291, current time 363, horizon 72\n", + "adding: mem time292, current time 363, horizon 71\n", + "adding: mem time293, current time 363, horizon 70\n", + "adding: mem time294, current time 363, horizon 69\n", + "adding: mem time295, current time 363, horizon 68\n", + "adding: mem time296, current time 363, horizon 67\n", + "adding: mem time297, current time 363, horizon 66\n", + "adding: mem time298, current time 363, horizon 65\n", + "adding: mem time299, current time 363, horizon 64\n", + "adding: mem time300, current time 363, horizon 63\n", + "adding: mem time301, current time 363, horizon 62\n", + "adding: mem time302, current time 363, horizon 61\n", + "adding: mem time303, current time 363, horizon 60\n", + "adding: mem time304, current time 363, horizon 59\n", + "adding: mem time305, current time 363, horizon 58\n", + "adding: mem time306, current time 363, horizon 57\n", + "adding: mem time307, current time 363, horizon 56\n", + "adding: mem time308, current time 363, horizon 55\n", + "adding: mem time309, current time 363, horizon 54\n", + "adding: mem time310, current time 363, horizon 53\n", + "adding: mem time311, current time 363, horizon 52\n", + "adding: mem time312, current time 363, horizon 51\n", + "adding: mem time313, current time 363, horizon 50\n", + "adding: mem time314, current time 363, horizon 49\n", + "adding: mem time315, current time 363, horizon 48\n", + "adding: mem time316, current time 363, horizon 47\n", + "adding: mem time317, current time 363, horizon 46\n", + "adding: mem time318, current time 363, horizon 45\n", + "adding: mem time319, current time 363, horizon 44\n", + "adding: mem time320, current time 363, horizon 43\n", + "adding: mem time321, current time 363, horizon 42\n", + "adding: mem time322, current time 363, horizon 41\n", + "adding: mem time323, current time 363, horizon 40\n", + "adding: mem time324, current time 363, horizon 39\n", + "adding: mem time325, current time 363, horizon 38\n", + "adding: mem time326, current time 363, horizon 37\n", + "adding: mem time327, current time 363, horizon 36\n", + "adding: mem time328, current time 363, horizon 35\n", + "adding: mem time329, current time 363, horizon 34\n", + "adding: mem time330, current time 363, horizon 33\n", + "adding: mem time331, current time 363, horizon 32\n", + "adding: mem time332, current time 363, horizon 31\n", + "adding: mem time333, current time 363, horizon 30\n", + "adding: mem time334, current time 363, horizon 29\n", + "adding: mem time335, current time 363, horizon 28\n", + "adding: mem time336, current time 363, horizon 27\n", + "adding: mem time337, current time 363, horizon 26\n", + "adding: mem time338, current time 363, horizon 25\n", + "adding: mem time339, current time 363, horizon 24\n", + "adding: mem time340, current time 363, horizon 23\n", + "adding: mem time341, current time 363, horizon 22\n", + "adding: mem time342, current time 363, horizon 21\n", + "adding: mem time343, current time 363, horizon 20\n", + "adding: mem time344, current time 363, horizon 19\n", + "adding: mem time345, current time 363, horizon 18\n", + "adding: mem time346, current time 363, horizon 17\n", + "adding: mem time347, current time 363, horizon 16\n", + "adding: mem time348, current time 363, horizon 15\n", + "adding: mem time349, current time 363, horizon 14\n", + "adding: mem time350, current time 363, horizon 13\n", + "adding: mem time351, current time 363, horizon 12\n", + "adding: mem time352, current time 363, horizon 11\n", + "adding: mem time353, current time 363, horizon 10\n", + "adding: mem time354, current time 363, horizon 9\n", + "adding: mem time355, current time 363, horizon 8\n", + "adding: mem time356, current time 363, horizon 7\n", + "adding: mem time357, current time 363, horizon 6\n", + "adding: mem time358, current time 363, horizon 5\n", + "adding: mem time359, current time 363, horizon 4\n", + "adding: mem time360, current time 363, horizon 3\n", + "adding: mem time361, current time 363, horizon 2\n", + "adding: mem time362, current time 363, horizon 1\n", + "adding: mem time200, current time 364, horizon 164\n", + "adding: mem time201, current time 364, horizon 163\n", + "adding: mem time202, current time 364, horizon 162\n", + "adding: mem time203, current time 364, horizon 161\n", + "adding: mem time204, current time 364, horizon 160\n", + "adding: mem time205, current time 364, horizon 159\n", + "adding: mem time206, current time 364, horizon 158\n", + "adding: mem time207, current time 364, horizon 157\n", + "adding: mem time208, current time 364, horizon 156\n", + "adding: mem time209, current time 364, horizon 155\n", + "adding: mem time210, current time 364, horizon 154\n", + "adding: mem time211, current time 364, horizon 153\n", + "adding: mem time212, current time 364, horizon 152\n", + "adding: mem time213, current time 364, horizon 151\n", + "adding: mem time214, current time 364, horizon 150\n", + "adding: mem time215, current time 364, horizon 149\n", + "adding: mem time216, current time 364, horizon 148\n", + "adding: mem time217, current time 364, horizon 147\n", + "adding: mem time218, current time 364, horizon 146\n", + "adding: mem time219, current time 364, horizon 145\n", + "adding: mem time220, current time 364, horizon 144\n", + "adding: mem time221, current time 364, horizon 143\n", + "adding: mem time222, current time 364, horizon 142\n", + "adding: mem time223, current time 364, horizon 141\n", + "adding: mem time224, current time 364, horizon 140\n", + "adding: mem time225, current time 364, horizon 139\n", + "adding: mem time226, current time 364, horizon 138\n", + "adding: mem time227, current time 364, horizon 137\n", + "adding: mem time228, current time 364, horizon 136\n", + "adding: mem time229, current time 364, horizon 135\n", + "adding: mem time230, current time 364, horizon 134\n", + "adding: mem time231, current time 364, horizon 133\n", + "adding: mem time232, current time 364, horizon 132\n", + "adding: mem time233, current time 364, horizon 131\n", + "adding: mem time234, current time 364, horizon 130\n", + "adding: mem time235, current time 364, horizon 129\n", + "adding: mem time236, current time 364, horizon 128\n", + "adding: mem time237, current time 364, horizon 127\n", + "adding: mem time238, current time 364, horizon 126\n", + "adding: mem time239, current time 364, horizon 125\n", + "adding: mem time240, current time 364, horizon 124\n", + "adding: mem time241, current time 364, horizon 123\n", + "adding: mem time242, current time 364, horizon 122\n", + "adding: mem time243, current time 364, horizon 121\n", + "adding: mem time244, current time 364, horizon 120\n", + "adding: mem time245, current time 364, horizon 119\n", + "adding: mem time246, current time 364, horizon 118\n", + "adding: mem time247, current time 364, horizon 117\n", + "adding: mem time248, current time 364, horizon 116\n", + "adding: mem time249, current time 364, horizon 115\n", + "adding: mem time250, current time 364, horizon 114\n", + "adding: mem time251, current time 364, horizon 113\n", + "adding: mem time252, current time 364, horizon 112\n", + "adding: mem time253, current time 364, horizon 111\n", + "adding: mem time254, current time 364, horizon 110\n", + "adding: mem time255, current time 364, horizon 109\n", + "adding: mem time256, current time 364, horizon 108\n", + "adding: mem time257, current time 364, horizon 107\n", + "adding: mem time258, current time 364, horizon 106\n", + "adding: mem time259, current time 364, horizon 105\n", + "adding: mem time260, current time 364, horizon 104\n", + "adding: mem time261, current time 364, horizon 103\n", + "adding: mem time262, current time 364, horizon 102\n", + "adding: mem time263, current time 364, horizon 101\n", + "adding: mem time264, current time 364, horizon 100\n", + "adding: mem time265, current time 364, horizon 99\n", + "adding: mem time266, current time 364, horizon 98\n", + "adding: mem time267, current time 364, horizon 97\n", + "adding: mem time268, current time 364, horizon 96\n", + "adding: mem time269, current time 364, horizon 95\n", + "adding: mem time270, current time 364, horizon 94\n", + "adding: mem time271, current time 364, horizon 93\n", + "adding: mem time272, current time 364, horizon 92\n", + "adding: mem time273, current time 364, horizon 91\n", + "adding: mem time274, current time 364, horizon 90\n", + "adding: mem time275, current time 364, horizon 89\n", + "adding: mem time276, current time 364, horizon 88\n", + "adding: mem time277, current time 364, horizon 87\n", + "adding: mem time278, current time 364, horizon 86\n", + "adding: mem time279, current time 364, horizon 85\n", + "adding: mem time280, current time 364, horizon 84\n", + "adding: mem time281, current time 364, horizon 83\n", + "adding: mem time282, current time 364, horizon 82\n", + "adding: mem time283, current time 364, horizon 81\n", + "adding: mem time284, current time 364, horizon 80\n", + "adding: mem time285, current time 364, horizon 79\n", + "adding: mem time286, current time 364, horizon 78\n", + "adding: mem time287, current time 364, horizon 77\n", + "adding: mem time288, current time 364, horizon 76\n", + "adding: mem time289, current time 364, horizon 75\n", + "adding: mem time290, current time 364, horizon 74\n", + "adding: mem time291, current time 364, horizon 73\n", + "adding: mem time292, current time 364, horizon 72\n", + "adding: mem time293, current time 364, horizon 71\n", + "adding: mem time294, current time 364, horizon 70\n", + "adding: mem time295, current time 364, horizon 69\n", + "adding: mem time296, current time 364, horizon 68\n", + "adding: mem time297, current time 364, horizon 67\n", + "adding: mem time298, current time 364, horizon 66\n", + "adding: mem time299, current time 364, horizon 65\n", + "adding: mem time300, current time 364, horizon 64\n", + "adding: mem time301, current time 364, horizon 63\n", + "adding: mem time302, current time 364, horizon 62\n", + "adding: mem time303, current time 364, horizon 61\n", + "adding: mem time304, current time 364, horizon 60\n", + "adding: mem time305, current time 364, horizon 59\n", + "adding: mem time306, current time 364, horizon 58\n", + "adding: mem time307, current time 364, horizon 57\n", + "adding: mem time308, current time 364, horizon 56\n", + "adding: mem time309, current time 364, horizon 55\n", + "adding: mem time310, current time 364, horizon 54\n", + "adding: mem time311, current time 364, horizon 53\n", + "adding: mem time312, current time 364, horizon 52\n", + "adding: mem time313, current time 364, horizon 51\n", + "adding: mem time314, current time 364, horizon 50\n", + "adding: mem time315, current time 364, horizon 49\n", + "adding: mem time316, current time 364, horizon 48\n", + "adding: mem time317, current time 364, horizon 47\n", + "adding: mem time318, current time 364, horizon 46\n", + "adding: mem time319, current time 364, horizon 45\n", + "adding: mem time320, current time 364, horizon 44\n", + "adding: mem time321, current time 364, horizon 43\n", + "adding: mem time322, current time 364, horizon 42\n", + "adding: mem time323, current time 364, horizon 41\n", + "adding: mem time324, current time 364, horizon 40\n", + "adding: mem time325, current time 364, horizon 39\n", + "adding: mem time326, current time 364, horizon 38\n", + "adding: mem time327, current time 364, horizon 37\n", + "adding: mem time328, current time 364, horizon 36\n", + "adding: mem time329, current time 364, horizon 35\n", + "adding: mem time330, current time 364, horizon 34\n", + "adding: mem time331, current time 364, horizon 33\n", + "adding: mem time332, current time 364, horizon 32\n", + "adding: mem time333, current time 364, horizon 31\n", + "adding: mem time334, current time 364, horizon 30\n", + "adding: mem time335, current time 364, horizon 29\n", + "adding: mem time336, current time 364, horizon 28\n", + "adding: mem time337, current time 364, horizon 27\n", + "adding: mem time338, current time 364, horizon 26\n", + "adding: mem time339, current time 364, horizon 25\n", + "adding: mem time340, current time 364, horizon 24\n", + "adding: mem time341, current time 364, horizon 23\n", + "adding: mem time342, current time 364, horizon 22\n", + "adding: mem time343, current time 364, horizon 21\n", + "adding: mem time344, current time 364, horizon 20\n", + "adding: mem time345, current time 364, horizon 19\n", + "adding: mem time346, current time 364, horizon 18\n", + "adding: mem time347, current time 364, horizon 17\n", + "adding: mem time348, current time 364, horizon 16\n", + "adding: mem time349, current time 364, horizon 15\n", + "adding: mem time350, current time 364, horizon 14\n", + "adding: mem time351, current time 364, horizon 13\n", + "adding: mem time352, current time 364, horizon 12\n", + "adding: mem time353, current time 364, horizon 11\n", + "adding: mem time354, current time 364, horizon 10\n", + "adding: mem time355, current time 364, horizon 9\n", + "adding: mem time356, current time 364, horizon 8\n", + "adding: mem time357, current time 364, horizon 7\n", + "adding: mem time358, current time 364, horizon 6\n", + "adding: mem time359, current time 364, horizon 5\n", + "adding: mem time360, current time 364, horizon 4\n", + "adding: mem time361, current time 364, horizon 3\n", + "adding: mem time362, current time 364, horizon 2\n", + "adding: mem time363, current time 364, horizon 1\n", + "adding: mem time200, current time 365, horizon 165\n", + "adding: mem time201, current time 365, horizon 164\n", + "adding: mem time202, current time 365, horizon 163\n", + "adding: mem time203, current time 365, horizon 162\n", + "adding: mem time204, current time 365, horizon 161\n", + "adding: mem time205, current time 365, horizon 160\n", + "adding: mem time206, current time 365, horizon 159\n", + "adding: mem time207, current time 365, horizon 158\n", + "adding: mem time208, current time 365, horizon 157\n", + "adding: mem time209, current time 365, horizon 156\n", + "adding: mem time210, current time 365, horizon 155\n", + "adding: mem time211, current time 365, horizon 154\n", + "adding: mem time212, current time 365, horizon 153\n", + "adding: mem time213, current time 365, horizon 152\n", + "adding: mem time214, current time 365, horizon 151\n", + "adding: mem time215, current time 365, horizon 150\n", + "adding: mem time216, current time 365, horizon 149\n", + "adding: mem time217, current time 365, horizon 148\n", + "adding: mem time218, current time 365, horizon 147\n", + "adding: mem time219, current time 365, horizon 146\n", + "adding: mem time220, current time 365, horizon 145\n", + "adding: mem time221, current time 365, horizon 144\n", + "adding: mem time222, current time 365, horizon 143\n", + "adding: mem time223, current time 365, horizon 142\n", + "adding: mem time224, current time 365, horizon 141\n", + "adding: mem time225, current time 365, horizon 140\n", + "adding: mem time226, current time 365, horizon 139\n", + "adding: mem time227, current time 365, horizon 138\n", + "adding: mem time228, current time 365, horizon 137\n", + "adding: mem time229, current time 365, horizon 136\n", + "adding: mem time230, current time 365, horizon 135\n", + "adding: mem time231, current time 365, horizon 134\n", + "adding: mem time232, current time 365, horizon 133\n", + "adding: mem time233, current time 365, horizon 132\n", + "adding: mem time234, current time 365, horizon 131\n", + "adding: mem time235, current time 365, horizon 130\n", + "adding: mem time236, current time 365, horizon 129\n", + "adding: mem time237, current time 365, horizon 128\n", + "adding: mem time238, current time 365, horizon 127\n", + "adding: mem time239, current time 365, horizon 126\n", + "adding: mem time240, current time 365, horizon 125\n", + "adding: mem time241, current time 365, horizon 124\n", + "adding: mem time242, current time 365, horizon 123\n", + "adding: mem time243, current time 365, horizon 122\n", + "adding: mem time244, current time 365, horizon 121\n", + "adding: mem time245, current time 365, horizon 120\n", + "adding: mem time246, current time 365, horizon 119\n", + "adding: mem time247, current time 365, horizon 118\n", + "adding: mem time248, current time 365, horizon 117\n", + "adding: mem time249, current time 365, horizon 116\n", + "adding: mem time250, current time 365, horizon 115\n", + "adding: mem time251, current time 365, horizon 114\n", + "adding: mem time252, current time 365, horizon 113\n", + "adding: mem time253, current time 365, horizon 112\n", + "adding: mem time254, current time 365, horizon 111\n", + "adding: mem time255, current time 365, horizon 110\n", + "adding: mem time256, current time 365, horizon 109\n", + "adding: mem time257, current time 365, horizon 108\n", + "adding: mem time258, current time 365, horizon 107\n", + "adding: mem time259, current time 365, horizon 106\n", + "adding: mem time260, current time 365, horizon 105\n", + "adding: mem time261, current time 365, horizon 104\n", + "adding: mem time262, current time 365, horizon 103\n", + "adding: mem time263, current time 365, horizon 102\n", + "adding: mem time264, current time 365, horizon 101\n", + "adding: mem time265, current time 365, horizon 100\n", + "adding: mem time266, current time 365, horizon 99\n", + "adding: mem time267, current time 365, horizon 98\n", + "adding: mem time268, current time 365, horizon 97\n", + "adding: mem time269, current time 365, horizon 96\n", + "adding: mem time270, current time 365, horizon 95\n", + "adding: mem time271, current time 365, horizon 94\n", + "adding: mem time272, current time 365, horizon 93\n", + "adding: mem time273, current time 365, horizon 92\n", + "adding: mem time274, current time 365, horizon 91\n", + "adding: mem time275, current time 365, horizon 90\n", + "adding: mem time276, current time 365, horizon 89\n", + "adding: mem time277, current time 365, horizon 88\n", + "adding: mem time278, current time 365, horizon 87\n", + "adding: mem time279, current time 365, horizon 86\n", + "adding: mem time280, current time 365, horizon 85\n", + "adding: mem time281, current time 365, horizon 84\n", + "adding: mem time282, current time 365, horizon 83\n", + "adding: mem time283, current time 365, horizon 82\n", + "adding: mem time284, current time 365, horizon 81\n", + "adding: mem time285, current time 365, horizon 80\n", + "adding: mem time286, current time 365, horizon 79\n", + "adding: mem time287, current time 365, horizon 78\n", + "adding: mem time288, current time 365, horizon 77\n", + "adding: mem time289, current time 365, horizon 76\n", + "adding: mem time290, current time 365, horizon 75\n", + "adding: mem time291, current time 365, horizon 74\n", + "adding: mem time292, current time 365, horizon 73\n", + "adding: mem time293, current time 365, horizon 72\n", + "adding: mem time294, current time 365, horizon 71\n", + "adding: mem time295, current time 365, horizon 70\n", + "adding: mem time296, current time 365, horizon 69\n", + "adding: mem time297, current time 365, horizon 68\n", + "adding: mem time298, current time 365, horizon 67\n", + "adding: mem time299, current time 365, horizon 66\n", + "adding: mem time300, current time 365, horizon 65\n", + "adding: mem time301, current time 365, horizon 64\n", + "adding: mem time302, current time 365, horizon 63\n", + "adding: mem time303, current time 365, horizon 62\n", + "adding: mem time304, current time 365, horizon 61\n", + "adding: mem time305, current time 365, horizon 60\n", + "adding: mem time306, current time 365, horizon 59\n", + "adding: mem time307, current time 365, horizon 58\n", + "adding: mem time308, current time 365, horizon 57\n", + "adding: mem time309, current time 365, horizon 56\n", + "adding: mem time310, current time 365, horizon 55\n", + "adding: mem time311, current time 365, horizon 54\n", + "adding: mem time312, current time 365, horizon 53\n", + "adding: mem time313, current time 365, horizon 52\n", + "adding: mem time314, current time 365, horizon 51\n", + "adding: mem time315, current time 365, horizon 50\n", + "adding: mem time316, current time 365, horizon 49\n", + "adding: mem time317, current time 365, horizon 48\n", + "adding: mem time318, current time 365, horizon 47\n", + "adding: mem time319, current time 365, horizon 46\n", + "adding: mem time320, current time 365, horizon 45\n", + "adding: mem time321, current time 365, horizon 44\n", + "adding: mem time322, current time 365, horizon 43\n", + "adding: mem time323, current time 365, horizon 42\n", + "adding: mem time324, current time 365, horizon 41\n", + "adding: mem time325, current time 365, horizon 40\n", + "adding: mem time326, current time 365, horizon 39\n", + "adding: mem time327, current time 365, horizon 38\n", + "adding: mem time328, current time 365, horizon 37\n", + "adding: mem time329, current time 365, horizon 36\n", + "adding: mem time330, current time 365, horizon 35\n", + "adding: mem time331, current time 365, horizon 34\n", + "adding: mem time332, current time 365, horizon 33\n", + "adding: mem time333, current time 365, horizon 32\n", + "adding: mem time334, current time 365, horizon 31\n", + "adding: mem time335, current time 365, horizon 30\n", + "adding: mem time336, current time 365, horizon 29\n", + "adding: mem time337, current time 365, horizon 28\n", + "adding: mem time338, current time 365, horizon 27\n", + "adding: mem time339, current time 365, horizon 26\n", + "adding: mem time340, current time 365, horizon 25\n", + "adding: mem time341, current time 365, horizon 24\n", + "adding: mem time342, current time 365, horizon 23\n", + "adding: mem time343, current time 365, horizon 22\n", + "adding: mem time344, current time 365, horizon 21\n", + "adding: mem time345, current time 365, horizon 20\n", + "adding: mem time346, current time 365, horizon 19\n", + "adding: mem time347, current time 365, horizon 18\n", + "adding: mem time348, current time 365, horizon 17\n", + "adding: mem time349, current time 365, horizon 16\n", + "adding: mem time350, current time 365, horizon 15\n", + "adding: mem time351, current time 365, horizon 14\n", + "adding: mem time352, current time 365, horizon 13\n", + "adding: mem time353, current time 365, horizon 12\n", + "adding: mem time354, current time 365, horizon 11\n", + "adding: mem time355, current time 365, horizon 10\n", + "adding: mem time356, current time 365, horizon 9\n", + "adding: mem time357, current time 365, horizon 8\n", + "adding: mem time358, current time 365, horizon 7\n", + "adding: mem time359, current time 365, horizon 6\n", + "adding: mem time360, current time 365, horizon 5\n", + "adding: mem time361, current time 365, horizon 4\n", + "adding: mem time362, current time 365, horizon 3\n", + "adding: mem time363, current time 365, horizon 2\n", + "adding: mem time364, current time 365, horizon 1\n", + "adding: mem time200, current time 366, horizon 166\n", + "adding: mem time201, current time 366, horizon 165\n", + "adding: mem time202, current time 366, horizon 164\n", + "adding: mem time203, current time 366, horizon 163\n", + "adding: mem time204, current time 366, horizon 162\n", + "adding: mem time205, current time 366, horizon 161\n", + "adding: mem time206, current time 366, horizon 160\n", + "adding: mem time207, current time 366, horizon 159\n", + "adding: mem time208, current time 366, horizon 158\n", + "adding: mem time209, current time 366, horizon 157\n", + "adding: mem time210, current time 366, horizon 156\n", + "adding: mem time211, current time 366, horizon 155\n", + "adding: mem time212, current time 366, horizon 154\n", + "adding: mem time213, current time 366, horizon 153\n", + "adding: mem time214, current time 366, horizon 152\n", + "adding: mem time215, current time 366, horizon 151\n", + "adding: mem time216, current time 366, horizon 150\n", + "adding: mem time217, current time 366, horizon 149\n", + "adding: mem time218, current time 366, horizon 148\n", + "adding: mem time219, current time 366, horizon 147\n", + "adding: mem time220, current time 366, horizon 146\n", + "adding: mem time221, current time 366, horizon 145\n", + "adding: mem time222, current time 366, horizon 144\n", + "adding: mem time223, current time 366, horizon 143\n", + "adding: mem time224, current time 366, horizon 142\n", + "adding: mem time225, current time 366, horizon 141\n", + "adding: mem time226, current time 366, horizon 140\n", + "adding: mem time227, current time 366, horizon 139\n", + "adding: mem time228, current time 366, horizon 138\n", + "adding: mem time229, current time 366, horizon 137\n", + "adding: mem time230, current time 366, horizon 136\n", + "adding: mem time231, current time 366, horizon 135\n", + "adding: mem time232, current time 366, horizon 134\n", + "adding: mem time233, current time 366, horizon 133\n", + "adding: mem time234, current time 366, horizon 132\n", + "adding: mem time235, current time 366, horizon 131\n", + "adding: mem time236, current time 366, horizon 130\n", + "adding: mem time237, current time 366, horizon 129\n", + "adding: mem time238, current time 366, horizon 128\n", + "adding: mem time239, current time 366, horizon 127\n", + "adding: mem time240, current time 366, horizon 126\n", + "adding: mem time241, current time 366, horizon 125\n", + "adding: mem time242, current time 366, horizon 124\n", + "adding: mem time243, current time 366, horizon 123\n", + "adding: mem time244, current time 366, horizon 122\n", + "adding: mem time245, current time 366, horizon 121\n", + "adding: mem time246, current time 366, horizon 120\n", + "adding: mem time247, current time 366, horizon 119\n", + "adding: mem time248, current time 366, horizon 118\n", + "adding: mem time249, current time 366, horizon 117\n", + "adding: mem time250, current time 366, horizon 116\n", + "adding: mem time251, current time 366, horizon 115\n", + "adding: mem time252, current time 366, horizon 114\n", + "adding: mem time253, current time 366, horizon 113\n", + "adding: mem time254, current time 366, horizon 112\n", + "adding: mem time255, current time 366, horizon 111\n", + "adding: mem time256, current time 366, horizon 110\n", + "adding: mem time257, current time 366, horizon 109\n", + "adding: mem time258, current time 366, horizon 108\n", + "adding: mem time259, current time 366, horizon 107\n", + "adding: mem time260, current time 366, horizon 106\n", + "adding: mem time261, current time 366, horizon 105\n", + "adding: mem time262, current time 366, horizon 104\n", + "adding: mem time263, current time 366, horizon 103\n", + "adding: mem time264, current time 366, horizon 102\n", + "adding: mem time265, current time 366, horizon 101\n", + "adding: mem time266, current time 366, horizon 100\n", + "adding: mem time267, current time 366, horizon 99\n", + "adding: mem time268, current time 366, horizon 98\n", + "adding: mem time269, current time 366, horizon 97\n", + "adding: mem time270, current time 366, horizon 96\n", + "adding: mem time271, current time 366, horizon 95\n", + "adding: mem time272, current time 366, horizon 94\n", + "adding: mem time273, current time 366, horizon 93\n", + "adding: mem time274, current time 366, horizon 92\n", + "adding: mem time275, current time 366, horizon 91\n", + "adding: mem time276, current time 366, horizon 90\n", + "adding: mem time277, current time 366, horizon 89\n", + "adding: mem time278, current time 366, horizon 88\n", + "adding: mem time279, current time 366, horizon 87\n", + "adding: mem time280, current time 366, horizon 86\n", + "adding: mem time281, current time 366, horizon 85\n", + "adding: mem time282, current time 366, horizon 84\n", + "adding: mem time283, current time 366, horizon 83\n", + "adding: mem time284, current time 366, horizon 82\n", + "adding: mem time285, current time 366, horizon 81\n", + "adding: mem time286, current time 366, horizon 80\n", + "adding: mem time287, current time 366, horizon 79\n", + "adding: mem time288, current time 366, horizon 78\n", + "adding: mem time289, current time 366, horizon 77\n", + "adding: mem time290, current time 366, horizon 76\n", + "adding: mem time291, current time 366, horizon 75\n", + "adding: mem time292, current time 366, horizon 74\n", + "adding: mem time293, current time 366, horizon 73\n", + "adding: mem time294, current time 366, horizon 72\n", + "adding: mem time295, current time 366, horizon 71\n", + "adding: mem time296, current time 366, horizon 70\n", + "adding: mem time297, current time 366, horizon 69\n", + "adding: mem time298, current time 366, horizon 68\n", + "adding: mem time299, current time 366, horizon 67\n", + "adding: mem time300, current time 366, horizon 66\n", + "adding: mem time301, current time 366, horizon 65\n", + "adding: mem time302, current time 366, horizon 64\n", + "adding: mem time303, current time 366, horizon 63\n", + "adding: mem time304, current time 366, horizon 62\n", + "adding: mem time305, current time 366, horizon 61\n", + "adding: mem time306, current time 366, horizon 60\n", + "adding: mem time307, current time 366, horizon 59\n", + "adding: mem time308, current time 366, horizon 58\n", + "adding: mem time309, current time 366, horizon 57\n", + "adding: mem time310, current time 366, horizon 56\n", + "adding: mem time311, current time 366, horizon 55\n", + "adding: mem time312, current time 366, horizon 54\n", + "adding: mem time313, current time 366, horizon 53\n", + "adding: mem time314, current time 366, horizon 52\n", + "adding: mem time315, current time 366, horizon 51\n", + "adding: mem time316, current time 366, horizon 50\n", + "adding: mem time317, current time 366, horizon 49\n", + "adding: mem time318, current time 366, horizon 48\n", + "adding: mem time319, current time 366, horizon 47\n", + "adding: mem time320, current time 366, horizon 46\n", + "adding: mem time321, current time 366, horizon 45\n", + "adding: mem time322, current time 366, horizon 44\n", + "adding: mem time323, current time 366, horizon 43\n", + "adding: mem time324, current time 366, horizon 42\n", + "adding: mem time325, current time 366, horizon 41\n", + "adding: mem time326, current time 366, horizon 40\n", + "adding: mem time327, current time 366, horizon 39\n", + "adding: mem time328, current time 366, horizon 38\n", + "adding: mem time329, current time 366, horizon 37\n", + "adding: mem time330, current time 366, horizon 36\n", + "adding: mem time331, current time 366, horizon 35\n", + "adding: mem time332, current time 366, horizon 34\n", + "adding: mem time333, current time 366, horizon 33\n", + "adding: mem time334, current time 366, horizon 32\n", + "adding: mem time335, current time 366, horizon 31\n", + "adding: mem time336, current time 366, horizon 30\n", + "adding: mem time337, current time 366, horizon 29\n", + "adding: mem time338, current time 366, horizon 28\n", + "adding: mem time339, current time 366, horizon 27\n", + "adding: mem time340, current time 366, horizon 26\n", + "adding: mem time341, current time 366, horizon 25\n", + "adding: mem time342, current time 366, horizon 24\n", + "adding: mem time343, current time 366, horizon 23\n", + "adding: mem time344, current time 366, horizon 22\n", + "adding: mem time345, current time 366, horizon 21\n", + "adding: mem time346, current time 366, horizon 20\n", + "adding: mem time347, current time 366, horizon 19\n", + "adding: mem time348, current time 366, horizon 18\n", + "adding: mem time349, current time 366, horizon 17\n", + "adding: mem time350, current time 366, horizon 16\n", + "adding: mem time351, current time 366, horizon 15\n", + "adding: mem time352, current time 366, horizon 14\n", + "adding: mem time353, current time 366, horizon 13\n", + "adding: mem time354, current time 366, horizon 12\n", + "adding: mem time355, current time 366, horizon 11\n", + "adding: mem time356, current time 366, horizon 10\n", + "adding: mem time357, current time 366, horizon 9\n", + "adding: mem time358, current time 366, horizon 8\n", + "adding: mem time359, current time 366, horizon 7\n", + "adding: mem time360, current time 366, horizon 6\n", + "adding: mem time361, current time 366, horizon 5\n", + "adding: mem time362, current time 366, horizon 4\n", + "adding: mem time363, current time 366, horizon 3\n", + "adding: mem time364, current time 366, horizon 2\n", + "adding: mem time365, current time 366, horizon 1\n", + "adding: mem time200, current time 367, horizon 167\n", + "adding: mem time201, current time 367, horizon 166\n", + "adding: mem time202, current time 367, horizon 165\n", + "adding: mem time203, current time 367, horizon 164\n", + "adding: mem time204, current time 367, horizon 163\n", + "adding: mem time205, current time 367, horizon 162\n", + "adding: mem time206, current time 367, horizon 161\n", + "adding: mem time207, current time 367, horizon 160\n", + "adding: mem time208, current time 367, horizon 159\n", + "adding: mem time209, current time 367, horizon 158\n", + "adding: mem time210, current time 367, horizon 157\n", + "adding: mem time211, current time 367, horizon 156\n", + "adding: mem time212, current time 367, horizon 155\n", + "adding: mem time213, current time 367, horizon 154\n", + "adding: mem time214, current time 367, horizon 153\n", + "adding: mem time215, current time 367, horizon 152\n", + "adding: mem time216, current time 367, horizon 151\n", + "adding: mem time217, current time 367, horizon 150\n", + "adding: mem time218, current time 367, horizon 149\n", + "adding: mem time219, current time 367, horizon 148\n", + "adding: mem time220, current time 367, horizon 147\n", + "adding: mem time221, current time 367, horizon 146\n", + "adding: mem time222, current time 367, horizon 145\n", + "adding: mem time223, current time 367, horizon 144\n", + "adding: mem time224, current time 367, horizon 143\n", + "adding: mem time225, current time 367, horizon 142\n", + "adding: mem time226, current time 367, horizon 141\n", + "adding: mem time227, current time 367, horizon 140\n", + "adding: mem time228, current time 367, horizon 139\n", + "adding: mem time229, current time 367, horizon 138\n", + "adding: mem time230, current time 367, horizon 137\n", + "adding: mem time231, current time 367, horizon 136\n", + "adding: mem time232, current time 367, horizon 135\n", + "adding: mem time233, current time 367, horizon 134\n", + "adding: mem time234, current time 367, horizon 133\n", + "adding: mem time235, current time 367, horizon 132\n", + "adding: mem time236, current time 367, horizon 131\n", + "adding: mem time237, current time 367, horizon 130\n", + "adding: mem time238, current time 367, horizon 129\n", + "adding: mem time239, current time 367, horizon 128\n", + "adding: mem time240, current time 367, horizon 127\n", + "adding: mem time241, current time 367, horizon 126\n", + "adding: mem time242, current time 367, horizon 125\n", + "adding: mem time243, current time 367, horizon 124\n", + "adding: mem time244, current time 367, horizon 123\n", + "adding: mem time245, current time 367, horizon 122\n", + "adding: mem time246, current time 367, horizon 121\n", + "adding: mem time247, current time 367, horizon 120\n", + "adding: mem time248, current time 367, horizon 119\n", + "adding: mem time249, current time 367, horizon 118\n", + "adding: mem time250, current time 367, horizon 117\n", + "adding: mem time251, current time 367, horizon 116\n", + "adding: mem time252, current time 367, horizon 115\n", + "adding: mem time253, current time 367, horizon 114\n", + "adding: mem time254, current time 367, horizon 113\n", + "adding: mem time255, current time 367, horizon 112\n", + "adding: mem time256, current time 367, horizon 111\n", + "adding: mem time257, current time 367, horizon 110\n", + "adding: mem time258, current time 367, horizon 109\n", + "adding: mem time259, current time 367, horizon 108\n", + "adding: mem time260, current time 367, horizon 107\n", + "adding: mem time261, current time 367, horizon 106\n", + "adding: mem time262, current time 367, horizon 105\n", + "adding: mem time263, current time 367, horizon 104\n", + "adding: mem time264, current time 367, horizon 103\n", + "adding: mem time265, current time 367, horizon 102\n", + "adding: mem time266, current time 367, horizon 101\n", + "adding: mem time267, current time 367, horizon 100\n", + "adding: mem time268, current time 367, horizon 99\n", + "adding: mem time269, current time 367, horizon 98\n", + "adding: mem time270, current time 367, horizon 97\n", + "adding: mem time271, current time 367, horizon 96\n", + "adding: mem time272, current time 367, horizon 95\n", + "adding: mem time273, current time 367, horizon 94\n", + "adding: mem time274, current time 367, horizon 93\n", + "adding: mem time275, current time 367, horizon 92\n", + "adding: mem time276, current time 367, horizon 91\n", + "adding: mem time277, current time 367, horizon 90\n", + "adding: mem time278, current time 367, horizon 89\n", + "adding: mem time279, current time 367, horizon 88\n", + "adding: mem time280, current time 367, horizon 87\n", + "adding: mem time281, current time 367, horizon 86\n", + "adding: mem time282, current time 367, horizon 85\n", + "adding: mem time283, current time 367, horizon 84\n", + "adding: mem time284, current time 367, horizon 83\n", + "adding: mem time285, current time 367, horizon 82\n", + "adding: mem time286, current time 367, horizon 81\n", + "adding: mem time287, current time 367, horizon 80\n", + "adding: mem time288, current time 367, horizon 79\n", + "adding: mem time289, current time 367, horizon 78\n", + "adding: mem time290, current time 367, horizon 77\n", + "adding: mem time291, current time 367, horizon 76\n", + "adding: mem time292, current time 367, horizon 75\n", + "adding: mem time293, current time 367, horizon 74\n", + "adding: mem time294, current time 367, horizon 73\n", + "adding: mem time295, current time 367, horizon 72\n", + "adding: mem time296, current time 367, horizon 71\n", + "adding: mem time297, current time 367, horizon 70\n", + "adding: mem time298, current time 367, horizon 69\n", + "adding: mem time299, current time 367, horizon 68\n", + "adding: mem time300, current time 367, horizon 67\n", + "adding: mem time301, current time 367, horizon 66\n", + "adding: mem time302, current time 367, horizon 65\n", + "adding: mem time303, current time 367, horizon 64\n", + "adding: mem time304, current time 367, horizon 63\n", + "adding: mem time305, current time 367, horizon 62\n", + "adding: mem time306, current time 367, horizon 61\n", + "adding: mem time307, current time 367, horizon 60\n", + "adding: mem time308, current time 367, horizon 59\n", + "adding: mem time309, current time 367, horizon 58\n", + "adding: mem time310, current time 367, horizon 57\n", + "adding: mem time311, current time 367, horizon 56\n", + "adding: mem time312, current time 367, horizon 55\n", + "adding: mem time313, current time 367, horizon 54\n", + "adding: mem time314, current time 367, horizon 53\n", + "adding: mem time315, current time 367, horizon 52\n", + "adding: mem time316, current time 367, horizon 51\n", + "adding: mem time317, current time 367, horizon 50\n", + "adding: mem time318, current time 367, horizon 49\n", + "adding: mem time319, current time 367, horizon 48\n", + "adding: mem time320, current time 367, horizon 47\n", + "adding: mem time321, current time 367, horizon 46\n", + "adding: mem time322, current time 367, horizon 45\n", + "adding: mem time323, current time 367, horizon 44\n", + "adding: mem time324, current time 367, horizon 43\n", + "adding: mem time325, current time 367, horizon 42\n", + "adding: mem time326, current time 367, horizon 41\n", + "adding: mem time327, current time 367, horizon 40\n", + "adding: mem time328, current time 367, horizon 39\n", + "adding: mem time329, current time 367, horizon 38\n", + "adding: mem time330, current time 367, horizon 37\n", + "adding: mem time331, current time 367, horizon 36\n", + "adding: mem time332, current time 367, horizon 35\n", + "adding: mem time333, current time 367, horizon 34\n", + "adding: mem time334, current time 367, horizon 33\n", + "adding: mem time335, current time 367, horizon 32\n", + "adding: mem time336, current time 367, horizon 31\n", + "adding: mem time337, current time 367, horizon 30\n", + "adding: mem time338, current time 367, horizon 29\n", + "adding: mem time339, current time 367, horizon 28\n", + "adding: mem time340, current time 367, horizon 27\n", + "adding: mem time341, current time 367, horizon 26\n", + "adding: mem time342, current time 367, horizon 25\n", + "adding: mem time343, current time 367, horizon 24\n", + "adding: mem time344, current time 367, horizon 23\n", + "adding: mem time345, current time 367, horizon 22\n", + "adding: mem time346, current time 367, horizon 21\n", + "adding: mem time347, current time 367, horizon 20\n", + "adding: mem time348, current time 367, horizon 19\n", + "adding: mem time349, current time 367, horizon 18\n", + "adding: mem time350, current time 367, horizon 17\n", + "adding: mem time351, current time 367, horizon 16\n", + "adding: mem time352, current time 367, horizon 15\n", + "adding: mem time353, current time 367, horizon 14\n", + "adding: mem time354, current time 367, horizon 13\n", + "adding: mem time355, current time 367, horizon 12\n", + "adding: mem time356, current time 367, horizon 11\n", + "adding: mem time357, current time 367, horizon 10\n", + "adding: mem time358, current time 367, horizon 9\n", + "adding: mem time359, current time 367, horizon 8\n", + "adding: mem time360, current time 367, horizon 7\n", + "adding: mem time361, current time 367, horizon 6\n", + "adding: mem time362, current time 367, horizon 5\n", + "adding: mem time363, current time 367, horizon 4\n", + "adding: mem time364, current time 367, horizon 3\n", + "adding: mem time365, current time 367, horizon 2\n", + "adding: mem time366, current time 367, horizon 1\n", + "adding: mem time200, current time 368, horizon 168\n", + "adding: mem time201, current time 368, horizon 167\n", + "adding: mem time202, current time 368, horizon 166\n", + "adding: mem time203, current time 368, horizon 165\n", + "adding: mem time204, current time 368, horizon 164\n", + "adding: mem time205, current time 368, horizon 163\n", + "adding: mem time206, current time 368, horizon 162\n", + "adding: mem time207, current time 368, horizon 161\n", + "adding: mem time208, current time 368, horizon 160\n", + "adding: mem time209, current time 368, horizon 159\n", + "adding: mem time210, current time 368, horizon 158\n", + "adding: mem time211, current time 368, horizon 157\n", + "adding: mem time212, current time 368, horizon 156\n", + "adding: mem time213, current time 368, horizon 155\n", + "adding: mem time214, current time 368, horizon 154\n", + "adding: mem time215, current time 368, horizon 153\n", + "adding: mem time216, current time 368, horizon 152\n", + "adding: mem time217, current time 368, horizon 151\n", + "adding: mem time218, current time 368, horizon 150\n", + "adding: mem time219, current time 368, horizon 149\n", + "adding: mem time220, current time 368, horizon 148\n", + "adding: mem time221, current time 368, horizon 147\n", + "adding: mem time222, current time 368, horizon 146\n", + "adding: mem time223, current time 368, horizon 145\n", + "adding: mem time224, current time 368, horizon 144\n", + "adding: mem time225, current time 368, horizon 143\n", + "adding: mem time226, current time 368, horizon 142\n", + "adding: mem time227, current time 368, horizon 141\n", + "adding: mem time228, current time 368, horizon 140\n", + "adding: mem time229, current time 368, horizon 139\n", + "adding: mem time230, current time 368, horizon 138\n", + "adding: mem time231, current time 368, horizon 137\n", + "adding: mem time232, current time 368, horizon 136\n", + "adding: mem time233, current time 368, horizon 135\n", + "adding: mem time234, current time 368, horizon 134\n", + "adding: mem time235, current time 368, horizon 133\n", + "adding: mem time236, current time 368, horizon 132\n", + "adding: mem time237, current time 368, horizon 131\n", + "adding: mem time238, current time 368, horizon 130\n", + "adding: mem time239, current time 368, horizon 129\n", + "adding: mem time240, current time 368, horizon 128\n", + "adding: mem time241, current time 368, horizon 127\n", + "adding: mem time242, current time 368, horizon 126\n", + "adding: mem time243, current time 368, horizon 125\n", + "adding: mem time244, current time 368, horizon 124\n", + "adding: mem time245, current time 368, horizon 123\n", + "adding: mem time246, current time 368, horizon 122\n", + "adding: mem time247, current time 368, horizon 121\n", + "adding: mem time248, current time 368, horizon 120\n", + "adding: mem time249, current time 368, horizon 119\n", + "adding: mem time250, current time 368, horizon 118\n", + "adding: mem time251, current time 368, horizon 117\n", + "adding: mem time252, current time 368, horizon 116\n", + "adding: mem time253, current time 368, horizon 115\n", + "adding: mem time254, current time 368, horizon 114\n", + "adding: mem time255, current time 368, horizon 113\n", + "adding: mem time256, current time 368, horizon 112\n", + "adding: mem time257, current time 368, horizon 111\n", + "adding: mem time258, current time 368, horizon 110\n", + "adding: mem time259, current time 368, horizon 109\n", + "adding: mem time260, current time 368, horizon 108\n", + "adding: mem time261, current time 368, horizon 107\n", + "adding: mem time262, current time 368, horizon 106\n", + "adding: mem time263, current time 368, horizon 105\n", + "adding: mem time264, current time 368, horizon 104\n", + "adding: mem time265, current time 368, horizon 103\n", + "adding: mem time266, current time 368, horizon 102\n", + "adding: mem time267, current time 368, horizon 101\n", + "adding: mem time268, current time 368, horizon 100\n", + "adding: mem time269, current time 368, horizon 99\n", + "adding: mem time270, current time 368, horizon 98\n", + "adding: mem time271, current time 368, horizon 97\n", + "adding: mem time272, current time 368, horizon 96\n", + "adding: mem time273, current time 368, horizon 95\n", + "adding: mem time274, current time 368, horizon 94\n", + "adding: mem time275, current time 368, horizon 93\n", + "adding: mem time276, current time 368, horizon 92\n", + "adding: mem time277, current time 368, horizon 91\n", + "adding: mem time278, current time 368, horizon 90\n", + "adding: mem time279, current time 368, horizon 89\n", + "adding: mem time280, current time 368, horizon 88\n", + "adding: mem time281, current time 368, horizon 87\n", + "adding: mem time282, current time 368, horizon 86\n", + "adding: mem time283, current time 368, horizon 85\n", + "adding: mem time284, current time 368, horizon 84\n", + "adding: mem time285, current time 368, horizon 83\n", + "adding: mem time286, current time 368, horizon 82\n", + "adding: mem time287, current time 368, horizon 81\n", + "adding: mem time288, current time 368, horizon 80\n", + "adding: mem time289, current time 368, horizon 79\n", + "adding: mem time290, current time 368, horizon 78\n", + "adding: mem time291, current time 368, horizon 77\n", + "adding: mem time292, current time 368, horizon 76\n", + "adding: mem time293, current time 368, horizon 75\n", + "adding: mem time294, current time 368, horizon 74\n", + "adding: mem time295, current time 368, horizon 73\n", + "adding: mem time296, current time 368, horizon 72\n", + "adding: mem time297, current time 368, horizon 71\n", + "adding: mem time298, current time 368, horizon 70\n", + "adding: mem time299, current time 368, horizon 69\n", + "adding: mem time300, current time 368, horizon 68\n", + "adding: mem time301, current time 368, horizon 67\n", + "adding: mem time302, current time 368, horizon 66\n", + "adding: mem time303, current time 368, horizon 65\n", + "adding: mem time304, current time 368, horizon 64\n", + "adding: mem time305, current time 368, horizon 63\n", + "adding: mem time306, current time 368, horizon 62\n", + "adding: mem time307, current time 368, horizon 61\n", + "adding: mem time308, current time 368, horizon 60\n", + "adding: mem time309, current time 368, horizon 59\n", + "adding: mem time310, current time 368, horizon 58\n", + "adding: mem time311, current time 368, horizon 57\n", + "adding: mem time312, current time 368, horizon 56\n", + "adding: mem time313, current time 368, horizon 55\n", + "adding: mem time314, current time 368, horizon 54\n", + "adding: mem time315, current time 368, horizon 53\n", + "adding: mem time316, current time 368, horizon 52\n", + "adding: mem time317, current time 368, horizon 51\n", + "adding: mem time318, current time 368, horizon 50\n", + "adding: mem time319, current time 368, horizon 49\n", + "adding: mem time320, current time 368, horizon 48\n", + "adding: mem time321, current time 368, horizon 47\n", + "adding: mem time322, current time 368, horizon 46\n", + "adding: mem time323, current time 368, horizon 45\n", + "adding: mem time324, current time 368, horizon 44\n", + "adding: mem time325, current time 368, horizon 43\n", + "adding: mem time326, current time 368, horizon 42\n", + "adding: mem time327, current time 368, horizon 41\n", + "adding: mem time328, current time 368, horizon 40\n", + "adding: mem time329, current time 368, horizon 39\n", + "adding: mem time330, current time 368, horizon 38\n", + "adding: mem time331, current time 368, horizon 37\n", + "adding: mem time332, current time 368, horizon 36\n", + "adding: mem time333, current time 368, horizon 35\n", + "adding: mem time334, current time 368, horizon 34\n", + "adding: mem time335, current time 368, horizon 33\n", + "adding: mem time336, current time 368, horizon 32\n", + "adding: mem time337, current time 368, horizon 31\n", + "adding: mem time338, current time 368, horizon 30\n", + "adding: mem time339, current time 368, horizon 29\n", + "adding: mem time340, current time 368, horizon 28\n", + "adding: mem time341, current time 368, horizon 27\n", + "adding: mem time342, current time 368, horizon 26\n", + "adding: mem time343, current time 368, horizon 25\n", + "adding: mem time344, current time 368, horizon 24\n", + "adding: mem time345, current time 368, horizon 23\n", + "adding: mem time346, current time 368, horizon 22\n", + "adding: mem time347, current time 368, horizon 21\n", + "adding: mem time348, current time 368, horizon 20\n", + "adding: mem time349, current time 368, horizon 19\n", + "adding: mem time350, current time 368, horizon 18\n", + "adding: mem time351, current time 368, horizon 17\n", + "adding: mem time352, current time 368, horizon 16\n", + "adding: mem time353, current time 368, horizon 15\n", + "adding: mem time354, current time 368, horizon 14\n", + "adding: mem time355, current time 368, horizon 13\n", + "adding: mem time356, current time 368, horizon 12\n", + "adding: mem time357, current time 368, horizon 11\n", + "adding: mem time358, current time 368, horizon 10\n", + "adding: mem time359, current time 368, horizon 9\n", + "adding: mem time360, current time 368, horizon 8\n", + "adding: mem time361, current time 368, horizon 7\n", + "adding: mem time362, current time 368, horizon 6\n", + "adding: mem time363, current time 368, horizon 5\n", + "adding: mem time364, current time 368, horizon 4\n", + "adding: mem time365, current time 368, horizon 3\n", + "adding: mem time366, current time 368, horizon 2\n", + "adding: mem time367, current time 368, horizon 1\n", + "adding: mem time200, current time 369, horizon 169\n", + "adding: mem time201, current time 369, horizon 168\n", + "adding: mem time202, current time 369, horizon 167\n", + "adding: mem time203, current time 369, horizon 166\n", + "adding: mem time204, current time 369, horizon 165\n", + "adding: mem time205, current time 369, horizon 164\n", + "adding: mem time206, current time 369, horizon 163\n", + "adding: mem time207, current time 369, horizon 162\n", + "adding: mem time208, current time 369, horizon 161\n", + "adding: mem time209, current time 369, horizon 160\n", + "adding: mem time210, current time 369, horizon 159\n", + "adding: mem time211, current time 369, horizon 158\n", + "adding: mem time212, current time 369, horizon 157\n", + "adding: mem time213, current time 369, horizon 156\n", + "adding: mem time214, current time 369, horizon 155\n", + "adding: mem time215, current time 369, horizon 154\n", + "adding: mem time216, current time 369, horizon 153\n", + "adding: mem time217, current time 369, horizon 152\n", + "adding: mem time218, current time 369, horizon 151\n", + "adding: mem time219, current time 369, horizon 150\n", + "adding: mem time220, current time 369, horizon 149\n", + "adding: mem time221, current time 369, horizon 148\n", + "adding: mem time222, current time 369, horizon 147\n", + "adding: mem time223, current time 369, horizon 146\n", + "adding: mem time224, current time 369, horizon 145\n", + "adding: mem time225, current time 369, horizon 144\n", + "adding: mem time226, current time 369, horizon 143\n", + "adding: mem time227, current time 369, horizon 142\n", + "adding: mem time228, current time 369, horizon 141\n", + "adding: mem time229, current time 369, horizon 140\n", + "adding: mem time230, current time 369, horizon 139\n", + "adding: mem time231, current time 369, horizon 138\n", + "adding: mem time232, current time 369, horizon 137\n", + "adding: mem time233, current time 369, horizon 136\n", + "adding: mem time234, current time 369, horizon 135\n", + "adding: mem time235, current time 369, horizon 134\n", + "adding: mem time236, current time 369, horizon 133\n", + "adding: mem time237, current time 369, horizon 132\n", + "adding: mem time238, current time 369, horizon 131\n", + "adding: mem time239, current time 369, horizon 130\n", + "adding: mem time240, current time 369, horizon 129\n", + "adding: mem time241, current time 369, horizon 128\n", + "adding: mem time242, current time 369, horizon 127\n", + "adding: mem time243, current time 369, horizon 126\n", + "adding: mem time244, current time 369, horizon 125\n", + "adding: mem time245, current time 369, horizon 124\n", + "adding: mem time246, current time 369, horizon 123\n", + "adding: mem time247, current time 369, horizon 122\n", + "adding: mem time248, current time 369, horizon 121\n", + "adding: mem time249, current time 369, horizon 120\n", + "adding: mem time250, current time 369, horizon 119\n", + "adding: mem time251, current time 369, horizon 118\n", + "adding: mem time252, current time 369, horizon 117\n", + "adding: mem time253, current time 369, horizon 116\n", + "adding: mem time254, current time 369, horizon 115\n", + "adding: mem time255, current time 369, horizon 114\n", + "adding: mem time256, current time 369, horizon 113\n", + "adding: mem time257, current time 369, horizon 112\n", + "adding: mem time258, current time 369, horizon 111\n", + "adding: mem time259, current time 369, horizon 110\n", + "adding: mem time260, current time 369, horizon 109\n", + "adding: mem time261, current time 369, horizon 108\n", + "adding: mem time262, current time 369, horizon 107\n", + "adding: mem time263, current time 369, horizon 106\n", + "adding: mem time264, current time 369, horizon 105\n", + "adding: mem time265, current time 369, horizon 104\n", + "adding: mem time266, current time 369, horizon 103\n", + "adding: mem time267, current time 369, horizon 102\n", + "adding: mem time268, current time 369, horizon 101\n", + "adding: mem time269, current time 369, horizon 100\n", + "adding: mem time270, current time 369, horizon 99\n", + "adding: mem time271, current time 369, horizon 98\n", + "adding: mem time272, current time 369, horizon 97\n", + "adding: mem time273, current time 369, horizon 96\n", + "adding: mem time274, current time 369, horizon 95\n", + "adding: mem time275, current time 369, horizon 94\n", + "adding: mem time276, current time 369, horizon 93\n", + "adding: mem time277, current time 369, horizon 92\n", + "adding: mem time278, current time 369, horizon 91\n", + "adding: mem time279, current time 369, horizon 90\n", + "adding: mem time280, current time 369, horizon 89\n", + "adding: mem time281, current time 369, horizon 88\n", + "adding: mem time282, current time 369, horizon 87\n", + "adding: mem time283, current time 369, horizon 86\n", + "adding: mem time284, current time 369, horizon 85\n", + "adding: mem time285, current time 369, horizon 84\n", + "adding: mem time286, current time 369, horizon 83\n", + "adding: mem time287, current time 369, horizon 82\n", + "adding: mem time288, current time 369, horizon 81\n", + "adding: mem time289, current time 369, horizon 80\n", + "adding: mem time290, current time 369, horizon 79\n", + "adding: mem time291, current time 369, horizon 78\n", + "adding: mem time292, current time 369, horizon 77\n", + "adding: mem time293, current time 369, horizon 76\n", + "adding: mem time294, current time 369, horizon 75\n", + "adding: mem time295, current time 369, horizon 74\n", + "adding: mem time296, current time 369, horizon 73\n", + "adding: mem time297, current time 369, horizon 72\n", + "adding: mem time298, current time 369, horizon 71\n", + "adding: mem time299, current time 369, horizon 70\n", + "adding: mem time300, current time 369, horizon 69\n", + "adding: mem time301, current time 369, horizon 68\n", + "adding: mem time302, current time 369, horizon 67\n", + "adding: mem time303, current time 369, horizon 66\n", + "adding: mem time304, current time 369, horizon 65\n", + "adding: mem time305, current time 369, horizon 64\n", + "adding: mem time306, current time 369, horizon 63\n", + "adding: mem time307, current time 369, horizon 62\n", + "adding: mem time308, current time 369, horizon 61\n", + "adding: mem time309, current time 369, horizon 60\n", + "adding: mem time310, current time 369, horizon 59\n", + "adding: mem time311, current time 369, horizon 58\n", + "adding: mem time312, current time 369, horizon 57\n", + "adding: mem time313, current time 369, horizon 56\n", + "adding: mem time314, current time 369, horizon 55\n", + "adding: mem time315, current time 369, horizon 54\n", + "adding: mem time316, current time 369, horizon 53\n", + "adding: mem time317, current time 369, horizon 52\n", + "adding: mem time318, current time 369, horizon 51\n", + "adding: mem time319, current time 369, horizon 50\n", + "adding: mem time320, current time 369, horizon 49\n", + "adding: mem time321, current time 369, horizon 48\n", + "adding: mem time322, current time 369, horizon 47\n", + "adding: mem time323, current time 369, horizon 46\n", + "adding: mem time324, current time 369, horizon 45\n", + "adding: mem time325, current time 369, horizon 44\n", + "adding: mem time326, current time 369, horizon 43\n", + "adding: mem time327, current time 369, horizon 42\n", + "adding: mem time328, current time 369, horizon 41\n", + "adding: mem time329, current time 369, horizon 40\n", + "adding: mem time330, current time 369, horizon 39\n", + "adding: mem time331, current time 369, horizon 38\n", + "adding: mem time332, current time 369, horizon 37\n", + "adding: mem time333, current time 369, horizon 36\n", + "adding: mem time334, current time 369, horizon 35\n", + "adding: mem time335, current time 369, horizon 34\n", + "adding: mem time336, current time 369, horizon 33\n", + "adding: mem time337, current time 369, horizon 32\n", + "adding: mem time338, current time 369, horizon 31\n", + "adding: mem time339, current time 369, horizon 30\n", + "adding: mem time340, current time 369, horizon 29\n", + "adding: mem time341, current time 369, horizon 28\n", + "adding: mem time342, current time 369, horizon 27\n", + "adding: mem time343, current time 369, horizon 26\n", + "adding: mem time344, current time 369, horizon 25\n", + "adding: mem time345, current time 369, horizon 24\n", + "adding: mem time346, current time 369, horizon 23\n", + "adding: mem time347, current time 369, horizon 22\n", + "adding: mem time348, current time 369, horizon 21\n", + "adding: mem time349, current time 369, horizon 20\n", + "adding: mem time350, current time 369, horizon 19\n", + "adding: mem time351, current time 369, horizon 18\n", + "adding: mem time352, current time 369, horizon 17\n", + "adding: mem time353, current time 369, horizon 16\n", + "adding: mem time354, current time 369, horizon 15\n", + "adding: mem time355, current time 369, horizon 14\n", + "adding: mem time356, current time 369, horizon 13\n", + "adding: mem time357, current time 369, horizon 12\n", + "adding: mem time358, current time 369, horizon 11\n", + "adding: mem time359, current time 369, horizon 10\n", + "adding: mem time360, current time 369, horizon 9\n", + "adding: mem time361, current time 369, horizon 8\n", + "adding: mem time362, current time 369, horizon 7\n", + "adding: mem time363, current time 369, horizon 6\n", + "adding: mem time364, current time 369, horizon 5\n", + "adding: mem time365, current time 369, horizon 4\n", + "adding: mem time366, current time 369, horizon 3\n", + "adding: mem time367, current time 369, horizon 2\n", + "adding: mem time368, current time 369, horizon 1\n", + "adding: mem time200, current time 370, horizon 170\n", + "adding: mem time201, current time 370, horizon 169\n", + "adding: mem time202, current time 370, horizon 168\n", + "adding: mem time203, current time 370, horizon 167\n", + "adding: mem time204, current time 370, horizon 166\n", + "adding: mem time205, current time 370, horizon 165\n", + "adding: mem time206, current time 370, horizon 164\n", + "adding: mem time207, current time 370, horizon 163\n", + "adding: mem time208, current time 370, horizon 162\n", + "adding: mem time209, current time 370, horizon 161\n", + "adding: mem time210, current time 370, horizon 160\n", + "adding: mem time211, current time 370, horizon 159\n", + "adding: mem time212, current time 370, horizon 158\n", + "adding: mem time213, current time 370, horizon 157\n", + "adding: mem time214, current time 370, horizon 156\n", + "adding: mem time215, current time 370, horizon 155\n", + "adding: mem time216, current time 370, horizon 154\n", + "adding: mem time217, current time 370, horizon 153\n", + "adding: mem time218, current time 370, horizon 152\n", + "adding: mem time219, current time 370, horizon 151\n", + "adding: mem time220, current time 370, horizon 150\n", + "adding: mem time221, current time 370, horizon 149\n", + "adding: mem time222, current time 370, horizon 148\n", + "adding: mem time223, current time 370, horizon 147\n", + "adding: mem time224, current time 370, horizon 146\n", + "adding: mem time225, current time 370, horizon 145\n", + "adding: mem time226, current time 370, horizon 144\n", + "adding: mem time227, current time 370, horizon 143\n", + "adding: mem time228, current time 370, horizon 142\n", + "adding: mem time229, current time 370, horizon 141\n", + "adding: mem time230, current time 370, horizon 140\n", + "adding: mem time231, current time 370, horizon 139\n", + "adding: mem time232, current time 370, horizon 138\n", + "adding: mem time233, current time 370, horizon 137\n", + "adding: mem time234, current time 370, horizon 136\n", + "adding: mem time235, current time 370, horizon 135\n", + "adding: mem time236, current time 370, horizon 134\n", + "adding: mem time237, current time 370, horizon 133\n", + "adding: mem time238, current time 370, horizon 132\n", + "adding: mem time239, current time 370, horizon 131\n", + "adding: mem time240, current time 370, horizon 130\n", + "adding: mem time241, current time 370, horizon 129\n", + "adding: mem time242, current time 370, horizon 128\n", + "adding: mem time243, current time 370, horizon 127\n", + "adding: mem time244, current time 370, horizon 126\n", + "adding: mem time245, current time 370, horizon 125\n", + "adding: mem time246, current time 370, horizon 124\n", + "adding: mem time247, current time 370, horizon 123\n", + "adding: mem time248, current time 370, horizon 122\n", + "adding: mem time249, current time 370, horizon 121\n", + "adding: mem time250, current time 370, horizon 120\n", + "adding: mem time251, current time 370, horizon 119\n", + "adding: mem time252, current time 370, horizon 118\n", + "adding: mem time253, current time 370, horizon 117\n", + "adding: mem time254, current time 370, horizon 116\n", + "adding: mem time255, current time 370, horizon 115\n", + "adding: mem time256, current time 370, horizon 114\n", + "adding: mem time257, current time 370, horizon 113\n", + "adding: mem time258, current time 370, horizon 112\n", + "adding: mem time259, current time 370, horizon 111\n", + "adding: mem time260, current time 370, horizon 110\n", + "adding: mem time261, current time 370, horizon 109\n", + "adding: mem time262, current time 370, horizon 108\n", + "adding: mem time263, current time 370, horizon 107\n", + "adding: mem time264, current time 370, horizon 106\n", + "adding: mem time265, current time 370, horizon 105\n", + "adding: mem time266, current time 370, horizon 104\n", + "adding: mem time267, current time 370, horizon 103\n", + "adding: mem time268, current time 370, horizon 102\n", + "adding: mem time269, current time 370, horizon 101\n", + "adding: mem time270, current time 370, horizon 100\n", + "adding: mem time271, current time 370, horizon 99\n", + "adding: mem time272, current time 370, horizon 98\n", + "adding: mem time273, current time 370, horizon 97\n", + "adding: mem time274, current time 370, horizon 96\n", + "adding: mem time275, current time 370, horizon 95\n", + "adding: mem time276, current time 370, horizon 94\n", + "adding: mem time277, current time 370, horizon 93\n", + "adding: mem time278, current time 370, horizon 92\n", + "adding: mem time279, current time 370, horizon 91\n", + "adding: mem time280, current time 370, horizon 90\n", + "adding: mem time281, current time 370, horizon 89\n", + "adding: mem time282, current time 370, horizon 88\n", + "adding: mem time283, current time 370, horizon 87\n", + "adding: mem time284, current time 370, horizon 86\n", + "adding: mem time285, current time 370, horizon 85\n", + "adding: mem time286, current time 370, horizon 84\n", + "adding: mem time287, current time 370, horizon 83\n", + "adding: mem time288, current time 370, horizon 82\n", + "adding: mem time289, current time 370, horizon 81\n", + "adding: mem time290, current time 370, horizon 80\n", + "adding: mem time291, current time 370, horizon 79\n", + "adding: mem time292, current time 370, horizon 78\n", + "adding: mem time293, current time 370, horizon 77\n", + "adding: mem time294, current time 370, horizon 76\n", + "adding: mem time295, current time 370, horizon 75\n", + "adding: mem time296, current time 370, horizon 74\n", + "adding: mem time297, current time 370, horizon 73\n", + "adding: mem time298, current time 370, horizon 72\n", + "adding: mem time299, current time 370, horizon 71\n", + "adding: mem time300, current time 370, horizon 70\n", + "adding: mem time301, current time 370, horizon 69\n", + "adding: mem time302, current time 370, horizon 68\n", + "adding: mem time303, current time 370, horizon 67\n", + "adding: mem time304, current time 370, horizon 66\n", + "adding: mem time305, current time 370, horizon 65\n", + "adding: mem time306, current time 370, horizon 64\n", + "adding: mem time307, current time 370, horizon 63\n", + "adding: mem time308, current time 370, horizon 62\n", + "adding: mem time309, current time 370, horizon 61\n", + "adding: mem time310, current time 370, horizon 60\n", + "adding: mem time311, current time 370, horizon 59\n", + "adding: mem time312, current time 370, horizon 58\n", + "adding: mem time313, current time 370, horizon 57\n", + "adding: mem time314, current time 370, horizon 56\n", + "adding: mem time315, current time 370, horizon 55\n", + "adding: mem time316, current time 370, horizon 54\n", + "adding: mem time317, current time 370, horizon 53\n", + "adding: mem time318, current time 370, horizon 52\n", + "adding: mem time319, current time 370, horizon 51\n", + "adding: mem time320, current time 370, horizon 50\n", + "adding: mem time321, current time 370, horizon 49\n", + "adding: mem time322, current time 370, horizon 48\n", + "adding: mem time323, current time 370, horizon 47\n", + "adding: mem time324, current time 370, horizon 46\n", + "adding: mem time325, current time 370, horizon 45\n", + "adding: mem time326, current time 370, horizon 44\n", + "adding: mem time327, current time 370, horizon 43\n", + "adding: mem time328, current time 370, horizon 42\n", + "adding: mem time329, current time 370, horizon 41\n", + "adding: mem time330, current time 370, horizon 40\n", + "adding: mem time331, current time 370, horizon 39\n", + "adding: mem time332, current time 370, horizon 38\n", + "adding: mem time333, current time 370, horizon 37\n", + "adding: mem time334, current time 370, horizon 36\n", + "adding: mem time335, current time 370, horizon 35\n", + "adding: mem time336, current time 370, horizon 34\n", + "adding: mem time337, current time 370, horizon 33\n", + "adding: mem time338, current time 370, horizon 32\n", + "adding: mem time339, current time 370, horizon 31\n", + "adding: mem time340, current time 370, horizon 30\n", + "adding: mem time341, current time 370, horizon 29\n", + "adding: mem time342, current time 370, horizon 28\n", + "adding: mem time343, current time 370, horizon 27\n", + "adding: mem time344, current time 370, horizon 26\n", + "adding: mem time345, current time 370, horizon 25\n", + "adding: mem time346, current time 370, horizon 24\n", + "adding: mem time347, current time 370, horizon 23\n", + "adding: mem time348, current time 370, horizon 22\n", + "adding: mem time349, current time 370, horizon 21\n", + "adding: mem time350, current time 370, horizon 20\n", + "adding: mem time351, current time 370, horizon 19\n", + "adding: mem time352, current time 370, horizon 18\n", + "adding: mem time353, current time 370, horizon 17\n", + "adding: mem time354, current time 370, horizon 16\n", + "adding: mem time355, current time 370, horizon 15\n", + "adding: mem time356, current time 370, horizon 14\n", + "adding: mem time357, current time 370, horizon 13\n", + "adding: mem time358, current time 370, horizon 12\n", + "adding: mem time359, current time 370, horizon 11\n", + "adding: mem time360, current time 370, horizon 10\n", + "adding: mem time361, current time 370, horizon 9\n", + "adding: mem time362, current time 370, horizon 8\n", + "adding: mem time363, current time 370, horizon 7\n", + "adding: mem time364, current time 370, horizon 6\n", + "adding: mem time365, current time 370, horizon 5\n", + "adding: mem time366, current time 370, horizon 4\n", + "adding: mem time367, current time 370, horizon 3\n", + "adding: mem time368, current time 370, horizon 2\n", + "adding: mem time369, current time 370, horizon 1\n", + "adding: mem time200, current time 371, horizon 171\n", + "adding: mem time201, current time 371, horizon 170\n", + "adding: mem time202, current time 371, horizon 169\n", + "adding: mem time203, current time 371, horizon 168\n", + "adding: mem time204, current time 371, horizon 167\n", + "adding: mem time205, current time 371, horizon 166\n", + "adding: mem time206, current time 371, horizon 165\n", + "adding: mem time207, current time 371, horizon 164\n", + "adding: mem time208, current time 371, horizon 163\n", + "adding: mem time209, current time 371, horizon 162\n", + "adding: mem time210, current time 371, horizon 161\n", + "adding: mem time211, current time 371, horizon 160\n", + "adding: mem time212, current time 371, horizon 159\n", + "adding: mem time213, current time 371, horizon 158\n", + "adding: mem time214, current time 371, horizon 157\n", + "adding: mem time215, current time 371, horizon 156\n", + "adding: mem time216, current time 371, horizon 155\n", + "adding: mem time217, current time 371, horizon 154\n", + "adding: mem time218, current time 371, horizon 153\n", + "adding: mem time219, current time 371, horizon 152\n", + "adding: mem time220, current time 371, horizon 151\n", + "adding: mem time221, current time 371, horizon 150\n", + "adding: mem time222, current time 371, horizon 149\n", + "adding: mem time223, current time 371, horizon 148\n", + "adding: mem time224, current time 371, horizon 147\n", + "adding: mem time225, current time 371, horizon 146\n", + "adding: mem time226, current time 371, horizon 145\n", + "adding: mem time227, current time 371, horizon 144\n", + "adding: mem time228, current time 371, horizon 143\n", + "adding: mem time229, current time 371, horizon 142\n", + "adding: mem time230, current time 371, horizon 141\n", + "adding: mem time231, current time 371, horizon 140\n", + "adding: mem time232, current time 371, horizon 139\n", + "adding: mem time233, current time 371, horizon 138\n", + "adding: mem time234, current time 371, horizon 137\n", + "adding: mem time235, current time 371, horizon 136\n", + "adding: mem time236, current time 371, horizon 135\n", + "adding: mem time237, current time 371, horizon 134\n", + "adding: mem time238, current time 371, horizon 133\n", + "adding: mem time239, current time 371, horizon 132\n", + "adding: mem time240, current time 371, horizon 131\n", + "adding: mem time241, current time 371, horizon 130\n", + "adding: mem time242, current time 371, horizon 129\n", + "adding: mem time243, current time 371, horizon 128\n", + "adding: mem time244, current time 371, horizon 127\n", + "adding: mem time245, current time 371, horizon 126\n", + "adding: mem time246, current time 371, horizon 125\n", + "adding: mem time247, current time 371, horizon 124\n", + "adding: mem time248, current time 371, horizon 123\n", + "adding: mem time249, current time 371, horizon 122\n", + "adding: mem time250, current time 371, horizon 121\n", + "adding: mem time251, current time 371, horizon 120\n", + "adding: mem time252, current time 371, horizon 119\n", + "adding: mem time253, current time 371, horizon 118\n", + "adding: mem time254, current time 371, horizon 117\n", + "adding: mem time255, current time 371, horizon 116\n", + "adding: mem time256, current time 371, horizon 115\n", + "adding: mem time257, current time 371, horizon 114\n", + "adding: mem time258, current time 371, horizon 113\n", + "adding: mem time259, current time 371, horizon 112\n", + "adding: mem time260, current time 371, horizon 111\n", + "adding: mem time261, current time 371, horizon 110\n", + "adding: mem time262, current time 371, horizon 109\n", + "adding: mem time263, current time 371, horizon 108\n", + "adding: mem time264, current time 371, horizon 107\n", + "adding: mem time265, current time 371, horizon 106\n", + "adding: mem time266, current time 371, horizon 105\n", + "adding: mem time267, current time 371, horizon 104\n", + "adding: mem time268, current time 371, horizon 103\n", + "adding: mem time269, current time 371, horizon 102\n", + "adding: mem time270, current time 371, horizon 101\n", + "adding: mem time271, current time 371, horizon 100\n", + "adding: mem time272, current time 371, horizon 99\n", + "adding: mem time273, current time 371, horizon 98\n", + "adding: mem time274, current time 371, horizon 97\n", + "adding: mem time275, current time 371, horizon 96\n", + "adding: mem time276, current time 371, horizon 95\n", + "adding: mem time277, current time 371, horizon 94\n", + "adding: mem time278, current time 371, horizon 93\n", + "adding: mem time279, current time 371, horizon 92\n", + "adding: mem time280, current time 371, horizon 91\n", + "adding: mem time281, current time 371, horizon 90\n", + "adding: mem time282, current time 371, horizon 89\n", + "adding: mem time283, current time 371, horizon 88\n", + "adding: mem time284, current time 371, horizon 87\n", + "adding: mem time285, current time 371, horizon 86\n", + "adding: mem time286, current time 371, horizon 85\n", + "adding: mem time287, current time 371, horizon 84\n", + "adding: mem time288, current time 371, horizon 83\n", + "adding: mem time289, current time 371, horizon 82\n", + "adding: mem time290, current time 371, horizon 81\n", + "adding: mem time291, current time 371, horizon 80\n", + "adding: mem time292, current time 371, horizon 79\n", + "adding: mem time293, current time 371, horizon 78\n", + "adding: mem time294, current time 371, horizon 77\n", + "adding: mem time295, current time 371, horizon 76\n", + "adding: mem time296, current time 371, horizon 75\n", + "adding: mem time297, current time 371, horizon 74\n", + "adding: mem time298, current time 371, horizon 73\n", + "adding: mem time299, current time 371, horizon 72\n", + "adding: mem time300, current time 371, horizon 71\n", + "adding: mem time301, current time 371, horizon 70\n", + "adding: mem time302, current time 371, horizon 69\n", + "adding: mem time303, current time 371, horizon 68\n", + "adding: mem time304, current time 371, horizon 67\n", + "adding: mem time305, current time 371, horizon 66\n", + "adding: mem time306, current time 371, horizon 65\n", + "adding: mem time307, current time 371, horizon 64\n", + "adding: mem time308, current time 371, horizon 63\n", + "adding: mem time309, current time 371, horizon 62\n", + "adding: mem time310, current time 371, horizon 61\n", + "adding: mem time311, current time 371, horizon 60\n", + "adding: mem time312, current time 371, horizon 59\n", + "adding: mem time313, current time 371, horizon 58\n", + "adding: mem time314, current time 371, horizon 57\n", + "adding: mem time315, current time 371, horizon 56\n", + "adding: mem time316, current time 371, horizon 55\n", + "adding: mem time317, current time 371, horizon 54\n", + "adding: mem time318, current time 371, horizon 53\n", + "adding: mem time319, current time 371, horizon 52\n", + "adding: mem time320, current time 371, horizon 51\n", + "adding: mem time321, current time 371, horizon 50\n", + "adding: mem time322, current time 371, horizon 49\n", + "adding: mem time323, current time 371, horizon 48\n", + "adding: mem time324, current time 371, horizon 47\n", + "adding: mem time325, current time 371, horizon 46\n", + "adding: mem time326, current time 371, horizon 45\n", + "adding: mem time327, current time 371, horizon 44\n", + "adding: mem time328, current time 371, horizon 43\n", + "adding: mem time329, current time 371, horizon 42\n", + "adding: mem time330, current time 371, horizon 41\n", + "adding: mem time331, current time 371, horizon 40\n", + "adding: mem time332, current time 371, horizon 39\n", + "adding: mem time333, current time 371, horizon 38\n", + "adding: mem time334, current time 371, horizon 37\n", + "adding: mem time335, current time 371, horizon 36\n", + "adding: mem time336, current time 371, horizon 35\n", + "adding: mem time337, current time 371, horizon 34\n", + "adding: mem time338, current time 371, horizon 33\n", + "adding: mem time339, current time 371, horizon 32\n", + "adding: mem time340, current time 371, horizon 31\n", + "adding: mem time341, current time 371, horizon 30\n", + "adding: mem time342, current time 371, horizon 29\n", + "adding: mem time343, current time 371, horizon 28\n", + "adding: mem time344, current time 371, horizon 27\n", + "adding: mem time345, current time 371, horizon 26\n", + "adding: mem time346, current time 371, horizon 25\n", + "adding: mem time347, current time 371, horizon 24\n", + "adding: mem time348, current time 371, horizon 23\n", + "adding: mem time349, current time 371, horizon 22\n", + "adding: mem time350, current time 371, horizon 21\n", + "adding: mem time351, current time 371, horizon 20\n", + "adding: mem time352, current time 371, horizon 19\n", + "adding: mem time353, current time 371, horizon 18\n", + "adding: mem time354, current time 371, horizon 17\n", + "adding: mem time355, current time 371, horizon 16\n", + "adding: mem time356, current time 371, horizon 15\n", + "adding: mem time357, current time 371, horizon 14\n", + "adding: mem time358, current time 371, horizon 13\n", + "adding: mem time359, current time 371, horizon 12\n", + "adding: mem time360, current time 371, horizon 11\n", + "adding: mem time361, current time 371, horizon 10\n", + "adding: mem time362, current time 371, horizon 9\n", + "adding: mem time363, current time 371, horizon 8\n", + "adding: mem time364, current time 371, horizon 7\n", + "adding: mem time365, current time 371, horizon 6\n", + "adding: mem time366, current time 371, horizon 5\n", + "adding: mem time367, current time 371, horizon 4\n", + "adding: mem time368, current time 371, horizon 3\n", + "adding: mem time369, current time 371, horizon 2\n", + "adding: mem time370, current time 371, horizon 1\n", + "adding: mem time200, current time 372, horizon 172\n", + "adding: mem time201, current time 372, horizon 171\n", + "adding: mem time202, current time 372, horizon 170\n", + "adding: mem time203, current time 372, horizon 169\n", + "adding: mem time204, current time 372, horizon 168\n", + "adding: mem time205, current time 372, horizon 167\n", + "adding: mem time206, current time 372, horizon 166\n", + "adding: mem time207, current time 372, horizon 165\n", + "adding: mem time208, current time 372, horizon 164\n", + "adding: mem time209, current time 372, horizon 163\n", + "adding: mem time210, current time 372, horizon 162\n", + "adding: mem time211, current time 372, horizon 161\n", + "adding: mem time212, current time 372, horizon 160\n", + "adding: mem time213, current time 372, horizon 159\n", + "adding: mem time214, current time 372, horizon 158\n", + "adding: mem time215, current time 372, horizon 157\n", + "adding: mem time216, current time 372, horizon 156\n", + "adding: mem time217, current time 372, horizon 155\n", + "adding: mem time218, current time 372, horizon 154\n", + "adding: mem time219, current time 372, horizon 153\n", + "adding: mem time220, current time 372, horizon 152\n", + "adding: mem time221, current time 372, horizon 151\n", + "adding: mem time222, current time 372, horizon 150\n", + "adding: mem time223, current time 372, horizon 149\n", + "adding: mem time224, current time 372, horizon 148\n", + "adding: mem time225, current time 372, horizon 147\n", + "adding: mem time226, current time 372, horizon 146\n", + "adding: mem time227, current time 372, horizon 145\n", + "adding: mem time228, current time 372, horizon 144\n", + "adding: mem time229, current time 372, horizon 143\n", + "adding: mem time230, current time 372, horizon 142\n", + "adding: mem time231, current time 372, horizon 141\n", + "adding: mem time232, current time 372, horizon 140\n", + "adding: mem time233, current time 372, horizon 139\n", + "adding: mem time234, current time 372, horizon 138\n", + "adding: mem time235, current time 372, horizon 137\n", + "adding: mem time236, current time 372, horizon 136\n", + "adding: mem time237, current time 372, horizon 135\n", + "adding: mem time238, current time 372, horizon 134\n", + "adding: mem time239, current time 372, horizon 133\n", + "adding: mem time240, current time 372, horizon 132\n", + "adding: mem time241, current time 372, horizon 131\n", + "adding: mem time242, current time 372, horizon 130\n", + "adding: mem time243, current time 372, horizon 129\n", + "adding: mem time244, current time 372, horizon 128\n", + "adding: mem time245, current time 372, horizon 127\n", + "adding: mem time246, current time 372, horizon 126\n", + "adding: mem time247, current time 372, horizon 125\n", + "adding: mem time248, current time 372, horizon 124\n", + "adding: mem time249, current time 372, horizon 123\n", + "adding: mem time250, current time 372, horizon 122\n", + "adding: mem time251, current time 372, horizon 121\n", + "adding: mem time252, current time 372, horizon 120\n", + "adding: mem time253, current time 372, horizon 119\n", + "adding: mem time254, current time 372, horizon 118\n", + "adding: mem time255, current time 372, horizon 117\n", + "adding: mem time256, current time 372, horizon 116\n", + "adding: mem time257, current time 372, horizon 115\n", + "adding: mem time258, current time 372, horizon 114\n", + "adding: mem time259, current time 372, horizon 113\n", + "adding: mem time260, current time 372, horizon 112\n", + "adding: mem time261, current time 372, horizon 111\n", + "adding: mem time262, current time 372, horizon 110\n", + "adding: mem time263, current time 372, horizon 109\n", + "adding: mem time264, current time 372, horizon 108\n", + "adding: mem time265, current time 372, horizon 107\n", + "adding: mem time266, current time 372, horizon 106\n", + "adding: mem time267, current time 372, horizon 105\n", + "adding: mem time268, current time 372, horizon 104\n", + "adding: mem time269, current time 372, horizon 103\n", + "adding: mem time270, current time 372, horizon 102\n", + "adding: mem time271, current time 372, horizon 101\n", + "adding: mem time272, current time 372, horizon 100\n", + "adding: mem time273, current time 372, horizon 99\n", + "adding: mem time274, current time 372, horizon 98\n", + "adding: mem time275, current time 372, horizon 97\n", + "adding: mem time276, current time 372, horizon 96\n", + "adding: mem time277, current time 372, horizon 95\n", + "adding: mem time278, current time 372, horizon 94\n", + "adding: mem time279, current time 372, horizon 93\n", + "adding: mem time280, current time 372, horizon 92\n", + "adding: mem time281, current time 372, horizon 91\n", + "adding: mem time282, current time 372, horizon 90\n", + "adding: mem time283, current time 372, horizon 89\n", + "adding: mem time284, current time 372, horizon 88\n", + "adding: mem time285, current time 372, horizon 87\n", + "adding: mem time286, current time 372, horizon 86\n", + "adding: mem time287, current time 372, horizon 85\n", + "adding: mem time288, current time 372, horizon 84\n", + "adding: mem time289, current time 372, horizon 83\n", + "adding: mem time290, current time 372, horizon 82\n", + "adding: mem time291, current time 372, horizon 81\n", + "adding: mem time292, current time 372, horizon 80\n", + "adding: mem time293, current time 372, horizon 79\n", + "adding: mem time294, current time 372, horizon 78\n", + "adding: mem time295, current time 372, horizon 77\n", + "adding: mem time296, current time 372, horizon 76\n", + "adding: mem time297, current time 372, horizon 75\n", + "adding: mem time298, current time 372, horizon 74\n", + "adding: mem time299, current time 372, horizon 73\n", + "adding: mem time300, current time 372, horizon 72\n", + "adding: mem time301, current time 372, horizon 71\n", + "adding: mem time302, current time 372, horizon 70\n", + "adding: mem time303, current time 372, horizon 69\n", + "adding: mem time304, current time 372, horizon 68\n", + "adding: mem time305, current time 372, horizon 67\n", + "adding: mem time306, current time 372, horizon 66\n", + "adding: mem time307, current time 372, horizon 65\n", + "adding: mem time308, current time 372, horizon 64\n", + "adding: mem time309, current time 372, horizon 63\n", + "adding: mem time310, current time 372, horizon 62\n", + "adding: mem time311, current time 372, horizon 61\n", + "adding: mem time312, current time 372, horizon 60\n", + "adding: mem time313, current time 372, horizon 59\n", + "adding: mem time314, current time 372, horizon 58\n", + "adding: mem time315, current time 372, horizon 57\n", + "adding: mem time316, current time 372, horizon 56\n", + "adding: mem time317, current time 372, horizon 55\n", + "adding: mem time318, current time 372, horizon 54\n", + "adding: mem time319, current time 372, horizon 53\n", + "adding: mem time320, current time 372, horizon 52\n", + "adding: mem time321, current time 372, horizon 51\n", + "adding: mem time322, current time 372, horizon 50\n", + "adding: mem time323, current time 372, horizon 49\n", + "adding: mem time324, current time 372, horizon 48\n", + "adding: mem time325, current time 372, horizon 47\n", + "adding: mem time326, current time 372, horizon 46\n", + "adding: mem time327, current time 372, horizon 45\n", + "adding: mem time328, current time 372, horizon 44\n", + "adding: mem time329, current time 372, horizon 43\n", + "adding: mem time330, current time 372, horizon 42\n", + "adding: mem time331, current time 372, horizon 41\n", + "adding: mem time332, current time 372, horizon 40\n", + "adding: mem time333, current time 372, horizon 39\n", + "adding: mem time334, current time 372, horizon 38\n", + "adding: mem time335, current time 372, horizon 37\n", + "adding: mem time336, current time 372, horizon 36\n", + "adding: mem time337, current time 372, horizon 35\n", + "adding: mem time338, current time 372, horizon 34\n", + "adding: mem time339, current time 372, horizon 33\n", + "adding: mem time340, current time 372, horizon 32\n", + "adding: mem time341, current time 372, horizon 31\n", + "adding: mem time342, current time 372, horizon 30\n", + "adding: mem time343, current time 372, horizon 29\n", + "adding: mem time344, current time 372, horizon 28\n", + "adding: mem time345, current time 372, horizon 27\n", + "adding: mem time346, current time 372, horizon 26\n", + "adding: mem time347, current time 372, horizon 25\n", + "adding: mem time348, current time 372, horizon 24\n", + "adding: mem time349, current time 372, horizon 23\n", + "adding: mem time350, current time 372, horizon 22\n", + "adding: mem time351, current time 372, horizon 21\n", + "adding: mem time352, current time 372, horizon 20\n", + "adding: mem time353, current time 372, horizon 19\n", + "adding: mem time354, current time 372, horizon 18\n", + "adding: mem time355, current time 372, horizon 17\n", + "adding: mem time356, current time 372, horizon 16\n", + "adding: mem time357, current time 372, horizon 15\n", + "adding: mem time358, current time 372, horizon 14\n", + "adding: mem time359, current time 372, horizon 13\n", + "adding: mem time360, current time 372, horizon 12\n", + "adding: mem time361, current time 372, horizon 11\n", + "adding: mem time362, current time 372, horizon 10\n", + "adding: mem time363, current time 372, horizon 9\n", + "adding: mem time364, current time 372, horizon 8\n", + "adding: mem time365, current time 372, horizon 7\n", + "adding: mem time366, current time 372, horizon 6\n", + "adding: mem time367, current time 372, horizon 5\n", + "adding: mem time368, current time 372, horizon 4\n", + "adding: mem time369, current time 372, horizon 3\n", + "adding: mem time370, current time 372, horizon 2\n", + "adding: mem time371, current time 372, horizon 1\n", + "adding: mem time200, current time 373, horizon 173\n", + "adding: mem time201, current time 373, horizon 172\n", + "adding: mem time202, current time 373, horizon 171\n", + "adding: mem time203, current time 373, horizon 170\n", + "adding: mem time204, current time 373, horizon 169\n", + "adding: mem time205, current time 373, horizon 168\n", + "adding: mem time206, current time 373, horizon 167\n", + "adding: mem time207, current time 373, horizon 166\n", + "adding: mem time208, current time 373, horizon 165\n", + "adding: mem time209, current time 373, horizon 164\n", + "adding: mem time210, current time 373, horizon 163\n", + "adding: mem time211, current time 373, horizon 162\n", + "adding: mem time212, current time 373, horizon 161\n", + "adding: mem time213, current time 373, horizon 160\n", + "adding: mem time214, current time 373, horizon 159\n", + "adding: mem time215, current time 373, horizon 158\n", + "adding: mem time216, current time 373, horizon 157\n", + "adding: mem time217, current time 373, horizon 156\n", + "adding: mem time218, current time 373, horizon 155\n", + "adding: mem time219, current time 373, horizon 154\n", + "adding: mem time220, current time 373, horizon 153\n", + "adding: mem time221, current time 373, horizon 152\n", + "adding: mem time222, current time 373, horizon 151\n", + "adding: mem time223, current time 373, horizon 150\n", + "adding: mem time224, current time 373, horizon 149\n", + "adding: mem time225, current time 373, horizon 148\n", + "adding: mem time226, current time 373, horizon 147\n", + "adding: mem time227, current time 373, horizon 146\n", + "adding: mem time228, current time 373, horizon 145\n", + "adding: mem time229, current time 373, horizon 144\n", + "adding: mem time230, current time 373, horizon 143\n", + "adding: mem time231, current time 373, horizon 142\n", + "adding: mem time232, current time 373, horizon 141\n", + "adding: mem time233, current time 373, horizon 140\n", + "adding: mem time234, current time 373, horizon 139\n", + "adding: mem time235, current time 373, horizon 138\n", + "adding: mem time236, current time 373, horizon 137\n", + "adding: mem time237, current time 373, horizon 136\n", + "adding: mem time238, current time 373, horizon 135\n", + "adding: mem time239, current time 373, horizon 134\n", + "adding: mem time240, current time 373, horizon 133\n", + "adding: mem time241, current time 373, horizon 132\n", + "adding: mem time242, current time 373, horizon 131\n", + "adding: mem time243, current time 373, horizon 130\n", + "adding: mem time244, current time 373, horizon 129\n", + "adding: mem time245, current time 373, horizon 128\n", + "adding: mem time246, current time 373, horizon 127\n", + "adding: mem time247, current time 373, horizon 126\n", + "adding: mem time248, current time 373, horizon 125\n", + "adding: mem time249, current time 373, horizon 124\n", + "adding: mem time250, current time 373, horizon 123\n", + "adding: mem time251, current time 373, horizon 122\n", + "adding: mem time252, current time 373, horizon 121\n", + "adding: mem time253, current time 373, horizon 120\n", + "adding: mem time254, current time 373, horizon 119\n", + "adding: mem time255, current time 373, horizon 118\n", + "adding: mem time256, current time 373, horizon 117\n", + "adding: mem time257, current time 373, horizon 116\n", + "adding: mem time258, current time 373, horizon 115\n", + "adding: mem time259, current time 373, horizon 114\n", + "adding: mem time260, current time 373, horizon 113\n", + "adding: mem time261, current time 373, horizon 112\n", + "adding: mem time262, current time 373, horizon 111\n", + "adding: mem time263, current time 373, horizon 110\n", + "adding: mem time264, current time 373, horizon 109\n", + "adding: mem time265, current time 373, horizon 108\n", + "adding: mem time266, current time 373, horizon 107\n", + "adding: mem time267, current time 373, horizon 106\n", + "adding: mem time268, current time 373, horizon 105\n", + "adding: mem time269, current time 373, horizon 104\n", + "adding: mem time270, current time 373, horizon 103\n", + "adding: mem time271, current time 373, horizon 102\n", + "adding: mem time272, current time 373, horizon 101\n", + "adding: mem time273, current time 373, horizon 100\n", + "adding: mem time274, current time 373, horizon 99\n", + "adding: mem time275, current time 373, horizon 98\n", + "adding: mem time276, current time 373, horizon 97\n", + "adding: mem time277, current time 373, horizon 96\n", + "adding: mem time278, current time 373, horizon 95\n", + "adding: mem time279, current time 373, horizon 94\n", + "adding: mem time280, current time 373, horizon 93\n", + "adding: mem time281, current time 373, horizon 92\n", + "adding: mem time282, current time 373, horizon 91\n", + "adding: mem time283, current time 373, horizon 90\n", + "adding: mem time284, current time 373, horizon 89\n", + "adding: mem time285, current time 373, horizon 88\n", + "adding: mem time286, current time 373, horizon 87\n", + "adding: mem time287, current time 373, horizon 86\n", + "adding: mem time288, current time 373, horizon 85\n", + "adding: mem time289, current time 373, horizon 84\n", + "adding: mem time290, current time 373, horizon 83\n", + "adding: mem time291, current time 373, horizon 82\n", + "adding: mem time292, current time 373, horizon 81\n", + "adding: mem time293, current time 373, horizon 80\n", + "adding: mem time294, current time 373, horizon 79\n", + "adding: mem time295, current time 373, horizon 78\n", + "adding: mem time296, current time 373, horizon 77\n", + "adding: mem time297, current time 373, horizon 76\n", + "adding: mem time298, current time 373, horizon 75\n", + "adding: mem time299, current time 373, horizon 74\n", + "adding: mem time300, current time 373, horizon 73\n", + "adding: mem time301, current time 373, horizon 72\n", + "adding: mem time302, current time 373, horizon 71\n", + "adding: mem time303, current time 373, horizon 70\n", + "adding: mem time304, current time 373, horizon 69\n", + "adding: mem time305, current time 373, horizon 68\n", + "adding: mem time306, current time 373, horizon 67\n", + "adding: mem time307, current time 373, horizon 66\n", + "adding: mem time308, current time 373, horizon 65\n", + "adding: mem time309, current time 373, horizon 64\n", + "adding: mem time310, current time 373, horizon 63\n", + "adding: mem time311, current time 373, horizon 62\n", + "adding: mem time312, current time 373, horizon 61\n", + "adding: mem time313, current time 373, horizon 60\n", + "adding: mem time314, current time 373, horizon 59\n", + "adding: mem time315, current time 373, horizon 58\n", + "adding: mem time316, current time 373, horizon 57\n", + "adding: mem time317, current time 373, horizon 56\n", + "adding: mem time318, current time 373, horizon 55\n", + "adding: mem time319, current time 373, horizon 54\n", + "adding: mem time320, current time 373, horizon 53\n", + "adding: mem time321, current time 373, horizon 52\n", + "adding: mem time322, current time 373, horizon 51\n", + "adding: mem time323, current time 373, horizon 50\n", + "adding: mem time324, current time 373, horizon 49\n", + "adding: mem time325, current time 373, horizon 48\n", + "adding: mem time326, current time 373, horizon 47\n", + "adding: mem time327, current time 373, horizon 46\n", + "adding: mem time328, current time 373, horizon 45\n", + "adding: mem time329, current time 373, horizon 44\n", + "adding: mem time330, current time 373, horizon 43\n", + "adding: mem time331, current time 373, horizon 42\n", + "adding: mem time332, current time 373, horizon 41\n", + "adding: mem time333, current time 373, horizon 40\n", + "adding: mem time334, current time 373, horizon 39\n", + "adding: mem time335, current time 373, horizon 38\n", + "adding: mem time336, current time 373, horizon 37\n", + "adding: mem time337, current time 373, horizon 36\n", + "adding: mem time338, current time 373, horizon 35\n", + "adding: mem time339, current time 373, horizon 34\n", + "adding: mem time340, current time 373, horizon 33\n", + "adding: mem time341, current time 373, horizon 32\n", + "adding: mem time342, current time 373, horizon 31\n", + "adding: mem time343, current time 373, horizon 30\n", + "adding: mem time344, current time 373, horizon 29\n", + "adding: mem time345, current time 373, horizon 28\n", + "adding: mem time346, current time 373, horizon 27\n", + "adding: mem time347, current time 373, horizon 26\n", + "adding: mem time348, current time 373, horizon 25\n", + "adding: mem time349, current time 373, horizon 24\n", + "adding: mem time350, current time 373, horizon 23\n", + "adding: mem time351, current time 373, horizon 22\n", + "adding: mem time352, current time 373, horizon 21\n", + "adding: mem time353, current time 373, horizon 20\n", + "adding: mem time354, current time 373, horizon 19\n", + "adding: mem time355, current time 373, horizon 18\n", + "adding: mem time356, current time 373, horizon 17\n", + "adding: mem time357, current time 373, horizon 16\n", + "adding: mem time358, current time 373, horizon 15\n", + "adding: mem time359, current time 373, horizon 14\n", + "adding: mem time360, current time 373, horizon 13\n", + "adding: mem time361, current time 373, horizon 12\n", + "adding: mem time362, current time 373, horizon 11\n", + "adding: mem time363, current time 373, horizon 10\n", + "adding: mem time364, current time 373, horizon 9\n", + "adding: mem time365, current time 373, horizon 8\n", + "adding: mem time366, current time 373, horizon 7\n", + "adding: mem time367, current time 373, horizon 6\n", + "adding: mem time368, current time 373, horizon 5\n", + "adding: mem time369, current time 373, horizon 4\n", + "adding: mem time370, current time 373, horizon 3\n", + "adding: mem time371, current time 373, horizon 2\n", + "adding: mem time372, current time 373, horizon 1\n", + "adding: mem time200, current time 374, horizon 174\n", + "adding: mem time201, current time 374, horizon 173\n", + "adding: mem time202, current time 374, horizon 172\n", + "adding: mem time203, current time 374, horizon 171\n", + "adding: mem time204, current time 374, horizon 170\n", + "adding: mem time205, current time 374, horizon 169\n", + "adding: mem time206, current time 374, horizon 168\n", + "adding: mem time207, current time 374, horizon 167\n", + "adding: mem time208, current time 374, horizon 166\n", + "adding: mem time209, current time 374, horizon 165\n", + "adding: mem time210, current time 374, horizon 164\n", + "adding: mem time211, current time 374, horizon 163\n", + "adding: mem time212, current time 374, horizon 162\n", + "adding: mem time213, current time 374, horizon 161\n", + "adding: mem time214, current time 374, horizon 160\n", + "adding: mem time215, current time 374, horizon 159\n", + "adding: mem time216, current time 374, horizon 158\n", + "adding: mem time217, current time 374, horizon 157\n", + "adding: mem time218, current time 374, horizon 156\n", + "adding: mem time219, current time 374, horizon 155\n", + "adding: mem time220, current time 374, horizon 154\n", + "adding: mem time221, current time 374, horizon 153\n", + "adding: mem time222, current time 374, horizon 152\n", + "adding: mem time223, current time 374, horizon 151\n", + "adding: mem time224, current time 374, horizon 150\n", + "adding: mem time225, current time 374, horizon 149\n", + "adding: mem time226, current time 374, horizon 148\n", + "adding: mem time227, current time 374, horizon 147\n", + "adding: mem time228, current time 374, horizon 146\n", + "adding: mem time229, current time 374, horizon 145\n", + "adding: mem time230, current time 374, horizon 144\n", + "adding: mem time231, current time 374, horizon 143\n", + "adding: mem time232, current time 374, horizon 142\n", + "adding: mem time233, current time 374, horizon 141\n", + "adding: mem time234, current time 374, horizon 140\n", + "adding: mem time235, current time 374, horizon 139\n", + "adding: mem time236, current time 374, horizon 138\n", + "adding: mem time237, current time 374, horizon 137\n", + "adding: mem time238, current time 374, horizon 136\n", + "adding: mem time239, current time 374, horizon 135\n", + "adding: mem time240, current time 374, horizon 134\n", + "adding: mem time241, current time 374, horizon 133\n", + "adding: mem time242, current time 374, horizon 132\n", + "adding: mem time243, current time 374, horizon 131\n", + "adding: mem time244, current time 374, horizon 130\n", + "adding: mem time245, current time 374, horizon 129\n", + "adding: mem time246, current time 374, horizon 128\n", + "adding: mem time247, current time 374, horizon 127\n", + "adding: mem time248, current time 374, horizon 126\n", + "adding: mem time249, current time 374, horizon 125\n", + "adding: mem time250, current time 374, horizon 124\n", + "adding: mem time251, current time 374, horizon 123\n", + "adding: mem time252, current time 374, horizon 122\n", + "adding: mem time253, current time 374, horizon 121\n", + "adding: mem time254, current time 374, horizon 120\n", + "adding: mem time255, current time 374, horizon 119\n", + "adding: mem time256, current time 374, horizon 118\n", + "adding: mem time257, current time 374, horizon 117\n", + "adding: mem time258, current time 374, horizon 116\n", + "adding: mem time259, current time 374, horizon 115\n", + "adding: mem time260, current time 374, horizon 114\n", + "adding: mem time261, current time 374, horizon 113\n", + "adding: mem time262, current time 374, horizon 112\n", + "adding: mem time263, current time 374, horizon 111\n", + "adding: mem time264, current time 374, horizon 110\n", + "adding: mem time265, current time 374, horizon 109\n", + "adding: mem time266, current time 374, horizon 108\n", + "adding: mem time267, current time 374, horizon 107\n", + "adding: mem time268, current time 374, horizon 106\n", + "adding: mem time269, current time 374, horizon 105\n", + "adding: mem time270, current time 374, horizon 104\n", + "adding: mem time271, current time 374, horizon 103\n", + "adding: mem time272, current time 374, horizon 102\n", + "adding: mem time273, current time 374, horizon 101\n", + "adding: mem time274, current time 374, horizon 100\n", + "adding: mem time275, current time 374, horizon 99\n", + "adding: mem time276, current time 374, horizon 98\n", + "adding: mem time277, current time 374, horizon 97\n", + "adding: mem time278, current time 374, horizon 96\n", + "adding: mem time279, current time 374, horizon 95\n", + "adding: mem time280, current time 374, horizon 94\n", + "adding: mem time281, current time 374, horizon 93\n", + "adding: mem time282, current time 374, horizon 92\n", + "adding: mem time283, current time 374, horizon 91\n", + "adding: mem time284, current time 374, horizon 90\n", + "adding: mem time285, current time 374, horizon 89\n", + "adding: mem time286, current time 374, horizon 88\n", + "adding: mem time287, current time 374, horizon 87\n", + "adding: mem time288, current time 374, horizon 86\n", + "adding: mem time289, current time 374, horizon 85\n", + "adding: mem time290, current time 374, horizon 84\n", + "adding: mem time291, current time 374, horizon 83\n", + "adding: mem time292, current time 374, horizon 82\n", + "adding: mem time293, current time 374, horizon 81\n", + "adding: mem time294, current time 374, horizon 80\n", + "adding: mem time295, current time 374, horizon 79\n", + "adding: mem time296, current time 374, horizon 78\n", + "adding: mem time297, current time 374, horizon 77\n", + "adding: mem time298, current time 374, horizon 76\n", + "adding: mem time299, current time 374, horizon 75\n", + "adding: mem time300, current time 374, horizon 74\n", + "adding: mem time301, current time 374, horizon 73\n", + "adding: mem time302, current time 374, horizon 72\n", + "adding: mem time303, current time 374, horizon 71\n", + "adding: mem time304, current time 374, horizon 70\n", + "adding: mem time305, current time 374, horizon 69\n", + "adding: mem time306, current time 374, horizon 68\n", + "adding: mem time307, current time 374, horizon 67\n", + "adding: mem time308, current time 374, horizon 66\n", + "adding: mem time309, current time 374, horizon 65\n", + "adding: mem time310, current time 374, horizon 64\n", + "adding: mem time311, current time 374, horizon 63\n", + "adding: mem time312, current time 374, horizon 62\n", + "adding: mem time313, current time 374, horizon 61\n", + "adding: mem time314, current time 374, horizon 60\n", + "adding: mem time315, current time 374, horizon 59\n", + "adding: mem time316, current time 374, horizon 58\n", + "adding: mem time317, current time 374, horizon 57\n", + "adding: mem time318, current time 374, horizon 56\n", + "adding: mem time319, current time 374, horizon 55\n", + "adding: mem time320, current time 374, horizon 54\n", + "adding: mem time321, current time 374, horizon 53\n", + "adding: mem time322, current time 374, horizon 52\n", + "adding: mem time323, current time 374, horizon 51\n", + "adding: mem time324, current time 374, horizon 50\n", + "adding: mem time325, current time 374, horizon 49\n", + "adding: mem time326, current time 374, horizon 48\n", + "adding: mem time327, current time 374, horizon 47\n", + "adding: mem time328, current time 374, horizon 46\n", + "adding: mem time329, current time 374, horizon 45\n", + "adding: mem time330, current time 374, horizon 44\n", + "adding: mem time331, current time 374, horizon 43\n", + "adding: mem time332, current time 374, horizon 42\n", + "adding: mem time333, current time 374, horizon 41\n", + "adding: mem time334, current time 374, horizon 40\n", + "adding: mem time335, current time 374, horizon 39\n", + "adding: mem time336, current time 374, horizon 38\n", + "adding: mem time337, current time 374, horizon 37\n", + "adding: mem time338, current time 374, horizon 36\n", + "adding: mem time339, current time 374, horizon 35\n", + "adding: mem time340, current time 374, horizon 34\n", + "adding: mem time341, current time 374, horizon 33\n", + "adding: mem time342, current time 374, horizon 32\n", + "adding: mem time343, current time 374, horizon 31\n", + "adding: mem time344, current time 374, horizon 30\n", + "adding: mem time345, current time 374, horizon 29\n", + "adding: mem time346, current time 374, horizon 28\n", + "adding: mem time347, current time 374, horizon 27\n", + "adding: mem time348, current time 374, horizon 26\n", + "adding: mem time349, current time 374, horizon 25\n", + "adding: mem time350, current time 374, horizon 24\n", + "adding: mem time351, current time 374, horizon 23\n", + "adding: mem time352, current time 374, horizon 22\n", + "adding: mem time353, current time 374, horizon 21\n", + "adding: mem time354, current time 374, horizon 20\n", + "adding: mem time355, current time 374, horizon 19\n", + "adding: mem time356, current time 374, horizon 18\n", + "adding: mem time357, current time 374, horizon 17\n", + "adding: mem time358, current time 374, horizon 16\n", + "adding: mem time359, current time 374, horizon 15\n", + "adding: mem time360, current time 374, horizon 14\n", + "adding: mem time361, current time 374, horizon 13\n", + "adding: mem time362, current time 374, horizon 12\n", + "adding: mem time363, current time 374, horizon 11\n", + "adding: mem time364, current time 374, horizon 10\n", + "adding: mem time365, current time 374, horizon 9\n", + "adding: mem time366, current time 374, horizon 8\n", + "adding: mem time367, current time 374, horizon 7\n", + "adding: mem time368, current time 374, horizon 6\n", + "adding: mem time369, current time 374, horizon 5\n", + "adding: mem time370, current time 374, horizon 4\n", + "adding: mem time371, current time 374, horizon 3\n", + "adding: mem time372, current time 374, horizon 2\n", + "adding: mem time373, current time 374, horizon 1\n", + "adding: mem time200, current time 375, horizon 175\n", + "adding: mem time201, current time 375, horizon 174\n", + "adding: mem time202, current time 375, horizon 173\n", + "adding: mem time203, current time 375, horizon 172\n", + "adding: mem time204, current time 375, horizon 171\n", + "adding: mem time205, current time 375, horizon 170\n", + "adding: mem time206, current time 375, horizon 169\n", + "adding: mem time207, current time 375, horizon 168\n", + "adding: mem time208, current time 375, horizon 167\n", + "adding: mem time209, current time 375, horizon 166\n", + "adding: mem time210, current time 375, horizon 165\n", + "adding: mem time211, current time 375, horizon 164\n", + "adding: mem time212, current time 375, horizon 163\n", + "adding: mem time213, current time 375, horizon 162\n", + "adding: mem time214, current time 375, horizon 161\n", + "adding: mem time215, current time 375, horizon 160\n", + "adding: mem time216, current time 375, horizon 159\n", + "adding: mem time217, current time 375, horizon 158\n", + "adding: mem time218, current time 375, horizon 157\n", + "adding: mem time219, current time 375, horizon 156\n", + "adding: mem time220, current time 375, horizon 155\n", + "adding: mem time221, current time 375, horizon 154\n", + "adding: mem time222, current time 375, horizon 153\n", + "adding: mem time223, current time 375, horizon 152\n", + "adding: mem time224, current time 375, horizon 151\n", + "adding: mem time225, current time 375, horizon 150\n", + "adding: mem time226, current time 375, horizon 149\n", + "adding: mem time227, current time 375, horizon 148\n", + "adding: mem time228, current time 375, horizon 147\n", + "adding: mem time229, current time 375, horizon 146\n", + "adding: mem time230, current time 375, horizon 145\n", + "adding: mem time231, current time 375, horizon 144\n", + "adding: mem time232, current time 375, horizon 143\n", + "adding: mem time233, current time 375, horizon 142\n", + "adding: mem time234, current time 375, horizon 141\n", + "adding: mem time235, current time 375, horizon 140\n", + "adding: mem time236, current time 375, horizon 139\n", + "adding: mem time237, current time 375, horizon 138\n", + "adding: mem time238, current time 375, horizon 137\n", + "adding: mem time239, current time 375, horizon 136\n", + "adding: mem time240, current time 375, horizon 135\n", + "adding: mem time241, current time 375, horizon 134\n", + "adding: mem time242, current time 375, horizon 133\n", + "adding: mem time243, current time 375, horizon 132\n", + "adding: mem time244, current time 375, horizon 131\n", + "adding: mem time245, current time 375, horizon 130\n", + "adding: mem time246, current time 375, horizon 129\n", + "adding: mem time247, current time 375, horizon 128\n", + "adding: mem time248, current time 375, horizon 127\n", + "adding: mem time249, current time 375, horizon 126\n", + "adding: mem time250, current time 375, horizon 125\n", + "adding: mem time251, current time 375, horizon 124\n", + "adding: mem time252, current time 375, horizon 123\n", + "adding: mem time253, current time 375, horizon 122\n", + "adding: mem time254, current time 375, horizon 121\n", + "adding: mem time255, current time 375, horizon 120\n", + "adding: mem time256, current time 375, horizon 119\n", + "adding: mem time257, current time 375, horizon 118\n", + "adding: mem time258, current time 375, horizon 117\n", + "adding: mem time259, current time 375, horizon 116\n", + "adding: mem time260, current time 375, horizon 115\n", + "adding: mem time261, current time 375, horizon 114\n", + "adding: mem time262, current time 375, horizon 113\n", + "adding: mem time263, current time 375, horizon 112\n", + "adding: mem time264, current time 375, horizon 111\n", + "adding: mem time265, current time 375, horizon 110\n", + "adding: mem time266, current time 375, horizon 109\n", + "adding: mem time267, current time 375, horizon 108\n", + "adding: mem time268, current time 375, horizon 107\n", + "adding: mem time269, current time 375, horizon 106\n", + "adding: mem time270, current time 375, horizon 105\n", + "adding: mem time271, current time 375, horizon 104\n", + "adding: mem time272, current time 375, horizon 103\n", + "adding: mem time273, current time 375, horizon 102\n", + "adding: mem time274, current time 375, horizon 101\n", + "adding: mem time275, current time 375, horizon 100\n", + "adding: mem time276, current time 375, horizon 99\n", + "adding: mem time277, current time 375, horizon 98\n", + "adding: mem time278, current time 375, horizon 97\n", + "adding: mem time279, current time 375, horizon 96\n", + "adding: mem time280, current time 375, horizon 95\n", + "adding: mem time281, current time 375, horizon 94\n", + "adding: mem time282, current time 375, horizon 93\n", + "adding: mem time283, current time 375, horizon 92\n", + "adding: mem time284, current time 375, horizon 91\n", + "adding: mem time285, current time 375, horizon 90\n", + "adding: mem time286, current time 375, horizon 89\n", + "adding: mem time287, current time 375, horizon 88\n", + "adding: mem time288, current time 375, horizon 87\n", + "adding: mem time289, current time 375, horizon 86\n", + "adding: mem time290, current time 375, horizon 85\n", + "adding: mem time291, current time 375, horizon 84\n", + "adding: mem time292, current time 375, horizon 83\n", + "adding: mem time293, current time 375, horizon 82\n", + "adding: mem time294, current time 375, horizon 81\n", + "adding: mem time295, current time 375, horizon 80\n", + "adding: mem time296, current time 375, horizon 79\n", + "adding: mem time297, current time 375, horizon 78\n", + "adding: mem time298, current time 375, horizon 77\n", + "adding: mem time299, current time 375, horizon 76\n", + "adding: mem time300, current time 375, horizon 75\n", + "adding: mem time301, current time 375, horizon 74\n", + "adding: mem time302, current time 375, horizon 73\n", + "adding: mem time303, current time 375, horizon 72\n", + "adding: mem time304, current time 375, horizon 71\n", + "adding: mem time305, current time 375, horizon 70\n", + "adding: mem time306, current time 375, horizon 69\n", + "adding: mem time307, current time 375, horizon 68\n", + "adding: mem time308, current time 375, horizon 67\n", + "adding: mem time309, current time 375, horizon 66\n", + "adding: mem time310, current time 375, horizon 65\n", + "adding: mem time311, current time 375, horizon 64\n", + "adding: mem time312, current time 375, horizon 63\n", + "adding: mem time313, current time 375, horizon 62\n", + "adding: mem time314, current time 375, horizon 61\n", + "adding: mem time315, current time 375, horizon 60\n", + "adding: mem time316, current time 375, horizon 59\n", + "adding: mem time317, current time 375, horizon 58\n", + "adding: mem time318, current time 375, horizon 57\n", + "adding: mem time319, current time 375, horizon 56\n", + "adding: mem time320, current time 375, horizon 55\n", + "adding: mem time321, current time 375, horizon 54\n", + "adding: mem time322, current time 375, horizon 53\n", + "adding: mem time323, current time 375, horizon 52\n", + "adding: mem time324, current time 375, horizon 51\n", + "adding: mem time325, current time 375, horizon 50\n", + "adding: mem time326, current time 375, horizon 49\n", + "adding: mem time327, current time 375, horizon 48\n", + "adding: mem time328, current time 375, horizon 47\n", + "adding: mem time329, current time 375, horizon 46\n", + "adding: mem time330, current time 375, horizon 45\n", + "adding: mem time331, current time 375, horizon 44\n", + "adding: mem time332, current time 375, horizon 43\n", + "adding: mem time333, current time 375, horizon 42\n", + "adding: mem time334, current time 375, horizon 41\n", + "adding: mem time335, current time 375, horizon 40\n", + "adding: mem time336, current time 375, horizon 39\n", + "adding: mem time337, current time 375, horizon 38\n", + "adding: mem time338, current time 375, horizon 37\n", + "adding: mem time339, current time 375, horizon 36\n", + "adding: mem time340, current time 375, horizon 35\n", + "adding: mem time341, current time 375, horizon 34\n", + "adding: mem time342, current time 375, horizon 33\n", + "adding: mem time343, current time 375, horizon 32\n", + "adding: mem time344, current time 375, horizon 31\n", + "adding: mem time345, current time 375, horizon 30\n", + "adding: mem time346, current time 375, horizon 29\n", + "adding: mem time347, current time 375, horizon 28\n", + "adding: mem time348, current time 375, horizon 27\n", + "adding: mem time349, current time 375, horizon 26\n", + "adding: mem time350, current time 375, horizon 25\n", + "adding: mem time351, current time 375, horizon 24\n", + "adding: mem time352, current time 375, horizon 23\n", + "adding: mem time353, current time 375, horizon 22\n", + "adding: mem time354, current time 375, horizon 21\n", + "adding: mem time355, current time 375, horizon 20\n", + "adding: mem time356, current time 375, horizon 19\n", + "adding: mem time357, current time 375, horizon 18\n", + "adding: mem time358, current time 375, horizon 17\n", + "adding: mem time359, current time 375, horizon 16\n", + "adding: mem time360, current time 375, horizon 15\n", + "adding: mem time361, current time 375, horizon 14\n", + "adding: mem time362, current time 375, horizon 13\n", + "adding: mem time363, current time 375, horizon 12\n", + "adding: mem time364, current time 375, horizon 11\n", + "adding: mem time365, current time 375, horizon 10\n", + "adding: mem time366, current time 375, horizon 9\n", + "adding: mem time367, current time 375, horizon 8\n", + "adding: mem time368, current time 375, horizon 7\n", + "adding: mem time369, current time 375, horizon 6\n", + "adding: mem time370, current time 375, horizon 5\n", + "adding: mem time371, current time 375, horizon 4\n", + "adding: mem time372, current time 375, horizon 3\n", + "adding: mem time373, current time 375, horizon 2\n", + "adding: mem time374, current time 375, horizon 1\n", + "adding: mem time200, current time 376, horizon 176\n", + "adding: mem time201, current time 376, horizon 175\n", + "adding: mem time202, current time 376, horizon 174\n", + "adding: mem time203, current time 376, horizon 173\n", + "adding: mem time204, current time 376, horizon 172\n", + "adding: mem time205, current time 376, horizon 171\n", + "adding: mem time206, current time 376, horizon 170\n", + "adding: mem time207, current time 376, horizon 169\n", + "adding: mem time208, current time 376, horizon 168\n", + "adding: mem time209, current time 376, horizon 167\n", + "adding: mem time210, current time 376, horizon 166\n", + "adding: mem time211, current time 376, horizon 165\n", + "adding: mem time212, current time 376, horizon 164\n", + "adding: mem time213, current time 376, horizon 163\n", + "adding: mem time214, current time 376, horizon 162\n", + "adding: mem time215, current time 376, horizon 161\n", + "adding: mem time216, current time 376, horizon 160\n", + "adding: mem time217, current time 376, horizon 159\n", + "adding: mem time218, current time 376, horizon 158\n", + "adding: mem time219, current time 376, horizon 157\n", + "adding: mem time220, current time 376, horizon 156\n", + "adding: mem time221, current time 376, horizon 155\n", + "adding: mem time222, current time 376, horizon 154\n", + "adding: mem time223, current time 376, horizon 153\n", + "adding: mem time224, current time 376, horizon 152\n", + "adding: mem time225, current time 376, horizon 151\n", + "adding: mem time226, current time 376, horizon 150\n", + "adding: mem time227, current time 376, horizon 149\n", + "adding: mem time228, current time 376, horizon 148\n", + "adding: mem time229, current time 376, horizon 147\n", + "adding: mem time230, current time 376, horizon 146\n", + "adding: mem time231, current time 376, horizon 145\n", + "adding: mem time232, current time 376, horizon 144\n", + "adding: mem time233, current time 376, horizon 143\n", + "adding: mem time234, current time 376, horizon 142\n", + "adding: mem time235, current time 376, horizon 141\n", + "adding: mem time236, current time 376, horizon 140\n", + "adding: mem time237, current time 376, horizon 139\n", + "adding: mem time238, current time 376, horizon 138\n", + "adding: mem time239, current time 376, horizon 137\n", + "adding: mem time240, current time 376, horizon 136\n", + "adding: mem time241, current time 376, horizon 135\n", + "adding: mem time242, current time 376, horizon 134\n", + "adding: mem time243, current time 376, horizon 133\n", + "adding: mem time244, current time 376, horizon 132\n", + "adding: mem time245, current time 376, horizon 131\n", + "adding: mem time246, current time 376, horizon 130\n", + "adding: mem time247, current time 376, horizon 129\n", + "adding: mem time248, current time 376, horizon 128\n", + "adding: mem time249, current time 376, horizon 127\n", + "adding: mem time250, current time 376, horizon 126\n", + "adding: mem time251, current time 376, horizon 125\n", + "adding: mem time252, current time 376, horizon 124\n", + "adding: mem time253, current time 376, horizon 123\n", + "adding: mem time254, current time 376, horizon 122\n", + "adding: mem time255, current time 376, horizon 121\n", + "adding: mem time256, current time 376, horizon 120\n", + "adding: mem time257, current time 376, horizon 119\n", + "adding: mem time258, current time 376, horizon 118\n", + "adding: mem time259, current time 376, horizon 117\n", + "adding: mem time260, current time 376, horizon 116\n", + "adding: mem time261, current time 376, horizon 115\n", + "adding: mem time262, current time 376, horizon 114\n", + "adding: mem time263, current time 376, horizon 113\n", + "adding: mem time264, current time 376, horizon 112\n", + "adding: mem time265, current time 376, horizon 111\n", + "adding: mem time266, current time 376, horizon 110\n", + "adding: mem time267, current time 376, horizon 109\n", + "adding: mem time268, current time 376, horizon 108\n", + "adding: mem time269, current time 376, horizon 107\n", + "adding: mem time270, current time 376, horizon 106\n", + "adding: mem time271, current time 376, horizon 105\n", + "adding: mem time272, current time 376, horizon 104\n", + "adding: mem time273, current time 376, horizon 103\n", + "adding: mem time274, current time 376, horizon 102\n", + "adding: mem time275, current time 376, horizon 101\n", + "adding: mem time276, current time 376, horizon 100\n", + "adding: mem time277, current time 376, horizon 99\n", + "adding: mem time278, current time 376, horizon 98\n", + "adding: mem time279, current time 376, horizon 97\n", + "adding: mem time280, current time 376, horizon 96\n", + "adding: mem time281, current time 376, horizon 95\n", + "adding: mem time282, current time 376, horizon 94\n", + "adding: mem time283, current time 376, horizon 93\n", + "adding: mem time284, current time 376, horizon 92\n", + "adding: mem time285, current time 376, horizon 91\n", + "adding: mem time286, current time 376, horizon 90\n", + "adding: mem time287, current time 376, horizon 89\n", + "adding: mem time288, current time 376, horizon 88\n", + "adding: mem time289, current time 376, horizon 87\n", + "adding: mem time290, current time 376, horizon 86\n", + "adding: mem time291, current time 376, horizon 85\n", + "adding: mem time292, current time 376, horizon 84\n", + "adding: mem time293, current time 376, horizon 83\n", + "adding: mem time294, current time 376, horizon 82\n", + "adding: mem time295, current time 376, horizon 81\n", + "adding: mem time296, current time 376, horizon 80\n", + "adding: mem time297, current time 376, horizon 79\n", + "adding: mem time298, current time 376, horizon 78\n", + "adding: mem time299, current time 376, horizon 77\n", + "adding: mem time300, current time 376, horizon 76\n", + "adding: mem time301, current time 376, horizon 75\n", + "adding: mem time302, current time 376, horizon 74\n", + "adding: mem time303, current time 376, horizon 73\n", + "adding: mem time304, current time 376, horizon 72\n", + "adding: mem time305, current time 376, horizon 71\n", + "adding: mem time306, current time 376, horizon 70\n", + "adding: mem time307, current time 376, horizon 69\n", + "adding: mem time308, current time 376, horizon 68\n", + "adding: mem time309, current time 376, horizon 67\n", + "adding: mem time310, current time 376, horizon 66\n", + "adding: mem time311, current time 376, horizon 65\n", + "adding: mem time312, current time 376, horizon 64\n", + "adding: mem time313, current time 376, horizon 63\n", + "adding: mem time314, current time 376, horizon 62\n", + "adding: mem time315, current time 376, horizon 61\n", + "adding: mem time316, current time 376, horizon 60\n", + "adding: mem time317, current time 376, horizon 59\n", + "adding: mem time318, current time 376, horizon 58\n", + "adding: mem time319, current time 376, horizon 57\n", + "adding: mem time320, current time 376, horizon 56\n", + "adding: mem time321, current time 376, horizon 55\n", + "adding: mem time322, current time 376, horizon 54\n", + "adding: mem time323, current time 376, horizon 53\n", + "adding: mem time324, current time 376, horizon 52\n", + "adding: mem time325, current time 376, horizon 51\n", + "adding: mem time326, current time 376, horizon 50\n", + "adding: mem time327, current time 376, horizon 49\n", + "adding: mem time328, current time 376, horizon 48\n", + "adding: mem time329, current time 376, horizon 47\n", + "adding: mem time330, current time 376, horizon 46\n", + "adding: mem time331, current time 376, horizon 45\n", + "adding: mem time332, current time 376, horizon 44\n", + "adding: mem time333, current time 376, horizon 43\n", + "adding: mem time334, current time 376, horizon 42\n", + "adding: mem time335, current time 376, horizon 41\n", + "adding: mem time336, current time 376, horizon 40\n", + "adding: mem time337, current time 376, horizon 39\n", + "adding: mem time338, current time 376, horizon 38\n", + "adding: mem time339, current time 376, horizon 37\n", + "adding: mem time340, current time 376, horizon 36\n", + "adding: mem time341, current time 376, horizon 35\n", + "adding: mem time342, current time 376, horizon 34\n", + "adding: mem time343, current time 376, horizon 33\n", + "adding: mem time344, current time 376, horizon 32\n", + "adding: mem time345, current time 376, horizon 31\n", + "adding: mem time346, current time 376, horizon 30\n", + "adding: mem time347, current time 376, horizon 29\n", + "adding: mem time348, current time 376, horizon 28\n", + "adding: mem time349, current time 376, horizon 27\n", + "adding: mem time350, current time 376, horizon 26\n", + "adding: mem time351, current time 376, horizon 25\n", + "adding: mem time352, current time 376, horizon 24\n", + "adding: mem time353, current time 376, horizon 23\n", + "adding: mem time354, current time 376, horizon 22\n", + "adding: mem time355, current time 376, horizon 21\n", + "adding: mem time356, current time 376, horizon 20\n", + "adding: mem time357, current time 376, horizon 19\n", + "adding: mem time358, current time 376, horizon 18\n", + "adding: mem time359, current time 376, horizon 17\n", + "adding: mem time360, current time 376, horizon 16\n", + "adding: mem time361, current time 376, horizon 15\n", + "adding: mem time362, current time 376, horizon 14\n", + "adding: mem time363, current time 376, horizon 13\n", + "adding: mem time364, current time 376, horizon 12\n", + "adding: mem time365, current time 376, horizon 11\n", + "adding: mem time366, current time 376, horizon 10\n", + "adding: mem time367, current time 376, horizon 9\n", + "adding: mem time368, current time 376, horizon 8\n", + "adding: mem time369, current time 376, horizon 7\n", + "adding: mem time370, current time 376, horizon 6\n", + "adding: mem time371, current time 376, horizon 5\n", + "adding: mem time372, current time 376, horizon 4\n", + "adding: mem time373, current time 376, horizon 3\n", + "adding: mem time374, current time 376, horizon 2\n", + "adding: mem time375, current time 376, horizon 1\n", + "adding: mem time200, current time 377, horizon 177\n", + "adding: mem time201, current time 377, horizon 176\n", + "adding: mem time202, current time 377, horizon 175\n", + "adding: mem time203, current time 377, horizon 174\n", + "adding: mem time204, current time 377, horizon 173\n", + "adding: mem time205, current time 377, horizon 172\n", + "adding: mem time206, current time 377, horizon 171\n", + "adding: mem time207, current time 377, horizon 170\n", + "adding: mem time208, current time 377, horizon 169\n", + "adding: mem time209, current time 377, horizon 168\n", + "adding: mem time210, current time 377, horizon 167\n", + "adding: mem time211, current time 377, horizon 166\n", + "adding: mem time212, current time 377, horizon 165\n", + "adding: mem time213, current time 377, horizon 164\n", + "adding: mem time214, current time 377, horizon 163\n", + "adding: mem time215, current time 377, horizon 162\n", + "adding: mem time216, current time 377, horizon 161\n", + "adding: mem time217, current time 377, horizon 160\n", + "adding: mem time218, current time 377, horizon 159\n", + "adding: mem time219, current time 377, horizon 158\n", + "adding: mem time220, current time 377, horizon 157\n", + "adding: mem time221, current time 377, horizon 156\n", + "adding: mem time222, current time 377, horizon 155\n", + "adding: mem time223, current time 377, horizon 154\n", + "adding: mem time224, current time 377, horizon 153\n", + "adding: mem time225, current time 377, horizon 152\n", + "adding: mem time226, current time 377, horizon 151\n", + "adding: mem time227, current time 377, horizon 150\n", + "adding: mem time228, current time 377, horizon 149\n", + "adding: mem time229, current time 377, horizon 148\n", + "adding: mem time230, current time 377, horizon 147\n", + "adding: mem time231, current time 377, horizon 146\n", + "adding: mem time232, current time 377, horizon 145\n", + "adding: mem time233, current time 377, horizon 144\n", + "adding: mem time234, current time 377, horizon 143\n", + "adding: mem time235, current time 377, horizon 142\n", + "adding: mem time236, current time 377, horizon 141\n", + "adding: mem time237, current time 377, horizon 140\n", + "adding: mem time238, current time 377, horizon 139\n", + "adding: mem time239, current time 377, horizon 138\n", + "adding: mem time240, current time 377, horizon 137\n", + "adding: mem time241, current time 377, horizon 136\n", + "adding: mem time242, current time 377, horizon 135\n", + "adding: mem time243, current time 377, horizon 134\n", + "adding: mem time244, current time 377, horizon 133\n", + "adding: mem time245, current time 377, horizon 132\n", + "adding: mem time246, current time 377, horizon 131\n", + "adding: mem time247, current time 377, horizon 130\n", + "adding: mem time248, current time 377, horizon 129\n", + "adding: mem time249, current time 377, horizon 128\n", + "adding: mem time250, current time 377, horizon 127\n", + "adding: mem time251, current time 377, horizon 126\n", + "adding: mem time252, current time 377, horizon 125\n", + "adding: mem time253, current time 377, horizon 124\n", + "adding: mem time254, current time 377, horizon 123\n", + "adding: mem time255, current time 377, horizon 122\n", + "adding: mem time256, current time 377, horizon 121\n", + "adding: mem time257, current time 377, horizon 120\n", + "adding: mem time258, current time 377, horizon 119\n", + "adding: mem time259, current time 377, horizon 118\n", + "adding: mem time260, current time 377, horizon 117\n", + "adding: mem time261, current time 377, horizon 116\n", + "adding: mem time262, current time 377, horizon 115\n", + "adding: mem time263, current time 377, horizon 114\n", + "adding: mem time264, current time 377, horizon 113\n", + "adding: mem time265, current time 377, horizon 112\n", + "adding: mem time266, current time 377, horizon 111\n", + "adding: mem time267, current time 377, horizon 110\n", + "adding: mem time268, current time 377, horizon 109\n", + "adding: mem time269, current time 377, horizon 108\n", + "adding: mem time270, current time 377, horizon 107\n", + "adding: mem time271, current time 377, horizon 106\n", + "adding: mem time272, current time 377, horizon 105\n", + "adding: mem time273, current time 377, horizon 104\n", + "adding: mem time274, current time 377, horizon 103\n", + "adding: mem time275, current time 377, horizon 102\n", + "adding: mem time276, current time 377, horizon 101\n", + "adding: mem time277, current time 377, horizon 100\n", + "adding: mem time278, current time 377, horizon 99\n", + "adding: mem time279, current time 377, horizon 98\n", + "adding: mem time280, current time 377, horizon 97\n", + "adding: mem time281, current time 377, horizon 96\n", + "adding: mem time282, current time 377, horizon 95\n", + "adding: mem time283, current time 377, horizon 94\n", + "adding: mem time284, current time 377, horizon 93\n", + "adding: mem time285, current time 377, horizon 92\n", + "adding: mem time286, current time 377, horizon 91\n", + "adding: mem time287, current time 377, horizon 90\n", + "adding: mem time288, current time 377, horizon 89\n", + "adding: mem time289, current time 377, horizon 88\n", + "adding: mem time290, current time 377, horizon 87\n", + "adding: mem time291, current time 377, horizon 86\n", + "adding: mem time292, current time 377, horizon 85\n", + "adding: mem time293, current time 377, horizon 84\n", + "adding: mem time294, current time 377, horizon 83\n", + "adding: mem time295, current time 377, horizon 82\n", + "adding: mem time296, current time 377, horizon 81\n", + "adding: mem time297, current time 377, horizon 80\n", + "adding: mem time298, current time 377, horizon 79\n", + "adding: mem time299, current time 377, horizon 78\n", + "adding: mem time300, current time 377, horizon 77\n", + "adding: mem time301, current time 377, horizon 76\n", + "adding: mem time302, current time 377, horizon 75\n", + "adding: mem time303, current time 377, horizon 74\n", + "adding: mem time304, current time 377, horizon 73\n", + "adding: mem time305, current time 377, horizon 72\n", + "adding: mem time306, current time 377, horizon 71\n", + "adding: mem time307, current time 377, horizon 70\n", + "adding: mem time308, current time 377, horizon 69\n", + "adding: mem time309, current time 377, horizon 68\n", + "adding: mem time310, current time 377, horizon 67\n", + "adding: mem time311, current time 377, horizon 66\n", + "adding: mem time312, current time 377, horizon 65\n", + "adding: mem time313, current time 377, horizon 64\n", + "adding: mem time314, current time 377, horizon 63\n", + "adding: mem time315, current time 377, horizon 62\n", + "adding: mem time316, current time 377, horizon 61\n", + "adding: mem time317, current time 377, horizon 60\n", + "adding: mem time318, current time 377, horizon 59\n", + "adding: mem time319, current time 377, horizon 58\n", + "adding: mem time320, current time 377, horizon 57\n", + "adding: mem time321, current time 377, horizon 56\n", + "adding: mem time322, current time 377, horizon 55\n", + "adding: mem time323, current time 377, horizon 54\n", + "adding: mem time324, current time 377, horizon 53\n", + "adding: mem time325, current time 377, horizon 52\n", + "adding: mem time326, current time 377, horizon 51\n", + "adding: mem time327, current time 377, horizon 50\n", + "adding: mem time328, current time 377, horizon 49\n", + "adding: mem time329, current time 377, horizon 48\n", + "adding: mem time330, current time 377, horizon 47\n", + "adding: mem time331, current time 377, horizon 46\n", + "adding: mem time332, current time 377, horizon 45\n", + "adding: mem time333, current time 377, horizon 44\n", + "adding: mem time334, current time 377, horizon 43\n", + "adding: mem time335, current time 377, horizon 42\n", + "adding: mem time336, current time 377, horizon 41\n", + "adding: mem time337, current time 377, horizon 40\n", + "adding: mem time338, current time 377, horizon 39\n", + "adding: mem time339, current time 377, horizon 38\n", + "adding: mem time340, current time 377, horizon 37\n", + "adding: mem time341, current time 377, horizon 36\n", + "adding: mem time342, current time 377, horizon 35\n", + "adding: mem time343, current time 377, horizon 34\n", + "adding: mem time344, current time 377, horizon 33\n", + "adding: mem time345, current time 377, horizon 32\n", + "adding: mem time346, current time 377, horizon 31\n", + "adding: mem time347, current time 377, horizon 30\n", + "adding: mem time348, current time 377, horizon 29\n", + "adding: mem time349, current time 377, horizon 28\n", + "adding: mem time350, current time 377, horizon 27\n", + "adding: mem time351, current time 377, horizon 26\n", + "adding: mem time352, current time 377, horizon 25\n", + "adding: mem time353, current time 377, horizon 24\n", + "adding: mem time354, current time 377, horizon 23\n", + "adding: mem time355, current time 377, horizon 22\n", + "adding: mem time356, current time 377, horizon 21\n", + "adding: mem time357, current time 377, horizon 20\n", + "adding: mem time358, current time 377, horizon 19\n", + "adding: mem time359, current time 377, horizon 18\n", + "adding: mem time360, current time 377, horizon 17\n", + "adding: mem time361, current time 377, horizon 16\n", + "adding: mem time362, current time 377, horizon 15\n", + "adding: mem time363, current time 377, horizon 14\n", + "adding: mem time364, current time 377, horizon 13\n", + "adding: mem time365, current time 377, horizon 12\n", + "adding: mem time366, current time 377, horizon 11\n", + "adding: mem time367, current time 377, horizon 10\n", + "adding: mem time368, current time 377, horizon 9\n", + "adding: mem time369, current time 377, horizon 8\n", + "adding: mem time370, current time 377, horizon 7\n", + "adding: mem time371, current time 377, horizon 6\n", + "adding: mem time372, current time 377, horizon 5\n", + "adding: mem time373, current time 377, horizon 4\n", + "adding: mem time374, current time 377, horizon 3\n", + "adding: mem time375, current time 377, horizon 2\n", + "adding: mem time376, current time 377, horizon 1\n", + "adding: mem time200, current time 378, horizon 178\n", + "adding: mem time201, current time 378, horizon 177\n", + "adding: mem time202, current time 378, horizon 176\n", + "adding: mem time203, current time 378, horizon 175\n", + "adding: mem time204, current time 378, horizon 174\n", + "adding: mem time205, current time 378, horizon 173\n", + "adding: mem time206, current time 378, horizon 172\n", + "adding: mem time207, current time 378, horizon 171\n", + "adding: mem time208, current time 378, horizon 170\n", + "adding: mem time209, current time 378, horizon 169\n", + "adding: mem time210, current time 378, horizon 168\n", + "adding: mem time211, current time 378, horizon 167\n", + "adding: mem time212, current time 378, horizon 166\n", + "adding: mem time213, current time 378, horizon 165\n", + "adding: mem time214, current time 378, horizon 164\n", + "adding: mem time215, current time 378, horizon 163\n", + "adding: mem time216, current time 378, horizon 162\n", + "adding: mem time217, current time 378, horizon 161\n", + "adding: mem time218, current time 378, horizon 160\n", + "adding: mem time219, current time 378, horizon 159\n", + "adding: mem time220, current time 378, horizon 158\n", + "adding: mem time221, current time 378, horizon 157\n", + "adding: mem time222, current time 378, horizon 156\n", + "adding: mem time223, current time 378, horizon 155\n", + "adding: mem time224, current time 378, horizon 154\n", + "adding: mem time225, current time 378, horizon 153\n", + "adding: mem time226, current time 378, horizon 152\n", + "adding: mem time227, current time 378, horizon 151\n", + "adding: mem time228, current time 378, horizon 150\n", + "adding: mem time229, current time 378, horizon 149\n", + "adding: mem time230, current time 378, horizon 148\n", + "adding: mem time231, current time 378, horizon 147\n", + "adding: mem time232, current time 378, horizon 146\n", + "adding: mem time233, current time 378, horizon 145\n", + "adding: mem time234, current time 378, horizon 144\n", + "adding: mem time235, current time 378, horizon 143\n", + "adding: mem time236, current time 378, horizon 142\n", + "adding: mem time237, current time 378, horizon 141\n", + "adding: mem time238, current time 378, horizon 140\n", + "adding: mem time239, current time 378, horizon 139\n", + "adding: mem time240, current time 378, horizon 138\n", + "adding: mem time241, current time 378, horizon 137\n", + "adding: mem time242, current time 378, horizon 136\n", + "adding: mem time243, current time 378, horizon 135\n", + "adding: mem time244, current time 378, horizon 134\n", + "adding: mem time245, current time 378, horizon 133\n", + "adding: mem time246, current time 378, horizon 132\n", + "adding: mem time247, current time 378, horizon 131\n", + "adding: mem time248, current time 378, horizon 130\n", + "adding: mem time249, current time 378, horizon 129\n", + "adding: mem time250, current time 378, horizon 128\n", + "adding: mem time251, current time 378, horizon 127\n", + "adding: mem time252, current time 378, horizon 126\n", + "adding: mem time253, current time 378, horizon 125\n", + "adding: mem time254, current time 378, horizon 124\n", + "adding: mem time255, current time 378, horizon 123\n", + "adding: mem time256, current time 378, horizon 122\n", + "adding: mem time257, current time 378, horizon 121\n", + "adding: mem time258, current time 378, horizon 120\n", + "adding: mem time259, current time 378, horizon 119\n", + "adding: mem time260, current time 378, horizon 118\n", + "adding: mem time261, current time 378, horizon 117\n", + "adding: mem time262, current time 378, horizon 116\n", + "adding: mem time263, current time 378, horizon 115\n", + "adding: mem time264, current time 378, horizon 114\n", + "adding: mem time265, current time 378, horizon 113\n", + "adding: mem time266, current time 378, horizon 112\n", + "adding: mem time267, current time 378, horizon 111\n", + "adding: mem time268, current time 378, horizon 110\n", + "adding: mem time269, current time 378, horizon 109\n", + "adding: mem time270, current time 378, horizon 108\n", + "adding: mem time271, current time 378, horizon 107\n", + "adding: mem time272, current time 378, horizon 106\n", + "adding: mem time273, current time 378, horizon 105\n", + "adding: mem time274, current time 378, horizon 104\n", + "adding: mem time275, current time 378, horizon 103\n", + "adding: mem time276, current time 378, horizon 102\n", + "adding: mem time277, current time 378, horizon 101\n", + "adding: mem time278, current time 378, horizon 100\n", + "adding: mem time279, current time 378, horizon 99\n", + "adding: mem time280, current time 378, horizon 98\n", + "adding: mem time281, current time 378, horizon 97\n", + "adding: mem time282, current time 378, horizon 96\n", + "adding: mem time283, current time 378, horizon 95\n", + "adding: mem time284, current time 378, horizon 94\n", + "adding: mem time285, current time 378, horizon 93\n", + "adding: mem time286, current time 378, horizon 92\n", + "adding: mem time287, current time 378, horizon 91\n", + "adding: mem time288, current time 378, horizon 90\n", + "adding: mem time289, current time 378, horizon 89\n", + "adding: mem time290, current time 378, horizon 88\n", + "adding: mem time291, current time 378, horizon 87\n", + "adding: mem time292, current time 378, horizon 86\n", + "adding: mem time293, current time 378, horizon 85\n", + "adding: mem time294, current time 378, horizon 84\n", + "adding: mem time295, current time 378, horizon 83\n", + "adding: mem time296, current time 378, horizon 82\n", + "adding: mem time297, current time 378, horizon 81\n", + "adding: mem time298, current time 378, horizon 80\n", + "adding: mem time299, current time 378, horizon 79\n", + "adding: mem time300, current time 378, horizon 78\n", + "adding: mem time301, current time 378, horizon 77\n", + "adding: mem time302, current time 378, horizon 76\n", + "adding: mem time303, current time 378, horizon 75\n", + "adding: mem time304, current time 378, horizon 74\n", + "adding: mem time305, current time 378, horizon 73\n", + "adding: mem time306, current time 378, horizon 72\n", + "adding: mem time307, current time 378, horizon 71\n", + "adding: mem time308, current time 378, horizon 70\n", + "adding: mem time309, current time 378, horizon 69\n", + "adding: mem time310, current time 378, horizon 68\n", + "adding: mem time311, current time 378, horizon 67\n", + "adding: mem time312, current time 378, horizon 66\n", + "adding: mem time313, current time 378, horizon 65\n", + "adding: mem time314, current time 378, horizon 64\n", + "adding: mem time315, current time 378, horizon 63\n", + "adding: mem time316, current time 378, horizon 62\n", + "adding: mem time317, current time 378, horizon 61\n", + "adding: mem time318, current time 378, horizon 60\n", + "adding: mem time319, current time 378, horizon 59\n", + "adding: mem time320, current time 378, horizon 58\n", + "adding: mem time321, current time 378, horizon 57\n", + "adding: mem time322, current time 378, horizon 56\n", + "adding: mem time323, current time 378, horizon 55\n", + "adding: mem time324, current time 378, horizon 54\n", + "adding: mem time325, current time 378, horizon 53\n", + "adding: mem time326, current time 378, horizon 52\n", + "adding: mem time327, current time 378, horizon 51\n", + "adding: mem time328, current time 378, horizon 50\n", + "adding: mem time329, current time 378, horizon 49\n", + "adding: mem time330, current time 378, horizon 48\n", + "adding: mem time331, current time 378, horizon 47\n", + "adding: mem time332, current time 378, horizon 46\n", + "adding: mem time333, current time 378, horizon 45\n", + "adding: mem time334, current time 378, horizon 44\n", + "adding: mem time335, current time 378, horizon 43\n", + "adding: mem time336, current time 378, horizon 42\n", + "adding: mem time337, current time 378, horizon 41\n", + "adding: mem time338, current time 378, horizon 40\n", + "adding: mem time339, current time 378, horizon 39\n", + "adding: mem time340, current time 378, horizon 38\n", + "adding: mem time341, current time 378, horizon 37\n", + "adding: mem time342, current time 378, horizon 36\n", + "adding: mem time343, current time 378, horizon 35\n", + "adding: mem time344, current time 378, horizon 34\n", + "adding: mem time345, current time 378, horizon 33\n", + "adding: mem time346, current time 378, horizon 32\n", + "adding: mem time347, current time 378, horizon 31\n", + "adding: mem time348, current time 378, horizon 30\n", + "adding: mem time349, current time 378, horizon 29\n", + "adding: mem time350, current time 378, horizon 28\n", + "adding: mem time351, current time 378, horizon 27\n", + "adding: mem time352, current time 378, horizon 26\n", + "adding: mem time353, current time 378, horizon 25\n", + "adding: mem time354, current time 378, horizon 24\n", + "adding: mem time355, current time 378, horizon 23\n", + "adding: mem time356, current time 378, horizon 22\n", + "adding: mem time357, current time 378, horizon 21\n", + "adding: mem time358, current time 378, horizon 20\n", + "adding: mem time359, current time 378, horizon 19\n", + "adding: mem time360, current time 378, horizon 18\n", + "adding: mem time361, current time 378, horizon 17\n", + "adding: mem time362, current time 378, horizon 16\n", + "adding: mem time363, current time 378, horizon 15\n", + "adding: mem time364, current time 378, horizon 14\n", + "adding: mem time365, current time 378, horizon 13\n", + "adding: mem time366, current time 378, horizon 12\n", + "adding: mem time367, current time 378, horizon 11\n", + "adding: mem time368, current time 378, horizon 10\n", + "adding: mem time369, current time 378, horizon 9\n", + "adding: mem time370, current time 378, horizon 8\n", + "adding: mem time371, current time 378, horizon 7\n", + "adding: mem time372, current time 378, horizon 6\n", + "adding: mem time373, current time 378, horizon 5\n", + "adding: mem time374, current time 378, horizon 4\n", + "adding: mem time375, current time 378, horizon 3\n", + "adding: mem time376, current time 378, horizon 2\n", + "adding: mem time377, current time 378, horizon 1\n", + "adding: mem time200, current time 379, horizon 179\n", + "adding: mem time201, current time 379, horizon 178\n", + "adding: mem time202, current time 379, horizon 177\n", + "adding: mem time203, current time 379, horizon 176\n", + "adding: mem time204, current time 379, horizon 175\n", + "adding: mem time205, current time 379, horizon 174\n", + "adding: mem time206, current time 379, horizon 173\n", + "adding: mem time207, current time 379, horizon 172\n", + "adding: mem time208, current time 379, horizon 171\n", + "adding: mem time209, current time 379, horizon 170\n", + "adding: mem time210, current time 379, horizon 169\n", + "adding: mem time211, current time 379, horizon 168\n", + "adding: mem time212, current time 379, horizon 167\n", + "adding: mem time213, current time 379, horizon 166\n", + "adding: mem time214, current time 379, horizon 165\n", + "adding: mem time215, current time 379, horizon 164\n", + "adding: mem time216, current time 379, horizon 163\n", + "adding: mem time217, current time 379, horizon 162\n", + "adding: mem time218, current time 379, horizon 161\n", + "adding: mem time219, current time 379, horizon 160\n", + "adding: mem time220, current time 379, horizon 159\n", + "adding: mem time221, current time 379, horizon 158\n", + "adding: mem time222, current time 379, horizon 157\n", + "adding: mem time223, current time 379, horizon 156\n", + "adding: mem time224, current time 379, horizon 155\n", + "adding: mem time225, current time 379, horizon 154\n", + "adding: mem time226, current time 379, horizon 153\n", + "adding: mem time227, current time 379, horizon 152\n", + "adding: mem time228, current time 379, horizon 151\n", + "adding: mem time229, current time 379, horizon 150\n", + "adding: mem time230, current time 379, horizon 149\n", + "adding: mem time231, current time 379, horizon 148\n", + "adding: mem time232, current time 379, horizon 147\n", + "adding: mem time233, current time 379, horizon 146\n", + "adding: mem time234, current time 379, horizon 145\n", + "adding: mem time235, current time 379, horizon 144\n", + "adding: mem time236, current time 379, horizon 143\n", + "adding: mem time237, current time 379, horizon 142\n", + "adding: mem time238, current time 379, horizon 141\n", + "adding: mem time239, current time 379, horizon 140\n", + "adding: mem time240, current time 379, horizon 139\n", + "adding: mem time241, current time 379, horizon 138\n", + "adding: mem time242, current time 379, horizon 137\n", + "adding: mem time243, current time 379, horizon 136\n", + "adding: mem time244, current time 379, horizon 135\n", + "adding: mem time245, current time 379, horizon 134\n", + "adding: mem time246, current time 379, horizon 133\n", + "adding: mem time247, current time 379, horizon 132\n", + "adding: mem time248, current time 379, horizon 131\n", + "adding: mem time249, current time 379, horizon 130\n", + "adding: mem time250, current time 379, horizon 129\n", + "adding: mem time251, current time 379, horizon 128\n", + "adding: mem time252, current time 379, horizon 127\n", + "adding: mem time253, current time 379, horizon 126\n", + "adding: mem time254, current time 379, horizon 125\n", + "adding: mem time255, current time 379, horizon 124\n", + "adding: mem time256, current time 379, horizon 123\n", + "adding: mem time257, current time 379, horizon 122\n", + "adding: mem time258, current time 379, horizon 121\n", + "adding: mem time259, current time 379, horizon 120\n", + "adding: mem time260, current time 379, horizon 119\n", + "adding: mem time261, current time 379, horizon 118\n", + "adding: mem time262, current time 379, horizon 117\n", + "adding: mem time263, current time 379, horizon 116\n", + "adding: mem time264, current time 379, horizon 115\n", + "adding: mem time265, current time 379, horizon 114\n", + "adding: mem time266, current time 379, horizon 113\n", + "adding: mem time267, current time 379, horizon 112\n", + "adding: mem time268, current time 379, horizon 111\n", + "adding: mem time269, current time 379, horizon 110\n", + "adding: mem time270, current time 379, horizon 109\n", + "adding: mem time271, current time 379, horizon 108\n", + "adding: mem time272, current time 379, horizon 107\n", + "adding: mem time273, current time 379, horizon 106\n", + "adding: mem time274, current time 379, horizon 105\n", + "adding: mem time275, current time 379, horizon 104\n", + "adding: mem time276, current time 379, horizon 103\n", + "adding: mem time277, current time 379, horizon 102\n", + "adding: mem time278, current time 379, horizon 101\n", + "adding: mem time279, current time 379, horizon 100\n", + "adding: mem time280, current time 379, horizon 99\n", + "adding: mem time281, current time 379, horizon 98\n", + "adding: mem time282, current time 379, horizon 97\n", + "adding: mem time283, current time 379, horizon 96\n", + "adding: mem time284, current time 379, horizon 95\n", + "adding: mem time285, current time 379, horizon 94\n", + "adding: mem time286, current time 379, horizon 93\n", + "adding: mem time287, current time 379, horizon 92\n", + "adding: mem time288, current time 379, horizon 91\n", + "adding: mem time289, current time 379, horizon 90\n", + "adding: mem time290, current time 379, horizon 89\n", + "adding: mem time291, current time 379, horizon 88\n", + "adding: mem time292, current time 379, horizon 87\n", + "adding: mem time293, current time 379, horizon 86\n", + "adding: mem time294, current time 379, horizon 85\n", + "adding: mem time295, current time 379, horizon 84\n", + "adding: mem time296, current time 379, horizon 83\n", + "adding: mem time297, current time 379, horizon 82\n", + "adding: mem time298, current time 379, horizon 81\n", + "adding: mem time299, current time 379, horizon 80\n", + "adding: mem time300, current time 379, horizon 79\n", + "adding: mem time301, current time 379, horizon 78\n", + "adding: mem time302, current time 379, horizon 77\n", + "adding: mem time303, current time 379, horizon 76\n", + "adding: mem time304, current time 379, horizon 75\n", + "adding: mem time305, current time 379, horizon 74\n", + "adding: mem time306, current time 379, horizon 73\n", + "adding: mem time307, current time 379, horizon 72\n", + "adding: mem time308, current time 379, horizon 71\n", + "adding: mem time309, current time 379, horizon 70\n", + "adding: mem time310, current time 379, horizon 69\n", + "adding: mem time311, current time 379, horizon 68\n", + "adding: mem time312, current time 379, horizon 67\n", + "adding: mem time313, current time 379, horizon 66\n", + "adding: mem time314, current time 379, horizon 65\n", + "adding: mem time315, current time 379, horizon 64\n", + "adding: mem time316, current time 379, horizon 63\n", + "adding: mem time317, current time 379, horizon 62\n", + "adding: mem time318, current time 379, horizon 61\n", + "adding: mem time319, current time 379, horizon 60\n", + "adding: mem time320, current time 379, horizon 59\n", + "adding: mem time321, current time 379, horizon 58\n", + "adding: mem time322, current time 379, horizon 57\n", + "adding: mem time323, current time 379, horizon 56\n", + "adding: mem time324, current time 379, horizon 55\n", + "adding: mem time325, current time 379, horizon 54\n", + "adding: mem time326, current time 379, horizon 53\n", + "adding: mem time327, current time 379, horizon 52\n", + "adding: mem time328, current time 379, horizon 51\n", + "adding: mem time329, current time 379, horizon 50\n", + "adding: mem time330, current time 379, horizon 49\n", + "adding: mem time331, current time 379, horizon 48\n", + "adding: mem time332, current time 379, horizon 47\n", + "adding: mem time333, current time 379, horizon 46\n", + "adding: mem time334, current time 379, horizon 45\n", + "adding: mem time335, current time 379, horizon 44\n", + "adding: mem time336, current time 379, horizon 43\n", + "adding: mem time337, current time 379, horizon 42\n", + "adding: mem time338, current time 379, horizon 41\n", + "adding: mem time339, current time 379, horizon 40\n", + "adding: mem time340, current time 379, horizon 39\n", + "adding: mem time341, current time 379, horizon 38\n", + "adding: mem time342, current time 379, horizon 37\n", + "adding: mem time343, current time 379, horizon 36\n", + "adding: mem time344, current time 379, horizon 35\n", + "adding: mem time345, current time 379, horizon 34\n", + "adding: mem time346, current time 379, horizon 33\n", + "adding: mem time347, current time 379, horizon 32\n", + "adding: mem time348, current time 379, horizon 31\n", + "adding: mem time349, current time 379, horizon 30\n", + "adding: mem time350, current time 379, horizon 29\n", + "adding: mem time351, current time 379, horizon 28\n", + "adding: mem time352, current time 379, horizon 27\n", + "adding: mem time353, current time 379, horizon 26\n", + "adding: mem time354, current time 379, horizon 25\n", + "adding: mem time355, current time 379, horizon 24\n", + "adding: mem time356, current time 379, horizon 23\n", + "adding: mem time357, current time 379, horizon 22\n", + "adding: mem time358, current time 379, horizon 21\n", + "adding: mem time359, current time 379, horizon 20\n", + "adding: mem time360, current time 379, horizon 19\n", + "adding: mem time361, current time 379, horizon 18\n", + "adding: mem time362, current time 379, horizon 17\n", + "adding: mem time363, current time 379, horizon 16\n", + "adding: mem time364, current time 379, horizon 15\n", + "adding: mem time365, current time 379, horizon 14\n", + "adding: mem time366, current time 379, horizon 13\n", + "adding: mem time367, current time 379, horizon 12\n", + "adding: mem time368, current time 379, horizon 11\n", + "adding: mem time369, current time 379, horizon 10\n", + "adding: mem time370, current time 379, horizon 9\n", + "adding: mem time371, current time 379, horizon 8\n", + "adding: mem time372, current time 379, horizon 7\n", + "adding: mem time373, current time 379, horizon 6\n", + "adding: mem time374, current time 379, horizon 5\n", + "adding: mem time375, current time 379, horizon 4\n", + "adding: mem time376, current time 379, horizon 3\n", + "adding: mem time377, current time 379, horizon 2\n", + "adding: mem time378, current time 379, horizon 1\n", + "adding: mem time200, current time 380, horizon 180\n", + "adding: mem time201, current time 380, horizon 179\n", + "adding: mem time202, current time 380, horizon 178\n", + "adding: mem time203, current time 380, horizon 177\n", + "adding: mem time204, current time 380, horizon 176\n", + "adding: mem time205, current time 380, horizon 175\n", + "adding: mem time206, current time 380, horizon 174\n", + "adding: mem time207, current time 380, horizon 173\n", + "adding: mem time208, current time 380, horizon 172\n", + "adding: mem time209, current time 380, horizon 171\n", + "adding: mem time210, current time 380, horizon 170\n", + "adding: mem time211, current time 380, horizon 169\n", + "adding: mem time212, current time 380, horizon 168\n", + "adding: mem time213, current time 380, horizon 167\n", + "adding: mem time214, current time 380, horizon 166\n", + "adding: mem time215, current time 380, horizon 165\n", + "adding: mem time216, current time 380, horizon 164\n", + "adding: mem time217, current time 380, horizon 163\n", + "adding: mem time218, current time 380, horizon 162\n", + "adding: mem time219, current time 380, horizon 161\n", + "adding: mem time220, current time 380, horizon 160\n", + "adding: mem time221, current time 380, horizon 159\n", + "adding: mem time222, current time 380, horizon 158\n", + "adding: mem time223, current time 380, horizon 157\n", + "adding: mem time224, current time 380, horizon 156\n", + "adding: mem time225, current time 380, horizon 155\n", + "adding: mem time226, current time 380, horizon 154\n", + "adding: mem time227, current time 380, horizon 153\n", + "adding: mem time228, current time 380, horizon 152\n", + "adding: mem time229, current time 380, horizon 151\n", + "adding: mem time230, current time 380, horizon 150\n", + "adding: mem time231, current time 380, horizon 149\n", + "adding: mem time232, current time 380, horizon 148\n", + "adding: mem time233, current time 380, horizon 147\n", + "adding: mem time234, current time 380, horizon 146\n", + "adding: mem time235, current time 380, horizon 145\n", + "adding: mem time236, current time 380, horizon 144\n", + "adding: mem time237, current time 380, horizon 143\n", + "adding: mem time238, current time 380, horizon 142\n", + "adding: mem time239, current time 380, horizon 141\n", + "adding: mem time240, current time 380, horizon 140\n", + "adding: mem time241, current time 380, horizon 139\n", + "adding: mem time242, current time 380, horizon 138\n", + "adding: mem time243, current time 380, horizon 137\n", + "adding: mem time244, current time 380, horizon 136\n", + "adding: mem time245, current time 380, horizon 135\n", + "adding: mem time246, current time 380, horizon 134\n", + "adding: mem time247, current time 380, horizon 133\n", + "adding: mem time248, current time 380, horizon 132\n", + "adding: mem time249, current time 380, horizon 131\n", + "adding: mem time250, current time 380, horizon 130\n", + "adding: mem time251, current time 380, horizon 129\n", + "adding: mem time252, current time 380, horizon 128\n", + "adding: mem time253, current time 380, horizon 127\n", + "adding: mem time254, current time 380, horizon 126\n", + "adding: mem time255, current time 380, horizon 125\n", + "adding: mem time256, current time 380, horizon 124\n", + "adding: mem time257, current time 380, horizon 123\n", + "adding: mem time258, current time 380, horizon 122\n", + "adding: mem time259, current time 380, horizon 121\n", + "adding: mem time260, current time 380, horizon 120\n", + "adding: mem time261, current time 380, horizon 119\n", + "adding: mem time262, current time 380, horizon 118\n", + "adding: mem time263, current time 380, horizon 117\n", + "adding: mem time264, current time 380, horizon 116\n", + "adding: mem time265, current time 380, horizon 115\n", + "adding: mem time266, current time 380, horizon 114\n", + "adding: mem time267, current time 380, horizon 113\n", + "adding: mem time268, current time 380, horizon 112\n", + "adding: mem time269, current time 380, horizon 111\n", + "adding: mem time270, current time 380, horizon 110\n", + "adding: mem time271, current time 380, horizon 109\n", + "adding: mem time272, current time 380, horizon 108\n", + "adding: mem time273, current time 380, horizon 107\n", + "adding: mem time274, current time 380, horizon 106\n", + "adding: mem time275, current time 380, horizon 105\n", + "adding: mem time276, current time 380, horizon 104\n", + "adding: mem time277, current time 380, horizon 103\n", + "adding: mem time278, current time 380, horizon 102\n", + "adding: mem time279, current time 380, horizon 101\n", + "adding: mem time280, current time 380, horizon 100\n", + "adding: mem time281, current time 380, horizon 99\n", + "adding: mem time282, current time 380, horizon 98\n", + "adding: mem time283, current time 380, horizon 97\n", + "adding: mem time284, current time 380, horizon 96\n", + "adding: mem time285, current time 380, horizon 95\n", + "adding: mem time286, current time 380, horizon 94\n", + "adding: mem time287, current time 380, horizon 93\n", + "adding: mem time288, current time 380, horizon 92\n", + "adding: mem time289, current time 380, horizon 91\n", + "adding: mem time290, current time 380, horizon 90\n", + "adding: mem time291, current time 380, horizon 89\n", + "adding: mem time292, current time 380, horizon 88\n", + "adding: mem time293, current time 380, horizon 87\n", + "adding: mem time294, current time 380, horizon 86\n", + "adding: mem time295, current time 380, horizon 85\n", + "adding: mem time296, current time 380, horizon 84\n", + "adding: mem time297, current time 380, horizon 83\n", + "adding: mem time298, current time 380, horizon 82\n", + "adding: mem time299, current time 380, horizon 81\n", + "adding: mem time300, current time 380, horizon 80\n", + "adding: mem time301, current time 380, horizon 79\n", + "adding: mem time302, current time 380, horizon 78\n", + "adding: mem time303, current time 380, horizon 77\n", + "adding: mem time304, current time 380, horizon 76\n", + "adding: mem time305, current time 380, horizon 75\n", + "adding: mem time306, current time 380, horizon 74\n", + "adding: mem time307, current time 380, horizon 73\n", + "adding: mem time308, current time 380, horizon 72\n", + "adding: mem time309, current time 380, horizon 71\n", + "adding: mem time310, current time 380, horizon 70\n", + "adding: mem time311, current time 380, horizon 69\n", + "adding: mem time312, current time 380, horizon 68\n", + "adding: mem time313, current time 380, horizon 67\n", + "adding: mem time314, current time 380, horizon 66\n", + "adding: mem time315, current time 380, horizon 65\n", + "adding: mem time316, current time 380, horizon 64\n", + "adding: mem time317, current time 380, horizon 63\n", + "adding: mem time318, current time 380, horizon 62\n", + "adding: mem time319, current time 380, horizon 61\n", + "adding: mem time320, current time 380, horizon 60\n", + "adding: mem time321, current time 380, horizon 59\n", + "adding: mem time322, current time 380, horizon 58\n", + "adding: mem time323, current time 380, horizon 57\n", + "adding: mem time324, current time 380, horizon 56\n", + "adding: mem time325, current time 380, horizon 55\n", + "adding: mem time326, current time 380, horizon 54\n", + "adding: mem time327, current time 380, horizon 53\n", + "adding: mem time328, current time 380, horizon 52\n", + "adding: mem time329, current time 380, horizon 51\n", + "adding: mem time330, current time 380, horizon 50\n", + "adding: mem time331, current time 380, horizon 49\n", + "adding: mem time332, current time 380, horizon 48\n", + "adding: mem time333, current time 380, horizon 47\n", + "adding: mem time334, current time 380, horizon 46\n", + "adding: mem time335, current time 380, horizon 45\n", + "adding: mem time336, current time 380, horizon 44\n", + "adding: mem time337, current time 380, horizon 43\n", + "adding: mem time338, current time 380, horizon 42\n", + "adding: mem time339, current time 380, horizon 41\n", + "adding: mem time340, current time 380, horizon 40\n", + "adding: mem time341, current time 380, horizon 39\n", + "adding: mem time342, current time 380, horizon 38\n", + "adding: mem time343, current time 380, horizon 37\n", + "adding: mem time344, current time 380, horizon 36\n", + "adding: mem time345, current time 380, horizon 35\n", + "adding: mem time346, current time 380, horizon 34\n", + "adding: mem time347, current time 380, horizon 33\n", + "adding: mem time348, current time 380, horizon 32\n", + "adding: mem time349, current time 380, horizon 31\n", + "adding: mem time350, current time 380, horizon 30\n", + "adding: mem time351, current time 380, horizon 29\n", + "adding: mem time352, current time 380, horizon 28\n", + "adding: mem time353, current time 380, horizon 27\n", + "adding: mem time354, current time 380, horizon 26\n", + "adding: mem time355, current time 380, horizon 25\n", + "adding: mem time356, current time 380, horizon 24\n", + "adding: mem time357, current time 380, horizon 23\n", + "adding: mem time358, current time 380, horizon 22\n", + "adding: mem time359, current time 380, horizon 21\n", + "adding: mem time360, current time 380, horizon 20\n", + "adding: mem time361, current time 380, horizon 19\n", + "adding: mem time362, current time 380, horizon 18\n", + "adding: mem time363, current time 380, horizon 17\n", + "adding: mem time364, current time 380, horizon 16\n", + "adding: mem time365, current time 380, horizon 15\n", + "adding: mem time366, current time 380, horizon 14\n", + "adding: mem time367, current time 380, horizon 13\n", + "adding: mem time368, current time 380, horizon 12\n", + "adding: mem time369, current time 380, horizon 11\n", + "adding: mem time370, current time 380, horizon 10\n", + "adding: mem time371, current time 380, horizon 9\n", + "adding: mem time372, current time 380, horizon 8\n", + "adding: mem time373, current time 380, horizon 7\n", + "adding: mem time374, current time 380, horizon 6\n", + "adding: mem time375, current time 380, horizon 5\n", + "adding: mem time376, current time 380, horizon 4\n", + "adding: mem time377, current time 380, horizon 3\n", + "adding: mem time378, current time 380, horizon 2\n", + "adding: mem time379, current time 380, horizon 1\n", + "adding: mem time200, current time 381, horizon 181\n", + "adding: mem time201, current time 381, horizon 180\n", + "adding: mem time202, current time 381, horizon 179\n", + "adding: mem time203, current time 381, horizon 178\n", + "adding: mem time204, current time 381, horizon 177\n", + "adding: mem time205, current time 381, horizon 176\n", + "adding: mem time206, current time 381, horizon 175\n", + "adding: mem time207, current time 381, horizon 174\n", + "adding: mem time208, current time 381, horizon 173\n", + "adding: mem time209, current time 381, horizon 172\n", + "adding: mem time210, current time 381, horizon 171\n", + "adding: mem time211, current time 381, horizon 170\n", + "adding: mem time212, current time 381, horizon 169\n", + "adding: mem time213, current time 381, horizon 168\n", + "adding: mem time214, current time 381, horizon 167\n", + "adding: mem time215, current time 381, horizon 166\n", + "adding: mem time216, current time 381, horizon 165\n", + "adding: mem time217, current time 381, horizon 164\n", + "adding: mem time218, current time 381, horizon 163\n", + "adding: mem time219, current time 381, horizon 162\n", + "adding: mem time220, current time 381, horizon 161\n", + "adding: mem time221, current time 381, horizon 160\n", + "adding: mem time222, current time 381, horizon 159\n", + "adding: mem time223, current time 381, horizon 158\n", + "adding: mem time224, current time 381, horizon 157\n", + "adding: mem time225, current time 381, horizon 156\n", + "adding: mem time226, current time 381, horizon 155\n", + "adding: mem time227, current time 381, horizon 154\n", + "adding: mem time228, current time 381, horizon 153\n", + "adding: mem time229, current time 381, horizon 152\n", + "adding: mem time230, current time 381, horizon 151\n", + "adding: mem time231, current time 381, horizon 150\n", + "adding: mem time232, current time 381, horizon 149\n", + "adding: mem time233, current time 381, horizon 148\n", + "adding: mem time234, current time 381, horizon 147\n", + "adding: mem time235, current time 381, horizon 146\n", + "adding: mem time236, current time 381, horizon 145\n", + "adding: mem time237, current time 381, horizon 144\n", + "adding: mem time238, current time 381, horizon 143\n", + "adding: mem time239, current time 381, horizon 142\n", + "adding: mem time240, current time 381, horizon 141\n", + "adding: mem time241, current time 381, horizon 140\n", + "adding: mem time242, current time 381, horizon 139\n", + "adding: mem time243, current time 381, horizon 138\n", + "adding: mem time244, current time 381, horizon 137\n", + "adding: mem time245, current time 381, horizon 136\n", + "adding: mem time246, current time 381, horizon 135\n", + "adding: mem time247, current time 381, horizon 134\n", + "adding: mem time248, current time 381, horizon 133\n", + "adding: mem time249, current time 381, horizon 132\n", + "adding: mem time250, current time 381, horizon 131\n", + "adding: mem time251, current time 381, horizon 130\n", + "adding: mem time252, current time 381, horizon 129\n", + "adding: mem time253, current time 381, horizon 128\n", + "adding: mem time254, current time 381, horizon 127\n", + "adding: mem time255, current time 381, horizon 126\n", + "adding: mem time256, current time 381, horizon 125\n", + "adding: mem time257, current time 381, horizon 124\n", + "adding: mem time258, current time 381, horizon 123\n", + "adding: mem time259, current time 381, horizon 122\n", + "adding: mem time260, current time 381, horizon 121\n", + "adding: mem time261, current time 381, horizon 120\n", + "adding: mem time262, current time 381, horizon 119\n", + "adding: mem time263, current time 381, horizon 118\n", + "adding: mem time264, current time 381, horizon 117\n", + "adding: mem time265, current time 381, horizon 116\n", + "adding: mem time266, current time 381, horizon 115\n", + "adding: mem time267, current time 381, horizon 114\n", + "adding: mem time268, current time 381, horizon 113\n", + "adding: mem time269, current time 381, horizon 112\n", + "adding: mem time270, current time 381, horizon 111\n", + "adding: mem time271, current time 381, horizon 110\n", + "adding: mem time272, current time 381, horizon 109\n", + "adding: mem time273, current time 381, horizon 108\n", + "adding: mem time274, current time 381, horizon 107\n", + "adding: mem time275, current time 381, horizon 106\n", + "adding: mem time276, current time 381, horizon 105\n", + "adding: mem time277, current time 381, horizon 104\n", + "adding: mem time278, current time 381, horizon 103\n", + "adding: mem time279, current time 381, horizon 102\n", + "adding: mem time280, current time 381, horizon 101\n", + "adding: mem time281, current time 381, horizon 100\n", + "adding: mem time282, current time 381, horizon 99\n", + "adding: mem time283, current time 381, horizon 98\n", + "adding: mem time284, current time 381, horizon 97\n", + "adding: mem time285, current time 381, horizon 96\n", + "adding: mem time286, current time 381, horizon 95\n", + "adding: mem time287, current time 381, horizon 94\n", + "adding: mem time288, current time 381, horizon 93\n", + "adding: mem time289, current time 381, horizon 92\n", + "adding: mem time290, current time 381, horizon 91\n", + "adding: mem time291, current time 381, horizon 90\n", + "adding: mem time292, current time 381, horizon 89\n", + "adding: mem time293, current time 381, horizon 88\n", + "adding: mem time294, current time 381, horizon 87\n", + "adding: mem time295, current time 381, horizon 86\n", + "adding: mem time296, current time 381, horizon 85\n", + "adding: mem time297, current time 381, horizon 84\n", + "adding: mem time298, current time 381, horizon 83\n", + "adding: mem time299, current time 381, horizon 82\n", + "adding: mem time300, current time 381, horizon 81\n", + "adding: mem time301, current time 381, horizon 80\n", + "adding: mem time302, current time 381, horizon 79\n", + "adding: mem time303, current time 381, horizon 78\n", + "adding: mem time304, current time 381, horizon 77\n", + "adding: mem time305, current time 381, horizon 76\n", + "adding: mem time306, current time 381, horizon 75\n", + "adding: mem time307, current time 381, horizon 74\n", + "adding: mem time308, current time 381, horizon 73\n", + "adding: mem time309, current time 381, horizon 72\n", + "adding: mem time310, current time 381, horizon 71\n", + "adding: mem time311, current time 381, horizon 70\n", + "adding: mem time312, current time 381, horizon 69\n", + "adding: mem time313, current time 381, horizon 68\n", + "adding: mem time314, current time 381, horizon 67\n", + "adding: mem time315, current time 381, horizon 66\n", + "adding: mem time316, current time 381, horizon 65\n", + "adding: mem time317, current time 381, horizon 64\n", + "adding: mem time318, current time 381, horizon 63\n", + "adding: mem time319, current time 381, horizon 62\n", + "adding: mem time320, current time 381, horizon 61\n", + "adding: mem time321, current time 381, horizon 60\n", + "adding: mem time322, current time 381, horizon 59\n", + "adding: mem time323, current time 381, horizon 58\n", + "adding: mem time324, current time 381, horizon 57\n", + "adding: mem time325, current time 381, horizon 56\n", + "adding: mem time326, current time 381, horizon 55\n", + "adding: mem time327, current time 381, horizon 54\n", + "adding: mem time328, current time 381, horizon 53\n", + "adding: mem time329, current time 381, horizon 52\n", + "adding: mem time330, current time 381, horizon 51\n", + "adding: mem time331, current time 381, horizon 50\n", + "adding: mem time332, current time 381, horizon 49\n", + "adding: mem time333, current time 381, horizon 48\n", + "adding: mem time334, current time 381, horizon 47\n", + "adding: mem time335, current time 381, horizon 46\n", + "adding: mem time336, current time 381, horizon 45\n", + "adding: mem time337, current time 381, horizon 44\n", + "adding: mem time338, current time 381, horizon 43\n", + "adding: mem time339, current time 381, horizon 42\n", + "adding: mem time340, current time 381, horizon 41\n", + "adding: mem time341, current time 381, horizon 40\n", + "adding: mem time342, current time 381, horizon 39\n", + "adding: mem time343, current time 381, horizon 38\n", + "adding: mem time344, current time 381, horizon 37\n", + "adding: mem time345, current time 381, horizon 36\n", + "adding: mem time346, current time 381, horizon 35\n", + "adding: mem time347, current time 381, horizon 34\n", + "adding: mem time348, current time 381, horizon 33\n", + "adding: mem time349, current time 381, horizon 32\n", + "adding: mem time350, current time 381, horizon 31\n", + "adding: mem time351, current time 381, horizon 30\n", + "adding: mem time352, current time 381, horizon 29\n", + "adding: mem time353, current time 381, horizon 28\n", + "adding: mem time354, current time 381, horizon 27\n", + "adding: mem time355, current time 381, horizon 26\n", + "adding: mem time356, current time 381, horizon 25\n", + "adding: mem time357, current time 381, horizon 24\n", + "adding: mem time358, current time 381, horizon 23\n", + "adding: mem time359, current time 381, horizon 22\n", + "adding: mem time360, current time 381, horizon 21\n", + "adding: mem time361, current time 381, horizon 20\n", + "adding: mem time362, current time 381, horizon 19\n", + "adding: mem time363, current time 381, horizon 18\n", + "adding: mem time364, current time 381, horizon 17\n", + "adding: mem time365, current time 381, horizon 16\n", + "adding: mem time366, current time 381, horizon 15\n", + "adding: mem time367, current time 381, horizon 14\n", + "adding: mem time368, current time 381, horizon 13\n", + "adding: mem time369, current time 381, horizon 12\n", + "adding: mem time370, current time 381, horizon 11\n", + "adding: mem time371, current time 381, horizon 10\n", + "adding: mem time372, current time 381, horizon 9\n", + "adding: mem time373, current time 381, horizon 8\n", + "adding: mem time374, current time 381, horizon 7\n", + "adding: mem time375, current time 381, horizon 6\n", + "adding: mem time376, current time 381, horizon 5\n", + "adding: mem time377, current time 381, horizon 4\n", + "adding: mem time378, current time 381, horizon 3\n", + "adding: mem time379, current time 381, horizon 2\n", + "adding: mem time380, current time 381, horizon 1\n", + "adding: mem time200, current time 382, horizon 182\n", + "adding: mem time201, current time 382, horizon 181\n", + "adding: mem time202, current time 382, horizon 180\n", + "adding: mem time203, current time 382, horizon 179\n", + "adding: mem time204, current time 382, horizon 178\n", + "adding: mem time205, current time 382, horizon 177\n", + "adding: mem time206, current time 382, horizon 176\n", + "adding: mem time207, current time 382, horizon 175\n", + "adding: mem time208, current time 382, horizon 174\n", + "adding: mem time209, current time 382, horizon 173\n", + "adding: mem time210, current time 382, horizon 172\n", + "adding: mem time211, current time 382, horizon 171\n", + "adding: mem time212, current time 382, horizon 170\n", + "adding: mem time213, current time 382, horizon 169\n", + "adding: mem time214, current time 382, horizon 168\n", + "adding: mem time215, current time 382, horizon 167\n", + "adding: mem time216, current time 382, horizon 166\n", + "adding: mem time217, current time 382, horizon 165\n", + "adding: mem time218, current time 382, horizon 164\n", + "adding: mem time219, current time 382, horizon 163\n", + "adding: mem time220, current time 382, horizon 162\n", + "adding: mem time221, current time 382, horizon 161\n", + "adding: mem time222, current time 382, horizon 160\n", + "adding: mem time223, current time 382, horizon 159\n", + "adding: mem time224, current time 382, horizon 158\n", + "adding: mem time225, current time 382, horizon 157\n", + "adding: mem time226, current time 382, horizon 156\n", + "adding: mem time227, current time 382, horizon 155\n", + "adding: mem time228, current time 382, horizon 154\n", + "adding: mem time229, current time 382, horizon 153\n", + "adding: mem time230, current time 382, horizon 152\n", + "adding: mem time231, current time 382, horizon 151\n", + "adding: mem time232, current time 382, horizon 150\n", + "adding: mem time233, current time 382, horizon 149\n", + "adding: mem time234, current time 382, horizon 148\n", + "adding: mem time235, current time 382, horizon 147\n", + "adding: mem time236, current time 382, horizon 146\n", + "adding: mem time237, current time 382, horizon 145\n", + "adding: mem time238, current time 382, horizon 144\n", + "adding: mem time239, current time 382, horizon 143\n", + "adding: mem time240, current time 382, horizon 142\n", + "adding: mem time241, current time 382, horizon 141\n", + "adding: mem time242, current time 382, horizon 140\n", + "adding: mem time243, current time 382, horizon 139\n", + "adding: mem time244, current time 382, horizon 138\n", + "adding: mem time245, current time 382, horizon 137\n", + "adding: mem time246, current time 382, horizon 136\n", + "adding: mem time247, current time 382, horizon 135\n", + "adding: mem time248, current time 382, horizon 134\n", + "adding: mem time249, current time 382, horizon 133\n", + "adding: mem time250, current time 382, horizon 132\n", + "adding: mem time251, current time 382, horizon 131\n", + "adding: mem time252, current time 382, horizon 130\n", + "adding: mem time253, current time 382, horizon 129\n", + "adding: mem time254, current time 382, horizon 128\n", + "adding: mem time255, current time 382, horizon 127\n", + "adding: mem time256, current time 382, horizon 126\n", + "adding: mem time257, current time 382, horizon 125\n", + "adding: mem time258, current time 382, horizon 124\n", + "adding: mem time259, current time 382, horizon 123\n", + "adding: mem time260, current time 382, horizon 122\n", + "adding: mem time261, current time 382, horizon 121\n", + "adding: mem time262, current time 382, horizon 120\n", + "adding: mem time263, current time 382, horizon 119\n", + "adding: mem time264, current time 382, horizon 118\n", + "adding: mem time265, current time 382, horizon 117\n", + "adding: mem time266, current time 382, horizon 116\n", + "adding: mem time267, current time 382, horizon 115\n", + "adding: mem time268, current time 382, horizon 114\n", + "adding: mem time269, current time 382, horizon 113\n", + "adding: mem time270, current time 382, horizon 112\n", + "adding: mem time271, current time 382, horizon 111\n", + "adding: mem time272, current time 382, horizon 110\n", + "adding: mem time273, current time 382, horizon 109\n", + "adding: mem time274, current time 382, horizon 108\n", + "adding: mem time275, current time 382, horizon 107\n", + "adding: mem time276, current time 382, horizon 106\n", + "adding: mem time277, current time 382, horizon 105\n", + "adding: mem time278, current time 382, horizon 104\n", + "adding: mem time279, current time 382, horizon 103\n", + "adding: mem time280, current time 382, horizon 102\n", + "adding: mem time281, current time 382, horizon 101\n", + "adding: mem time282, current time 382, horizon 100\n", + "adding: mem time283, current time 382, horizon 99\n", + "adding: mem time284, current time 382, horizon 98\n", + "adding: mem time285, current time 382, horizon 97\n", + "adding: mem time286, current time 382, horizon 96\n", + "adding: mem time287, current time 382, horizon 95\n", + "adding: mem time288, current time 382, horizon 94\n", + "adding: mem time289, current time 382, horizon 93\n", + "adding: mem time290, current time 382, horizon 92\n", + "adding: mem time291, current time 382, horizon 91\n", + "adding: mem time292, current time 382, horizon 90\n", + "adding: mem time293, current time 382, horizon 89\n", + "adding: mem time294, current time 382, horizon 88\n", + "adding: mem time295, current time 382, horizon 87\n", + "adding: mem time296, current time 382, horizon 86\n", + "adding: mem time297, current time 382, horizon 85\n", + "adding: mem time298, current time 382, horizon 84\n", + "adding: mem time299, current time 382, horizon 83\n", + "adding: mem time300, current time 382, horizon 82\n", + "adding: mem time301, current time 382, horizon 81\n", + "adding: mem time302, current time 382, horizon 80\n", + "adding: mem time303, current time 382, horizon 79\n", + "adding: mem time304, current time 382, horizon 78\n", + "adding: mem time305, current time 382, horizon 77\n", + "adding: mem time306, current time 382, horizon 76\n", + "adding: mem time307, current time 382, horizon 75\n", + "adding: mem time308, current time 382, horizon 74\n", + "adding: mem time309, current time 382, horizon 73\n", + "adding: mem time310, current time 382, horizon 72\n", + "adding: mem time311, current time 382, horizon 71\n", + "adding: mem time312, current time 382, horizon 70\n", + "adding: mem time313, current time 382, horizon 69\n", + "adding: mem time314, current time 382, horizon 68\n", + "adding: mem time315, current time 382, horizon 67\n", + "adding: mem time316, current time 382, horizon 66\n", + "adding: mem time317, current time 382, horizon 65\n", + "adding: mem time318, current time 382, horizon 64\n", + "adding: mem time319, current time 382, horizon 63\n", + "adding: mem time320, current time 382, horizon 62\n", + "adding: mem time321, current time 382, horizon 61\n", + "adding: mem time322, current time 382, horizon 60\n", + "adding: mem time323, current time 382, horizon 59\n", + "adding: mem time324, current time 382, horizon 58\n", + "adding: mem time325, current time 382, horizon 57\n", + "adding: mem time326, current time 382, horizon 56\n", + "adding: mem time327, current time 382, horizon 55\n", + "adding: mem time328, current time 382, horizon 54\n", + "adding: mem time329, current time 382, horizon 53\n", + "adding: mem time330, current time 382, horizon 52\n", + "adding: mem time331, current time 382, horizon 51\n", + "adding: mem time332, current time 382, horizon 50\n", + "adding: mem time333, current time 382, horizon 49\n", + "adding: mem time334, current time 382, horizon 48\n", + "adding: mem time335, current time 382, horizon 47\n", + "adding: mem time336, current time 382, horizon 46\n", + "adding: mem time337, current time 382, horizon 45\n", + "adding: mem time338, current time 382, horizon 44\n", + "adding: mem time339, current time 382, horizon 43\n", + "adding: mem time340, current time 382, horizon 42\n", + "adding: mem time341, current time 382, horizon 41\n", + "adding: mem time342, current time 382, horizon 40\n", + "adding: mem time343, current time 382, horizon 39\n", + "adding: mem time344, current time 382, horizon 38\n", + "adding: mem time345, current time 382, horizon 37\n", + "adding: mem time346, current time 382, horizon 36\n", + "adding: mem time347, current time 382, horizon 35\n", + "adding: mem time348, current time 382, horizon 34\n", + "adding: mem time349, current time 382, horizon 33\n", + "adding: mem time350, current time 382, horizon 32\n", + "adding: mem time351, current time 382, horizon 31\n", + "adding: mem time352, current time 382, horizon 30\n", + "adding: mem time353, current time 382, horizon 29\n", + "adding: mem time354, current time 382, horizon 28\n", + "adding: mem time355, current time 382, horizon 27\n", + "adding: mem time356, current time 382, horizon 26\n", + "adding: mem time357, current time 382, horizon 25\n", + "adding: mem time358, current time 382, horizon 24\n", + "adding: mem time359, current time 382, horizon 23\n", + "adding: mem time360, current time 382, horizon 22\n", + "adding: mem time361, current time 382, horizon 21\n", + "adding: mem time362, current time 382, horizon 20\n", + "adding: mem time363, current time 382, horizon 19\n", + "adding: mem time364, current time 382, horizon 18\n", + "adding: mem time365, current time 382, horizon 17\n", + "adding: mem time366, current time 382, horizon 16\n", + "adding: mem time367, current time 382, horizon 15\n", + "adding: mem time368, current time 382, horizon 14\n", + "adding: mem time369, current time 382, horizon 13\n", + "adding: mem time370, current time 382, horizon 12\n", + "adding: mem time371, current time 382, horizon 11\n", + "adding: mem time372, current time 382, horizon 10\n", + "adding: mem time373, current time 382, horizon 9\n", + "adding: mem time374, current time 382, horizon 8\n", + "adding: mem time375, current time 382, horizon 7\n", + "adding: mem time376, current time 382, horizon 6\n", + "adding: mem time377, current time 382, horizon 5\n", + "adding: mem time378, current time 382, horizon 4\n", + "adding: mem time379, current time 382, horizon 3\n", + "adding: mem time380, current time 382, horizon 2\n", + "adding: mem time381, current time 382, horizon 1\n", + "adding: mem time200, current time 383, horizon 183\n", + "adding: mem time201, current time 383, horizon 182\n", + "adding: mem time202, current time 383, horizon 181\n", + "adding: mem time203, current time 383, horizon 180\n", + "adding: mem time204, current time 383, horizon 179\n", + "adding: mem time205, current time 383, horizon 178\n", + "adding: mem time206, current time 383, horizon 177\n", + "adding: mem time207, current time 383, horizon 176\n", + "adding: mem time208, current time 383, horizon 175\n", + "adding: mem time209, current time 383, horizon 174\n", + "adding: mem time210, current time 383, horizon 173\n", + "adding: mem time211, current time 383, horizon 172\n", + "adding: mem time212, current time 383, horizon 171\n", + "adding: mem time213, current time 383, horizon 170\n", + "adding: mem time214, current time 383, horizon 169\n", + "adding: mem time215, current time 383, horizon 168\n", + "adding: mem time216, current time 383, horizon 167\n", + "adding: mem time217, current time 383, horizon 166\n", + "adding: mem time218, current time 383, horizon 165\n", + "adding: mem time219, current time 383, horizon 164\n", + "adding: mem time220, current time 383, horizon 163\n", + "adding: mem time221, current time 383, horizon 162\n", + "adding: mem time222, current time 383, horizon 161\n", + "adding: mem time223, current time 383, horizon 160\n", + "adding: mem time224, current time 383, horizon 159\n", + "adding: mem time225, current time 383, horizon 158\n", + "adding: mem time226, current time 383, horizon 157\n", + "adding: mem time227, current time 383, horizon 156\n", + "adding: mem time228, current time 383, horizon 155\n", + "adding: mem time229, current time 383, horizon 154\n", + "adding: mem time230, current time 383, horizon 153\n", + "adding: mem time231, current time 383, horizon 152\n", + "adding: mem time232, current time 383, horizon 151\n", + "adding: mem time233, current time 383, horizon 150\n", + "adding: mem time234, current time 383, horizon 149\n", + "adding: mem time235, current time 383, horizon 148\n", + "adding: mem time236, current time 383, horizon 147\n", + "adding: mem time237, current time 383, horizon 146\n", + "adding: mem time238, current time 383, horizon 145\n", + "adding: mem time239, current time 383, horizon 144\n", + "adding: mem time240, current time 383, horizon 143\n", + "adding: mem time241, current time 383, horizon 142\n", + "adding: mem time242, current time 383, horizon 141\n", + "adding: mem time243, current time 383, horizon 140\n", + "adding: mem time244, current time 383, horizon 139\n", + "adding: mem time245, current time 383, horizon 138\n", + "adding: mem time246, current time 383, horizon 137\n", + "adding: mem time247, current time 383, horizon 136\n", + "adding: mem time248, current time 383, horizon 135\n", + "adding: mem time249, current time 383, horizon 134\n", + "adding: mem time250, current time 383, horizon 133\n", + "adding: mem time251, current time 383, horizon 132\n", + "adding: mem time252, current time 383, horizon 131\n", + "adding: mem time253, current time 383, horizon 130\n", + "adding: mem time254, current time 383, horizon 129\n", + "adding: mem time255, current time 383, horizon 128\n", + "adding: mem time256, current time 383, horizon 127\n", + "adding: mem time257, current time 383, horizon 126\n", + "adding: mem time258, current time 383, horizon 125\n", + "adding: mem time259, current time 383, horizon 124\n", + "adding: mem time260, current time 383, horizon 123\n", + "adding: mem time261, current time 383, horizon 122\n", + "adding: mem time262, current time 383, horizon 121\n", + "adding: mem time263, current time 383, horizon 120\n", + "adding: mem time264, current time 383, horizon 119\n", + "adding: mem time265, current time 383, horizon 118\n", + "adding: mem time266, current time 383, horizon 117\n", + "adding: mem time267, current time 383, horizon 116\n", + "adding: mem time268, current time 383, horizon 115\n", + "adding: mem time269, current time 383, horizon 114\n", + "adding: mem time270, current time 383, horizon 113\n", + "adding: mem time271, current time 383, horizon 112\n", + "adding: mem time272, current time 383, horizon 111\n", + "adding: mem time273, current time 383, horizon 110\n", + "adding: mem time274, current time 383, horizon 109\n", + "adding: mem time275, current time 383, horizon 108\n", + "adding: mem time276, current time 383, horizon 107\n", + "adding: mem time277, current time 383, horizon 106\n", + "adding: mem time278, current time 383, horizon 105\n", + "adding: mem time279, current time 383, horizon 104\n", + "adding: mem time280, current time 383, horizon 103\n", + "adding: mem time281, current time 383, horizon 102\n", + "adding: mem time282, current time 383, horizon 101\n", + "adding: mem time283, current time 383, horizon 100\n", + "adding: mem time284, current time 383, horizon 99\n", + "adding: mem time285, current time 383, horizon 98\n", + "adding: mem time286, current time 383, horizon 97\n", + "adding: mem time287, current time 383, horizon 96\n", + "adding: mem time288, current time 383, horizon 95\n", + "adding: mem time289, current time 383, horizon 94\n", + "adding: mem time290, current time 383, horizon 93\n", + "adding: mem time291, current time 383, horizon 92\n", + "adding: mem time292, current time 383, horizon 91\n", + "adding: mem time293, current time 383, horizon 90\n", + "adding: mem time294, current time 383, horizon 89\n", + "adding: mem time295, current time 383, horizon 88\n", + "adding: mem time296, current time 383, horizon 87\n", + "adding: mem time297, current time 383, horizon 86\n", + "adding: mem time298, current time 383, horizon 85\n", + "adding: mem time299, current time 383, horizon 84\n", + "adding: mem time300, current time 383, horizon 83\n", + "adding: mem time301, current time 383, horizon 82\n", + "adding: mem time302, current time 383, horizon 81\n", + "adding: mem time303, current time 383, horizon 80\n", + "adding: mem time304, current time 383, horizon 79\n", + "adding: mem time305, current time 383, horizon 78\n", + "adding: mem time306, current time 383, horizon 77\n", + "adding: mem time307, current time 383, horizon 76\n", + "adding: mem time308, current time 383, horizon 75\n", + "adding: mem time309, current time 383, horizon 74\n", + "adding: mem time310, current time 383, horizon 73\n", + "adding: mem time311, current time 383, horizon 72\n", + "adding: mem time312, current time 383, horizon 71\n", + "adding: mem time313, current time 383, horizon 70\n", + "adding: mem time314, current time 383, horizon 69\n", + "adding: mem time315, current time 383, horizon 68\n", + "adding: mem time316, current time 383, horizon 67\n", + "adding: mem time317, current time 383, horizon 66\n", + "adding: mem time318, current time 383, horizon 65\n", + "adding: mem time319, current time 383, horizon 64\n", + "adding: mem time320, current time 383, horizon 63\n", + "adding: mem time321, current time 383, horizon 62\n", + "adding: mem time322, current time 383, horizon 61\n", + "adding: mem time323, current time 383, horizon 60\n", + "adding: mem time324, current time 383, horizon 59\n", + "adding: mem time325, current time 383, horizon 58\n", + "adding: mem time326, current time 383, horizon 57\n", + "adding: mem time327, current time 383, horizon 56\n", + "adding: mem time328, current time 383, horizon 55\n", + "adding: mem time329, current time 383, horizon 54\n", + "adding: mem time330, current time 383, horizon 53\n", + "adding: mem time331, current time 383, horizon 52\n", + "adding: mem time332, current time 383, horizon 51\n", + "adding: mem time333, current time 383, horizon 50\n", + "adding: mem time334, current time 383, horizon 49\n", + "adding: mem time335, current time 383, horizon 48\n", + "adding: mem time336, current time 383, horizon 47\n", + "adding: mem time337, current time 383, horizon 46\n", + "adding: mem time338, current time 383, horizon 45\n", + "adding: mem time339, current time 383, horizon 44\n", + "adding: mem time340, current time 383, horizon 43\n", + "adding: mem time341, current time 383, horizon 42\n", + "adding: mem time342, current time 383, horizon 41\n", + "adding: mem time343, current time 383, horizon 40\n", + "adding: mem time344, current time 383, horizon 39\n", + "adding: mem time345, current time 383, horizon 38\n", + "adding: mem time346, current time 383, horizon 37\n", + "adding: mem time347, current time 383, horizon 36\n", + "adding: mem time348, current time 383, horizon 35\n", + "adding: mem time349, current time 383, horizon 34\n", + "adding: mem time350, current time 383, horizon 33\n", + "adding: mem time351, current time 383, horizon 32\n", + "adding: mem time352, current time 383, horizon 31\n", + "adding: mem time353, current time 383, horizon 30\n", + "adding: mem time354, current time 383, horizon 29\n", + "adding: mem time355, current time 383, horizon 28\n", + "adding: mem time356, current time 383, horizon 27\n", + "adding: mem time357, current time 383, horizon 26\n", + "adding: mem time358, current time 383, horizon 25\n", + "adding: mem time359, current time 383, horizon 24\n", + "adding: mem time360, current time 383, horizon 23\n", + "adding: mem time361, current time 383, horizon 22\n", + "adding: mem time362, current time 383, horizon 21\n", + "adding: mem time363, current time 383, horizon 20\n", + "adding: mem time364, current time 383, horizon 19\n", + "adding: mem time365, current time 383, horizon 18\n", + "adding: mem time366, current time 383, horizon 17\n", + "adding: mem time367, current time 383, horizon 16\n", + "adding: mem time368, current time 383, horizon 15\n", + "adding: mem time369, current time 383, horizon 14\n", + "adding: mem time370, current time 383, horizon 13\n", + "adding: mem time371, current time 383, horizon 12\n", + "adding: mem time372, current time 383, horizon 11\n", + "adding: mem time373, current time 383, horizon 10\n", + "adding: mem time374, current time 383, horizon 9\n", + "adding: mem time375, current time 383, horizon 8\n", + "adding: mem time376, current time 383, horizon 7\n", + "adding: mem time377, current time 383, horizon 6\n", + "adding: mem time378, current time 383, horizon 5\n", + "adding: mem time379, current time 383, horizon 4\n", + "adding: mem time380, current time 383, horizon 3\n", + "adding: mem time381, current time 383, horizon 2\n", + "adding: mem time382, current time 383, horizon 1\n", + "adding: mem time200, current time 384, horizon 184\n", + "adding: mem time201, current time 384, horizon 183\n", + "adding: mem time202, current time 384, horizon 182\n", + "adding: mem time203, current time 384, horizon 181\n", + "adding: mem time204, current time 384, horizon 180\n", + "adding: mem time205, current time 384, horizon 179\n", + "adding: mem time206, current time 384, horizon 178\n", + "adding: mem time207, current time 384, horizon 177\n", + "adding: mem time208, current time 384, horizon 176\n", + "adding: mem time209, current time 384, horizon 175\n", + "adding: mem time210, current time 384, horizon 174\n", + "adding: mem time211, current time 384, horizon 173\n", + "adding: mem time212, current time 384, horizon 172\n", + "adding: mem time213, current time 384, horizon 171\n", + "adding: mem time214, current time 384, horizon 170\n", + "adding: mem time215, current time 384, horizon 169\n", + "adding: mem time216, current time 384, horizon 168\n", + "adding: mem time217, current time 384, horizon 167\n", + "adding: mem time218, current time 384, horizon 166\n", + "adding: mem time219, current time 384, horizon 165\n", + "adding: mem time220, current time 384, horizon 164\n", + "adding: mem time221, current time 384, horizon 163\n", + "adding: mem time222, current time 384, horizon 162\n", + "adding: mem time223, current time 384, horizon 161\n", + "adding: mem time224, current time 384, horizon 160\n", + "adding: mem time225, current time 384, horizon 159\n", + "adding: mem time226, current time 384, horizon 158\n", + "adding: mem time227, current time 384, horizon 157\n", + "adding: mem time228, current time 384, horizon 156\n", + "adding: mem time229, current time 384, horizon 155\n", + "adding: mem time230, current time 384, horizon 154\n", + "adding: mem time231, current time 384, horizon 153\n", + "adding: mem time232, current time 384, horizon 152\n", + "adding: mem time233, current time 384, horizon 151\n", + "adding: mem time234, current time 384, horizon 150\n", + "adding: mem time235, current time 384, horizon 149\n", + "adding: mem time236, current time 384, horizon 148\n", + "adding: mem time237, current time 384, horizon 147\n", + "adding: mem time238, current time 384, horizon 146\n", + "adding: mem time239, current time 384, horizon 145\n", + "adding: mem time240, current time 384, horizon 144\n", + "adding: mem time241, current time 384, horizon 143\n", + "adding: mem time242, current time 384, horizon 142\n", + "adding: mem time243, current time 384, horizon 141\n", + "adding: mem time244, current time 384, horizon 140\n", + "adding: mem time245, current time 384, horizon 139\n", + "adding: mem time246, current time 384, horizon 138\n", + "adding: mem time247, current time 384, horizon 137\n", + "adding: mem time248, current time 384, horizon 136\n", + "adding: mem time249, current time 384, horizon 135\n", + "adding: mem time250, current time 384, horizon 134\n", + "adding: mem time251, current time 384, horizon 133\n", + "adding: mem time252, current time 384, horizon 132\n", + "adding: mem time253, current time 384, horizon 131\n", + "adding: mem time254, current time 384, horizon 130\n", + "adding: mem time255, current time 384, horizon 129\n", + "adding: mem time256, current time 384, horizon 128\n", + "adding: mem time257, current time 384, horizon 127\n", + "adding: mem time258, current time 384, horizon 126\n", + "adding: mem time259, current time 384, horizon 125\n", + "adding: mem time260, current time 384, horizon 124\n", + "adding: mem time261, current time 384, horizon 123\n", + "adding: mem time262, current time 384, horizon 122\n", + "adding: mem time263, current time 384, horizon 121\n", + "adding: mem time264, current time 384, horizon 120\n", + "adding: mem time265, current time 384, horizon 119\n", + "adding: mem time266, current time 384, horizon 118\n", + "adding: mem time267, current time 384, horizon 117\n", + "adding: mem time268, current time 384, horizon 116\n", + "adding: mem time269, current time 384, horizon 115\n", + "adding: mem time270, current time 384, horizon 114\n", + "adding: mem time271, current time 384, horizon 113\n", + "adding: mem time272, current time 384, horizon 112\n", + "adding: mem time273, current time 384, horizon 111\n", + "adding: mem time274, current time 384, horizon 110\n", + "adding: mem time275, current time 384, horizon 109\n", + "adding: mem time276, current time 384, horizon 108\n", + "adding: mem time277, current time 384, horizon 107\n", + "adding: mem time278, current time 384, horizon 106\n", + "adding: mem time279, current time 384, horizon 105\n", + "adding: mem time280, current time 384, horizon 104\n", + "adding: mem time281, current time 384, horizon 103\n", + "adding: mem time282, current time 384, horizon 102\n", + "adding: mem time283, current time 384, horizon 101\n", + "adding: mem time284, current time 384, horizon 100\n", + "adding: mem time285, current time 384, horizon 99\n", + "adding: mem time286, current time 384, horizon 98\n", + "adding: mem time287, current time 384, horizon 97\n", + "adding: mem time288, current time 384, horizon 96\n", + "adding: mem time289, current time 384, horizon 95\n", + "adding: mem time290, current time 384, horizon 94\n", + "adding: mem time291, current time 384, horizon 93\n", + "adding: mem time292, current time 384, horizon 92\n", + "adding: mem time293, current time 384, horizon 91\n", + "adding: mem time294, current time 384, horizon 90\n", + "adding: mem time295, current time 384, horizon 89\n", + "adding: mem time296, current time 384, horizon 88\n", + "adding: mem time297, current time 384, horizon 87\n", + "adding: mem time298, current time 384, horizon 86\n", + "adding: mem time299, current time 384, horizon 85\n", + "adding: mem time300, current time 384, horizon 84\n", + "adding: mem time301, current time 384, horizon 83\n", + "adding: mem time302, current time 384, horizon 82\n", + "adding: mem time303, current time 384, horizon 81\n", + "adding: mem time304, current time 384, horizon 80\n", + "adding: mem time305, current time 384, horizon 79\n", + "adding: mem time306, current time 384, horizon 78\n", + "adding: mem time307, current time 384, horizon 77\n", + "adding: mem time308, current time 384, horizon 76\n", + "adding: mem time309, current time 384, horizon 75\n", + "adding: mem time310, current time 384, horizon 74\n", + "adding: mem time311, current time 384, horizon 73\n", + "adding: mem time312, current time 384, horizon 72\n", + "adding: mem time313, current time 384, horizon 71\n", + "adding: mem time314, current time 384, horizon 70\n", + "adding: mem time315, current time 384, horizon 69\n", + "adding: mem time316, current time 384, horizon 68\n", + "adding: mem time317, current time 384, horizon 67\n", + "adding: mem time318, current time 384, horizon 66\n", + "adding: mem time319, current time 384, horizon 65\n", + "adding: mem time320, current time 384, horizon 64\n", + "adding: mem time321, current time 384, horizon 63\n", + "adding: mem time322, current time 384, horizon 62\n", + "adding: mem time323, current time 384, horizon 61\n", + "adding: mem time324, current time 384, horizon 60\n", + "adding: mem time325, current time 384, horizon 59\n", + "adding: mem time326, current time 384, horizon 58\n", + "adding: mem time327, current time 384, horizon 57\n", + "adding: mem time328, current time 384, horizon 56\n", + "adding: mem time329, current time 384, horizon 55\n", + "adding: mem time330, current time 384, horizon 54\n", + "adding: mem time331, current time 384, horizon 53\n", + "adding: mem time332, current time 384, horizon 52\n", + "adding: mem time333, current time 384, horizon 51\n", + "adding: mem time334, current time 384, horizon 50\n", + "adding: mem time335, current time 384, horizon 49\n", + "adding: mem time336, current time 384, horizon 48\n", + "adding: mem time337, current time 384, horizon 47\n", + "adding: mem time338, current time 384, horizon 46\n", + "adding: mem time339, current time 384, horizon 45\n", + "adding: mem time340, current time 384, horizon 44\n", + "adding: mem time341, current time 384, horizon 43\n", + "adding: mem time342, current time 384, horizon 42\n", + "adding: mem time343, current time 384, horizon 41\n", + "adding: mem time344, current time 384, horizon 40\n", + "adding: mem time345, current time 384, horizon 39\n", + "adding: mem time346, current time 384, horizon 38\n", + "adding: mem time347, current time 384, horizon 37\n", + "adding: mem time348, current time 384, horizon 36\n", + "adding: mem time349, current time 384, horizon 35\n", + "adding: mem time350, current time 384, horizon 34\n", + "adding: mem time351, current time 384, horizon 33\n", + "adding: mem time352, current time 384, horizon 32\n", + "adding: mem time353, current time 384, horizon 31\n", + "adding: mem time354, current time 384, horizon 30\n", + "adding: mem time355, current time 384, horizon 29\n", + "adding: mem time356, current time 384, horizon 28\n", + "adding: mem time357, current time 384, horizon 27\n", + "adding: mem time358, current time 384, horizon 26\n", + "adding: mem time359, current time 384, horizon 25\n", + "adding: mem time360, current time 384, horizon 24\n", + "adding: mem time361, current time 384, horizon 23\n", + "adding: mem time362, current time 384, horizon 22\n", + "adding: mem time363, current time 384, horizon 21\n", + "adding: mem time364, current time 384, horizon 20\n", + "adding: mem time365, current time 384, horizon 19\n", + "adding: mem time366, current time 384, horizon 18\n", + "adding: mem time367, current time 384, horizon 17\n", + "adding: mem time368, current time 384, horizon 16\n", + "adding: mem time369, current time 384, horizon 15\n", + "adding: mem time370, current time 384, horizon 14\n", + "adding: mem time371, current time 384, horizon 13\n", + "adding: mem time372, current time 384, horizon 12\n", + "adding: mem time373, current time 384, horizon 11\n", + "adding: mem time374, current time 384, horizon 10\n", + "adding: mem time375, current time 384, horizon 9\n", + "adding: mem time376, current time 384, horizon 8\n", + "adding: mem time377, current time 384, horizon 7\n", + "adding: mem time378, current time 384, horizon 6\n", + "adding: mem time379, current time 384, horizon 5\n", + "adding: mem time380, current time 384, horizon 4\n", + "adding: mem time381, current time 384, horizon 3\n", + "adding: mem time382, current time 384, horizon 2\n", + "adding: mem time383, current time 384, horizon 1\n", + "adding: mem time200, current time 385, horizon 185\n", + "adding: mem time201, current time 385, horizon 184\n", + "adding: mem time202, current time 385, horizon 183\n", + "adding: mem time203, current time 385, horizon 182\n", + "adding: mem time204, current time 385, horizon 181\n", + "adding: mem time205, current time 385, horizon 180\n", + "adding: mem time206, current time 385, horizon 179\n", + "adding: mem time207, current time 385, horizon 178\n", + "adding: mem time208, current time 385, horizon 177\n", + "adding: mem time209, current time 385, horizon 176\n", + "adding: mem time210, current time 385, horizon 175\n", + "adding: mem time211, current time 385, horizon 174\n", + "adding: mem time212, current time 385, horizon 173\n", + "adding: mem time213, current time 385, horizon 172\n", + "adding: mem time214, current time 385, horizon 171\n", + "adding: mem time215, current time 385, horizon 170\n", + "adding: mem time216, current time 385, horizon 169\n", + "adding: mem time217, current time 385, horizon 168\n", + "adding: mem time218, current time 385, horizon 167\n", + "adding: mem time219, current time 385, horizon 166\n", + "adding: mem time220, current time 385, horizon 165\n", + "adding: mem time221, current time 385, horizon 164\n", + "adding: mem time222, current time 385, horizon 163\n", + "adding: mem time223, current time 385, horizon 162\n", + "adding: mem time224, current time 385, horizon 161\n", + "adding: mem time225, current time 385, horizon 160\n", + "adding: mem time226, current time 385, horizon 159\n", + "adding: mem time227, current time 385, horizon 158\n", + "adding: mem time228, current time 385, horizon 157\n", + "adding: mem time229, current time 385, horizon 156\n", + "adding: mem time230, current time 385, horizon 155\n", + "adding: mem time231, current time 385, horizon 154\n", + "adding: mem time232, current time 385, horizon 153\n", + "adding: mem time233, current time 385, horizon 152\n", + "adding: mem time234, current time 385, horizon 151\n", + "adding: mem time235, current time 385, horizon 150\n", + "adding: mem time236, current time 385, horizon 149\n", + "adding: mem time237, current time 385, horizon 148\n", + "adding: mem time238, current time 385, horizon 147\n", + "adding: mem time239, current time 385, horizon 146\n", + "adding: mem time240, current time 385, horizon 145\n", + "adding: mem time241, current time 385, horizon 144\n", + "adding: mem time242, current time 385, horizon 143\n", + "adding: mem time243, current time 385, horizon 142\n", + "adding: mem time244, current time 385, horizon 141\n", + "adding: mem time245, current time 385, horizon 140\n", + "adding: mem time246, current time 385, horizon 139\n", + "adding: mem time247, current time 385, horizon 138\n", + "adding: mem time248, current time 385, horizon 137\n", + "adding: mem time249, current time 385, horizon 136\n", + "adding: mem time250, current time 385, horizon 135\n", + "adding: mem time251, current time 385, horizon 134\n", + "adding: mem time252, current time 385, horizon 133\n", + "adding: mem time253, current time 385, horizon 132\n", + "adding: mem time254, current time 385, horizon 131\n", + "adding: mem time255, current time 385, horizon 130\n", + "adding: mem time256, current time 385, horizon 129\n", + "adding: mem time257, current time 385, horizon 128\n", + "adding: mem time258, current time 385, horizon 127\n", + "adding: mem time259, current time 385, horizon 126\n", + "adding: mem time260, current time 385, horizon 125\n", + "adding: mem time261, current time 385, horizon 124\n", + "adding: mem time262, current time 385, horizon 123\n", + "adding: mem time263, current time 385, horizon 122\n", + "adding: mem time264, current time 385, horizon 121\n", + "adding: mem time265, current time 385, horizon 120\n", + "adding: mem time266, current time 385, horizon 119\n", + "adding: mem time267, current time 385, horizon 118\n", + "adding: mem time268, current time 385, horizon 117\n", + "adding: mem time269, current time 385, horizon 116\n", + "adding: mem time270, current time 385, horizon 115\n", + "adding: mem time271, current time 385, horizon 114\n", + "adding: mem time272, current time 385, horizon 113\n", + "adding: mem time273, current time 385, horizon 112\n", + "adding: mem time274, current time 385, horizon 111\n", + "adding: mem time275, current time 385, horizon 110\n", + "adding: mem time276, current time 385, horizon 109\n", + "adding: mem time277, current time 385, horizon 108\n", + "adding: mem time278, current time 385, horizon 107\n", + "adding: mem time279, current time 385, horizon 106\n", + "adding: mem time280, current time 385, horizon 105\n", + "adding: mem time281, current time 385, horizon 104\n", + "adding: mem time282, current time 385, horizon 103\n", + "adding: mem time283, current time 385, horizon 102\n", + "adding: mem time284, current time 385, horizon 101\n", + "adding: mem time285, current time 385, horizon 100\n", + "adding: mem time286, current time 385, horizon 99\n", + "adding: mem time287, current time 385, horizon 98\n", + "adding: mem time288, current time 385, horizon 97\n", + "adding: mem time289, current time 385, horizon 96\n", + "adding: mem time290, current time 385, horizon 95\n", + "adding: mem time291, current time 385, horizon 94\n", + "adding: mem time292, current time 385, horizon 93\n", + "adding: mem time293, current time 385, horizon 92\n", + "adding: mem time294, current time 385, horizon 91\n", + "adding: mem time295, current time 385, horizon 90\n", + "adding: mem time296, current time 385, horizon 89\n", + "adding: mem time297, current time 385, horizon 88\n", + "adding: mem time298, current time 385, horizon 87\n", + "adding: mem time299, current time 385, horizon 86\n", + "adding: mem time300, current time 385, horizon 85\n", + "adding: mem time301, current time 385, horizon 84\n", + "adding: mem time302, current time 385, horizon 83\n", + "adding: mem time303, current time 385, horizon 82\n", + "adding: mem time304, current time 385, horizon 81\n", + "adding: mem time305, current time 385, horizon 80\n", + "adding: mem time306, current time 385, horizon 79\n", + "adding: mem time307, current time 385, horizon 78\n", + "adding: mem time308, current time 385, horizon 77\n", + "adding: mem time309, current time 385, horizon 76\n", + "adding: mem time310, current time 385, horizon 75\n", + "adding: mem time311, current time 385, horizon 74\n", + "adding: mem time312, current time 385, horizon 73\n", + "adding: mem time313, current time 385, horizon 72\n", + "adding: mem time314, current time 385, horizon 71\n", + "adding: mem time315, current time 385, horizon 70\n", + "adding: mem time316, current time 385, horizon 69\n", + "adding: mem time317, current time 385, horizon 68\n", + "adding: mem time318, current time 385, horizon 67\n", + "adding: mem time319, current time 385, horizon 66\n", + "adding: mem time320, current time 385, horizon 65\n", + "adding: mem time321, current time 385, horizon 64\n", + "adding: mem time322, current time 385, horizon 63\n", + "adding: mem time323, current time 385, horizon 62\n", + "adding: mem time324, current time 385, horizon 61\n", + "adding: mem time325, current time 385, horizon 60\n", + "adding: mem time326, current time 385, horizon 59\n", + "adding: mem time327, current time 385, horizon 58\n", + "adding: mem time328, current time 385, horizon 57\n", + "adding: mem time329, current time 385, horizon 56\n", + "adding: mem time330, current time 385, horizon 55\n", + "adding: mem time331, current time 385, horizon 54\n", + "adding: mem time332, current time 385, horizon 53\n", + "adding: mem time333, current time 385, horizon 52\n", + "adding: mem time334, current time 385, horizon 51\n", + "adding: mem time335, current time 385, horizon 50\n", + "adding: mem time336, current time 385, horizon 49\n", + "adding: mem time337, current time 385, horizon 48\n", + "adding: mem time338, current time 385, horizon 47\n", + "adding: mem time339, current time 385, horizon 46\n", + "adding: mem time340, current time 385, horizon 45\n", + "adding: mem time341, current time 385, horizon 44\n", + "adding: mem time342, current time 385, horizon 43\n", + "adding: mem time343, current time 385, horizon 42\n", + "adding: mem time344, current time 385, horizon 41\n", + "adding: mem time345, current time 385, horizon 40\n", + "adding: mem time346, current time 385, horizon 39\n", + "adding: mem time347, current time 385, horizon 38\n", + "adding: mem time348, current time 385, horizon 37\n", + "adding: mem time349, current time 385, horizon 36\n", + "adding: mem time350, current time 385, horizon 35\n", + "adding: mem time351, current time 385, horizon 34\n", + "adding: mem time352, current time 385, horizon 33\n", + "adding: mem time353, current time 385, horizon 32\n", + "adding: mem time354, current time 385, horizon 31\n", + "adding: mem time355, current time 385, horizon 30\n", + "adding: mem time356, current time 385, horizon 29\n", + "adding: mem time357, current time 385, horizon 28\n", + "adding: mem time358, current time 385, horizon 27\n", + "adding: mem time359, current time 385, horizon 26\n", + "adding: mem time360, current time 385, horizon 25\n", + "adding: mem time361, current time 385, horizon 24\n", + "adding: mem time362, current time 385, horizon 23\n", + "adding: mem time363, current time 385, horizon 22\n", + "adding: mem time364, current time 385, horizon 21\n", + "adding: mem time365, current time 385, horizon 20\n", + "adding: mem time366, current time 385, horizon 19\n", + "adding: mem time367, current time 385, horizon 18\n", + "adding: mem time368, current time 385, horizon 17\n", + "adding: mem time369, current time 385, horizon 16\n", + "adding: mem time370, current time 385, horizon 15\n", + "adding: mem time371, current time 385, horizon 14\n", + "adding: mem time372, current time 385, horizon 13\n", + "adding: mem time373, current time 385, horizon 12\n", + "adding: mem time374, current time 385, horizon 11\n", + "adding: mem time375, current time 385, horizon 10\n", + "adding: mem time376, current time 385, horizon 9\n", + "adding: mem time377, current time 385, horizon 8\n", + "adding: mem time378, current time 385, horizon 7\n", + "adding: mem time379, current time 385, horizon 6\n", + "adding: mem time380, current time 385, horizon 5\n", + "adding: mem time381, current time 385, horizon 4\n", + "adding: mem time382, current time 385, horizon 3\n", + "adding: mem time383, current time 385, horizon 2\n", + "adding: mem time384, current time 385, horizon 1\n", + "adding: mem time200, current time 386, horizon 186\n", + "adding: mem time201, current time 386, horizon 185\n", + "adding: mem time202, current time 386, horizon 184\n", + "adding: mem time203, current time 386, horizon 183\n", + "adding: mem time204, current time 386, horizon 182\n", + "adding: mem time205, current time 386, horizon 181\n", + "adding: mem time206, current time 386, horizon 180\n", + "adding: mem time207, current time 386, horizon 179\n", + "adding: mem time208, current time 386, horizon 178\n", + "adding: mem time209, current time 386, horizon 177\n", + "adding: mem time210, current time 386, horizon 176\n", + "adding: mem time211, current time 386, horizon 175\n", + "adding: mem time212, current time 386, horizon 174\n", + "adding: mem time213, current time 386, horizon 173\n", + "adding: mem time214, current time 386, horizon 172\n", + "adding: mem time215, current time 386, horizon 171\n", + "adding: mem time216, current time 386, horizon 170\n", + "adding: mem time217, current time 386, horizon 169\n", + "adding: mem time218, current time 386, horizon 168\n", + "adding: mem time219, current time 386, horizon 167\n", + "adding: mem time220, current time 386, horizon 166\n", + "adding: mem time221, current time 386, horizon 165\n", + "adding: mem time222, current time 386, horizon 164\n", + "adding: mem time223, current time 386, horizon 163\n", + "adding: mem time224, current time 386, horizon 162\n", + "adding: mem time225, current time 386, horizon 161\n", + "adding: mem time226, current time 386, horizon 160\n", + "adding: mem time227, current time 386, horizon 159\n", + "adding: mem time228, current time 386, horizon 158\n", + "adding: mem time229, current time 386, horizon 157\n", + "adding: mem time230, current time 386, horizon 156\n", + "adding: mem time231, current time 386, horizon 155\n", + "adding: mem time232, current time 386, horizon 154\n", + "adding: mem time233, current time 386, horizon 153\n", + "adding: mem time234, current time 386, horizon 152\n", + "adding: mem time235, current time 386, horizon 151\n", + "adding: mem time236, current time 386, horizon 150\n", + "adding: mem time237, current time 386, horizon 149\n", + "adding: mem time238, current time 386, horizon 148\n", + "adding: mem time239, current time 386, horizon 147\n", + "adding: mem time240, current time 386, horizon 146\n", + "adding: mem time241, current time 386, horizon 145\n", + "adding: mem time242, current time 386, horizon 144\n", + "adding: mem time243, current time 386, horizon 143\n", + "adding: mem time244, current time 386, horizon 142\n", + "adding: mem time245, current time 386, horizon 141\n", + "adding: mem time246, current time 386, horizon 140\n", + "adding: mem time247, current time 386, horizon 139\n", + "adding: mem time248, current time 386, horizon 138\n", + "adding: mem time249, current time 386, horizon 137\n", + "adding: mem time250, current time 386, horizon 136\n", + "adding: mem time251, current time 386, horizon 135\n", + "adding: mem time252, current time 386, horizon 134\n", + "adding: mem time253, current time 386, horizon 133\n", + "adding: mem time254, current time 386, horizon 132\n", + "adding: mem time255, current time 386, horizon 131\n", + "adding: mem time256, current time 386, horizon 130\n", + "adding: mem time257, current time 386, horizon 129\n", + "adding: mem time258, current time 386, horizon 128\n", + "adding: mem time259, current time 386, horizon 127\n", + "adding: mem time260, current time 386, horizon 126\n", + "adding: mem time261, current time 386, horizon 125\n", + "adding: mem time262, current time 386, horizon 124\n", + "adding: mem time263, current time 386, horizon 123\n", + "adding: mem time264, current time 386, horizon 122\n", + "adding: mem time265, current time 386, horizon 121\n", + "adding: mem time266, current time 386, horizon 120\n", + "adding: mem time267, current time 386, horizon 119\n", + "adding: mem time268, current time 386, horizon 118\n", + "adding: mem time269, current time 386, horizon 117\n", + "adding: mem time270, current time 386, horizon 116\n", + "adding: mem time271, current time 386, horizon 115\n", + "adding: mem time272, current time 386, horizon 114\n", + "adding: mem time273, current time 386, horizon 113\n", + "adding: mem time274, current time 386, horizon 112\n", + "adding: mem time275, current time 386, horizon 111\n", + "adding: mem time276, current time 386, horizon 110\n", + "adding: mem time277, current time 386, horizon 109\n", + "adding: mem time278, current time 386, horizon 108\n", + "adding: mem time279, current time 386, horizon 107\n", + "adding: mem time280, current time 386, horizon 106\n", + "adding: mem time281, current time 386, horizon 105\n", + "adding: mem time282, current time 386, horizon 104\n", + "adding: mem time283, current time 386, horizon 103\n", + "adding: mem time284, current time 386, horizon 102\n", + "adding: mem time285, current time 386, horizon 101\n", + "adding: mem time286, current time 386, horizon 100\n", + "adding: mem time287, current time 386, horizon 99\n", + "adding: mem time288, current time 386, horizon 98\n", + "adding: mem time289, current time 386, horizon 97\n", + "adding: mem time290, current time 386, horizon 96\n", + "adding: mem time291, current time 386, horizon 95\n", + "adding: mem time292, current time 386, horizon 94\n", + "adding: mem time293, current time 386, horizon 93\n", + "adding: mem time294, current time 386, horizon 92\n", + "adding: mem time295, current time 386, horizon 91\n", + "adding: mem time296, current time 386, horizon 90\n", + "adding: mem time297, current time 386, horizon 89\n", + "adding: mem time298, current time 386, horizon 88\n", + "adding: mem time299, current time 386, horizon 87\n", + "adding: mem time300, current time 386, horizon 86\n", + "adding: mem time301, current time 386, horizon 85\n", + "adding: mem time302, current time 386, horizon 84\n", + "adding: mem time303, current time 386, horizon 83\n", + "adding: mem time304, current time 386, horizon 82\n", + "adding: mem time305, current time 386, horizon 81\n", + "adding: mem time306, current time 386, horizon 80\n", + "adding: mem time307, current time 386, horizon 79\n", + "adding: mem time308, current time 386, horizon 78\n", + "adding: mem time309, current time 386, horizon 77\n", + "adding: mem time310, current time 386, horizon 76\n", + "adding: mem time311, current time 386, horizon 75\n", + "adding: mem time312, current time 386, horizon 74\n", + "adding: mem time313, current time 386, horizon 73\n", + "adding: mem time314, current time 386, horizon 72\n", + "adding: mem time315, current time 386, horizon 71\n", + "adding: mem time316, current time 386, horizon 70\n", + "adding: mem time317, current time 386, horizon 69\n", + "adding: mem time318, current time 386, horizon 68\n", + "adding: mem time319, current time 386, horizon 67\n", + "adding: mem time320, current time 386, horizon 66\n", + "adding: mem time321, current time 386, horizon 65\n", + "adding: mem time322, current time 386, horizon 64\n", + "adding: mem time323, current time 386, horizon 63\n", + "adding: mem time324, current time 386, horizon 62\n", + "adding: mem time325, current time 386, horizon 61\n", + "adding: mem time326, current time 386, horizon 60\n", + "adding: mem time327, current time 386, horizon 59\n", + "adding: mem time328, current time 386, horizon 58\n", + "adding: mem time329, current time 386, horizon 57\n", + "adding: mem time330, current time 386, horizon 56\n", + "adding: mem time331, current time 386, horizon 55\n", + "adding: mem time332, current time 386, horizon 54\n", + "adding: mem time333, current time 386, horizon 53\n", + "adding: mem time334, current time 386, horizon 52\n", + "adding: mem time335, current time 386, horizon 51\n", + "adding: mem time336, current time 386, horizon 50\n", + "adding: mem time337, current time 386, horizon 49\n", + "adding: mem time338, current time 386, horizon 48\n", + "adding: mem time339, current time 386, horizon 47\n", + "adding: mem time340, current time 386, horizon 46\n", + "adding: mem time341, current time 386, horizon 45\n", + "adding: mem time342, current time 386, horizon 44\n", + "adding: mem time343, current time 386, horizon 43\n", + "adding: mem time344, current time 386, horizon 42\n", + "adding: mem time345, current time 386, horizon 41\n", + "adding: mem time346, current time 386, horizon 40\n", + "adding: mem time347, current time 386, horizon 39\n", + "adding: mem time348, current time 386, horizon 38\n", + "adding: mem time349, current time 386, horizon 37\n", + "adding: mem time350, current time 386, horizon 36\n", + "adding: mem time351, current time 386, horizon 35\n", + "adding: mem time352, current time 386, horizon 34\n", + "adding: mem time353, current time 386, horizon 33\n", + "adding: mem time354, current time 386, horizon 32\n", + "adding: mem time355, current time 386, horizon 31\n", + "adding: mem time356, current time 386, horizon 30\n", + "adding: mem time357, current time 386, horizon 29\n", + "adding: mem time358, current time 386, horizon 28\n", + "adding: mem time359, current time 386, horizon 27\n", + "adding: mem time360, current time 386, horizon 26\n", + "adding: mem time361, current time 386, horizon 25\n", + "adding: mem time362, current time 386, horizon 24\n", + "adding: mem time363, current time 386, horizon 23\n", + "adding: mem time364, current time 386, horizon 22\n", + "adding: mem time365, current time 386, horizon 21\n", + "adding: mem time366, current time 386, horizon 20\n", + "adding: mem time367, current time 386, horizon 19\n", + "adding: mem time368, current time 386, horizon 18\n", + "adding: mem time369, current time 386, horizon 17\n", + "adding: mem time370, current time 386, horizon 16\n", + "adding: mem time371, current time 386, horizon 15\n", + "adding: mem time372, current time 386, horizon 14\n", + "adding: mem time373, current time 386, horizon 13\n", + "adding: mem time374, current time 386, horizon 12\n", + "adding: mem time375, current time 386, horizon 11\n", + "adding: mem time376, current time 386, horizon 10\n", + "adding: mem time377, current time 386, horizon 9\n", + "adding: mem time378, current time 386, horizon 8\n", + "adding: mem time379, current time 386, horizon 7\n", + "adding: mem time380, current time 386, horizon 6\n", + "adding: mem time381, current time 386, horizon 5\n", + "adding: mem time382, current time 386, horizon 4\n", + "adding: mem time383, current time 386, horizon 3\n", + "adding: mem time384, current time 386, horizon 2\n", + "adding: mem time385, current time 386, horizon 1\n", + "adding: mem time200, current time 387, horizon 187\n", + "adding: mem time201, current time 387, horizon 186\n", + "adding: mem time202, current time 387, horizon 185\n", + "adding: mem time203, current time 387, horizon 184\n", + "adding: mem time204, current time 387, horizon 183\n", + "adding: mem time205, current time 387, horizon 182\n", + "adding: mem time206, current time 387, horizon 181\n", + "adding: mem time207, current time 387, horizon 180\n", + "adding: mem time208, current time 387, horizon 179\n", + "adding: mem time209, current time 387, horizon 178\n", + "adding: mem time210, current time 387, horizon 177\n", + "adding: mem time211, current time 387, horizon 176\n", + "adding: mem time212, current time 387, horizon 175\n", + "adding: mem time213, current time 387, horizon 174\n", + "adding: mem time214, current time 387, horizon 173\n", + "adding: mem time215, current time 387, horizon 172\n", + "adding: mem time216, current time 387, horizon 171\n", + "adding: mem time217, current time 387, horizon 170\n", + "adding: mem time218, current time 387, horizon 169\n", + "adding: mem time219, current time 387, horizon 168\n", + "adding: mem time220, current time 387, horizon 167\n", + "adding: mem time221, current time 387, horizon 166\n", + "adding: mem time222, current time 387, horizon 165\n", + "adding: mem time223, current time 387, horizon 164\n", + "adding: mem time224, current time 387, horizon 163\n", + "adding: mem time225, current time 387, horizon 162\n", + "adding: mem time226, current time 387, horizon 161\n", + "adding: mem time227, current time 387, horizon 160\n", + "adding: mem time228, current time 387, horizon 159\n", + "adding: mem time229, current time 387, horizon 158\n", + "adding: mem time230, current time 387, horizon 157\n", + "adding: mem time231, current time 387, horizon 156\n", + "adding: mem time232, current time 387, horizon 155\n", + "adding: mem time233, current time 387, horizon 154\n", + "adding: mem time234, current time 387, horizon 153\n", + "adding: mem time235, current time 387, horizon 152\n", + "adding: mem time236, current time 387, horizon 151\n", + "adding: mem time237, current time 387, horizon 150\n", + "adding: mem time238, current time 387, horizon 149\n", + "adding: mem time239, current time 387, horizon 148\n", + "adding: mem time240, current time 387, horizon 147\n", + "adding: mem time241, current time 387, horizon 146\n", + "adding: mem time242, current time 387, horizon 145\n", + "adding: mem time243, current time 387, horizon 144\n", + "adding: mem time244, current time 387, horizon 143\n", + "adding: mem time245, current time 387, horizon 142\n", + "adding: mem time246, current time 387, horizon 141\n", + "adding: mem time247, current time 387, horizon 140\n", + "adding: mem time248, current time 387, horizon 139\n", + "adding: mem time249, current time 387, horizon 138\n", + "adding: mem time250, current time 387, horizon 137\n", + "adding: mem time251, current time 387, horizon 136\n", + "adding: mem time252, current time 387, horizon 135\n", + "adding: mem time253, current time 387, horizon 134\n", + "adding: mem time254, current time 387, horizon 133\n", + "adding: mem time255, current time 387, horizon 132\n", + "adding: mem time256, current time 387, horizon 131\n", + "adding: mem time257, current time 387, horizon 130\n", + "adding: mem time258, current time 387, horizon 129\n", + "adding: mem time259, current time 387, horizon 128\n", + "adding: mem time260, current time 387, horizon 127\n", + "adding: mem time261, current time 387, horizon 126\n", + "adding: mem time262, current time 387, horizon 125\n", + "adding: mem time263, current time 387, horizon 124\n", + "adding: mem time264, current time 387, horizon 123\n", + "adding: mem time265, current time 387, horizon 122\n", + "adding: mem time266, current time 387, horizon 121\n", + "adding: mem time267, current time 387, horizon 120\n", + "adding: mem time268, current time 387, horizon 119\n", + "adding: mem time269, current time 387, horizon 118\n", + "adding: mem time270, current time 387, horizon 117\n", + "adding: mem time271, current time 387, horizon 116\n", + "adding: mem time272, current time 387, horizon 115\n", + "adding: mem time273, current time 387, horizon 114\n", + "adding: mem time274, current time 387, horizon 113\n", + "adding: mem time275, current time 387, horizon 112\n", + "adding: mem time276, current time 387, horizon 111\n", + "adding: mem time277, current time 387, horizon 110\n", + "adding: mem time278, current time 387, horizon 109\n", + "adding: mem time279, current time 387, horizon 108\n", + "adding: mem time280, current time 387, horizon 107\n", + "adding: mem time281, current time 387, horizon 106\n", + "adding: mem time282, current time 387, horizon 105\n", + "adding: mem time283, current time 387, horizon 104\n", + "adding: mem time284, current time 387, horizon 103\n", + "adding: mem time285, current time 387, horizon 102\n", + "adding: mem time286, current time 387, horizon 101\n", + "adding: mem time287, current time 387, horizon 100\n", + "adding: mem time288, current time 387, horizon 99\n", + "adding: mem time289, current time 387, horizon 98\n", + "adding: mem time290, current time 387, horizon 97\n", + "adding: mem time291, current time 387, horizon 96\n", + "adding: mem time292, current time 387, horizon 95\n", + "adding: mem time293, current time 387, horizon 94\n", + "adding: mem time294, current time 387, horizon 93\n", + "adding: mem time295, current time 387, horizon 92\n", + "adding: mem time296, current time 387, horizon 91\n", + "adding: mem time297, current time 387, horizon 90\n", + "adding: mem time298, current time 387, horizon 89\n", + "adding: mem time299, current time 387, horizon 88\n", + "adding: mem time300, current time 387, horizon 87\n", + "adding: mem time301, current time 387, horizon 86\n", + "adding: mem time302, current time 387, horizon 85\n", + "adding: mem time303, current time 387, horizon 84\n", + "adding: mem time304, current time 387, horizon 83\n", + "adding: mem time305, current time 387, horizon 82\n", + "adding: mem time306, current time 387, horizon 81\n", + "adding: mem time307, current time 387, horizon 80\n", + "adding: mem time308, current time 387, horizon 79\n", + "adding: mem time309, current time 387, horizon 78\n", + "adding: mem time310, current time 387, horizon 77\n", + "adding: mem time311, current time 387, horizon 76\n", + "adding: mem time312, current time 387, horizon 75\n", + "adding: mem time313, current time 387, horizon 74\n", + "adding: mem time314, current time 387, horizon 73\n", + "adding: mem time315, current time 387, horizon 72\n", + "adding: mem time316, current time 387, horizon 71\n", + "adding: mem time317, current time 387, horizon 70\n", + "adding: mem time318, current time 387, horizon 69\n", + "adding: mem time319, current time 387, horizon 68\n", + "adding: mem time320, current time 387, horizon 67\n", + "adding: mem time321, current time 387, horizon 66\n", + "adding: mem time322, current time 387, horizon 65\n", + "adding: mem time323, current time 387, horizon 64\n", + "adding: mem time324, current time 387, horizon 63\n", + "adding: mem time325, current time 387, horizon 62\n", + "adding: mem time326, current time 387, horizon 61\n", + "adding: mem time327, current time 387, horizon 60\n", + "adding: mem time328, current time 387, horizon 59\n", + "adding: mem time329, current time 387, horizon 58\n", + "adding: mem time330, current time 387, horizon 57\n", + "adding: mem time331, current time 387, horizon 56\n", + "adding: mem time332, current time 387, horizon 55\n", + "adding: mem time333, current time 387, horizon 54\n", + "adding: mem time334, current time 387, horizon 53\n", + "adding: mem time335, current time 387, horizon 52\n", + "adding: mem time336, current time 387, horizon 51\n", + "adding: mem time337, current time 387, horizon 50\n", + "adding: mem time338, current time 387, horizon 49\n", + "adding: mem time339, current time 387, horizon 48\n", + "adding: mem time340, current time 387, horizon 47\n", + "adding: mem time341, current time 387, horizon 46\n", + "adding: mem time342, current time 387, horizon 45\n", + "adding: mem time343, current time 387, horizon 44\n", + "adding: mem time344, current time 387, horizon 43\n", + "adding: mem time345, current time 387, horizon 42\n", + "adding: mem time346, current time 387, horizon 41\n", + "adding: mem time347, current time 387, horizon 40\n", + "adding: mem time348, current time 387, horizon 39\n", + "adding: mem time349, current time 387, horizon 38\n", + "adding: mem time350, current time 387, horizon 37\n", + "adding: mem time351, current time 387, horizon 36\n", + "adding: mem time352, current time 387, horizon 35\n", + "adding: mem time353, current time 387, horizon 34\n", + "adding: mem time354, current time 387, horizon 33\n", + "adding: mem time355, current time 387, horizon 32\n", + "adding: mem time356, current time 387, horizon 31\n", + "adding: mem time357, current time 387, horizon 30\n", + "adding: mem time358, current time 387, horizon 29\n", + "adding: mem time359, current time 387, horizon 28\n", + "adding: mem time360, current time 387, horizon 27\n", + "adding: mem time361, current time 387, horizon 26\n", + "adding: mem time362, current time 387, horizon 25\n", + "adding: mem time363, current time 387, horizon 24\n", + "adding: mem time364, current time 387, horizon 23\n", + "adding: mem time365, current time 387, horizon 22\n", + "adding: mem time366, current time 387, horizon 21\n", + "adding: mem time367, current time 387, horizon 20\n", + "adding: mem time368, current time 387, horizon 19\n", + "adding: mem time369, current time 387, horizon 18\n", + "adding: mem time370, current time 387, horizon 17\n", + "adding: mem time371, current time 387, horizon 16\n", + "adding: mem time372, current time 387, horizon 15\n", + "adding: mem time373, current time 387, horizon 14\n", + "adding: mem time374, current time 387, horizon 13\n", + "adding: mem time375, current time 387, horizon 12\n", + "adding: mem time376, current time 387, horizon 11\n", + "adding: mem time377, current time 387, horizon 10\n", + "adding: mem time378, current time 387, horizon 9\n", + "adding: mem time379, current time 387, horizon 8\n", + "adding: mem time380, current time 387, horizon 7\n", + "adding: mem time381, current time 387, horizon 6\n", + "adding: mem time382, current time 387, horizon 5\n", + "adding: mem time383, current time 387, horizon 4\n", + "adding: mem time384, current time 387, horizon 3\n", + "adding: mem time385, current time 387, horizon 2\n", + "adding: mem time386, current time 387, horizon 1\n", + "adding: mem time200, current time 388, horizon 188\n", + "adding: mem time201, current time 388, horizon 187\n", + "adding: mem time202, current time 388, horizon 186\n", + "adding: mem time203, current time 388, horizon 185\n", + "adding: mem time204, current time 388, horizon 184\n", + "adding: mem time205, current time 388, horizon 183\n", + "adding: mem time206, current time 388, horizon 182\n", + "adding: mem time207, current time 388, horizon 181\n", + "adding: mem time208, current time 388, horizon 180\n", + "adding: mem time209, current time 388, horizon 179\n", + "adding: mem time210, current time 388, horizon 178\n", + "adding: mem time211, current time 388, horizon 177\n", + "adding: mem time212, current time 388, horizon 176\n", + "adding: mem time213, current time 388, horizon 175\n", + "adding: mem time214, current time 388, horizon 174\n", + "adding: mem time215, current time 388, horizon 173\n", + "adding: mem time216, current time 388, horizon 172\n", + "adding: mem time217, current time 388, horizon 171\n", + "adding: mem time218, current time 388, horizon 170\n", + "adding: mem time219, current time 388, horizon 169\n", + "adding: mem time220, current time 388, horizon 168\n", + "adding: mem time221, current time 388, horizon 167\n", + "adding: mem time222, current time 388, horizon 166\n", + "adding: mem time223, current time 388, horizon 165\n", + "adding: mem time224, current time 388, horizon 164\n", + "adding: mem time225, current time 388, horizon 163\n", + "adding: mem time226, current time 388, horizon 162\n", + "adding: mem time227, current time 388, horizon 161\n", + "adding: mem time228, current time 388, horizon 160\n", + "adding: mem time229, current time 388, horizon 159\n", + "adding: mem time230, current time 388, horizon 158\n", + "adding: mem time231, current time 388, horizon 157\n", + "adding: mem time232, current time 388, horizon 156\n", + "adding: mem time233, current time 388, horizon 155\n", + "adding: mem time234, current time 388, horizon 154\n", + "adding: mem time235, current time 388, horizon 153\n", + "adding: mem time236, current time 388, horizon 152\n", + "adding: mem time237, current time 388, horizon 151\n", + "adding: mem time238, current time 388, horizon 150\n", + "adding: mem time239, current time 388, horizon 149\n", + "adding: mem time240, current time 388, horizon 148\n", + "adding: mem time241, current time 388, horizon 147\n", + "adding: mem time242, current time 388, horizon 146\n", + "adding: mem time243, current time 388, horizon 145\n", + "adding: mem time244, current time 388, horizon 144\n", + "adding: mem time245, current time 388, horizon 143\n", + "adding: mem time246, current time 388, horizon 142\n", + "adding: mem time247, current time 388, horizon 141\n", + "adding: mem time248, current time 388, horizon 140\n", + "adding: mem time249, current time 388, horizon 139\n", + "adding: mem time250, current time 388, horizon 138\n", + "adding: mem time251, current time 388, horizon 137\n", + "adding: mem time252, current time 388, horizon 136\n", + "adding: mem time253, current time 388, horizon 135\n", + "adding: mem time254, current time 388, horizon 134\n", + "adding: mem time255, current time 388, horizon 133\n", + "adding: mem time256, current time 388, horizon 132\n", + "adding: mem time257, current time 388, horizon 131\n", + "adding: mem time258, current time 388, horizon 130\n", + "adding: mem time259, current time 388, horizon 129\n", + "adding: mem time260, current time 388, horizon 128\n", + "adding: mem time261, current time 388, horizon 127\n", + "adding: mem time262, current time 388, horizon 126\n", + "adding: mem time263, current time 388, horizon 125\n", + "adding: mem time264, current time 388, horizon 124\n", + "adding: mem time265, current time 388, horizon 123\n", + "adding: mem time266, current time 388, horizon 122\n", + "adding: mem time267, current time 388, horizon 121\n", + "adding: mem time268, current time 388, horizon 120\n", + "adding: mem time269, current time 388, horizon 119\n", + "adding: mem time270, current time 388, horizon 118\n", + "adding: mem time271, current time 388, horizon 117\n", + "adding: mem time272, current time 388, horizon 116\n", + "adding: mem time273, current time 388, horizon 115\n", + "adding: mem time274, current time 388, horizon 114\n", + "adding: mem time275, current time 388, horizon 113\n", + "adding: mem time276, current time 388, horizon 112\n", + "adding: mem time277, current time 388, horizon 111\n", + "adding: mem time278, current time 388, horizon 110\n", + "adding: mem time279, current time 388, horizon 109\n", + "adding: mem time280, current time 388, horizon 108\n", + "adding: mem time281, current time 388, horizon 107\n", + "adding: mem time282, current time 388, horizon 106\n", + "adding: mem time283, current time 388, horizon 105\n", + "adding: mem time284, current time 388, horizon 104\n", + "adding: mem time285, current time 388, horizon 103\n", + "adding: mem time286, current time 388, horizon 102\n", + "adding: mem time287, current time 388, horizon 101\n", + "adding: mem time288, current time 388, horizon 100\n", + "adding: mem time289, current time 388, horizon 99\n", + "adding: mem time290, current time 388, horizon 98\n", + "adding: mem time291, current time 388, horizon 97\n", + "adding: mem time292, current time 388, horizon 96\n", + "adding: mem time293, current time 388, horizon 95\n", + "adding: mem time294, current time 388, horizon 94\n", + "adding: mem time295, current time 388, horizon 93\n", + "adding: mem time296, current time 388, horizon 92\n", + "adding: mem time297, current time 388, horizon 91\n", + "adding: mem time298, current time 388, horizon 90\n", + "adding: mem time299, current time 388, horizon 89\n", + "adding: mem time300, current time 388, horizon 88\n", + "adding: mem time301, current time 388, horizon 87\n", + "adding: mem time302, current time 388, horizon 86\n", + "adding: mem time303, current time 388, horizon 85\n", + "adding: mem time304, current time 388, horizon 84\n", + "adding: mem time305, current time 388, horizon 83\n", + "adding: mem time306, current time 388, horizon 82\n", + "adding: mem time307, current time 388, horizon 81\n", + "adding: mem time308, current time 388, horizon 80\n", + "adding: mem time309, current time 388, horizon 79\n", + "adding: mem time310, current time 388, horizon 78\n", + "adding: mem time311, current time 388, horizon 77\n", + "adding: mem time312, current time 388, horizon 76\n", + "adding: mem time313, current time 388, horizon 75\n", + "adding: mem time314, current time 388, horizon 74\n", + "adding: mem time315, current time 388, horizon 73\n", + "adding: mem time316, current time 388, horizon 72\n", + "adding: mem time317, current time 388, horizon 71\n", + "adding: mem time318, current time 388, horizon 70\n", + "adding: mem time319, current time 388, horizon 69\n", + "adding: mem time320, current time 388, horizon 68\n", + "adding: mem time321, current time 388, horizon 67\n", + "adding: mem time322, current time 388, horizon 66\n", + "adding: mem time323, current time 388, horizon 65\n", + "adding: mem time324, current time 388, horizon 64\n", + "adding: mem time325, current time 388, horizon 63\n", + "adding: mem time326, current time 388, horizon 62\n", + "adding: mem time327, current time 388, horizon 61\n", + "adding: mem time328, current time 388, horizon 60\n", + "adding: mem time329, current time 388, horizon 59\n", + "adding: mem time330, current time 388, horizon 58\n", + "adding: mem time331, current time 388, horizon 57\n", + "adding: mem time332, current time 388, horizon 56\n", + "adding: mem time333, current time 388, horizon 55\n", + "adding: mem time334, current time 388, horizon 54\n", + "adding: mem time335, current time 388, horizon 53\n", + "adding: mem time336, current time 388, horizon 52\n", + "adding: mem time337, current time 388, horizon 51\n", + "adding: mem time338, current time 388, horizon 50\n", + "adding: mem time339, current time 388, horizon 49\n", + "adding: mem time340, current time 388, horizon 48\n", + "adding: mem time341, current time 388, horizon 47\n", + "adding: mem time342, current time 388, horizon 46\n", + "adding: mem time343, current time 388, horizon 45\n", + "adding: mem time344, current time 388, horizon 44\n", + "adding: mem time345, current time 388, horizon 43\n", + "adding: mem time346, current time 388, horizon 42\n", + "adding: mem time347, current time 388, horizon 41\n", + "adding: mem time348, current time 388, horizon 40\n", + "adding: mem time349, current time 388, horizon 39\n", + "adding: mem time350, current time 388, horizon 38\n", + "adding: mem time351, current time 388, horizon 37\n", + "adding: mem time352, current time 388, horizon 36\n", + "adding: mem time353, current time 388, horizon 35\n", + "adding: mem time354, current time 388, horizon 34\n", + "adding: mem time355, current time 388, horizon 33\n", + "adding: mem time356, current time 388, horizon 32\n", + "adding: mem time357, current time 388, horizon 31\n", + "adding: mem time358, current time 388, horizon 30\n", + "adding: mem time359, current time 388, horizon 29\n", + "adding: mem time360, current time 388, horizon 28\n", + "adding: mem time361, current time 388, horizon 27\n", + "adding: mem time362, current time 388, horizon 26\n", + "adding: mem time363, current time 388, horizon 25\n", + "adding: mem time364, current time 388, horizon 24\n", + "adding: mem time365, current time 388, horizon 23\n", + "adding: mem time366, current time 388, horizon 22\n", + "adding: mem time367, current time 388, horizon 21\n", + "adding: mem time368, current time 388, horizon 20\n", + "adding: mem time369, current time 388, horizon 19\n", + "adding: mem time370, current time 388, horizon 18\n", + "adding: mem time371, current time 388, horizon 17\n", + "adding: mem time372, current time 388, horizon 16\n", + "adding: mem time373, current time 388, horizon 15\n", + "adding: mem time374, current time 388, horizon 14\n", + "adding: mem time375, current time 388, horizon 13\n", + "adding: mem time376, current time 388, horizon 12\n", + "adding: mem time377, current time 388, horizon 11\n", + "adding: mem time378, current time 388, horizon 10\n", + "adding: mem time379, current time 388, horizon 9\n", + "adding: mem time380, current time 388, horizon 8\n", + "adding: mem time381, current time 388, horizon 7\n", + "adding: mem time382, current time 388, horizon 6\n", + "adding: mem time383, current time 388, horizon 5\n", + "adding: mem time384, current time 388, horizon 4\n", + "adding: mem time385, current time 388, horizon 3\n", + "adding: mem time386, current time 388, horizon 2\n", + "adding: mem time387, current time 388, horizon 1\n", + "adding: mem time200, current time 389, horizon 189\n", + "adding: mem time201, current time 389, horizon 188\n", + "adding: mem time202, current time 389, horizon 187\n", + "adding: mem time203, current time 389, horizon 186\n", + "adding: mem time204, current time 389, horizon 185\n", + "adding: mem time205, current time 389, horizon 184\n", + "adding: mem time206, current time 389, horizon 183\n", + "adding: mem time207, current time 389, horizon 182\n", + "adding: mem time208, current time 389, horizon 181\n", + "adding: mem time209, current time 389, horizon 180\n", + "adding: mem time210, current time 389, horizon 179\n", + "adding: mem time211, current time 389, horizon 178\n", + "adding: mem time212, current time 389, horizon 177\n", + "adding: mem time213, current time 389, horizon 176\n", + "adding: mem time214, current time 389, horizon 175\n", + "adding: mem time215, current time 389, horizon 174\n", + "adding: mem time216, current time 389, horizon 173\n", + "adding: mem time217, current time 389, horizon 172\n", + "adding: mem time218, current time 389, horizon 171\n", + "adding: mem time219, current time 389, horizon 170\n", + "adding: mem time220, current time 389, horizon 169\n", + "adding: mem time221, current time 389, horizon 168\n", + "adding: mem time222, current time 389, horizon 167\n", + "adding: mem time223, current time 389, horizon 166\n", + "adding: mem time224, current time 389, horizon 165\n", + "adding: mem time225, current time 389, horizon 164\n", + "adding: mem time226, current time 389, horizon 163\n", + "adding: mem time227, current time 389, horizon 162\n", + "adding: mem time228, current time 389, horizon 161\n", + "adding: mem time229, current time 389, horizon 160\n", + "adding: mem time230, current time 389, horizon 159\n", + "adding: mem time231, current time 389, horizon 158\n", + "adding: mem time232, current time 389, horizon 157\n", + "adding: mem time233, current time 389, horizon 156\n", + "adding: mem time234, current time 389, horizon 155\n", + "adding: mem time235, current time 389, horizon 154\n", + "adding: mem time236, current time 389, horizon 153\n", + "adding: mem time237, current time 389, horizon 152\n", + "adding: mem time238, current time 389, horizon 151\n", + "adding: mem time239, current time 389, horizon 150\n", + "adding: mem time240, current time 389, horizon 149\n", + "adding: mem time241, current time 389, horizon 148\n", + "adding: mem time242, current time 389, horizon 147\n", + "adding: mem time243, current time 389, horizon 146\n", + "adding: mem time244, current time 389, horizon 145\n", + "adding: mem time245, current time 389, horizon 144\n", + "adding: mem time246, current time 389, horizon 143\n", + "adding: mem time247, current time 389, horizon 142\n", + "adding: mem time248, current time 389, horizon 141\n", + "adding: mem time249, current time 389, horizon 140\n", + "adding: mem time250, current time 389, horizon 139\n", + "adding: mem time251, current time 389, horizon 138\n", + "adding: mem time252, current time 389, horizon 137\n", + "adding: mem time253, current time 389, horizon 136\n", + "adding: mem time254, current time 389, horizon 135\n", + "adding: mem time255, current time 389, horizon 134\n", + "adding: mem time256, current time 389, horizon 133\n", + "adding: mem time257, current time 389, horizon 132\n", + "adding: mem time258, current time 389, horizon 131\n", + "adding: mem time259, current time 389, horizon 130\n", + "adding: mem time260, current time 389, horizon 129\n", + "adding: mem time261, current time 389, horizon 128\n", + "adding: mem time262, current time 389, horizon 127\n", + "adding: mem time263, current time 389, horizon 126\n", + "adding: mem time264, current time 389, horizon 125\n", + "adding: mem time265, current time 389, horizon 124\n", + "adding: mem time266, current time 389, horizon 123\n", + "adding: mem time267, current time 389, horizon 122\n", + "adding: mem time268, current time 389, horizon 121\n", + "adding: mem time269, current time 389, horizon 120\n", + "adding: mem time270, current time 389, horizon 119\n", + "adding: mem time271, current time 389, horizon 118\n", + "adding: mem time272, current time 389, horizon 117\n", + "adding: mem time273, current time 389, horizon 116\n", + "adding: mem time274, current time 389, horizon 115\n", + "adding: mem time275, current time 389, horizon 114\n", + "adding: mem time276, current time 389, horizon 113\n", + "adding: mem time277, current time 389, horizon 112\n", + "adding: mem time278, current time 389, horizon 111\n", + "adding: mem time279, current time 389, horizon 110\n", + "adding: mem time280, current time 389, horizon 109\n", + "adding: mem time281, current time 389, horizon 108\n", + "adding: mem time282, current time 389, horizon 107\n", + "adding: mem time283, current time 389, horizon 106\n", + "adding: mem time284, current time 389, horizon 105\n", + "adding: mem time285, current time 389, horizon 104\n", + "adding: mem time286, current time 389, horizon 103\n", + "adding: mem time287, current time 389, horizon 102\n", + "adding: mem time288, current time 389, horizon 101\n", + "adding: mem time289, current time 389, horizon 100\n", + "adding: mem time290, current time 389, horizon 99\n", + "adding: mem time291, current time 389, horizon 98\n", + "adding: mem time292, current time 389, horizon 97\n", + "adding: mem time293, current time 389, horizon 96\n", + "adding: mem time294, current time 389, horizon 95\n", + "adding: mem time295, current time 389, horizon 94\n", + "adding: mem time296, current time 389, horizon 93\n", + "adding: mem time297, current time 389, horizon 92\n", + "adding: mem time298, current time 389, horizon 91\n", + "adding: mem time299, current time 389, horizon 90\n", + "adding: mem time300, current time 389, horizon 89\n", + "adding: mem time301, current time 389, horizon 88\n", + "adding: mem time302, current time 389, horizon 87\n", + "adding: mem time303, current time 389, horizon 86\n", + "adding: mem time304, current time 389, horizon 85\n", + "adding: mem time305, current time 389, horizon 84\n", + "adding: mem time306, current time 389, horizon 83\n", + "adding: mem time307, current time 389, horizon 82\n", + "adding: mem time308, current time 389, horizon 81\n", + "adding: mem time309, current time 389, horizon 80\n", + "adding: mem time310, current time 389, horizon 79\n", + "adding: mem time311, current time 389, horizon 78\n", + "adding: mem time312, current time 389, horizon 77\n", + "adding: mem time313, current time 389, horizon 76\n", + "adding: mem time314, current time 389, horizon 75\n", + "adding: mem time315, current time 389, horizon 74\n", + "adding: mem time316, current time 389, horizon 73\n", + "adding: mem time317, current time 389, horizon 72\n", + "adding: mem time318, current time 389, horizon 71\n", + "adding: mem time319, current time 389, horizon 70\n", + "adding: mem time320, current time 389, horizon 69\n", + "adding: mem time321, current time 389, horizon 68\n", + "adding: mem time322, current time 389, horizon 67\n", + "adding: mem time323, current time 389, horizon 66\n", + "adding: mem time324, current time 389, horizon 65\n", + "adding: mem time325, current time 389, horizon 64\n", + "adding: mem time326, current time 389, horizon 63\n", + "adding: mem time327, current time 389, horizon 62\n", + "adding: mem time328, current time 389, horizon 61\n", + "adding: mem time329, current time 389, horizon 60\n", + "adding: mem time330, current time 389, horizon 59\n", + "adding: mem time331, current time 389, horizon 58\n", + "adding: mem time332, current time 389, horizon 57\n", + "adding: mem time333, current time 389, horizon 56\n", + "adding: mem time334, current time 389, horizon 55\n", + "adding: mem time335, current time 389, horizon 54\n", + "adding: mem time336, current time 389, horizon 53\n", + "adding: mem time337, current time 389, horizon 52\n", + "adding: mem time338, current time 389, horizon 51\n", + "adding: mem time339, current time 389, horizon 50\n", + "adding: mem time340, current time 389, horizon 49\n", + "adding: mem time341, current time 389, horizon 48\n", + "adding: mem time342, current time 389, horizon 47\n", + "adding: mem time343, current time 389, horizon 46\n", + "adding: mem time344, current time 389, horizon 45\n", + "adding: mem time345, current time 389, horizon 44\n", + "adding: mem time346, current time 389, horizon 43\n", + "adding: mem time347, current time 389, horizon 42\n", + "adding: mem time348, current time 389, horizon 41\n", + "adding: mem time349, current time 389, horizon 40\n", + "adding: mem time350, current time 389, horizon 39\n", + "adding: mem time351, current time 389, horizon 38\n", + "adding: mem time352, current time 389, horizon 37\n", + "adding: mem time353, current time 389, horizon 36\n", + "adding: mem time354, current time 389, horizon 35\n", + "adding: mem time355, current time 389, horizon 34\n", + "adding: mem time356, current time 389, horizon 33\n", + "adding: mem time357, current time 389, horizon 32\n", + "adding: mem time358, current time 389, horizon 31\n", + "adding: mem time359, current time 389, horizon 30\n", + "adding: mem time360, current time 389, horizon 29\n", + "adding: mem time361, current time 389, horizon 28\n", + "adding: mem time362, current time 389, horizon 27\n", + "adding: mem time363, current time 389, horizon 26\n", + "adding: mem time364, current time 389, horizon 25\n", + "adding: mem time365, current time 389, horizon 24\n", + "adding: mem time366, current time 389, horizon 23\n", + "adding: mem time367, current time 389, horizon 22\n", + "adding: mem time368, current time 389, horizon 21\n", + "adding: mem time369, current time 389, horizon 20\n", + "adding: mem time370, current time 389, horizon 19\n", + "adding: mem time371, current time 389, horizon 18\n", + "adding: mem time372, current time 389, horizon 17\n", + "adding: mem time373, current time 389, horizon 16\n", + "adding: mem time374, current time 389, horizon 15\n", + "adding: mem time375, current time 389, horizon 14\n", + "adding: mem time376, current time 389, horizon 13\n", + "adding: mem time377, current time 389, horizon 12\n", + "adding: mem time378, current time 389, horizon 11\n", + "adding: mem time379, current time 389, horizon 10\n", + "adding: mem time380, current time 389, horizon 9\n", + "adding: mem time381, current time 389, horizon 8\n", + "adding: mem time382, current time 389, horizon 7\n", + "adding: mem time383, current time 389, horizon 6\n", + "adding: mem time384, current time 389, horizon 5\n", + "adding: mem time385, current time 389, horizon 4\n", + "adding: mem time386, current time 389, horizon 3\n", + "adding: mem time387, current time 389, horizon 2\n", + "adding: mem time388, current time 389, horizon 1\n", + "adding: mem time200, current time 390, horizon 190\n", + "adding: mem time201, current time 390, horizon 189\n", + "adding: mem time202, current time 390, horizon 188\n", + "adding: mem time203, current time 390, horizon 187\n", + "adding: mem time204, current time 390, horizon 186\n", + "adding: mem time205, current time 390, horizon 185\n", + "adding: mem time206, current time 390, horizon 184\n", + "adding: mem time207, current time 390, horizon 183\n", + "adding: mem time208, current time 390, horizon 182\n", + "adding: mem time209, current time 390, horizon 181\n", + "adding: mem time210, current time 390, horizon 180\n", + "adding: mem time211, current time 390, horizon 179\n", + "adding: mem time212, current time 390, horizon 178\n", + "adding: mem time213, current time 390, horizon 177\n", + "adding: mem time214, current time 390, horizon 176\n", + "adding: mem time215, current time 390, horizon 175\n", + "adding: mem time216, current time 390, horizon 174\n", + "adding: mem time217, current time 390, horizon 173\n", + "adding: mem time218, current time 390, horizon 172\n", + "adding: mem time219, current time 390, horizon 171\n", + "adding: mem time220, current time 390, horizon 170\n", + "adding: mem time221, current time 390, horizon 169\n", + "adding: mem time222, current time 390, horizon 168\n", + "adding: mem time223, current time 390, horizon 167\n", + "adding: mem time224, current time 390, horizon 166\n", + "adding: mem time225, current time 390, horizon 165\n", + "adding: mem time226, current time 390, horizon 164\n", + "adding: mem time227, current time 390, horizon 163\n", + "adding: mem time228, current time 390, horizon 162\n", + "adding: mem time229, current time 390, horizon 161\n", + "adding: mem time230, current time 390, horizon 160\n", + "adding: mem time231, current time 390, horizon 159\n", + "adding: mem time232, current time 390, horizon 158\n", + "adding: mem time233, current time 390, horizon 157\n", + "adding: mem time234, current time 390, horizon 156\n", + "adding: mem time235, current time 390, horizon 155\n", + "adding: mem time236, current time 390, horizon 154\n", + "adding: mem time237, current time 390, horizon 153\n", + "adding: mem time238, current time 390, horizon 152\n", + "adding: mem time239, current time 390, horizon 151\n", + "adding: mem time240, current time 390, horizon 150\n", + "adding: mem time241, current time 390, horizon 149\n", + "adding: mem time242, current time 390, horizon 148\n", + "adding: mem time243, current time 390, horizon 147\n", + "adding: mem time244, current time 390, horizon 146\n", + "adding: mem time245, current time 390, horizon 145\n", + "adding: mem time246, current time 390, horizon 144\n", + "adding: mem time247, current time 390, horizon 143\n", + "adding: mem time248, current time 390, horizon 142\n", + "adding: mem time249, current time 390, horizon 141\n", + "adding: mem time250, current time 390, horizon 140\n", + "adding: mem time251, current time 390, horizon 139\n", + "adding: mem time252, current time 390, horizon 138\n", + "adding: mem time253, current time 390, horizon 137\n", + "adding: mem time254, current time 390, horizon 136\n", + "adding: mem time255, current time 390, horizon 135\n", + "adding: mem time256, current time 390, horizon 134\n", + "adding: mem time257, current time 390, horizon 133\n", + "adding: mem time258, current time 390, horizon 132\n", + "adding: mem time259, current time 390, horizon 131\n", + "adding: mem time260, current time 390, horizon 130\n", + "adding: mem time261, current time 390, horizon 129\n", + "adding: mem time262, current time 390, horizon 128\n", + "adding: mem time263, current time 390, horizon 127\n", + "adding: mem time264, current time 390, horizon 126\n", + "adding: mem time265, current time 390, horizon 125\n", + "adding: mem time266, current time 390, horizon 124\n", + "adding: mem time267, current time 390, horizon 123\n", + "adding: mem time268, current time 390, horizon 122\n", + "adding: mem time269, current time 390, horizon 121\n", + "adding: mem time270, current time 390, horizon 120\n", + "adding: mem time271, current time 390, horizon 119\n", + "adding: mem time272, current time 390, horizon 118\n", + "adding: mem time273, current time 390, horizon 117\n", + "adding: mem time274, current time 390, horizon 116\n", + "adding: mem time275, current time 390, horizon 115\n", + "adding: mem time276, current time 390, horizon 114\n", + "adding: mem time277, current time 390, horizon 113\n", + "adding: mem time278, current time 390, horizon 112\n", + "adding: mem time279, current time 390, horizon 111\n", + "adding: mem time280, current time 390, horizon 110\n", + "adding: mem time281, current time 390, horizon 109\n", + "adding: mem time282, current time 390, horizon 108\n", + "adding: mem time283, current time 390, horizon 107\n", + "adding: mem time284, current time 390, horizon 106\n", + "adding: mem time285, current time 390, horizon 105\n", + "adding: mem time286, current time 390, horizon 104\n", + "adding: mem time287, current time 390, horizon 103\n", + "adding: mem time288, current time 390, horizon 102\n", + "adding: mem time289, current time 390, horizon 101\n", + "adding: mem time290, current time 390, horizon 100\n", + "adding: mem time291, current time 390, horizon 99\n", + "adding: mem time292, current time 390, horizon 98\n", + "adding: mem time293, current time 390, horizon 97\n", + "adding: mem time294, current time 390, horizon 96\n", + "adding: mem time295, current time 390, horizon 95\n", + "adding: mem time296, current time 390, horizon 94\n", + "adding: mem time297, current time 390, horizon 93\n", + "adding: mem time298, current time 390, horizon 92\n", + "adding: mem time299, current time 390, horizon 91\n", + "adding: mem time300, current time 390, horizon 90\n", + "adding: mem time301, current time 390, horizon 89\n", + "adding: mem time302, current time 390, horizon 88\n", + "adding: mem time303, current time 390, horizon 87\n", + "adding: mem time304, current time 390, horizon 86\n", + "adding: mem time305, current time 390, horizon 85\n", + "adding: mem time306, current time 390, horizon 84\n", + "adding: mem time307, current time 390, horizon 83\n", + "adding: mem time308, current time 390, horizon 82\n", + "adding: mem time309, current time 390, horizon 81\n", + "adding: mem time310, current time 390, horizon 80\n", + "adding: mem time311, current time 390, horizon 79\n", + "adding: mem time312, current time 390, horizon 78\n", + "adding: mem time313, current time 390, horizon 77\n", + "adding: mem time314, current time 390, horizon 76\n", + "adding: mem time315, current time 390, horizon 75\n", + "adding: mem time316, current time 390, horizon 74\n", + "adding: mem time317, current time 390, horizon 73\n", + "adding: mem time318, current time 390, horizon 72\n", + "adding: mem time319, current time 390, horizon 71\n", + "adding: mem time320, current time 390, horizon 70\n", + "adding: mem time321, current time 390, horizon 69\n", + "adding: mem time322, current time 390, horizon 68\n", + "adding: mem time323, current time 390, horizon 67\n", + "adding: mem time324, current time 390, horizon 66\n", + "adding: mem time325, current time 390, horizon 65\n", + "adding: mem time326, current time 390, horizon 64\n", + "adding: mem time327, current time 390, horizon 63\n", + "adding: mem time328, current time 390, horizon 62\n", + "adding: mem time329, current time 390, horizon 61\n", + "adding: mem time330, current time 390, horizon 60\n", + "adding: mem time331, current time 390, horizon 59\n", + "adding: mem time332, current time 390, horizon 58\n", + "adding: mem time333, current time 390, horizon 57\n", + "adding: mem time334, current time 390, horizon 56\n", + "adding: mem time335, current time 390, horizon 55\n", + "adding: mem time336, current time 390, horizon 54\n", + "adding: mem time337, current time 390, horizon 53\n", + "adding: mem time338, current time 390, horizon 52\n", + "adding: mem time339, current time 390, horizon 51\n", + "adding: mem time340, current time 390, horizon 50\n", + "adding: mem time341, current time 390, horizon 49\n", + "adding: mem time342, current time 390, horizon 48\n", + "adding: mem time343, current time 390, horizon 47\n", + "adding: mem time344, current time 390, horizon 46\n", + "adding: mem time345, current time 390, horizon 45\n", + "adding: mem time346, current time 390, horizon 44\n", + "adding: mem time347, current time 390, horizon 43\n", + "adding: mem time348, current time 390, horizon 42\n", + "adding: mem time349, current time 390, horizon 41\n", + "adding: mem time350, current time 390, horizon 40\n", + "adding: mem time351, current time 390, horizon 39\n", + "adding: mem time352, current time 390, horizon 38\n", + "adding: mem time353, current time 390, horizon 37\n", + "adding: mem time354, current time 390, horizon 36\n", + "adding: mem time355, current time 390, horizon 35\n", + "adding: mem time356, current time 390, horizon 34\n", + "adding: mem time357, current time 390, horizon 33\n", + "adding: mem time358, current time 390, horizon 32\n", + "adding: mem time359, current time 390, horizon 31\n", + "adding: mem time360, current time 390, horizon 30\n", + "adding: mem time361, current time 390, horizon 29\n", + "adding: mem time362, current time 390, horizon 28\n", + "adding: mem time363, current time 390, horizon 27\n", + "adding: mem time364, current time 390, horizon 26\n", + "adding: mem time365, current time 390, horizon 25\n", + "adding: mem time366, current time 390, horizon 24\n", + "adding: mem time367, current time 390, horizon 23\n", + "adding: mem time368, current time 390, horizon 22\n", + "adding: mem time369, current time 390, horizon 21\n", + "adding: mem time370, current time 390, horizon 20\n", + "adding: mem time371, current time 390, horizon 19\n", + "adding: mem time372, current time 390, horizon 18\n", + "adding: mem time373, current time 390, horizon 17\n", + "adding: mem time374, current time 390, horizon 16\n", + "adding: mem time375, current time 390, horizon 15\n", + "adding: mem time376, current time 390, horizon 14\n", + "adding: mem time377, current time 390, horizon 13\n", + "adding: mem time378, current time 390, horizon 12\n", + "adding: mem time379, current time 390, horizon 11\n", + "adding: mem time380, current time 390, horizon 10\n", + "adding: mem time381, current time 390, horizon 9\n", + "adding: mem time382, current time 390, horizon 8\n", + "adding: mem time383, current time 390, horizon 7\n", + "adding: mem time384, current time 390, horizon 6\n", + "adding: mem time385, current time 390, horizon 5\n", + "adding: mem time386, current time 390, horizon 4\n", + "adding: mem time387, current time 390, horizon 3\n", + "adding: mem time388, current time 390, horizon 2\n", + "adding: mem time389, current time 390, horizon 1\n", + "adding: mem time200, current time 391, horizon 191\n", + "adding: mem time201, current time 391, horizon 190\n", + "adding: mem time202, current time 391, horizon 189\n", + "adding: mem time203, current time 391, horizon 188\n", + "adding: mem time204, current time 391, horizon 187\n", + "adding: mem time205, current time 391, horizon 186\n", + "adding: mem time206, current time 391, horizon 185\n", + "adding: mem time207, current time 391, horizon 184\n", + "adding: mem time208, current time 391, horizon 183\n", + "adding: mem time209, current time 391, horizon 182\n", + "adding: mem time210, current time 391, horizon 181\n", + "adding: mem time211, current time 391, horizon 180\n", + "adding: mem time212, current time 391, horizon 179\n", + "adding: mem time213, current time 391, horizon 178\n", + "adding: mem time214, current time 391, horizon 177\n", + "adding: mem time215, current time 391, horizon 176\n", + "adding: mem time216, current time 391, horizon 175\n", + "adding: mem time217, current time 391, horizon 174\n", + "adding: mem time218, current time 391, horizon 173\n", + "adding: mem time219, current time 391, horizon 172\n", + "adding: mem time220, current time 391, horizon 171\n", + "adding: mem time221, current time 391, horizon 170\n", + "adding: mem time222, current time 391, horizon 169\n", + "adding: mem time223, current time 391, horizon 168\n", + "adding: mem time224, current time 391, horizon 167\n", + "adding: mem time225, current time 391, horizon 166\n", + "adding: mem time226, current time 391, horizon 165\n", + "adding: mem time227, current time 391, horizon 164\n", + "adding: mem time228, current time 391, horizon 163\n", + "adding: mem time229, current time 391, horizon 162\n", + "adding: mem time230, current time 391, horizon 161\n", + "adding: mem time231, current time 391, horizon 160\n", + "adding: mem time232, current time 391, horizon 159\n", + "adding: mem time233, current time 391, horizon 158\n", + "adding: mem time234, current time 391, horizon 157\n", + "adding: mem time235, current time 391, horizon 156\n", + "adding: mem time236, current time 391, horizon 155\n", + "adding: mem time237, current time 391, horizon 154\n", + "adding: mem time238, current time 391, horizon 153\n", + "adding: mem time239, current time 391, horizon 152\n", + "adding: mem time240, current time 391, horizon 151\n", + "adding: mem time241, current time 391, horizon 150\n", + "adding: mem time242, current time 391, horizon 149\n", + "adding: mem time243, current time 391, horizon 148\n", + "adding: mem time244, current time 391, horizon 147\n", + "adding: mem time245, current time 391, horizon 146\n", + "adding: mem time246, current time 391, horizon 145\n", + "adding: mem time247, current time 391, horizon 144\n", + "adding: mem time248, current time 391, horizon 143\n", + "adding: mem time249, current time 391, horizon 142\n", + "adding: mem time250, current time 391, horizon 141\n", + "adding: mem time251, current time 391, horizon 140\n", + "adding: mem time252, current time 391, horizon 139\n", + "adding: mem time253, current time 391, horizon 138\n", + "adding: mem time254, current time 391, horizon 137\n", + "adding: mem time255, current time 391, horizon 136\n", + "adding: mem time256, current time 391, horizon 135\n", + "adding: mem time257, current time 391, horizon 134\n", + "adding: mem time258, current time 391, horizon 133\n", + "adding: mem time259, current time 391, horizon 132\n", + "adding: mem time260, current time 391, horizon 131\n", + "adding: mem time261, current time 391, horizon 130\n", + "adding: mem time262, current time 391, horizon 129\n", + "adding: mem time263, current time 391, horizon 128\n", + "adding: mem time264, current time 391, horizon 127\n", + "adding: mem time265, current time 391, horizon 126\n", + "adding: mem time266, current time 391, horizon 125\n", + "adding: mem time267, current time 391, horizon 124\n", + "adding: mem time268, current time 391, horizon 123\n", + "adding: mem time269, current time 391, horizon 122\n", + "adding: mem time270, current time 391, horizon 121\n", + "adding: mem time271, current time 391, horizon 120\n", + "adding: mem time272, current time 391, horizon 119\n", + "adding: mem time273, current time 391, horizon 118\n", + "adding: mem time274, current time 391, horizon 117\n", + "adding: mem time275, current time 391, horizon 116\n", + "adding: mem time276, current time 391, horizon 115\n", + "adding: mem time277, current time 391, horizon 114\n", + "adding: mem time278, current time 391, horizon 113\n", + "adding: mem time279, current time 391, horizon 112\n", + "adding: mem time280, current time 391, horizon 111\n", + "adding: mem time281, current time 391, horizon 110\n", + "adding: mem time282, current time 391, horizon 109\n", + "adding: mem time283, current time 391, horizon 108\n", + "adding: mem time284, current time 391, horizon 107\n", + "adding: mem time285, current time 391, horizon 106\n", + "adding: mem time286, current time 391, horizon 105\n", + "adding: mem time287, current time 391, horizon 104\n", + "adding: mem time288, current time 391, horizon 103\n", + "adding: mem time289, current time 391, horizon 102\n", + "adding: mem time290, current time 391, horizon 101\n", + "adding: mem time291, current time 391, horizon 100\n", + "adding: mem time292, current time 391, horizon 99\n", + "adding: mem time293, current time 391, horizon 98\n", + "adding: mem time294, current time 391, horizon 97\n", + "adding: mem time295, current time 391, horizon 96\n", + "adding: mem time296, current time 391, horizon 95\n", + "adding: mem time297, current time 391, horizon 94\n", + "adding: mem time298, current time 391, horizon 93\n", + "adding: mem time299, current time 391, horizon 92\n", + "adding: mem time300, current time 391, horizon 91\n", + "adding: mem time301, current time 391, horizon 90\n", + "adding: mem time302, current time 391, horizon 89\n", + "adding: mem time303, current time 391, horizon 88\n", + "adding: mem time304, current time 391, horizon 87\n", + "adding: mem time305, current time 391, horizon 86\n", + "adding: mem time306, current time 391, horizon 85\n", + "adding: mem time307, current time 391, horizon 84\n", + "adding: mem time308, current time 391, horizon 83\n", + "adding: mem time309, current time 391, horizon 82\n", + "adding: mem time310, current time 391, horizon 81\n", + "adding: mem time311, current time 391, horizon 80\n", + "adding: mem time312, current time 391, horizon 79\n", + "adding: mem time313, current time 391, horizon 78\n", + "adding: mem time314, current time 391, horizon 77\n", + "adding: mem time315, current time 391, horizon 76\n", + "adding: mem time316, current time 391, horizon 75\n", + "adding: mem time317, current time 391, horizon 74\n", + "adding: mem time318, current time 391, horizon 73\n", + "adding: mem time319, current time 391, horizon 72\n", + "adding: mem time320, current time 391, horizon 71\n", + "adding: mem time321, current time 391, horizon 70\n", + "adding: mem time322, current time 391, horizon 69\n", + "adding: mem time323, current time 391, horizon 68\n", + "adding: mem time324, current time 391, horizon 67\n", + "adding: mem time325, current time 391, horizon 66\n", + "adding: mem time326, current time 391, horizon 65\n", + "adding: mem time327, current time 391, horizon 64\n", + "adding: mem time328, current time 391, horizon 63\n", + "adding: mem time329, current time 391, horizon 62\n", + "adding: mem time330, current time 391, horizon 61\n", + "adding: mem time331, current time 391, horizon 60\n", + "adding: mem time332, current time 391, horizon 59\n", + "adding: mem time333, current time 391, horizon 58\n", + "adding: mem time334, current time 391, horizon 57\n", + "adding: mem time335, current time 391, horizon 56\n", + "adding: mem time336, current time 391, horizon 55\n", + "adding: mem time337, current time 391, horizon 54\n", + "adding: mem time338, current time 391, horizon 53\n", + "adding: mem time339, current time 391, horizon 52\n", + "adding: mem time340, current time 391, horizon 51\n", + "adding: mem time341, current time 391, horizon 50\n", + "adding: mem time342, current time 391, horizon 49\n", + "adding: mem time343, current time 391, horizon 48\n", + "adding: mem time344, current time 391, horizon 47\n", + "adding: mem time345, current time 391, horizon 46\n", + "adding: mem time346, current time 391, horizon 45\n", + "adding: mem time347, current time 391, horizon 44\n", + "adding: mem time348, current time 391, horizon 43\n", + "adding: mem time349, current time 391, horizon 42\n", + "adding: mem time350, current time 391, horizon 41\n", + "adding: mem time351, current time 391, horizon 40\n", + "adding: mem time352, current time 391, horizon 39\n", + "adding: mem time353, current time 391, horizon 38\n", + "adding: mem time354, current time 391, horizon 37\n", + "adding: mem time355, current time 391, horizon 36\n", + "adding: mem time356, current time 391, horizon 35\n", + "adding: mem time357, current time 391, horizon 34\n", + "adding: mem time358, current time 391, horizon 33\n", + "adding: mem time359, current time 391, horizon 32\n", + "adding: mem time360, current time 391, horizon 31\n", + "adding: mem time361, current time 391, horizon 30\n", + "adding: mem time362, current time 391, horizon 29\n", + "adding: mem time363, current time 391, horizon 28\n", + "adding: mem time364, current time 391, horizon 27\n", + "adding: mem time365, current time 391, horizon 26\n", + "adding: mem time366, current time 391, horizon 25\n", + "adding: mem time367, current time 391, horizon 24\n", + "adding: mem time368, current time 391, horizon 23\n", + "adding: mem time369, current time 391, horizon 22\n", + "adding: mem time370, current time 391, horizon 21\n", + "adding: mem time371, current time 391, horizon 20\n", + "adding: mem time372, current time 391, horizon 19\n", + "adding: mem time373, current time 391, horizon 18\n", + "adding: mem time374, current time 391, horizon 17\n", + "adding: mem time375, current time 391, horizon 16\n", + "adding: mem time376, current time 391, horizon 15\n", + "adding: mem time377, current time 391, horizon 14\n", + "adding: mem time378, current time 391, horizon 13\n", + "adding: mem time379, current time 391, horizon 12\n", + "adding: mem time380, current time 391, horizon 11\n", + "adding: mem time381, current time 391, horizon 10\n", + "adding: mem time382, current time 391, horizon 9\n", + "adding: mem time383, current time 391, horizon 8\n", + "adding: mem time384, current time 391, horizon 7\n", + "adding: mem time385, current time 391, horizon 6\n", + "adding: mem time386, current time 391, horizon 5\n", + "adding: mem time387, current time 391, horizon 4\n", + "adding: mem time388, current time 391, horizon 3\n", + "adding: mem time389, current time 391, horizon 2\n", + "adding: mem time390, current time 391, horizon 1\n", + "adding: mem time200, current time 392, horizon 192\n", + "adding: mem time201, current time 392, horizon 191\n", + "adding: mem time202, current time 392, horizon 190\n", + "adding: mem time203, current time 392, horizon 189\n", + "adding: mem time204, current time 392, horizon 188\n", + "adding: mem time205, current time 392, horizon 187\n", + "adding: mem time206, current time 392, horizon 186\n", + "adding: mem time207, current time 392, horizon 185\n", + "adding: mem time208, current time 392, horizon 184\n", + "adding: mem time209, current time 392, horizon 183\n", + "adding: mem time210, current time 392, horizon 182\n", + "adding: mem time211, current time 392, horizon 181\n", + "adding: mem time212, current time 392, horizon 180\n", + "adding: mem time213, current time 392, horizon 179\n", + "adding: mem time214, current time 392, horizon 178\n", + "adding: mem time215, current time 392, horizon 177\n", + "adding: mem time216, current time 392, horizon 176\n", + "adding: mem time217, current time 392, horizon 175\n", + "adding: mem time218, current time 392, horizon 174\n", + "adding: mem time219, current time 392, horizon 173\n", + "adding: mem time220, current time 392, horizon 172\n", + "adding: mem time221, current time 392, horizon 171\n", + "adding: mem time222, current time 392, horizon 170\n", + "adding: mem time223, current time 392, horizon 169\n", + "adding: mem time224, current time 392, horizon 168\n", + "adding: mem time225, current time 392, horizon 167\n", + "adding: mem time226, current time 392, horizon 166\n", + "adding: mem time227, current time 392, horizon 165\n", + "adding: mem time228, current time 392, horizon 164\n", + "adding: mem time229, current time 392, horizon 163\n", + "adding: mem time230, current time 392, horizon 162\n", + "adding: mem time231, current time 392, horizon 161\n", + "adding: mem time232, current time 392, horizon 160\n", + "adding: mem time233, current time 392, horizon 159\n", + "adding: mem time234, current time 392, horizon 158\n", + "adding: mem time235, current time 392, horizon 157\n", + "adding: mem time236, current time 392, horizon 156\n", + "adding: mem time237, current time 392, horizon 155\n", + "adding: mem time238, current time 392, horizon 154\n", + "adding: mem time239, current time 392, horizon 153\n", + "adding: mem time240, current time 392, horizon 152\n", + "adding: mem time241, current time 392, horizon 151\n", + "adding: mem time242, current time 392, horizon 150\n", + "adding: mem time243, current time 392, horizon 149\n", + "adding: mem time244, current time 392, horizon 148\n", + "adding: mem time245, current time 392, horizon 147\n", + "adding: mem time246, current time 392, horizon 146\n", + "adding: mem time247, current time 392, horizon 145\n", + "adding: mem time248, current time 392, horizon 144\n", + "adding: mem time249, current time 392, horizon 143\n", + "adding: mem time250, current time 392, horizon 142\n", + "adding: mem time251, current time 392, horizon 141\n", + "adding: mem time252, current time 392, horizon 140\n", + "adding: mem time253, current time 392, horizon 139\n", + "adding: mem time254, current time 392, horizon 138\n", + "adding: mem time255, current time 392, horizon 137\n", + "adding: mem time256, current time 392, horizon 136\n", + "adding: mem time257, current time 392, horizon 135\n", + "adding: mem time258, current time 392, horizon 134\n", + "adding: mem time259, current time 392, horizon 133\n", + "adding: mem time260, current time 392, horizon 132\n", + "adding: mem time261, current time 392, horizon 131\n", + "adding: mem time262, current time 392, horizon 130\n", + "adding: mem time263, current time 392, horizon 129\n", + "adding: mem time264, current time 392, horizon 128\n", + "adding: mem time265, current time 392, horizon 127\n", + "adding: mem time266, current time 392, horizon 126\n", + "adding: mem time267, current time 392, horizon 125\n", + "adding: mem time268, current time 392, horizon 124\n", + "adding: mem time269, current time 392, horizon 123\n", + "adding: mem time270, current time 392, horizon 122\n", + "adding: mem time271, current time 392, horizon 121\n", + "adding: mem time272, current time 392, horizon 120\n", + "adding: mem time273, current time 392, horizon 119\n", + "adding: mem time274, current time 392, horizon 118\n", + "adding: mem time275, current time 392, horizon 117\n", + "adding: mem time276, current time 392, horizon 116\n", + "adding: mem time277, current time 392, horizon 115\n", + "adding: mem time278, current time 392, horizon 114\n", + "adding: mem time279, current time 392, horizon 113\n", + "adding: mem time280, current time 392, horizon 112\n", + "adding: mem time281, current time 392, horizon 111\n", + "adding: mem time282, current time 392, horizon 110\n", + "adding: mem time283, current time 392, horizon 109\n", + "adding: mem time284, current time 392, horizon 108\n", + "adding: mem time285, current time 392, horizon 107\n", + "adding: mem time286, current time 392, horizon 106\n", + "adding: mem time287, current time 392, horizon 105\n", + "adding: mem time288, current time 392, horizon 104\n", + "adding: mem time289, current time 392, horizon 103\n", + "adding: mem time290, current time 392, horizon 102\n", + "adding: mem time291, current time 392, horizon 101\n", + "adding: mem time292, current time 392, horizon 100\n", + "adding: mem time293, current time 392, horizon 99\n", + "adding: mem time294, current time 392, horizon 98\n", + "adding: mem time295, current time 392, horizon 97\n", + "adding: mem time296, current time 392, horizon 96\n", + "adding: mem time297, current time 392, horizon 95\n", + "adding: mem time298, current time 392, horizon 94\n", + "adding: mem time299, current time 392, horizon 93\n", + "adding: mem time300, current time 392, horizon 92\n", + "adding: mem time301, current time 392, horizon 91\n", + "adding: mem time302, current time 392, horizon 90\n", + "adding: mem time303, current time 392, horizon 89\n", + "adding: mem time304, current time 392, horizon 88\n", + "adding: mem time305, current time 392, horizon 87\n", + "adding: mem time306, current time 392, horizon 86\n", + "adding: mem time307, current time 392, horizon 85\n", + "adding: mem time308, current time 392, horizon 84\n", + "adding: mem time309, current time 392, horizon 83\n", + "adding: mem time310, current time 392, horizon 82\n", + "adding: mem time311, current time 392, horizon 81\n", + "adding: mem time312, current time 392, horizon 80\n", + "adding: mem time313, current time 392, horizon 79\n", + "adding: mem time314, current time 392, horizon 78\n", + "adding: mem time315, current time 392, horizon 77\n", + "adding: mem time316, current time 392, horizon 76\n", + "adding: mem time317, current time 392, horizon 75\n", + "adding: mem time318, current time 392, horizon 74\n", + "adding: mem time319, current time 392, horizon 73\n", + "adding: mem time320, current time 392, horizon 72\n", + "adding: mem time321, current time 392, horizon 71\n", + "adding: mem time322, current time 392, horizon 70\n", + "adding: mem time323, current time 392, horizon 69\n", + "adding: mem time324, current time 392, horizon 68\n", + "adding: mem time325, current time 392, horizon 67\n", + "adding: mem time326, current time 392, horizon 66\n", + "adding: mem time327, current time 392, horizon 65\n", + "adding: mem time328, current time 392, horizon 64\n", + "adding: mem time329, current time 392, horizon 63\n", + "adding: mem time330, current time 392, horizon 62\n", + "adding: mem time331, current time 392, horizon 61\n", + "adding: mem time332, current time 392, horizon 60\n", + "adding: mem time333, current time 392, horizon 59\n", + "adding: mem time334, current time 392, horizon 58\n", + "adding: mem time335, current time 392, horizon 57\n", + "adding: mem time336, current time 392, horizon 56\n", + "adding: mem time337, current time 392, horizon 55\n", + "adding: mem time338, current time 392, horizon 54\n", + "adding: mem time339, current time 392, horizon 53\n", + "adding: mem time340, current time 392, horizon 52\n", + "adding: mem time341, current time 392, horizon 51\n", + "adding: mem time342, current time 392, horizon 50\n", + "adding: mem time343, current time 392, horizon 49\n", + "adding: mem time344, current time 392, horizon 48\n", + "adding: mem time345, current time 392, horizon 47\n", + "adding: mem time346, current time 392, horizon 46\n", + "adding: mem time347, current time 392, horizon 45\n", + "adding: mem time348, current time 392, horizon 44\n", + "adding: mem time349, current time 392, horizon 43\n", + "adding: mem time350, current time 392, horizon 42\n", + "adding: mem time351, current time 392, horizon 41\n", + "adding: mem time352, current time 392, horizon 40\n", + "adding: mem time353, current time 392, horizon 39\n", + "adding: mem time354, current time 392, horizon 38\n", + "adding: mem time355, current time 392, horizon 37\n", + "adding: mem time356, current time 392, horizon 36\n", + "adding: mem time357, current time 392, horizon 35\n", + "adding: mem time358, current time 392, horizon 34\n", + "adding: mem time359, current time 392, horizon 33\n", + "adding: mem time360, current time 392, horizon 32\n", + "adding: mem time361, current time 392, horizon 31\n", + "adding: mem time362, current time 392, horizon 30\n", + "adding: mem time363, current time 392, horizon 29\n", + "adding: mem time364, current time 392, horizon 28\n", + "adding: mem time365, current time 392, horizon 27\n", + "adding: mem time366, current time 392, horizon 26\n", + "adding: mem time367, current time 392, horizon 25\n", + "adding: mem time368, current time 392, horizon 24\n", + "adding: mem time369, current time 392, horizon 23\n", + "adding: mem time370, current time 392, horizon 22\n", + "adding: mem time371, current time 392, horizon 21\n", + "adding: mem time372, current time 392, horizon 20\n", + "adding: mem time373, current time 392, horizon 19\n", + "adding: mem time374, current time 392, horizon 18\n", + "adding: mem time375, current time 392, horizon 17\n", + "adding: mem time376, current time 392, horizon 16\n", + "adding: mem time377, current time 392, horizon 15\n", + "adding: mem time378, current time 392, horizon 14\n", + "adding: mem time379, current time 392, horizon 13\n", + "adding: mem time380, current time 392, horizon 12\n", + "adding: mem time381, current time 392, horizon 11\n", + "adding: mem time382, current time 392, horizon 10\n", + "adding: mem time383, current time 392, horizon 9\n", + "adding: mem time384, current time 392, horizon 8\n", + "adding: mem time385, current time 392, horizon 7\n", + "adding: mem time386, current time 392, horizon 6\n", + "adding: mem time387, current time 392, horizon 5\n", + "adding: mem time388, current time 392, horizon 4\n", + "adding: mem time389, current time 392, horizon 3\n", + "adding: mem time390, current time 392, horizon 2\n", + "adding: mem time391, current time 392, horizon 1\n", + "adding: mem time200, current time 393, horizon 193\n", + "adding: mem time201, current time 393, horizon 192\n", + "adding: mem time202, current time 393, horizon 191\n", + "adding: mem time203, current time 393, horizon 190\n", + "adding: mem time204, current time 393, horizon 189\n", + "adding: mem time205, current time 393, horizon 188\n", + "adding: mem time206, current time 393, horizon 187\n", + "adding: mem time207, current time 393, horizon 186\n", + "adding: mem time208, current time 393, horizon 185\n", + "adding: mem time209, current time 393, horizon 184\n", + "adding: mem time210, current time 393, horizon 183\n", + "adding: mem time211, current time 393, horizon 182\n", + "adding: mem time212, current time 393, horizon 181\n", + "adding: mem time213, current time 393, horizon 180\n", + "adding: mem time214, current time 393, horizon 179\n", + "adding: mem time215, current time 393, horizon 178\n", + "adding: mem time216, current time 393, horizon 177\n", + "adding: mem time217, current time 393, horizon 176\n", + "adding: mem time218, current time 393, horizon 175\n", + "adding: mem time219, current time 393, horizon 174\n", + "adding: mem time220, current time 393, horizon 173\n", + "adding: mem time221, current time 393, horizon 172\n", + "adding: mem time222, current time 393, horizon 171\n", + "adding: mem time223, current time 393, horizon 170\n", + "adding: mem time224, current time 393, horizon 169\n", + "adding: mem time225, current time 393, horizon 168\n", + "adding: mem time226, current time 393, horizon 167\n", + "adding: mem time227, current time 393, horizon 166\n", + "adding: mem time228, current time 393, horizon 165\n", + "adding: mem time229, current time 393, horizon 164\n", + "adding: mem time230, current time 393, horizon 163\n", + "adding: mem time231, current time 393, horizon 162\n", + "adding: mem time232, current time 393, horizon 161\n", + "adding: mem time233, current time 393, horizon 160\n", + "adding: mem time234, current time 393, horizon 159\n", + "adding: mem time235, current time 393, horizon 158\n", + "adding: mem time236, current time 393, horizon 157\n", + "adding: mem time237, current time 393, horizon 156\n", + "adding: mem time238, current time 393, horizon 155\n", + "adding: mem time239, current time 393, horizon 154\n", + "adding: mem time240, current time 393, horizon 153\n", + "adding: mem time241, current time 393, horizon 152\n", + "adding: mem time242, current time 393, horizon 151\n", + "adding: mem time243, current time 393, horizon 150\n", + "adding: mem time244, current time 393, horizon 149\n", + "adding: mem time245, current time 393, horizon 148\n", + "adding: mem time246, current time 393, horizon 147\n", + "adding: mem time247, current time 393, horizon 146\n", + "adding: mem time248, current time 393, horizon 145\n", + "adding: mem time249, current time 393, horizon 144\n", + "adding: mem time250, current time 393, horizon 143\n", + "adding: mem time251, current time 393, horizon 142\n", + "adding: mem time252, current time 393, horizon 141\n", + "adding: mem time253, current time 393, horizon 140\n", + "adding: mem time254, current time 393, horizon 139\n", + "adding: mem time255, current time 393, horizon 138\n", + "adding: mem time256, current time 393, horizon 137\n", + "adding: mem time257, current time 393, horizon 136\n", + "adding: mem time258, current time 393, horizon 135\n", + "adding: mem time259, current time 393, horizon 134\n", + "adding: mem time260, current time 393, horizon 133\n", + "adding: mem time261, current time 393, horizon 132\n", + "adding: mem time262, current time 393, horizon 131\n", + "adding: mem time263, current time 393, horizon 130\n", + "adding: mem time264, current time 393, horizon 129\n", + "adding: mem time265, current time 393, horizon 128\n", + "adding: mem time266, current time 393, horizon 127\n", + "adding: mem time267, current time 393, horizon 126\n", + "adding: mem time268, current time 393, horizon 125\n", + "adding: mem time269, current time 393, horizon 124\n", + "adding: mem time270, current time 393, horizon 123\n", + "adding: mem time271, current time 393, horizon 122\n", + "adding: mem time272, current time 393, horizon 121\n", + "adding: mem time273, current time 393, horizon 120\n", + "adding: mem time274, current time 393, horizon 119\n", + "adding: mem time275, current time 393, horizon 118\n", + "adding: mem time276, current time 393, horizon 117\n", + "adding: mem time277, current time 393, horizon 116\n", + "adding: mem time278, current time 393, horizon 115\n", + "adding: mem time279, current time 393, horizon 114\n", + "adding: mem time280, current time 393, horizon 113\n", + "adding: mem time281, current time 393, horizon 112\n", + "adding: mem time282, current time 393, horizon 111\n", + "adding: mem time283, current time 393, horizon 110\n", + "adding: mem time284, current time 393, horizon 109\n", + "adding: mem time285, current time 393, horizon 108\n", + "adding: mem time286, current time 393, horizon 107\n", + "adding: mem time287, current time 393, horizon 106\n", + "adding: mem time288, current time 393, horizon 105\n", + "adding: mem time289, current time 393, horizon 104\n", + "adding: mem time290, current time 393, horizon 103\n", + "adding: mem time291, current time 393, horizon 102\n", + "adding: mem time292, current time 393, horizon 101\n", + "adding: mem time293, current time 393, horizon 100\n", + "adding: mem time294, current time 393, horizon 99\n", + "adding: mem time295, current time 393, horizon 98\n", + "adding: mem time296, current time 393, horizon 97\n", + "adding: mem time297, current time 393, horizon 96\n", + "adding: mem time298, current time 393, horizon 95\n", + "adding: mem time299, current time 393, horizon 94\n", + "adding: mem time300, current time 393, horizon 93\n", + "adding: mem time301, current time 393, horizon 92\n", + "adding: mem time302, current time 393, horizon 91\n", + "adding: mem time303, current time 393, horizon 90\n", + "adding: mem time304, current time 393, horizon 89\n", + "adding: mem time305, current time 393, horizon 88\n", + "adding: mem time306, current time 393, horizon 87\n", + "adding: mem time307, current time 393, horizon 86\n", + "adding: mem time308, current time 393, horizon 85\n", + "adding: mem time309, current time 393, horizon 84\n", + "adding: mem time310, current time 393, horizon 83\n", + "adding: mem time311, current time 393, horizon 82\n", + "adding: mem time312, current time 393, horizon 81\n", + "adding: mem time313, current time 393, horizon 80\n", + "adding: mem time314, current time 393, horizon 79\n", + "adding: mem time315, current time 393, horizon 78\n", + "adding: mem time316, current time 393, horizon 77\n", + "adding: mem time317, current time 393, horizon 76\n", + "adding: mem time318, current time 393, horizon 75\n", + "adding: mem time319, current time 393, horizon 74\n", + "adding: mem time320, current time 393, horizon 73\n", + "adding: mem time321, current time 393, horizon 72\n", + "adding: mem time322, current time 393, horizon 71\n", + "adding: mem time323, current time 393, horizon 70\n", + "adding: mem time324, current time 393, horizon 69\n", + "adding: mem time325, current time 393, horizon 68\n", + "adding: mem time326, current time 393, horizon 67\n", + "adding: mem time327, current time 393, horizon 66\n", + "adding: mem time328, current time 393, horizon 65\n", + "adding: mem time329, current time 393, horizon 64\n", + "adding: mem time330, current time 393, horizon 63\n", + "adding: mem time331, current time 393, horizon 62\n", + "adding: mem time332, current time 393, horizon 61\n", + "adding: mem time333, current time 393, horizon 60\n", + "adding: mem time334, current time 393, horizon 59\n", + "adding: mem time335, current time 393, horizon 58\n", + "adding: mem time336, current time 393, horizon 57\n", + "adding: mem time337, current time 393, horizon 56\n", + "adding: mem time338, current time 393, horizon 55\n", + "adding: mem time339, current time 393, horizon 54\n", + "adding: mem time340, current time 393, horizon 53\n", + "adding: mem time341, current time 393, horizon 52\n", + "adding: mem time342, current time 393, horizon 51\n", + "adding: mem time343, current time 393, horizon 50\n", + "adding: mem time344, current time 393, horizon 49\n", + "adding: mem time345, current time 393, horizon 48\n", + "adding: mem time346, current time 393, horizon 47\n", + "adding: mem time347, current time 393, horizon 46\n", + "adding: mem time348, current time 393, horizon 45\n", + "adding: mem time349, current time 393, horizon 44\n", + "adding: mem time350, current time 393, horizon 43\n", + "adding: mem time351, current time 393, horizon 42\n", + "adding: mem time352, current time 393, horizon 41\n", + "adding: mem time353, current time 393, horizon 40\n", + "adding: mem time354, current time 393, horizon 39\n", + "adding: mem time355, current time 393, horizon 38\n", + "adding: mem time356, current time 393, horizon 37\n", + "adding: mem time357, current time 393, horizon 36\n", + "adding: mem time358, current time 393, horizon 35\n", + "adding: mem time359, current time 393, horizon 34\n", + "adding: mem time360, current time 393, horizon 33\n", + "adding: mem time361, current time 393, horizon 32\n", + "adding: mem time362, current time 393, horizon 31\n", + "adding: mem time363, current time 393, horizon 30\n", + "adding: mem time364, current time 393, horizon 29\n", + "adding: mem time365, current time 393, horizon 28\n", + "adding: mem time366, current time 393, horizon 27\n", + "adding: mem time367, current time 393, horizon 26\n", + "adding: mem time368, current time 393, horizon 25\n", + "adding: mem time369, current time 393, horizon 24\n", + "adding: mem time370, current time 393, horizon 23\n", + "adding: mem time371, current time 393, horizon 22\n", + "adding: mem time372, current time 393, horizon 21\n", + "adding: mem time373, current time 393, horizon 20\n", + "adding: mem time374, current time 393, horizon 19\n", + "adding: mem time375, current time 393, horizon 18\n", + "adding: mem time376, current time 393, horizon 17\n", + "adding: mem time377, current time 393, horizon 16\n", + "adding: mem time378, current time 393, horizon 15\n", + "adding: mem time379, current time 393, horizon 14\n", + "adding: mem time380, current time 393, horizon 13\n", + "adding: mem time381, current time 393, horizon 12\n", + "adding: mem time382, current time 393, horizon 11\n", + "adding: mem time383, current time 393, horizon 10\n", + "adding: mem time384, current time 393, horizon 9\n", + "adding: mem time385, current time 393, horizon 8\n", + "adding: mem time386, current time 393, horizon 7\n", + "adding: mem time387, current time 393, horizon 6\n", + "adding: mem time388, current time 393, horizon 5\n", + "adding: mem time389, current time 393, horizon 4\n", + "adding: mem time390, current time 393, horizon 3\n", + "adding: mem time391, current time 393, horizon 2\n", + "adding: mem time392, current time 393, horizon 1\n", + "adding: mem time200, current time 394, horizon 194\n", + "adding: mem time201, current time 394, horizon 193\n", + "adding: mem time202, current time 394, horizon 192\n", + "adding: mem time203, current time 394, horizon 191\n", + "adding: mem time204, current time 394, horizon 190\n", + "adding: mem time205, current time 394, horizon 189\n", + "adding: mem time206, current time 394, horizon 188\n", + "adding: mem time207, current time 394, horizon 187\n", + "adding: mem time208, current time 394, horizon 186\n", + "adding: mem time209, current time 394, horizon 185\n", + "adding: mem time210, current time 394, horizon 184\n", + "adding: mem time211, current time 394, horizon 183\n", + "adding: mem time212, current time 394, horizon 182\n", + "adding: mem time213, current time 394, horizon 181\n", + "adding: mem time214, current time 394, horizon 180\n", + "adding: mem time215, current time 394, horizon 179\n", + "adding: mem time216, current time 394, horizon 178\n", + "adding: mem time217, current time 394, horizon 177\n", + "adding: mem time218, current time 394, horizon 176\n", + "adding: mem time219, current time 394, horizon 175\n", + "adding: mem time220, current time 394, horizon 174\n", + "adding: mem time221, current time 394, horizon 173\n", + "adding: mem time222, current time 394, horizon 172\n", + "adding: mem time223, current time 394, horizon 171\n", + "adding: mem time224, current time 394, horizon 170\n", + "adding: mem time225, current time 394, horizon 169\n", + "adding: mem time226, current time 394, horizon 168\n", + "adding: mem time227, current time 394, horizon 167\n", + "adding: mem time228, current time 394, horizon 166\n", + "adding: mem time229, current time 394, horizon 165\n", + "adding: mem time230, current time 394, horizon 164\n", + "adding: mem time231, current time 394, horizon 163\n", + "adding: mem time232, current time 394, horizon 162\n", + "adding: mem time233, current time 394, horizon 161\n", + "adding: mem time234, current time 394, horizon 160\n", + "adding: mem time235, current time 394, horizon 159\n", + "adding: mem time236, current time 394, horizon 158\n", + "adding: mem time237, current time 394, horizon 157\n", + "adding: mem time238, current time 394, horizon 156\n", + "adding: mem time239, current time 394, horizon 155\n", + "adding: mem time240, current time 394, horizon 154\n", + "adding: mem time241, current time 394, horizon 153\n", + "adding: mem time242, current time 394, horizon 152\n", + "adding: mem time243, current time 394, horizon 151\n", + "adding: mem time244, current time 394, horizon 150\n", + "adding: mem time245, current time 394, horizon 149\n", + "adding: mem time246, current time 394, horizon 148\n", + "adding: mem time247, current time 394, horizon 147\n", + "adding: mem time248, current time 394, horizon 146\n", + "adding: mem time249, current time 394, horizon 145\n", + "adding: mem time250, current time 394, horizon 144\n", + "adding: mem time251, current time 394, horizon 143\n", + "adding: mem time252, current time 394, horizon 142\n", + "adding: mem time253, current time 394, horizon 141\n", + "adding: mem time254, current time 394, horizon 140\n", + "adding: mem time255, current time 394, horizon 139\n", + "adding: mem time256, current time 394, horizon 138\n", + "adding: mem time257, current time 394, horizon 137\n", + "adding: mem time258, current time 394, horizon 136\n", + "adding: mem time259, current time 394, horizon 135\n", + "adding: mem time260, current time 394, horizon 134\n", + "adding: mem time261, current time 394, horizon 133\n", + "adding: mem time262, current time 394, horizon 132\n", + "adding: mem time263, current time 394, horizon 131\n", + "adding: mem time264, current time 394, horizon 130\n", + "adding: mem time265, current time 394, horizon 129\n", + "adding: mem time266, current time 394, horizon 128\n", + "adding: mem time267, current time 394, horizon 127\n", + "adding: mem time268, current time 394, horizon 126\n", + "adding: mem time269, current time 394, horizon 125\n", + "adding: mem time270, current time 394, horizon 124\n", + "adding: mem time271, current time 394, horizon 123\n", + "adding: mem time272, current time 394, horizon 122\n", + "adding: mem time273, current time 394, horizon 121\n", + "adding: mem time274, current time 394, horizon 120\n", + "adding: mem time275, current time 394, horizon 119\n", + "adding: mem time276, current time 394, horizon 118\n", + "adding: mem time277, current time 394, horizon 117\n", + "adding: mem time278, current time 394, horizon 116\n", + "adding: mem time279, current time 394, horizon 115\n", + "adding: mem time280, current time 394, horizon 114\n", + "adding: mem time281, current time 394, horizon 113\n", + "adding: mem time282, current time 394, horizon 112\n", + "adding: mem time283, current time 394, horizon 111\n", + "adding: mem time284, current time 394, horizon 110\n", + "adding: mem time285, current time 394, horizon 109\n", + "adding: mem time286, current time 394, horizon 108\n", + "adding: mem time287, current time 394, horizon 107\n", + "adding: mem time288, current time 394, horizon 106\n", + "adding: mem time289, current time 394, horizon 105\n", + "adding: mem time290, current time 394, horizon 104\n", + "adding: mem time291, current time 394, horizon 103\n", + "adding: mem time292, current time 394, horizon 102\n", + "adding: mem time293, current time 394, horizon 101\n", + "adding: mem time294, current time 394, horizon 100\n", + "adding: mem time295, current time 394, horizon 99\n", + "adding: mem time296, current time 394, horizon 98\n", + "adding: mem time297, current time 394, horizon 97\n", + "adding: mem time298, current time 394, horizon 96\n", + "adding: mem time299, current time 394, horizon 95\n", + "adding: mem time300, current time 394, horizon 94\n", + "adding: mem time301, current time 394, horizon 93\n", + "adding: mem time302, current time 394, horizon 92\n", + "adding: mem time303, current time 394, horizon 91\n", + "adding: mem time304, current time 394, horizon 90\n", + "adding: mem time305, current time 394, horizon 89\n", + "adding: mem time306, current time 394, horizon 88\n", + "adding: mem time307, current time 394, horizon 87\n", + "adding: mem time308, current time 394, horizon 86\n", + "adding: mem time309, current time 394, horizon 85\n", + "adding: mem time310, current time 394, horizon 84\n", + "adding: mem time311, current time 394, horizon 83\n", + "adding: mem time312, current time 394, horizon 82\n", + "adding: mem time313, current time 394, horizon 81\n", + "adding: mem time314, current time 394, horizon 80\n", + "adding: mem time315, current time 394, horizon 79\n", + "adding: mem time316, current time 394, horizon 78\n", + "adding: mem time317, current time 394, horizon 77\n", + "adding: mem time318, current time 394, horizon 76\n", + "adding: mem time319, current time 394, horizon 75\n", + "adding: mem time320, current time 394, horizon 74\n", + "adding: mem time321, current time 394, horizon 73\n", + "adding: mem time322, current time 394, horizon 72\n", + "adding: mem time323, current time 394, horizon 71\n", + "adding: mem time324, current time 394, horizon 70\n", + "adding: mem time325, current time 394, horizon 69\n", + "adding: mem time326, current time 394, horizon 68\n", + "adding: mem time327, current time 394, horizon 67\n", + "adding: mem time328, current time 394, horizon 66\n", + "adding: mem time329, current time 394, horizon 65\n", + "adding: mem time330, current time 394, horizon 64\n", + "adding: mem time331, current time 394, horizon 63\n", + "adding: mem time332, current time 394, horizon 62\n", + "adding: mem time333, current time 394, horizon 61\n", + "adding: mem time334, current time 394, horizon 60\n", + "adding: mem time335, current time 394, horizon 59\n", + "adding: mem time336, current time 394, horizon 58\n", + "adding: mem time337, current time 394, horizon 57\n", + "adding: mem time338, current time 394, horizon 56\n", + "adding: mem time339, current time 394, horizon 55\n", + "adding: mem time340, current time 394, horizon 54\n", + "adding: mem time341, current time 394, horizon 53\n", + "adding: mem time342, current time 394, horizon 52\n", + "adding: mem time343, current time 394, horizon 51\n", + "adding: mem time344, current time 394, horizon 50\n", + "adding: mem time345, current time 394, horizon 49\n", + "adding: mem time346, current time 394, horizon 48\n", + "adding: mem time347, current time 394, horizon 47\n", + "adding: mem time348, current time 394, horizon 46\n", + "adding: mem time349, current time 394, horizon 45\n", + "adding: mem time350, current time 394, horizon 44\n", + "adding: mem time351, current time 394, horizon 43\n", + "adding: mem time352, current time 394, horizon 42\n", + "adding: mem time353, current time 394, horizon 41\n", + "adding: mem time354, current time 394, horizon 40\n", + "adding: mem time355, current time 394, horizon 39\n", + "adding: mem time356, current time 394, horizon 38\n", + "adding: mem time357, current time 394, horizon 37\n", + "adding: mem time358, current time 394, horizon 36\n", + "adding: mem time359, current time 394, horizon 35\n", + "adding: mem time360, current time 394, horizon 34\n", + "adding: mem time361, current time 394, horizon 33\n", + "adding: mem time362, current time 394, horizon 32\n", + "adding: mem time363, current time 394, horizon 31\n", + "adding: mem time364, current time 394, horizon 30\n", + "adding: mem time365, current time 394, horizon 29\n", + "adding: mem time366, current time 394, horizon 28\n", + "adding: mem time367, current time 394, horizon 27\n", + "adding: mem time368, current time 394, horizon 26\n", + "adding: mem time369, current time 394, horizon 25\n", + "adding: mem time370, current time 394, horizon 24\n", + "adding: mem time371, current time 394, horizon 23\n", + "adding: mem time372, current time 394, horizon 22\n", + "adding: mem time373, current time 394, horizon 21\n", + "adding: mem time374, current time 394, horizon 20\n", + "adding: mem time375, current time 394, horizon 19\n", + "adding: mem time376, current time 394, horizon 18\n", + "adding: mem time377, current time 394, horizon 17\n", + "adding: mem time378, current time 394, horizon 16\n", + "adding: mem time379, current time 394, horizon 15\n", + "adding: mem time380, current time 394, horizon 14\n", + "adding: mem time381, current time 394, horizon 13\n", + "adding: mem time382, current time 394, horizon 12\n", + "adding: mem time383, current time 394, horizon 11\n", + "adding: mem time384, current time 394, horizon 10\n", + "adding: mem time385, current time 394, horizon 9\n", + "adding: mem time386, current time 394, horizon 8\n", + "adding: mem time387, current time 394, horizon 7\n", + "adding: mem time388, current time 394, horizon 6\n", + "adding: mem time389, current time 394, horizon 5\n", + "adding: mem time390, current time 394, horizon 4\n", + "adding: mem time391, current time 394, horizon 3\n", + "adding: mem time392, current time 394, horizon 2\n", + "adding: mem time393, current time 394, horizon 1\n", + "adding: mem time200, current time 395, horizon 195\n", + "adding: mem time201, current time 395, horizon 194\n", + "adding: mem time202, current time 395, horizon 193\n", + "adding: mem time203, current time 395, horizon 192\n", + "adding: mem time204, current time 395, horizon 191\n", + "adding: mem time205, current time 395, horizon 190\n", + "adding: mem time206, current time 395, horizon 189\n", + "adding: mem time207, current time 395, horizon 188\n", + "adding: mem time208, current time 395, horizon 187\n", + "adding: mem time209, current time 395, horizon 186\n", + "adding: mem time210, current time 395, horizon 185\n", + "adding: mem time211, current time 395, horizon 184\n", + "adding: mem time212, current time 395, horizon 183\n", + "adding: mem time213, current time 395, horizon 182\n", + "adding: mem time214, current time 395, horizon 181\n", + "adding: mem time215, current time 395, horizon 180\n", + "adding: mem time216, current time 395, horizon 179\n", + "adding: mem time217, current time 395, horizon 178\n", + "adding: mem time218, current time 395, horizon 177\n", + "adding: mem time219, current time 395, horizon 176\n", + "adding: mem time220, current time 395, horizon 175\n", + "adding: mem time221, current time 395, horizon 174\n", + "adding: mem time222, current time 395, horizon 173\n", + "adding: mem time223, current time 395, horizon 172\n", + "adding: mem time224, current time 395, horizon 171\n", + "adding: mem time225, current time 395, horizon 170\n", + "adding: mem time226, current time 395, horizon 169\n", + "adding: mem time227, current time 395, horizon 168\n", + "adding: mem time228, current time 395, horizon 167\n", + "adding: mem time229, current time 395, horizon 166\n", + "adding: mem time230, current time 395, horizon 165\n", + "adding: mem time231, current time 395, horizon 164\n", + "adding: mem time232, current time 395, horizon 163\n", + "adding: mem time233, current time 395, horizon 162\n", + "adding: mem time234, current time 395, horizon 161\n", + "adding: mem time235, current time 395, horizon 160\n", + "adding: mem time236, current time 395, horizon 159\n", + "adding: mem time237, current time 395, horizon 158\n", + "adding: mem time238, current time 395, horizon 157\n", + "adding: mem time239, current time 395, horizon 156\n", + "adding: mem time240, current time 395, horizon 155\n", + "adding: mem time241, current time 395, horizon 154\n", + "adding: mem time242, current time 395, horizon 153\n", + "adding: mem time243, current time 395, horizon 152\n", + "adding: mem time244, current time 395, horizon 151\n", + "adding: mem time245, current time 395, horizon 150\n", + "adding: mem time246, current time 395, horizon 149\n", + "adding: mem time247, current time 395, horizon 148\n", + "adding: mem time248, current time 395, horizon 147\n", + "adding: mem time249, current time 395, horizon 146\n", + "adding: mem time250, current time 395, horizon 145\n", + "adding: mem time251, current time 395, horizon 144\n", + "adding: mem time252, current time 395, horizon 143\n", + "adding: mem time253, current time 395, horizon 142\n", + "adding: mem time254, current time 395, horizon 141\n", + "adding: mem time255, current time 395, horizon 140\n", + "adding: mem time256, current time 395, horizon 139\n", + "adding: mem time257, current time 395, horizon 138\n", + "adding: mem time258, current time 395, horizon 137\n", + "adding: mem time259, current time 395, horizon 136\n", + "adding: mem time260, current time 395, horizon 135\n", + "adding: mem time261, current time 395, horizon 134\n", + "adding: mem time262, current time 395, horizon 133\n", + "adding: mem time263, current time 395, horizon 132\n", + "adding: mem time264, current time 395, horizon 131\n", + "adding: mem time265, current time 395, horizon 130\n", + "adding: mem time266, current time 395, horizon 129\n", + "adding: mem time267, current time 395, horizon 128\n", + "adding: mem time268, current time 395, horizon 127\n", + "adding: mem time269, current time 395, horizon 126\n", + "adding: mem time270, current time 395, horizon 125\n", + "adding: mem time271, current time 395, horizon 124\n", + "adding: mem time272, current time 395, horizon 123\n", + "adding: mem time273, current time 395, horizon 122\n", + "adding: mem time274, current time 395, horizon 121\n", + "adding: mem time275, current time 395, horizon 120\n", + "adding: mem time276, current time 395, horizon 119\n", + "adding: mem time277, current time 395, horizon 118\n", + "adding: mem time278, current time 395, horizon 117\n", + "adding: mem time279, current time 395, horizon 116\n", + "adding: mem time280, current time 395, horizon 115\n", + "adding: mem time281, current time 395, horizon 114\n", + "adding: mem time282, current time 395, horizon 113\n", + "adding: mem time283, current time 395, horizon 112\n", + "adding: mem time284, current time 395, horizon 111\n", + "adding: mem time285, current time 395, horizon 110\n", + "adding: mem time286, current time 395, horizon 109\n", + "adding: mem time287, current time 395, horizon 108\n", + "adding: mem time288, current time 395, horizon 107\n", + "adding: mem time289, current time 395, horizon 106\n", + "adding: mem time290, current time 395, horizon 105\n", + "adding: mem time291, current time 395, horizon 104\n", + "adding: mem time292, current time 395, horizon 103\n", + "adding: mem time293, current time 395, horizon 102\n", + "adding: mem time294, current time 395, horizon 101\n", + "adding: mem time295, current time 395, horizon 100\n", + "adding: mem time296, current time 395, horizon 99\n", + "adding: mem time297, current time 395, horizon 98\n", + "adding: mem time298, current time 395, horizon 97\n", + "adding: mem time299, current time 395, horizon 96\n", + "adding: mem time300, current time 395, horizon 95\n", + "adding: mem time301, current time 395, horizon 94\n", + "adding: mem time302, current time 395, horizon 93\n", + "adding: mem time303, current time 395, horizon 92\n", + "adding: mem time304, current time 395, horizon 91\n", + "adding: mem time305, current time 395, horizon 90\n", + "adding: mem time306, current time 395, horizon 89\n", + "adding: mem time307, current time 395, horizon 88\n", + "adding: mem time308, current time 395, horizon 87\n", + "adding: mem time309, current time 395, horizon 86\n", + "adding: mem time310, current time 395, horizon 85\n", + "adding: mem time311, current time 395, horizon 84\n", + "adding: mem time312, current time 395, horizon 83\n", + "adding: mem time313, current time 395, horizon 82\n", + "adding: mem time314, current time 395, horizon 81\n", + "adding: mem time315, current time 395, horizon 80\n", + "adding: mem time316, current time 395, horizon 79\n", + "adding: mem time317, current time 395, horizon 78\n", + "adding: mem time318, current time 395, horizon 77\n", + "adding: mem time319, current time 395, horizon 76\n", + "adding: mem time320, current time 395, horizon 75\n", + "adding: mem time321, current time 395, horizon 74\n", + "adding: mem time322, current time 395, horizon 73\n", + "adding: mem time323, current time 395, horizon 72\n", + "adding: mem time324, current time 395, horizon 71\n", + "adding: mem time325, current time 395, horizon 70\n", + "adding: mem time326, current time 395, horizon 69\n", + "adding: mem time327, current time 395, horizon 68\n", + "adding: mem time328, current time 395, horizon 67\n", + "adding: mem time329, current time 395, horizon 66\n", + "adding: mem time330, current time 395, horizon 65\n", + "adding: mem time331, current time 395, horizon 64\n", + "adding: mem time332, current time 395, horizon 63\n", + "adding: mem time333, current time 395, horizon 62\n", + "adding: mem time334, current time 395, horizon 61\n", + "adding: mem time335, current time 395, horizon 60\n", + "adding: mem time336, current time 395, horizon 59\n", + "adding: mem time337, current time 395, horizon 58\n", + "adding: mem time338, current time 395, horizon 57\n", + "adding: mem time339, current time 395, horizon 56\n", + "adding: mem time340, current time 395, horizon 55\n", + "adding: mem time341, current time 395, horizon 54\n", + "adding: mem time342, current time 395, horizon 53\n", + "adding: mem time343, current time 395, horizon 52\n", + "adding: mem time344, current time 395, horizon 51\n", + "adding: mem time345, current time 395, horizon 50\n", + "adding: mem time346, current time 395, horizon 49\n", + "adding: mem time347, current time 395, horizon 48\n", + "adding: mem time348, current time 395, horizon 47\n", + "adding: mem time349, current time 395, horizon 46\n", + "adding: mem time350, current time 395, horizon 45\n", + "adding: mem time351, current time 395, horizon 44\n", + "adding: mem time352, current time 395, horizon 43\n", + "adding: mem time353, current time 395, horizon 42\n", + "adding: mem time354, current time 395, horizon 41\n", + "adding: mem time355, current time 395, horizon 40\n", + "adding: mem time356, current time 395, horizon 39\n", + "adding: mem time357, current time 395, horizon 38\n", + "adding: mem time358, current time 395, horizon 37\n", + "adding: mem time359, current time 395, horizon 36\n", + "adding: mem time360, current time 395, horizon 35\n", + "adding: mem time361, current time 395, horizon 34\n", + "adding: mem time362, current time 395, horizon 33\n", + "adding: mem time363, current time 395, horizon 32\n", + "adding: mem time364, current time 395, horizon 31\n", + "adding: mem time365, current time 395, horizon 30\n", + "adding: mem time366, current time 395, horizon 29\n", + "adding: mem time367, current time 395, horizon 28\n", + "adding: mem time368, current time 395, horizon 27\n", + "adding: mem time369, current time 395, horizon 26\n", + "adding: mem time370, current time 395, horizon 25\n", + "adding: mem time371, current time 395, horizon 24\n", + "adding: mem time372, current time 395, horizon 23\n", + "adding: mem time373, current time 395, horizon 22\n", + "adding: mem time374, current time 395, horizon 21\n", + "adding: mem time375, current time 395, horizon 20\n", + "adding: mem time376, current time 395, horizon 19\n", + "adding: mem time377, current time 395, horizon 18\n", + "adding: mem time378, current time 395, horizon 17\n", + "adding: mem time379, current time 395, horizon 16\n", + "adding: mem time380, current time 395, horizon 15\n", + "adding: mem time381, current time 395, horizon 14\n", + "adding: mem time382, current time 395, horizon 13\n", + "adding: mem time383, current time 395, horizon 12\n", + "adding: mem time384, current time 395, horizon 11\n", + "adding: mem time385, current time 395, horizon 10\n", + "adding: mem time386, current time 395, horizon 9\n", + "adding: mem time387, current time 395, horizon 8\n", + "adding: mem time388, current time 395, horizon 7\n", + "adding: mem time389, current time 395, horizon 6\n", + "adding: mem time390, current time 395, horizon 5\n", + "adding: mem time391, current time 395, horizon 4\n", + "adding: mem time392, current time 395, horizon 3\n", + "adding: mem time393, current time 395, horizon 2\n", + "adding: mem time394, current time 395, horizon 1\n", + "adding: mem time200, current time 396, horizon 196\n", + "adding: mem time201, current time 396, horizon 195\n", + "adding: mem time202, current time 396, horizon 194\n", + "adding: mem time203, current time 396, horizon 193\n", + "adding: mem time204, current time 396, horizon 192\n", + "adding: mem time205, current time 396, horizon 191\n", + "adding: mem time206, current time 396, horizon 190\n", + "adding: mem time207, current time 396, horizon 189\n", + "adding: mem time208, current time 396, horizon 188\n", + "adding: mem time209, current time 396, horizon 187\n", + "adding: mem time210, current time 396, horizon 186\n", + "adding: mem time211, current time 396, horizon 185\n", + "adding: mem time212, current time 396, horizon 184\n", + "adding: mem time213, current time 396, horizon 183\n", + "adding: mem time214, current time 396, horizon 182\n", + "adding: mem time215, current time 396, horizon 181\n", + "adding: mem time216, current time 396, horizon 180\n", + "adding: mem time217, current time 396, horizon 179\n", + "adding: mem time218, current time 396, horizon 178\n", + "adding: mem time219, current time 396, horizon 177\n", + "adding: mem time220, current time 396, horizon 176\n", + "adding: mem time221, current time 396, horizon 175\n", + "adding: mem time222, current time 396, horizon 174\n", + "adding: mem time223, current time 396, horizon 173\n", + "adding: mem time224, current time 396, horizon 172\n", + "adding: mem time225, current time 396, horizon 171\n", + "adding: mem time226, current time 396, horizon 170\n", + "adding: mem time227, current time 396, horizon 169\n", + "adding: mem time228, current time 396, horizon 168\n", + "adding: mem time229, current time 396, horizon 167\n", + "adding: mem time230, current time 396, horizon 166\n", + "adding: mem time231, current time 396, horizon 165\n", + "adding: mem time232, current time 396, horizon 164\n", + "adding: mem time233, current time 396, horizon 163\n", + "adding: mem time234, current time 396, horizon 162\n", + "adding: mem time235, current time 396, horizon 161\n", + "adding: mem time236, current time 396, horizon 160\n", + "adding: mem time237, current time 396, horizon 159\n", + "adding: mem time238, current time 396, horizon 158\n", + "adding: mem time239, current time 396, horizon 157\n", + "adding: mem time240, current time 396, horizon 156\n", + "adding: mem time241, current time 396, horizon 155\n", + "adding: mem time242, current time 396, horizon 154\n", + "adding: mem time243, current time 396, horizon 153\n", + "adding: mem time244, current time 396, horizon 152\n", + "adding: mem time245, current time 396, horizon 151\n", + "adding: mem time246, current time 396, horizon 150\n", + "adding: mem time247, current time 396, horizon 149\n", + "adding: mem time248, current time 396, horizon 148\n", + "adding: mem time249, current time 396, horizon 147\n", + "adding: mem time250, current time 396, horizon 146\n", + "adding: mem time251, current time 396, horizon 145\n", + "adding: mem time252, current time 396, horizon 144\n", + "adding: mem time253, current time 396, horizon 143\n", + "adding: mem time254, current time 396, horizon 142\n", + "adding: mem time255, current time 396, horizon 141\n", + "adding: mem time256, current time 396, horizon 140\n", + "adding: mem time257, current time 396, horizon 139\n", + "adding: mem time258, current time 396, horizon 138\n", + "adding: mem time259, current time 396, horizon 137\n", + "adding: mem time260, current time 396, horizon 136\n", + "adding: mem time261, current time 396, horizon 135\n", + "adding: mem time262, current time 396, horizon 134\n", + "adding: mem time263, current time 396, horizon 133\n", + "adding: mem time264, current time 396, horizon 132\n", + "adding: mem time265, current time 396, horizon 131\n", + "adding: mem time266, current time 396, horizon 130\n", + "adding: mem time267, current time 396, horizon 129\n", + "adding: mem time268, current time 396, horizon 128\n", + "adding: mem time269, current time 396, horizon 127\n", + "adding: mem time270, current time 396, horizon 126\n", + "adding: mem time271, current time 396, horizon 125\n", + "adding: mem time272, current time 396, horizon 124\n", + "adding: mem time273, current time 396, horizon 123\n", + "adding: mem time274, current time 396, horizon 122\n", + "adding: mem time275, current time 396, horizon 121\n", + "adding: mem time276, current time 396, horizon 120\n", + "adding: mem time277, current time 396, horizon 119\n", + "adding: mem time278, current time 396, horizon 118\n", + "adding: mem time279, current time 396, horizon 117\n", + "adding: mem time280, current time 396, horizon 116\n", + "adding: mem time281, current time 396, horizon 115\n", + "adding: mem time282, current time 396, horizon 114\n", + "adding: mem time283, current time 396, horizon 113\n", + "adding: mem time284, current time 396, horizon 112\n", + "adding: mem time285, current time 396, horizon 111\n", + "adding: mem time286, current time 396, horizon 110\n", + "adding: mem time287, current time 396, horizon 109\n", + "adding: mem time288, current time 396, horizon 108\n", + "adding: mem time289, current time 396, horizon 107\n", + "adding: mem time290, current time 396, horizon 106\n", + "adding: mem time291, current time 396, horizon 105\n", + "adding: mem time292, current time 396, horizon 104\n", + "adding: mem time293, current time 396, horizon 103\n", + "adding: mem time294, current time 396, horizon 102\n", + "adding: mem time295, current time 396, horizon 101\n", + "adding: mem time296, current time 396, horizon 100\n", + "adding: mem time297, current time 396, horizon 99\n", + "adding: mem time298, current time 396, horizon 98\n", + "adding: mem time299, current time 396, horizon 97\n", + "adding: mem time300, current time 396, horizon 96\n", + "adding: mem time301, current time 396, horizon 95\n", + "adding: mem time302, current time 396, horizon 94\n", + "adding: mem time303, current time 396, horizon 93\n", + "adding: mem time304, current time 396, horizon 92\n", + "adding: mem time305, current time 396, horizon 91\n", + "adding: mem time306, current time 396, horizon 90\n", + "adding: mem time307, current time 396, horizon 89\n", + "adding: mem time308, current time 396, horizon 88\n", + "adding: mem time309, current time 396, horizon 87\n", + "adding: mem time310, current time 396, horizon 86\n", + "adding: mem time311, current time 396, horizon 85\n", + "adding: mem time312, current time 396, horizon 84\n", + "adding: mem time313, current time 396, horizon 83\n", + "adding: mem time314, current time 396, horizon 82\n", + "adding: mem time315, current time 396, horizon 81\n", + "adding: mem time316, current time 396, horizon 80\n", + "adding: mem time317, current time 396, horizon 79\n", + "adding: mem time318, current time 396, horizon 78\n", + "adding: mem time319, current time 396, horizon 77\n", + "adding: mem time320, current time 396, horizon 76\n", + "adding: mem time321, current time 396, horizon 75\n", + "adding: mem time322, current time 396, horizon 74\n", + "adding: mem time323, current time 396, horizon 73\n", + "adding: mem time324, current time 396, horizon 72\n", + "adding: mem time325, current time 396, horizon 71\n", + "adding: mem time326, current time 396, horizon 70\n", + "adding: mem time327, current time 396, horizon 69\n", + "adding: mem time328, current time 396, horizon 68\n", + "adding: mem time329, current time 396, horizon 67\n", + "adding: mem time330, current time 396, horizon 66\n", + "adding: mem time331, current time 396, horizon 65\n", + "adding: mem time332, current time 396, horizon 64\n", + "adding: mem time333, current time 396, horizon 63\n", + "adding: mem time334, current time 396, horizon 62\n", + "adding: mem time335, current time 396, horizon 61\n", + "adding: mem time336, current time 396, horizon 60\n", + "adding: mem time337, current time 396, horizon 59\n", + "adding: mem time338, current time 396, horizon 58\n", + "adding: mem time339, current time 396, horizon 57\n", + "adding: mem time340, current time 396, horizon 56\n", + "adding: mem time341, current time 396, horizon 55\n", + "adding: mem time342, current time 396, horizon 54\n", + "adding: mem time343, current time 396, horizon 53\n", + "adding: mem time344, current time 396, horizon 52\n", + "adding: mem time345, current time 396, horizon 51\n", + "adding: mem time346, current time 396, horizon 50\n", + "adding: mem time347, current time 396, horizon 49\n", + "adding: mem time348, current time 396, horizon 48\n", + "adding: mem time349, current time 396, horizon 47\n", + "adding: mem time350, current time 396, horizon 46\n", + "adding: mem time351, current time 396, horizon 45\n", + "adding: mem time352, current time 396, horizon 44\n", + "adding: mem time353, current time 396, horizon 43\n", + "adding: mem time354, current time 396, horizon 42\n", + "adding: mem time355, current time 396, horizon 41\n", + "adding: mem time356, current time 396, horizon 40\n", + "adding: mem time357, current time 396, horizon 39\n", + "adding: mem time358, current time 396, horizon 38\n", + "adding: mem time359, current time 396, horizon 37\n", + "adding: mem time360, current time 396, horizon 36\n", + "adding: mem time361, current time 396, horizon 35\n", + "adding: mem time362, current time 396, horizon 34\n", + "adding: mem time363, current time 396, horizon 33\n", + "adding: mem time364, current time 396, horizon 32\n", + "adding: mem time365, current time 396, horizon 31\n", + "adding: mem time366, current time 396, horizon 30\n", + "adding: mem time367, current time 396, horizon 29\n", + "adding: mem time368, current time 396, horizon 28\n", + "adding: mem time369, current time 396, horizon 27\n", + "adding: mem time370, current time 396, horizon 26\n", + "adding: mem time371, current time 396, horizon 25\n", + "adding: mem time372, current time 396, horizon 24\n", + "adding: mem time373, current time 396, horizon 23\n", + "adding: mem time374, current time 396, horizon 22\n", + "adding: mem time375, current time 396, horizon 21\n", + "adding: mem time376, current time 396, horizon 20\n", + "adding: mem time377, current time 396, horizon 19\n", + "adding: mem time378, current time 396, horizon 18\n", + "adding: mem time379, current time 396, horizon 17\n", + "adding: mem time380, current time 396, horizon 16\n", + "adding: mem time381, current time 396, horizon 15\n", + "adding: mem time382, current time 396, horizon 14\n", + "adding: mem time383, current time 396, horizon 13\n", + "adding: mem time384, current time 396, horizon 12\n", + "adding: mem time385, current time 396, horizon 11\n", + "adding: mem time386, current time 396, horizon 10\n", + "adding: mem time387, current time 396, horizon 9\n", + "adding: mem time388, current time 396, horizon 8\n", + "adding: mem time389, current time 396, horizon 7\n", + "adding: mem time390, current time 396, horizon 6\n", + "adding: mem time391, current time 396, horizon 5\n", + "adding: mem time392, current time 396, horizon 4\n", + "adding: mem time393, current time 396, horizon 3\n", + "adding: mem time394, current time 396, horizon 2\n", + "adding: mem time395, current time 396, horizon 1\n", + "adding: mem time200, current time 397, horizon 197\n", + "adding: mem time201, current time 397, horizon 196\n", + "adding: mem time202, current time 397, horizon 195\n", + "adding: mem time203, current time 397, horizon 194\n", + "adding: mem time204, current time 397, horizon 193\n", + "adding: mem time205, current time 397, horizon 192\n", + "adding: mem time206, current time 397, horizon 191\n", + "adding: mem time207, current time 397, horizon 190\n", + "adding: mem time208, current time 397, horizon 189\n", + "adding: mem time209, current time 397, horizon 188\n", + "adding: mem time210, current time 397, horizon 187\n", + "adding: mem time211, current time 397, horizon 186\n", + "adding: mem time212, current time 397, horizon 185\n", + "adding: mem time213, current time 397, horizon 184\n", + "adding: mem time214, current time 397, horizon 183\n", + "adding: mem time215, current time 397, horizon 182\n", + "adding: mem time216, current time 397, horizon 181\n", + "adding: mem time217, current time 397, horizon 180\n", + "adding: mem time218, current time 397, horizon 179\n", + "adding: mem time219, current time 397, horizon 178\n", + "adding: mem time220, current time 397, horizon 177\n", + "adding: mem time221, current time 397, horizon 176\n", + "adding: mem time222, current time 397, horizon 175\n", + "adding: mem time223, current time 397, horizon 174\n", + "adding: mem time224, current time 397, horizon 173\n", + "adding: mem time225, current time 397, horizon 172\n", + "adding: mem time226, current time 397, horizon 171\n", + "adding: mem time227, current time 397, horizon 170\n", + "adding: mem time228, current time 397, horizon 169\n", + "adding: mem time229, current time 397, horizon 168\n", + "adding: mem time230, current time 397, horizon 167\n", + "adding: mem time231, current time 397, horizon 166\n", + "adding: mem time232, current time 397, horizon 165\n", + "adding: mem time233, current time 397, horizon 164\n", + "adding: mem time234, current time 397, horizon 163\n", + "adding: mem time235, current time 397, horizon 162\n", + "adding: mem time236, current time 397, horizon 161\n", + "adding: mem time237, current time 397, horizon 160\n", + "adding: mem time238, current time 397, horizon 159\n", + "adding: mem time239, current time 397, horizon 158\n", + "adding: mem time240, current time 397, horizon 157\n", + "adding: mem time241, current time 397, horizon 156\n", + "adding: mem time242, current time 397, horizon 155\n", + "adding: mem time243, current time 397, horizon 154\n", + "adding: mem time244, current time 397, horizon 153\n", + "adding: mem time245, current time 397, horizon 152\n", + "adding: mem time246, current time 397, horizon 151\n", + "adding: mem time247, current time 397, horizon 150\n", + "adding: mem time248, current time 397, horizon 149\n", + "adding: mem time249, current time 397, horizon 148\n", + "adding: mem time250, current time 397, horizon 147\n", + "adding: mem time251, current time 397, horizon 146\n", + "adding: mem time252, current time 397, horizon 145\n", + "adding: mem time253, current time 397, horizon 144\n", + "adding: mem time254, current time 397, horizon 143\n", + "adding: mem time255, current time 397, horizon 142\n", + "adding: mem time256, current time 397, horizon 141\n", + "adding: mem time257, current time 397, horizon 140\n", + "adding: mem time258, current time 397, horizon 139\n", + "adding: mem time259, current time 397, horizon 138\n", + "adding: mem time260, current time 397, horizon 137\n", + "adding: mem time261, current time 397, horizon 136\n", + "adding: mem time262, current time 397, horizon 135\n", + "adding: mem time263, current time 397, horizon 134\n", + "adding: mem time264, current time 397, horizon 133\n", + "adding: mem time265, current time 397, horizon 132\n", + "adding: mem time266, current time 397, horizon 131\n", + "adding: mem time267, current time 397, horizon 130\n", + "adding: mem time268, current time 397, horizon 129\n", + "adding: mem time269, current time 397, horizon 128\n", + "adding: mem time270, current time 397, horizon 127\n", + "adding: mem time271, current time 397, horizon 126\n", + "adding: mem time272, current time 397, horizon 125\n", + "adding: mem time273, current time 397, horizon 124\n", + "adding: mem time274, current time 397, horizon 123\n", + "adding: mem time275, current time 397, horizon 122\n", + "adding: mem time276, current time 397, horizon 121\n", + "adding: mem time277, current time 397, horizon 120\n", + "adding: mem time278, current time 397, horizon 119\n", + "adding: mem time279, current time 397, horizon 118\n", + "adding: mem time280, current time 397, horizon 117\n", + "adding: mem time281, current time 397, horizon 116\n", + "adding: mem time282, current time 397, horizon 115\n", + "adding: mem time283, current time 397, horizon 114\n", + "adding: mem time284, current time 397, horizon 113\n", + "adding: mem time285, current time 397, horizon 112\n", + "adding: mem time286, current time 397, horizon 111\n", + "adding: mem time287, current time 397, horizon 110\n", + "adding: mem time288, current time 397, horizon 109\n", + "adding: mem time289, current time 397, horizon 108\n", + "adding: mem time290, current time 397, horizon 107\n", + "adding: mem time291, current time 397, horizon 106\n", + "adding: mem time292, current time 397, horizon 105\n", + "adding: mem time293, current time 397, horizon 104\n", + "adding: mem time294, current time 397, horizon 103\n", + "adding: mem time295, current time 397, horizon 102\n", + "adding: mem time296, current time 397, horizon 101\n", + "adding: mem time297, current time 397, horizon 100\n", + "adding: mem time298, current time 397, horizon 99\n", + "adding: mem time299, current time 397, horizon 98\n", + "adding: mem time300, current time 397, horizon 97\n", + "adding: mem time301, current time 397, horizon 96\n", + "adding: mem time302, current time 397, horizon 95\n", + "adding: mem time303, current time 397, horizon 94\n", + "adding: mem time304, current time 397, horizon 93\n", + "adding: mem time305, current time 397, horizon 92\n", + "adding: mem time306, current time 397, horizon 91\n", + "adding: mem time307, current time 397, horizon 90\n", + "adding: mem time308, current time 397, horizon 89\n", + "adding: mem time309, current time 397, horizon 88\n", + "adding: mem time310, current time 397, horizon 87\n", + "adding: mem time311, current time 397, horizon 86\n", + "adding: mem time312, current time 397, horizon 85\n", + "adding: mem time313, current time 397, horizon 84\n", + "adding: mem time314, current time 397, horizon 83\n", + "adding: mem time315, current time 397, horizon 82\n", + "adding: mem time316, current time 397, horizon 81\n", + "adding: mem time317, current time 397, horizon 80\n", + "adding: mem time318, current time 397, horizon 79\n", + "adding: mem time319, current time 397, horizon 78\n", + "adding: mem time320, current time 397, horizon 77\n", + "adding: mem time321, current time 397, horizon 76\n", + "adding: mem time322, current time 397, horizon 75\n", + "adding: mem time323, current time 397, horizon 74\n", + "adding: mem time324, current time 397, horizon 73\n", + "adding: mem time325, current time 397, horizon 72\n", + "adding: mem time326, current time 397, horizon 71\n", + "adding: mem time327, current time 397, horizon 70\n", + "adding: mem time328, current time 397, horizon 69\n", + "adding: mem time329, current time 397, horizon 68\n", + "adding: mem time330, current time 397, horizon 67\n", + "adding: mem time331, current time 397, horizon 66\n", + "adding: mem time332, current time 397, horizon 65\n", + "adding: mem time333, current time 397, horizon 64\n", + "adding: mem time334, current time 397, horizon 63\n", + "adding: mem time335, current time 397, horizon 62\n", + "adding: mem time336, current time 397, horizon 61\n", + "adding: mem time337, current time 397, horizon 60\n", + "adding: mem time338, current time 397, horizon 59\n", + "adding: mem time339, current time 397, horizon 58\n", + "adding: mem time340, current time 397, horizon 57\n", + "adding: mem time341, current time 397, horizon 56\n", + "adding: mem time342, current time 397, horizon 55\n", + "adding: mem time343, current time 397, horizon 54\n", + "adding: mem time344, current time 397, horizon 53\n", + "adding: mem time345, current time 397, horizon 52\n", + "adding: mem time346, current time 397, horizon 51\n", + "adding: mem time347, current time 397, horizon 50\n", + "adding: mem time348, current time 397, horizon 49\n", + "adding: mem time349, current time 397, horizon 48\n", + "adding: mem time350, current time 397, horizon 47\n", + "adding: mem time351, current time 397, horizon 46\n", + "adding: mem time352, current time 397, horizon 45\n", + "adding: mem time353, current time 397, horizon 44\n", + "adding: mem time354, current time 397, horizon 43\n", + "adding: mem time355, current time 397, horizon 42\n", + "adding: mem time356, current time 397, horizon 41\n", + "adding: mem time357, current time 397, horizon 40\n", + "adding: mem time358, current time 397, horizon 39\n", + "adding: mem time359, current time 397, horizon 38\n", + "adding: mem time360, current time 397, horizon 37\n", + "adding: mem time361, current time 397, horizon 36\n", + "adding: mem time362, current time 397, horizon 35\n", + "adding: mem time363, current time 397, horizon 34\n", + "adding: mem time364, current time 397, horizon 33\n", + "adding: mem time365, current time 397, horizon 32\n", + "adding: mem time366, current time 397, horizon 31\n", + "adding: mem time367, current time 397, horizon 30\n", + "adding: mem time368, current time 397, horizon 29\n", + "adding: mem time369, current time 397, horizon 28\n", + "adding: mem time370, current time 397, horizon 27\n", + "adding: mem time371, current time 397, horizon 26\n", + "adding: mem time372, current time 397, horizon 25\n", + "adding: mem time373, current time 397, horizon 24\n", + "adding: mem time374, current time 397, horizon 23\n", + "adding: mem time375, current time 397, horizon 22\n", + "adding: mem time376, current time 397, horizon 21\n", + "adding: mem time377, current time 397, horizon 20\n", + "adding: mem time378, current time 397, horizon 19\n", + "adding: mem time379, current time 397, horizon 18\n", + "adding: mem time380, current time 397, horizon 17\n", + "adding: mem time381, current time 397, horizon 16\n", + "adding: mem time382, current time 397, horizon 15\n", + "adding: mem time383, current time 397, horizon 14\n", + "adding: mem time384, current time 397, horizon 13\n", + "adding: mem time385, current time 397, horizon 12\n", + "adding: mem time386, current time 397, horizon 11\n", + "adding: mem time387, current time 397, horizon 10\n", + "adding: mem time388, current time 397, horizon 9\n", + "adding: mem time389, current time 397, horizon 8\n", + "adding: mem time390, current time 397, horizon 7\n", + "adding: mem time391, current time 397, horizon 6\n", + "adding: mem time392, current time 397, horizon 5\n", + "adding: mem time393, current time 397, horizon 4\n", + "adding: mem time394, current time 397, horizon 3\n", + "adding: mem time395, current time 397, horizon 2\n", + "adding: mem time396, current time 397, horizon 1\n", + "adding: mem time200, current time 398, horizon 198\n", + "adding: mem time201, current time 398, horizon 197\n", + "adding: mem time202, current time 398, horizon 196\n", + "adding: mem time203, current time 398, horizon 195\n", + "adding: mem time204, current time 398, horizon 194\n", + "adding: mem time205, current time 398, horizon 193\n", + "adding: mem time206, current time 398, horizon 192\n", + "adding: mem time207, current time 398, horizon 191\n", + "adding: mem time208, current time 398, horizon 190\n", + "adding: mem time209, current time 398, horizon 189\n", + "adding: mem time210, current time 398, horizon 188\n", + "adding: mem time211, current time 398, horizon 187\n", + "adding: mem time212, current time 398, horizon 186\n", + "adding: mem time213, current time 398, horizon 185\n", + "adding: mem time214, current time 398, horizon 184\n", + "adding: mem time215, current time 398, horizon 183\n", + "adding: mem time216, current time 398, horizon 182\n", + "adding: mem time217, current time 398, horizon 181\n", + "adding: mem time218, current time 398, horizon 180\n", + "adding: mem time219, current time 398, horizon 179\n", + "adding: mem time220, current time 398, horizon 178\n", + "adding: mem time221, current time 398, horizon 177\n", + "adding: mem time222, current time 398, horizon 176\n", + "adding: mem time223, current time 398, horizon 175\n", + "adding: mem time224, current time 398, horizon 174\n", + "adding: mem time225, current time 398, horizon 173\n", + "adding: mem time226, current time 398, horizon 172\n", + "adding: mem time227, current time 398, horizon 171\n", + "adding: mem time228, current time 398, horizon 170\n", + "adding: mem time229, current time 398, horizon 169\n", + "adding: mem time230, current time 398, horizon 168\n", + "adding: mem time231, current time 398, horizon 167\n", + "adding: mem time232, current time 398, horizon 166\n", + "adding: mem time233, current time 398, horizon 165\n", + "adding: mem time234, current time 398, horizon 164\n", + "adding: mem time235, current time 398, horizon 163\n", + "adding: mem time236, current time 398, horizon 162\n", + "adding: mem time237, current time 398, horizon 161\n", + "adding: mem time238, current time 398, horizon 160\n", + "adding: mem time239, current time 398, horizon 159\n", + "adding: mem time240, current time 398, horizon 158\n", + "adding: mem time241, current time 398, horizon 157\n", + "adding: mem time242, current time 398, horizon 156\n", + "adding: mem time243, current time 398, horizon 155\n", + "adding: mem time244, current time 398, horizon 154\n", + "adding: mem time245, current time 398, horizon 153\n", + "adding: mem time246, current time 398, horizon 152\n", + "adding: mem time247, current time 398, horizon 151\n", + "adding: mem time248, current time 398, horizon 150\n", + "adding: mem time249, current time 398, horizon 149\n", + "adding: mem time250, current time 398, horizon 148\n", + "adding: mem time251, current time 398, horizon 147\n", + "adding: mem time252, current time 398, horizon 146\n", + "adding: mem time253, current time 398, horizon 145\n", + "adding: mem time254, current time 398, horizon 144\n", + "adding: mem time255, current time 398, horizon 143\n", + "adding: mem time256, current time 398, horizon 142\n", + "adding: mem time257, current time 398, horizon 141\n", + "adding: mem time258, current time 398, horizon 140\n", + "adding: mem time259, current time 398, horizon 139\n", + "adding: mem time260, current time 398, horizon 138\n", + "adding: mem time261, current time 398, horizon 137\n", + "adding: mem time262, current time 398, horizon 136\n", + "adding: mem time263, current time 398, horizon 135\n", + "adding: mem time264, current time 398, horizon 134\n", + "adding: mem time265, current time 398, horizon 133\n", + "adding: mem time266, current time 398, horizon 132\n", + "adding: mem time267, current time 398, horizon 131\n", + "adding: mem time268, current time 398, horizon 130\n", + "adding: mem time269, current time 398, horizon 129\n", + "adding: mem time270, current time 398, horizon 128\n", + "adding: mem time271, current time 398, horizon 127\n", + "adding: mem time272, current time 398, horizon 126\n", + "adding: mem time273, current time 398, horizon 125\n", + "adding: mem time274, current time 398, horizon 124\n", + "adding: mem time275, current time 398, horizon 123\n", + "adding: mem time276, current time 398, horizon 122\n", + "adding: mem time277, current time 398, horizon 121\n", + "adding: mem time278, current time 398, horizon 120\n", + "adding: mem time279, current time 398, horizon 119\n", + "adding: mem time280, current time 398, horizon 118\n", + "adding: mem time281, current time 398, horizon 117\n", + "adding: mem time282, current time 398, horizon 116\n", + "adding: mem time283, current time 398, horizon 115\n", + "adding: mem time284, current time 398, horizon 114\n", + "adding: mem time285, current time 398, horizon 113\n", + "adding: mem time286, current time 398, horizon 112\n", + "adding: mem time287, current time 398, horizon 111\n", + "adding: mem time288, current time 398, horizon 110\n", + "adding: mem time289, current time 398, horizon 109\n", + "adding: mem time290, current time 398, horizon 108\n", + "adding: mem time291, current time 398, horizon 107\n", + "adding: mem time292, current time 398, horizon 106\n", + "adding: mem time293, current time 398, horizon 105\n", + "adding: mem time294, current time 398, horizon 104\n", + "adding: mem time295, current time 398, horizon 103\n", + "adding: mem time296, current time 398, horizon 102\n", + "adding: mem time297, current time 398, horizon 101\n", + "adding: mem time298, current time 398, horizon 100\n", + "adding: mem time299, current time 398, horizon 99\n", + "adding: mem time300, current time 398, horizon 98\n", + "adding: mem time301, current time 398, horizon 97\n", + "adding: mem time302, current time 398, horizon 96\n", + "adding: mem time303, current time 398, horizon 95\n", + "adding: mem time304, current time 398, horizon 94\n", + "adding: mem time305, current time 398, horizon 93\n", + "adding: mem time306, current time 398, horizon 92\n", + "adding: mem time307, current time 398, horizon 91\n", + "adding: mem time308, current time 398, horizon 90\n", + "adding: mem time309, current time 398, horizon 89\n", + "adding: mem time310, current time 398, horizon 88\n", + "adding: mem time311, current time 398, horizon 87\n", + "adding: mem time312, current time 398, horizon 86\n", + "adding: mem time313, current time 398, horizon 85\n", + "adding: mem time314, current time 398, horizon 84\n", + "adding: mem time315, current time 398, horizon 83\n", + "adding: mem time316, current time 398, horizon 82\n", + "adding: mem time317, current time 398, horizon 81\n", + "adding: mem time318, current time 398, horizon 80\n", + "adding: mem time319, current time 398, horizon 79\n", + "adding: mem time320, current time 398, horizon 78\n", + "adding: mem time321, current time 398, horizon 77\n", + "adding: mem time322, current time 398, horizon 76\n", + "adding: mem time323, current time 398, horizon 75\n", + "adding: mem time324, current time 398, horizon 74\n", + "adding: mem time325, current time 398, horizon 73\n", + "adding: mem time326, current time 398, horizon 72\n", + "adding: mem time327, current time 398, horizon 71\n", + "adding: mem time328, current time 398, horizon 70\n", + "adding: mem time329, current time 398, horizon 69\n", + "adding: mem time330, current time 398, horizon 68\n", + "adding: mem time331, current time 398, horizon 67\n", + "adding: mem time332, current time 398, horizon 66\n", + "adding: mem time333, current time 398, horizon 65\n", + "adding: mem time334, current time 398, horizon 64\n", + "adding: mem time335, current time 398, horizon 63\n", + "adding: mem time336, current time 398, horizon 62\n", + "adding: mem time337, current time 398, horizon 61\n", + "adding: mem time338, current time 398, horizon 60\n", + "adding: mem time339, current time 398, horizon 59\n", + "adding: mem time340, current time 398, horizon 58\n", + "adding: mem time341, current time 398, horizon 57\n", + "adding: mem time342, current time 398, horizon 56\n", + "adding: mem time343, current time 398, horizon 55\n", + "adding: mem time344, current time 398, horizon 54\n", + "adding: mem time345, current time 398, horizon 53\n", + "adding: mem time346, current time 398, horizon 52\n", + "adding: mem time347, current time 398, horizon 51\n", + "adding: mem time348, current time 398, horizon 50\n", + "adding: mem time349, current time 398, horizon 49\n", + "adding: mem time350, current time 398, horizon 48\n", + "adding: mem time351, current time 398, horizon 47\n", + "adding: mem time352, current time 398, horizon 46\n", + "adding: mem time353, current time 398, horizon 45\n", + "adding: mem time354, current time 398, horizon 44\n", + "adding: mem time355, current time 398, horizon 43\n", + "adding: mem time356, current time 398, horizon 42\n", + "adding: mem time357, current time 398, horizon 41\n", + "adding: mem time358, current time 398, horizon 40\n", + "adding: mem time359, current time 398, horizon 39\n", + "adding: mem time360, current time 398, horizon 38\n", + "adding: mem time361, current time 398, horizon 37\n", + "adding: mem time362, current time 398, horizon 36\n", + "adding: mem time363, current time 398, horizon 35\n", + "adding: mem time364, current time 398, horizon 34\n", + "adding: mem time365, current time 398, horizon 33\n", + "adding: mem time366, current time 398, horizon 32\n", + "adding: mem time367, current time 398, horizon 31\n", + "adding: mem time368, current time 398, horizon 30\n", + "adding: mem time369, current time 398, horizon 29\n", + "adding: mem time370, current time 398, horizon 28\n", + "adding: mem time371, current time 398, horizon 27\n", + "adding: mem time372, current time 398, horizon 26\n", + "adding: mem time373, current time 398, horizon 25\n", + "adding: mem time374, current time 398, horizon 24\n", + "adding: mem time375, current time 398, horizon 23\n", + "adding: mem time376, current time 398, horizon 22\n", + "adding: mem time377, current time 398, horizon 21\n", + "adding: mem time378, current time 398, horizon 20\n", + "adding: mem time379, current time 398, horizon 19\n", + "adding: mem time380, current time 398, horizon 18\n", + "adding: mem time381, current time 398, horizon 17\n", + "adding: mem time382, current time 398, horizon 16\n", + "adding: mem time383, current time 398, horizon 15\n", + "adding: mem time384, current time 398, horizon 14\n", + "adding: mem time385, current time 398, horizon 13\n", + "adding: mem time386, current time 398, horizon 12\n", + "adding: mem time387, current time 398, horizon 11\n", + "adding: mem time388, current time 398, horizon 10\n", + "adding: mem time389, current time 398, horizon 9\n", + "adding: mem time390, current time 398, horizon 8\n", + "adding: mem time391, current time 398, horizon 7\n", + "adding: mem time392, current time 398, horizon 6\n", + "adding: mem time393, current time 398, horizon 5\n", + "adding: mem time394, current time 398, horizon 4\n", + "adding: mem time395, current time 398, horizon 3\n", + "adding: mem time396, current time 398, horizon 2\n", + "adding: mem time397, current time 398, horizon 1\n", + "adding: mem time200, current time 399, horizon 199\n", + "adding: mem time201, current time 399, horizon 198\n", + "adding: mem time202, current time 399, horizon 197\n", + "adding: mem time203, current time 399, horizon 196\n", + "adding: mem time204, current time 399, horizon 195\n", + "adding: mem time205, current time 399, horizon 194\n", + "adding: mem time206, current time 399, horizon 193\n", + "adding: mem time207, current time 399, horizon 192\n", + "adding: mem time208, current time 399, horizon 191\n", + "adding: mem time209, current time 399, horizon 190\n", + "adding: mem time210, current time 399, horizon 189\n", + "adding: mem time211, current time 399, horizon 188\n", + "adding: mem time212, current time 399, horizon 187\n", + "adding: mem time213, current time 399, horizon 186\n", + "adding: mem time214, current time 399, horizon 185\n", + "adding: mem time215, current time 399, horizon 184\n", + "adding: mem time216, current time 399, horizon 183\n", + "adding: mem time217, current time 399, horizon 182\n", + "adding: mem time218, current time 399, horizon 181\n", + "adding: mem time219, current time 399, horizon 180\n", + "adding: mem time220, current time 399, horizon 179\n", + "adding: mem time221, current time 399, horizon 178\n", + "adding: mem time222, current time 399, horizon 177\n", + "adding: mem time223, current time 399, horizon 176\n", + "adding: mem time224, current time 399, horizon 175\n", + "adding: mem time225, current time 399, horizon 174\n", + "adding: mem time226, current time 399, horizon 173\n", + "adding: mem time227, current time 399, horizon 172\n", + "adding: mem time228, current time 399, horizon 171\n", + "adding: mem time229, current time 399, horizon 170\n", + "adding: mem time230, current time 399, horizon 169\n", + "adding: mem time231, current time 399, horizon 168\n", + "adding: mem time232, current time 399, horizon 167\n", + "adding: mem time233, current time 399, horizon 166\n", + "adding: mem time234, current time 399, horizon 165\n", + "adding: mem time235, current time 399, horizon 164\n", + "adding: mem time236, current time 399, horizon 163\n", + "adding: mem time237, current time 399, horizon 162\n", + "adding: mem time238, current time 399, horizon 161\n", + "adding: mem time239, current time 399, horizon 160\n", + "adding: mem time240, current time 399, horizon 159\n", + "adding: mem time241, current time 399, horizon 158\n", + "adding: mem time242, current time 399, horizon 157\n", + "adding: mem time243, current time 399, horizon 156\n", + "adding: mem time244, current time 399, horizon 155\n", + "adding: mem time245, current time 399, horizon 154\n", + "adding: mem time246, current time 399, horizon 153\n", + "adding: mem time247, current time 399, horizon 152\n", + "adding: mem time248, current time 399, horizon 151\n", + "adding: mem time249, current time 399, horizon 150\n", + "adding: mem time250, current time 399, horizon 149\n", + "adding: mem time251, current time 399, horizon 148\n", + "adding: mem time252, current time 399, horizon 147\n", + "adding: mem time253, current time 399, horizon 146\n", + "adding: mem time254, current time 399, horizon 145\n", + "adding: mem time255, current time 399, horizon 144\n", + "adding: mem time256, current time 399, horizon 143\n", + "adding: mem time257, current time 399, horizon 142\n", + "adding: mem time258, current time 399, horizon 141\n", + "adding: mem time259, current time 399, horizon 140\n", + "adding: mem time260, current time 399, horizon 139\n", + "adding: mem time261, current time 399, horizon 138\n", + "adding: mem time262, current time 399, horizon 137\n", + "adding: mem time263, current time 399, horizon 136\n", + "adding: mem time264, current time 399, horizon 135\n", + "adding: mem time265, current time 399, horizon 134\n", + "adding: mem time266, current time 399, horizon 133\n", + "adding: mem time267, current time 399, horizon 132\n", + "adding: mem time268, current time 399, horizon 131\n", + "adding: mem time269, current time 399, horizon 130\n", + "adding: mem time270, current time 399, horizon 129\n", + "adding: mem time271, current time 399, horizon 128\n", + "adding: mem time272, current time 399, horizon 127\n", + "adding: mem time273, current time 399, horizon 126\n", + "adding: mem time274, current time 399, horizon 125\n", + "adding: mem time275, current time 399, horizon 124\n", + "adding: mem time276, current time 399, horizon 123\n", + "adding: mem time277, current time 399, horizon 122\n", + "adding: mem time278, current time 399, horizon 121\n", + "adding: mem time279, current time 399, horizon 120\n", + "adding: mem time280, current time 399, horizon 119\n", + "adding: mem time281, current time 399, horizon 118\n", + "adding: mem time282, current time 399, horizon 117\n", + "adding: mem time283, current time 399, horizon 116\n", + "adding: mem time284, current time 399, horizon 115\n", + "adding: mem time285, current time 399, horizon 114\n", + "adding: mem time286, current time 399, horizon 113\n", + "adding: mem time287, current time 399, horizon 112\n", + "adding: mem time288, current time 399, horizon 111\n", + "adding: mem time289, current time 399, horizon 110\n", + "adding: mem time290, current time 399, horizon 109\n", + "adding: mem time291, current time 399, horizon 108\n", + "adding: mem time292, current time 399, horizon 107\n", + "adding: mem time293, current time 399, horizon 106\n", + "adding: mem time294, current time 399, horizon 105\n", + "adding: mem time295, current time 399, horizon 104\n", + "adding: mem time296, current time 399, horizon 103\n", + "adding: mem time297, current time 399, horizon 102\n", + "adding: mem time298, current time 399, horizon 101\n", + "adding: mem time299, current time 399, horizon 100\n", + "adding: mem time300, current time 399, horizon 99\n", + "adding: mem time301, current time 399, horizon 98\n", + "adding: mem time302, current time 399, horizon 97\n", + "adding: mem time303, current time 399, horizon 96\n", + "adding: mem time304, current time 399, horizon 95\n", + "adding: mem time305, current time 399, horizon 94\n", + "adding: mem time306, current time 399, horizon 93\n", + "adding: mem time307, current time 399, horizon 92\n", + "adding: mem time308, current time 399, horizon 91\n", + "adding: mem time309, current time 399, horizon 90\n", + "adding: mem time310, current time 399, horizon 89\n", + "adding: mem time311, current time 399, horizon 88\n", + "adding: mem time312, current time 399, horizon 87\n", + "adding: mem time313, current time 399, horizon 86\n", + "adding: mem time314, current time 399, horizon 85\n", + "adding: mem time315, current time 399, horizon 84\n", + "adding: mem time316, current time 399, horizon 83\n", + "adding: mem time317, current time 399, horizon 82\n", + "adding: mem time318, current time 399, horizon 81\n", + "adding: mem time319, current time 399, horizon 80\n", + "adding: mem time320, current time 399, horizon 79\n", + "adding: mem time321, current time 399, horizon 78\n", + "adding: mem time322, current time 399, horizon 77\n", + "adding: mem time323, current time 399, horizon 76\n", + "adding: mem time324, current time 399, horizon 75\n", + "adding: mem time325, current time 399, horizon 74\n", + "adding: mem time326, current time 399, horizon 73\n", + "adding: mem time327, current time 399, horizon 72\n", + "adding: mem time328, current time 399, horizon 71\n", + "adding: mem time329, current time 399, horizon 70\n", + "adding: mem time330, current time 399, horizon 69\n", + "adding: mem time331, current time 399, horizon 68\n", + "adding: mem time332, current time 399, horizon 67\n", + "adding: mem time333, current time 399, horizon 66\n", + "adding: mem time334, current time 399, horizon 65\n", + "adding: mem time335, current time 399, horizon 64\n", + "adding: mem time336, current time 399, horizon 63\n", + "adding: mem time337, current time 399, horizon 62\n", + "adding: mem time338, current time 399, horizon 61\n", + "adding: mem time339, current time 399, horizon 60\n", + "adding: mem time340, current time 399, horizon 59\n", + "adding: mem time341, current time 399, horizon 58\n", + "adding: mem time342, current time 399, horizon 57\n", + "adding: mem time343, current time 399, horizon 56\n", + "adding: mem time344, current time 399, horizon 55\n", + "adding: mem time345, current time 399, horizon 54\n", + "adding: mem time346, current time 399, horizon 53\n", + "adding: mem time347, current time 399, horizon 52\n", + "adding: mem time348, current time 399, horizon 51\n", + "adding: mem time349, current time 399, horizon 50\n", + "adding: mem time350, current time 399, horizon 49\n", + "adding: mem time351, current time 399, horizon 48\n", + "adding: mem time352, current time 399, horizon 47\n", + "adding: mem time353, current time 399, horizon 46\n", + "adding: mem time354, current time 399, horizon 45\n", + "adding: mem time355, current time 399, horizon 44\n", + "adding: mem time356, current time 399, horizon 43\n", + "adding: mem time357, current time 399, horizon 42\n", + "adding: mem time358, current time 399, horizon 41\n", + "adding: mem time359, current time 399, horizon 40\n", + "adding: mem time360, current time 399, horizon 39\n", + "adding: mem time361, current time 399, horizon 38\n", + "adding: mem time362, current time 399, horizon 37\n", + "adding: mem time363, current time 399, horizon 36\n", + "adding: mem time364, current time 399, horizon 35\n", + "adding: mem time365, current time 399, horizon 34\n", + "adding: mem time366, current time 399, horizon 33\n", + "adding: mem time367, current time 399, horizon 32\n", + "adding: mem time368, current time 399, horizon 31\n", + "adding: mem time369, current time 399, horizon 30\n", + "adding: mem time370, current time 399, horizon 29\n", + "adding: mem time371, current time 399, horizon 28\n", + "adding: mem time372, current time 399, horizon 27\n", + "adding: mem time373, current time 399, horizon 26\n", + "adding: mem time374, current time 399, horizon 25\n", + "adding: mem time375, current time 399, horizon 24\n", + "adding: mem time376, current time 399, horizon 23\n", + "adding: mem time377, current time 399, horizon 22\n", + "adding: mem time378, current time 399, horizon 21\n", + "adding: mem time379, current time 399, horizon 20\n", + "adding: mem time380, current time 399, horizon 19\n", + "adding: mem time381, current time 399, horizon 18\n", + "adding: mem time382, current time 399, horizon 17\n", + "adding: mem time383, current time 399, horizon 16\n", + "adding: mem time384, current time 399, horizon 15\n", + "adding: mem time385, current time 399, horizon 14\n", + "adding: mem time386, current time 399, horizon 13\n", + "adding: mem time387, current time 399, horizon 12\n", + "adding: mem time388, current time 399, horizon 11\n", + "adding: mem time389, current time 399, horizon 10\n", + "adding: mem time390, current time 399, horizon 9\n", + "adding: mem time391, current time 399, horizon 8\n", + "adding: mem time392, current time 399, horizon 7\n", + "adding: mem time393, current time 399, horizon 6\n", + "adding: mem time394, current time 399, horizon 5\n", + "adding: mem time395, current time 399, horizon 4\n", + "adding: mem time396, current time 399, horizon 3\n", + "adding: mem time397, current time 399, horizon 2\n", + "adding: mem time398, current time 399, horizon 1\n", + "adding: mem time400, current time 401, horizon 1\n", + "adding: mem time400, current time 402, horizon 2\n", + "adding: mem time401, current time 402, horizon 1\n", + "adding: mem time400, current time 403, horizon 3\n", + "adding: mem time401, current time 403, horizon 2\n", + "adding: mem time402, current time 403, horizon 1\n", + "adding: mem time400, current time 404, horizon 4\n", + "adding: mem time401, current time 404, horizon 3\n", + "adding: mem time402, current time 404, horizon 2\n", + "adding: mem time403, current time 404, horizon 1\n", + "adding: mem time400, current time 405, horizon 5\n", + "adding: mem time401, current time 405, horizon 4\n", + "adding: mem time402, current time 405, horizon 3\n", + "adding: mem time403, current time 405, horizon 2\n", + "adding: mem time404, current time 405, horizon 1\n", + "adding: mem time400, current time 406, horizon 6\n", + "adding: mem time401, current time 406, horizon 5\n", + "adding: mem time402, current time 406, horizon 4\n", + "adding: mem time403, current time 406, horizon 3\n", + "adding: mem time404, current time 406, horizon 2\n", + "adding: mem time405, current time 406, horizon 1\n", + "adding: mem time400, current time 407, horizon 7\n", + "adding: mem time401, current time 407, horizon 6\n", + "adding: mem time402, current time 407, horizon 5\n", + "adding: mem time403, current time 407, horizon 4\n", + "adding: mem time404, current time 407, horizon 3\n", + "adding: mem time405, current time 407, horizon 2\n", + "adding: mem time406, current time 407, horizon 1\n", + "adding: mem time400, current time 408, horizon 8\n", + "adding: mem time401, current time 408, horizon 7\n", + "adding: mem time402, current time 408, horizon 6\n", + "adding: mem time403, current time 408, horizon 5\n", + "adding: mem time404, current time 408, horizon 4\n", + "adding: mem time405, current time 408, horizon 3\n", + "adding: mem time406, current time 408, horizon 2\n", + "adding: mem time407, current time 408, horizon 1\n", + "adding: mem time400, current time 409, horizon 9\n", + "adding: mem time401, current time 409, horizon 8\n", + "adding: mem time402, current time 409, horizon 7\n", + "adding: mem time403, current time 409, horizon 6\n", + "adding: mem time404, current time 409, horizon 5\n", + "adding: mem time405, current time 409, horizon 4\n", + "adding: mem time406, current time 409, horizon 3\n", + "adding: mem time407, current time 409, horizon 2\n", + "adding: mem time408, current time 409, horizon 1\n", + "adding: mem time400, current time 410, horizon 10\n", + "adding: mem time401, current time 410, horizon 9\n", + "adding: mem time402, current time 410, horizon 8\n", + "adding: mem time403, current time 410, horizon 7\n", + "adding: mem time404, current time 410, horizon 6\n", + "adding: mem time405, current time 410, horizon 5\n", + "adding: mem time406, current time 410, horizon 4\n", + "adding: mem time407, current time 410, horizon 3\n", + "adding: mem time408, current time 410, horizon 2\n", + "adding: mem time409, current time 410, horizon 1\n", + "adding: mem time400, current time 411, horizon 11\n", + "adding: mem time401, current time 411, horizon 10\n", + "adding: mem time402, current time 411, horizon 9\n", + "adding: mem time403, current time 411, horizon 8\n", + "adding: mem time404, current time 411, horizon 7\n", + "adding: mem time405, current time 411, horizon 6\n", + "adding: mem time406, current time 411, horizon 5\n", + "adding: mem time407, current time 411, horizon 4\n", + "adding: mem time408, current time 411, horizon 3\n", + "adding: mem time409, current time 411, horizon 2\n", + "adding: mem time410, current time 411, horizon 1\n", + "adding: mem time400, current time 412, horizon 12\n", + "adding: mem time401, current time 412, horizon 11\n", + "adding: mem time402, current time 412, horizon 10\n", + "adding: mem time403, current time 412, horizon 9\n", + "adding: mem time404, current time 412, horizon 8\n", + "adding: mem time405, current time 412, horizon 7\n", + "adding: mem time406, current time 412, horizon 6\n", + "adding: mem time407, current time 412, horizon 5\n", + "adding: mem time408, current time 412, horizon 4\n", + "adding: mem time409, current time 412, horizon 3\n", + "adding: mem time410, current time 412, horizon 2\n", + "adding: mem time411, current time 412, horizon 1\n", + "adding: mem time400, current time 413, horizon 13\n", + "adding: mem time401, current time 413, horizon 12\n", + "adding: mem time402, current time 413, horizon 11\n", + "adding: mem time403, current time 413, horizon 10\n", + "adding: mem time404, current time 413, horizon 9\n", + "adding: mem time405, current time 413, horizon 8\n", + "adding: mem time406, current time 413, horizon 7\n", + "adding: mem time407, current time 413, horizon 6\n", + "adding: mem time408, current time 413, horizon 5\n", + "adding: mem time409, current time 413, horizon 4\n", + "adding: mem time410, current time 413, horizon 3\n", + "adding: mem time411, current time 413, horizon 2\n", + "adding: mem time412, current time 413, horizon 1\n", + "adding: mem time400, current time 414, horizon 14\n", + "adding: mem time401, current time 414, horizon 13\n", + "adding: mem time402, current time 414, horizon 12\n", + "adding: mem time403, current time 414, horizon 11\n", + "adding: mem time404, current time 414, horizon 10\n", + "adding: mem time405, current time 414, horizon 9\n", + "adding: mem time406, current time 414, horizon 8\n", + "adding: mem time407, current time 414, horizon 7\n", + "adding: mem time408, current time 414, horizon 6\n", + "adding: mem time409, current time 414, horizon 5\n", + "adding: mem time410, current time 414, horizon 4\n", + "adding: mem time411, current time 414, horizon 3\n", + "adding: mem time412, current time 414, horizon 2\n", + "adding: mem time413, current time 414, horizon 1\n", + "adding: mem time400, current time 415, horizon 15\n", + "adding: mem time401, current time 415, horizon 14\n", + "adding: mem time402, current time 415, horizon 13\n", + "adding: mem time403, current time 415, horizon 12\n", + "adding: mem time404, current time 415, horizon 11\n", + "adding: mem time405, current time 415, horizon 10\n", + "adding: mem time406, current time 415, horizon 9\n", + "adding: mem time407, current time 415, horizon 8\n", + "adding: mem time408, current time 415, horizon 7\n", + "adding: mem time409, current time 415, horizon 6\n", + "adding: mem time410, current time 415, horizon 5\n", + "adding: mem time411, current time 415, horizon 4\n", + "adding: mem time412, current time 415, horizon 3\n", + "adding: mem time413, current time 415, horizon 2\n", + "adding: mem time414, current time 415, horizon 1\n", + "adding: mem time400, current time 416, horizon 16\n", + "adding: mem time401, current time 416, horizon 15\n", + "adding: mem time402, current time 416, horizon 14\n", + "adding: mem time403, current time 416, horizon 13\n", + "adding: mem time404, current time 416, horizon 12\n", + "adding: mem time405, current time 416, horizon 11\n", + "adding: mem time406, current time 416, horizon 10\n", + "adding: mem time407, current time 416, horizon 9\n", + "adding: mem time408, current time 416, horizon 8\n", + "adding: mem time409, current time 416, horizon 7\n", + "adding: mem time410, current time 416, horizon 6\n", + "adding: mem time411, current time 416, horizon 5\n", + "adding: mem time412, current time 416, horizon 4\n", + "adding: mem time413, current time 416, horizon 3\n", + "adding: mem time414, current time 416, horizon 2\n", + "adding: mem time415, current time 416, horizon 1\n", + "adding: mem time400, current time 417, horizon 17\n", + "adding: mem time401, current time 417, horizon 16\n", + "adding: mem time402, current time 417, horizon 15\n", + "adding: mem time403, current time 417, horizon 14\n", + "adding: mem time404, current time 417, horizon 13\n", + "adding: mem time405, current time 417, horizon 12\n", + "adding: mem time406, current time 417, horizon 11\n", + "adding: mem time407, current time 417, horizon 10\n", + "adding: mem time408, current time 417, horizon 9\n", + "adding: mem time409, current time 417, horizon 8\n", + "adding: mem time410, current time 417, horizon 7\n", + "adding: mem time411, current time 417, horizon 6\n", + "adding: mem time412, current time 417, horizon 5\n", + "adding: mem time413, current time 417, horizon 4\n", + "adding: mem time414, current time 417, horizon 3\n", + "adding: mem time415, current time 417, horizon 2\n", + "adding: mem time416, current time 417, horizon 1\n", + "adding: mem time400, current time 418, horizon 18\n", + "adding: mem time401, current time 418, horizon 17\n", + "adding: mem time402, current time 418, horizon 16\n", + "adding: mem time403, current time 418, horizon 15\n", + "adding: mem time404, current time 418, horizon 14\n", + "adding: mem time405, current time 418, horizon 13\n", + "adding: mem time406, current time 418, horizon 12\n", + "adding: mem time407, current time 418, horizon 11\n", + "adding: mem time408, current time 418, horizon 10\n", + "adding: mem time409, current time 418, horizon 9\n", + "adding: mem time410, current time 418, horizon 8\n", + "adding: mem time411, current time 418, horizon 7\n", + "adding: mem time412, current time 418, horizon 6\n", + "adding: mem time413, current time 418, horizon 5\n", + "adding: mem time414, current time 418, horizon 4\n", + "adding: mem time415, current time 418, horizon 3\n", + "adding: mem time416, current time 418, horizon 2\n", + "adding: mem time417, current time 418, horizon 1\n", + "adding: mem time400, current time 419, horizon 19\n", + "adding: mem time401, current time 419, horizon 18\n", + "adding: mem time402, current time 419, horizon 17\n", + "adding: mem time403, current time 419, horizon 16\n", + "adding: mem time404, current time 419, horizon 15\n", + "adding: mem time405, current time 419, horizon 14\n", + "adding: mem time406, current time 419, horizon 13\n", + "adding: mem time407, current time 419, horizon 12\n", + "adding: mem time408, current time 419, horizon 11\n", + "adding: mem time409, current time 419, horizon 10\n", + "adding: mem time410, current time 419, horizon 9\n", + "adding: mem time411, current time 419, horizon 8\n", + "adding: mem time412, current time 419, horizon 7\n", + "adding: mem time413, current time 419, horizon 6\n", + "adding: mem time414, current time 419, horizon 5\n", + "adding: mem time415, current time 419, horizon 4\n", + "adding: mem time416, current time 419, horizon 3\n", + "adding: mem time417, current time 419, horizon 2\n", + "adding: mem time418, current time 419, horizon 1\n", + "adding: mem time400, current time 420, horizon 20\n", + "adding: mem time401, current time 420, horizon 19\n", + "adding: mem time402, current time 420, horizon 18\n", + "adding: mem time403, current time 420, horizon 17\n", + "adding: mem time404, current time 420, horizon 16\n", + "adding: mem time405, current time 420, horizon 15\n", + "adding: mem time406, current time 420, horizon 14\n", + "adding: mem time407, current time 420, horizon 13\n", + "adding: mem time408, current time 420, horizon 12\n", + "adding: mem time409, current time 420, horizon 11\n", + "adding: mem time410, current time 420, horizon 10\n", + "adding: mem time411, current time 420, horizon 9\n", + "adding: mem time412, current time 420, horizon 8\n", + "adding: mem time413, current time 420, horizon 7\n", + "adding: mem time414, current time 420, horizon 6\n", + "adding: mem time415, current time 420, horizon 5\n", + "adding: mem time416, current time 420, horizon 4\n", + "adding: mem time417, current time 420, horizon 3\n", + "adding: mem time418, current time 420, horizon 2\n", + "adding: mem time419, current time 420, horizon 1\n", + "adding: mem time400, current time 421, horizon 21\n", + "adding: mem time401, current time 421, horizon 20\n", + "adding: mem time402, current time 421, horizon 19\n", + "adding: mem time403, current time 421, horizon 18\n", + "adding: mem time404, current time 421, horizon 17\n", + "adding: mem time405, current time 421, horizon 16\n", + "adding: mem time406, current time 421, horizon 15\n", + "adding: mem time407, current time 421, horizon 14\n", + "adding: mem time408, current time 421, horizon 13\n", + "adding: mem time409, current time 421, horizon 12\n", + "adding: mem time410, current time 421, horizon 11\n", + "adding: mem time411, current time 421, horizon 10\n", + "adding: mem time412, current time 421, horizon 9\n", + "adding: mem time413, current time 421, horizon 8\n", + "adding: mem time414, current time 421, horizon 7\n", + "adding: mem time415, current time 421, horizon 6\n", + "adding: mem time416, current time 421, horizon 5\n", + "adding: mem time417, current time 421, horizon 4\n", + "adding: mem time418, current time 421, horizon 3\n", + "adding: mem time419, current time 421, horizon 2\n", + "adding: mem time420, current time 421, horizon 1\n", + "adding: mem time400, current time 422, horizon 22\n", + "adding: mem time401, current time 422, horizon 21\n", + "adding: mem time402, current time 422, horizon 20\n", + "adding: mem time403, current time 422, horizon 19\n", + "adding: mem time404, current time 422, horizon 18\n", + "adding: mem time405, current time 422, horizon 17\n", + "adding: mem time406, current time 422, horizon 16\n", + "adding: mem time407, current time 422, horizon 15\n", + "adding: mem time408, current time 422, horizon 14\n", + "adding: mem time409, current time 422, horizon 13\n", + "adding: mem time410, current time 422, horizon 12\n", + "adding: mem time411, current time 422, horizon 11\n", + "adding: mem time412, current time 422, horizon 10\n", + "adding: mem time413, current time 422, horizon 9\n", + "adding: mem time414, current time 422, horizon 8\n", + "adding: mem time415, current time 422, horizon 7\n", + "adding: mem time416, current time 422, horizon 6\n", + "adding: mem time417, current time 422, horizon 5\n", + "adding: mem time418, current time 422, horizon 4\n", + "adding: mem time419, current time 422, horizon 3\n", + "adding: mem time420, current time 422, horizon 2\n", + "adding: mem time421, current time 422, horizon 1\n", + "adding: mem time400, current time 423, horizon 23\n", + "adding: mem time401, current time 423, horizon 22\n", + "adding: mem time402, current time 423, horizon 21\n", + "adding: mem time403, current time 423, horizon 20\n", + "adding: mem time404, current time 423, horizon 19\n", + "adding: mem time405, current time 423, horizon 18\n", + "adding: mem time406, current time 423, horizon 17\n", + "adding: mem time407, current time 423, horizon 16\n", + "adding: mem time408, current time 423, horizon 15\n", + "adding: mem time409, current time 423, horizon 14\n", + "adding: mem time410, current time 423, horizon 13\n", + "adding: mem time411, current time 423, horizon 12\n", + "adding: mem time412, current time 423, horizon 11\n", + "adding: mem time413, current time 423, horizon 10\n", + "adding: mem time414, current time 423, horizon 9\n", + "adding: mem time415, current time 423, horizon 8\n", + "adding: mem time416, current time 423, horizon 7\n", + "adding: mem time417, current time 423, horizon 6\n", + "adding: mem time418, current time 423, horizon 5\n", + "adding: mem time419, current time 423, horizon 4\n", + "adding: mem time420, current time 423, horizon 3\n", + "adding: mem time421, current time 423, horizon 2\n", + "adding: mem time422, current time 423, horizon 1\n", + "adding: mem time400, current time 424, horizon 24\n", + "adding: mem time401, current time 424, horizon 23\n", + "adding: mem time402, current time 424, horizon 22\n", + "adding: mem time403, current time 424, horizon 21\n", + "adding: mem time404, current time 424, horizon 20\n", + "adding: mem time405, current time 424, horizon 19\n", + "adding: mem time406, current time 424, horizon 18\n", + "adding: mem time407, current time 424, horizon 17\n", + "adding: mem time408, current time 424, horizon 16\n", + "adding: mem time409, current time 424, horizon 15\n", + "adding: mem time410, current time 424, horizon 14\n", + "adding: mem time411, current time 424, horizon 13\n", + "adding: mem time412, current time 424, horizon 12\n", + "adding: mem time413, current time 424, horizon 11\n", + "adding: mem time414, current time 424, horizon 10\n", + "adding: mem time415, current time 424, horizon 9\n", + "adding: mem time416, current time 424, horizon 8\n", + "adding: mem time417, current time 424, horizon 7\n", + "adding: mem time418, current time 424, horizon 6\n", + "adding: mem time419, current time 424, horizon 5\n", + "adding: mem time420, current time 424, horizon 4\n", + "adding: mem time421, current time 424, horizon 3\n", + "adding: mem time422, current time 424, horizon 2\n", + "adding: mem time423, current time 424, horizon 1\n", + "adding: mem time400, current time 425, horizon 25\n", + "adding: mem time401, current time 425, horizon 24\n", + "adding: mem time402, current time 425, horizon 23\n", + "adding: mem time403, current time 425, horizon 22\n", + "adding: mem time404, current time 425, horizon 21\n", + "adding: mem time405, current time 425, horizon 20\n", + "adding: mem time406, current time 425, horizon 19\n", + "adding: mem time407, current time 425, horizon 18\n", + "adding: mem time408, current time 425, horizon 17\n", + "adding: mem time409, current time 425, horizon 16\n", + "adding: mem time410, current time 425, horizon 15\n", + "adding: mem time411, current time 425, horizon 14\n", + "adding: mem time412, current time 425, horizon 13\n", + "adding: mem time413, current time 425, horizon 12\n", + "adding: mem time414, current time 425, horizon 11\n", + "adding: mem time415, current time 425, horizon 10\n", + "adding: mem time416, current time 425, horizon 9\n", + "adding: mem time417, current time 425, horizon 8\n", + "adding: mem time418, current time 425, horizon 7\n", + "adding: mem time419, current time 425, horizon 6\n", + "adding: mem time420, current time 425, horizon 5\n", + "adding: mem time421, current time 425, horizon 4\n", + "adding: mem time422, current time 425, horizon 3\n", + "adding: mem time423, current time 425, horizon 2\n", + "adding: mem time424, current time 425, horizon 1\n", + "adding: mem time400, current time 426, horizon 26\n", + "adding: mem time401, current time 426, horizon 25\n", + "adding: mem time402, current time 426, horizon 24\n", + "adding: mem time403, current time 426, horizon 23\n", + "adding: mem time404, current time 426, horizon 22\n", + "adding: mem time405, current time 426, horizon 21\n", + "adding: mem time406, current time 426, horizon 20\n", + "adding: mem time407, current time 426, horizon 19\n", + "adding: mem time408, current time 426, horizon 18\n", + "adding: mem time409, current time 426, horizon 17\n", + "adding: mem time410, current time 426, horizon 16\n", + "adding: mem time411, current time 426, horizon 15\n", + "adding: mem time412, current time 426, horizon 14\n", + "adding: mem time413, current time 426, horizon 13\n", + "adding: mem time414, current time 426, horizon 12\n", + "adding: mem time415, current time 426, horizon 11\n", + "adding: mem time416, current time 426, horizon 10\n", + "adding: mem time417, current time 426, horizon 9\n", + "adding: mem time418, current time 426, horizon 8\n", + "adding: mem time419, current time 426, horizon 7\n", + "adding: mem time420, current time 426, horizon 6\n", + "adding: mem time421, current time 426, horizon 5\n", + "adding: mem time422, current time 426, horizon 4\n", + "adding: mem time423, current time 426, horizon 3\n", + "adding: mem time424, current time 426, horizon 2\n", + "adding: mem time425, current time 426, horizon 1\n", + "adding: mem time400, current time 427, horizon 27\n", + "adding: mem time401, current time 427, horizon 26\n", + "adding: mem time402, current time 427, horizon 25\n", + "adding: mem time403, current time 427, horizon 24\n", + "adding: mem time404, current time 427, horizon 23\n", + "adding: mem time405, current time 427, horizon 22\n", + "adding: mem time406, current time 427, horizon 21\n", + "adding: mem time407, current time 427, horizon 20\n", + "adding: mem time408, current time 427, horizon 19\n", + "adding: mem time409, current time 427, horizon 18\n", + "adding: mem time410, current time 427, horizon 17\n", + "adding: mem time411, current time 427, horizon 16\n", + "adding: mem time412, current time 427, horizon 15\n", + "adding: mem time413, current time 427, horizon 14\n", + "adding: mem time414, current time 427, horizon 13\n", + "adding: mem time415, current time 427, horizon 12\n", + "adding: mem time416, current time 427, horizon 11\n", + "adding: mem time417, current time 427, horizon 10\n", + "adding: mem time418, current time 427, horizon 9\n", + "adding: mem time419, current time 427, horizon 8\n", + "adding: mem time420, current time 427, horizon 7\n", + "adding: mem time421, current time 427, horizon 6\n", + "adding: mem time422, current time 427, horizon 5\n", + "adding: mem time423, current time 427, horizon 4\n", + "adding: mem time424, current time 427, horizon 3\n", + "adding: mem time425, current time 427, horizon 2\n", + "adding: mem time426, current time 427, horizon 1\n", + "adding: mem time400, current time 428, horizon 28\n", + "adding: mem time401, current time 428, horizon 27\n", + "adding: mem time402, current time 428, horizon 26\n", + "adding: mem time403, current time 428, horizon 25\n", + "adding: mem time404, current time 428, horizon 24\n", + "adding: mem time405, current time 428, horizon 23\n", + "adding: mem time406, current time 428, horizon 22\n", + "adding: mem time407, current time 428, horizon 21\n", + "adding: mem time408, current time 428, horizon 20\n", + "adding: mem time409, current time 428, horizon 19\n", + "adding: mem time410, current time 428, horizon 18\n", + "adding: mem time411, current time 428, horizon 17\n", + "adding: mem time412, current time 428, horizon 16\n", + "adding: mem time413, current time 428, horizon 15\n", + "adding: mem time414, current time 428, horizon 14\n", + "adding: mem time415, current time 428, horizon 13\n", + "adding: mem time416, current time 428, horizon 12\n", + "adding: mem time417, current time 428, horizon 11\n", + "adding: mem time418, current time 428, horizon 10\n", + "adding: mem time419, current time 428, horizon 9\n", + "adding: mem time420, current time 428, horizon 8\n", + "adding: mem time421, current time 428, horizon 7\n", + "adding: mem time422, current time 428, horizon 6\n", + "adding: mem time423, current time 428, horizon 5\n", + "adding: mem time424, current time 428, horizon 4\n", + "adding: mem time425, current time 428, horizon 3\n", + "adding: mem time426, current time 428, horizon 2\n", + "adding: mem time427, current time 428, horizon 1\n", + "adding: mem time400, current time 429, horizon 29\n", + "adding: mem time401, current time 429, horizon 28\n", + "adding: mem time402, current time 429, horizon 27\n", + "adding: mem time403, current time 429, horizon 26\n", + "adding: mem time404, current time 429, horizon 25\n", + "adding: mem time405, current time 429, horizon 24\n", + "adding: mem time406, current time 429, horizon 23\n", + "adding: mem time407, current time 429, horizon 22\n", + "adding: mem time408, current time 429, horizon 21\n", + "adding: mem time409, current time 429, horizon 20\n", + "adding: mem time410, current time 429, horizon 19\n", + "adding: mem time411, current time 429, horizon 18\n", + "adding: mem time412, current time 429, horizon 17\n", + "adding: mem time413, current time 429, horizon 16\n", + "adding: mem time414, current time 429, horizon 15\n", + "adding: mem time415, current time 429, horizon 14\n", + "adding: mem time416, current time 429, horizon 13\n", + "adding: mem time417, current time 429, horizon 12\n", + "adding: mem time418, current time 429, horizon 11\n", + "adding: mem time419, current time 429, horizon 10\n", + "adding: mem time420, current time 429, horizon 9\n", + "adding: mem time421, current time 429, horizon 8\n", + "adding: mem time422, current time 429, horizon 7\n", + "adding: mem time423, current time 429, horizon 6\n", + "adding: mem time424, current time 429, horizon 5\n", + "adding: mem time425, current time 429, horizon 4\n", + "adding: mem time426, current time 429, horizon 3\n", + "adding: mem time427, current time 429, horizon 2\n", + "adding: mem time428, current time 429, horizon 1\n", + "adding: mem time400, current time 430, horizon 30\n", + "adding: mem time401, current time 430, horizon 29\n", + "adding: mem time402, current time 430, horizon 28\n", + "adding: mem time403, current time 430, horizon 27\n", + "adding: mem time404, current time 430, horizon 26\n", + "adding: mem time405, current time 430, horizon 25\n", + "adding: mem time406, current time 430, horizon 24\n", + "adding: mem time407, current time 430, horizon 23\n", + "adding: mem time408, current time 430, horizon 22\n", + "adding: mem time409, current time 430, horizon 21\n", + "adding: mem time410, current time 430, horizon 20\n", + "adding: mem time411, current time 430, horizon 19\n", + "adding: mem time412, current time 430, horizon 18\n", + "adding: mem time413, current time 430, horizon 17\n", + "adding: mem time414, current time 430, horizon 16\n", + "adding: mem time415, current time 430, horizon 15\n", + "adding: mem time416, current time 430, horizon 14\n", + "adding: mem time417, current time 430, horizon 13\n", + "adding: mem time418, current time 430, horizon 12\n", + "adding: mem time419, current time 430, horizon 11\n", + "adding: mem time420, current time 430, horizon 10\n", + "adding: mem time421, current time 430, horizon 9\n", + "adding: mem time422, current time 430, horizon 8\n", + "adding: mem time423, current time 430, horizon 7\n", + "adding: mem time424, current time 430, horizon 6\n", + "adding: mem time425, current time 430, horizon 5\n", + "adding: mem time426, current time 430, horizon 4\n", + "adding: mem time427, current time 430, horizon 3\n", + "adding: mem time428, current time 430, horizon 2\n", + "adding: mem time429, current time 430, horizon 1\n", + "adding: mem time400, current time 431, horizon 31\n", + "adding: mem time401, current time 431, horizon 30\n", + "adding: mem time402, current time 431, horizon 29\n", + "adding: mem time403, current time 431, horizon 28\n", + "adding: mem time404, current time 431, horizon 27\n", + "adding: mem time405, current time 431, horizon 26\n", + "adding: mem time406, current time 431, horizon 25\n", + "adding: mem time407, current time 431, horizon 24\n", + "adding: mem time408, current time 431, horizon 23\n", + "adding: mem time409, current time 431, horizon 22\n", + "adding: mem time410, current time 431, horizon 21\n", + "adding: mem time411, current time 431, horizon 20\n", + "adding: mem time412, current time 431, horizon 19\n", + "adding: mem time413, current time 431, horizon 18\n", + "adding: mem time414, current time 431, horizon 17\n", + "adding: mem time415, current time 431, horizon 16\n", + "adding: mem time416, current time 431, horizon 15\n", + "adding: mem time417, current time 431, horizon 14\n", + "adding: mem time418, current time 431, horizon 13\n", + "adding: mem time419, current time 431, horizon 12\n", + "adding: mem time420, current time 431, horizon 11\n", + "adding: mem time421, current time 431, horizon 10\n", + "adding: mem time422, current time 431, horizon 9\n", + "adding: mem time423, current time 431, horizon 8\n", + "adding: mem time424, current time 431, horizon 7\n", + "adding: mem time425, current time 431, horizon 6\n", + "adding: mem time426, current time 431, horizon 5\n", + "adding: mem time427, current time 431, horizon 4\n", + "adding: mem time428, current time 431, horizon 3\n", + "adding: mem time429, current time 431, horizon 2\n", + "adding: mem time430, current time 431, horizon 1\n", + "adding: mem time400, current time 432, horizon 32\n", + "adding: mem time401, current time 432, horizon 31\n", + "adding: mem time402, current time 432, horizon 30\n", + "adding: mem time403, current time 432, horizon 29\n", + "adding: mem time404, current time 432, horizon 28\n", + "adding: mem time405, current time 432, horizon 27\n", + "adding: mem time406, current time 432, horizon 26\n", + "adding: mem time407, current time 432, horizon 25\n", + "adding: mem time408, current time 432, horizon 24\n", + "adding: mem time409, current time 432, horizon 23\n", + "adding: mem time410, current time 432, horizon 22\n", + "adding: mem time411, current time 432, horizon 21\n", + "adding: mem time412, current time 432, horizon 20\n", + "adding: mem time413, current time 432, horizon 19\n", + "adding: mem time414, current time 432, horizon 18\n", + "adding: mem time415, current time 432, horizon 17\n", + "adding: mem time416, current time 432, horizon 16\n", + "adding: mem time417, current time 432, horizon 15\n", + "adding: mem time418, current time 432, horizon 14\n", + "adding: mem time419, current time 432, horizon 13\n", + "adding: mem time420, current time 432, horizon 12\n", + "adding: mem time421, current time 432, horizon 11\n", + "adding: mem time422, current time 432, horizon 10\n", + "adding: mem time423, current time 432, horizon 9\n", + "adding: mem time424, current time 432, horizon 8\n", + "adding: mem time425, current time 432, horizon 7\n", + "adding: mem time426, current time 432, horizon 6\n", + "adding: mem time427, current time 432, horizon 5\n", + "adding: mem time428, current time 432, horizon 4\n", + "adding: mem time429, current time 432, horizon 3\n", + "adding: mem time430, current time 432, horizon 2\n", + "adding: mem time431, current time 432, horizon 1\n", + "adding: mem time400, current time 433, horizon 33\n", + "adding: mem time401, current time 433, horizon 32\n", + "adding: mem time402, current time 433, horizon 31\n", + "adding: mem time403, current time 433, horizon 30\n", + "adding: mem time404, current time 433, horizon 29\n", + "adding: mem time405, current time 433, horizon 28\n", + "adding: mem time406, current time 433, horizon 27\n", + "adding: mem time407, current time 433, horizon 26\n", + "adding: mem time408, current time 433, horizon 25\n", + "adding: mem time409, current time 433, horizon 24\n", + "adding: mem time410, current time 433, horizon 23\n", + "adding: mem time411, current time 433, horizon 22\n", + "adding: mem time412, current time 433, horizon 21\n", + "adding: mem time413, current time 433, horizon 20\n", + "adding: mem time414, current time 433, horizon 19\n", + "adding: mem time415, current time 433, horizon 18\n", + "adding: mem time416, current time 433, horizon 17\n", + "adding: mem time417, current time 433, horizon 16\n", + "adding: mem time418, current time 433, horizon 15\n", + "adding: mem time419, current time 433, horizon 14\n", + "adding: mem time420, current time 433, horizon 13\n", + "adding: mem time421, current time 433, horizon 12\n", + "adding: mem time422, current time 433, horizon 11\n", + "adding: mem time423, current time 433, horizon 10\n", + "adding: mem time424, current time 433, horizon 9\n", + "adding: mem time425, current time 433, horizon 8\n", + "adding: mem time426, current time 433, horizon 7\n", + "adding: mem time427, current time 433, horizon 6\n", + "adding: mem time428, current time 433, horizon 5\n", + "adding: mem time429, current time 433, horizon 4\n", + "adding: mem time430, current time 433, horizon 3\n", + "adding: mem time431, current time 433, horizon 2\n", + "adding: mem time432, current time 433, horizon 1\n", + "adding: mem time400, current time 434, horizon 34\n", + "adding: mem time401, current time 434, horizon 33\n", + "adding: mem time402, current time 434, horizon 32\n", + "adding: mem time403, current time 434, horizon 31\n", + "adding: mem time404, current time 434, horizon 30\n", + "adding: mem time405, current time 434, horizon 29\n", + "adding: mem time406, current time 434, horizon 28\n", + "adding: mem time407, current time 434, horizon 27\n", + "adding: mem time408, current time 434, horizon 26\n", + "adding: mem time409, current time 434, horizon 25\n", + "adding: mem time410, current time 434, horizon 24\n", + "adding: mem time411, current time 434, horizon 23\n", + "adding: mem time412, current time 434, horizon 22\n", + "adding: mem time413, current time 434, horizon 21\n", + "adding: mem time414, current time 434, horizon 20\n", + "adding: mem time415, current time 434, horizon 19\n", + "adding: mem time416, current time 434, horizon 18\n", + "adding: mem time417, current time 434, horizon 17\n", + "adding: mem time418, current time 434, horizon 16\n", + "adding: mem time419, current time 434, horizon 15\n", + "adding: mem time420, current time 434, horizon 14\n", + "adding: mem time421, current time 434, horizon 13\n", + "adding: mem time422, current time 434, horizon 12\n", + "adding: mem time423, current time 434, horizon 11\n", + "adding: mem time424, current time 434, horizon 10\n", + "adding: mem time425, current time 434, horizon 9\n", + "adding: mem time426, current time 434, horizon 8\n", + "adding: mem time427, current time 434, horizon 7\n", + "adding: mem time428, current time 434, horizon 6\n", + "adding: mem time429, current time 434, horizon 5\n", + "adding: mem time430, current time 434, horizon 4\n", + "adding: mem time431, current time 434, horizon 3\n", + "adding: mem time432, current time 434, horizon 2\n", + "adding: mem time433, current time 434, horizon 1\n", + "adding: mem time400, current time 435, horizon 35\n", + "adding: mem time401, current time 435, horizon 34\n", + "adding: mem time402, current time 435, horizon 33\n", + "adding: mem time403, current time 435, horizon 32\n", + "adding: mem time404, current time 435, horizon 31\n", + "adding: mem time405, current time 435, horizon 30\n", + "adding: mem time406, current time 435, horizon 29\n", + "adding: mem time407, current time 435, horizon 28\n", + "adding: mem time408, current time 435, horizon 27\n", + "adding: mem time409, current time 435, horizon 26\n", + "adding: mem time410, current time 435, horizon 25\n", + "adding: mem time411, current time 435, horizon 24\n", + "adding: mem time412, current time 435, horizon 23\n", + "adding: mem time413, current time 435, horizon 22\n", + "adding: mem time414, current time 435, horizon 21\n", + "adding: mem time415, current time 435, horizon 20\n", + "adding: mem time416, current time 435, horizon 19\n", + "adding: mem time417, current time 435, horizon 18\n", + "adding: mem time418, current time 435, horizon 17\n", + "adding: mem time419, current time 435, horizon 16\n", + "adding: mem time420, current time 435, horizon 15\n", + "adding: mem time421, current time 435, horizon 14\n", + "adding: mem time422, current time 435, horizon 13\n", + "adding: mem time423, current time 435, horizon 12\n", + "adding: mem time424, current time 435, horizon 11\n", + "adding: mem time425, current time 435, horizon 10\n", + "adding: mem time426, current time 435, horizon 9\n", + "adding: mem time427, current time 435, horizon 8\n", + "adding: mem time428, current time 435, horizon 7\n", + "adding: mem time429, current time 435, horizon 6\n", + "adding: mem time430, current time 435, horizon 5\n", + "adding: mem time431, current time 435, horizon 4\n", + "adding: mem time432, current time 435, horizon 3\n", + "adding: mem time433, current time 435, horizon 2\n", + "adding: mem time434, current time 435, horizon 1\n", + "adding: mem time400, current time 436, horizon 36\n", + "adding: mem time401, current time 436, horizon 35\n", + "adding: mem time402, current time 436, horizon 34\n", + "adding: mem time403, current time 436, horizon 33\n", + "adding: mem time404, current time 436, horizon 32\n", + "adding: mem time405, current time 436, horizon 31\n", + "adding: mem time406, current time 436, horizon 30\n", + "adding: mem time407, current time 436, horizon 29\n", + "adding: mem time408, current time 436, horizon 28\n", + "adding: mem time409, current time 436, horizon 27\n", + "adding: mem time410, current time 436, horizon 26\n", + "adding: mem time411, current time 436, horizon 25\n", + "adding: mem time412, current time 436, horizon 24\n", + "adding: mem time413, current time 436, horizon 23\n", + "adding: mem time414, current time 436, horizon 22\n", + "adding: mem time415, current time 436, horizon 21\n", + "adding: mem time416, current time 436, horizon 20\n", + "adding: mem time417, current time 436, horizon 19\n", + "adding: mem time418, current time 436, horizon 18\n", + "adding: mem time419, current time 436, horizon 17\n", + "adding: mem time420, current time 436, horizon 16\n", + "adding: mem time421, current time 436, horizon 15\n", + "adding: mem time422, current time 436, horizon 14\n", + "adding: mem time423, current time 436, horizon 13\n", + "adding: mem time424, current time 436, horizon 12\n", + "adding: mem time425, current time 436, horizon 11\n", + "adding: mem time426, current time 436, horizon 10\n", + "adding: mem time427, current time 436, horizon 9\n", + "adding: mem time428, current time 436, horizon 8\n", + "adding: mem time429, current time 436, horizon 7\n", + "adding: mem time430, current time 436, horizon 6\n", + "adding: mem time431, current time 436, horizon 5\n", + "adding: mem time432, current time 436, horizon 4\n", + "adding: mem time433, current time 436, horizon 3\n", + "adding: mem time434, current time 436, horizon 2\n", + "adding: mem time435, current time 436, horizon 1\n", + "adding: mem time400, current time 437, horizon 37\n", + "adding: mem time401, current time 437, horizon 36\n", + "adding: mem time402, current time 437, horizon 35\n", + "adding: mem time403, current time 437, horizon 34\n", + "adding: mem time404, current time 437, horizon 33\n", + "adding: mem time405, current time 437, horizon 32\n", + "adding: mem time406, current time 437, horizon 31\n", + "adding: mem time407, current time 437, horizon 30\n", + "adding: mem time408, current time 437, horizon 29\n", + "adding: mem time409, current time 437, horizon 28\n", + "adding: mem time410, current time 437, horizon 27\n", + "adding: mem time411, current time 437, horizon 26\n", + "adding: mem time412, current time 437, horizon 25\n", + "adding: mem time413, current time 437, horizon 24\n", + "adding: mem time414, current time 437, horizon 23\n", + "adding: mem time415, current time 437, horizon 22\n", + "adding: mem time416, current time 437, horizon 21\n", + "adding: mem time417, current time 437, horizon 20\n", + "adding: mem time418, current time 437, horizon 19\n", + "adding: mem time419, current time 437, horizon 18\n", + "adding: mem time420, current time 437, horizon 17\n", + "adding: mem time421, current time 437, horizon 16\n", + "adding: mem time422, current time 437, horizon 15\n", + "adding: mem time423, current time 437, horizon 14\n", + "adding: mem time424, current time 437, horizon 13\n", + "adding: mem time425, current time 437, horizon 12\n", + "adding: mem time426, current time 437, horizon 11\n", + "adding: mem time427, current time 437, horizon 10\n", + "adding: mem time428, current time 437, horizon 9\n", + "adding: mem time429, current time 437, horizon 8\n", + "adding: mem time430, current time 437, horizon 7\n", + "adding: mem time431, current time 437, horizon 6\n", + "adding: mem time432, current time 437, horizon 5\n", + "adding: mem time433, current time 437, horizon 4\n", + "adding: mem time434, current time 437, horizon 3\n", + "adding: mem time435, current time 437, horizon 2\n", + "adding: mem time436, current time 437, horizon 1\n", + "adding: mem time400, current time 438, horizon 38\n", + "adding: mem time401, current time 438, horizon 37\n", + "adding: mem time402, current time 438, horizon 36\n", + "adding: mem time403, current time 438, horizon 35\n", + "adding: mem time404, current time 438, horizon 34\n", + "adding: mem time405, current time 438, horizon 33\n", + "adding: mem time406, current time 438, horizon 32\n", + "adding: mem time407, current time 438, horizon 31\n", + "adding: mem time408, current time 438, horizon 30\n", + "adding: mem time409, current time 438, horizon 29\n", + "adding: mem time410, current time 438, horizon 28\n", + "adding: mem time411, current time 438, horizon 27\n", + "adding: mem time412, current time 438, horizon 26\n", + "adding: mem time413, current time 438, horizon 25\n", + "adding: mem time414, current time 438, horizon 24\n", + "adding: mem time415, current time 438, horizon 23\n", + "adding: mem time416, current time 438, horizon 22\n", + "adding: mem time417, current time 438, horizon 21\n", + "adding: mem time418, current time 438, horizon 20\n", + "adding: mem time419, current time 438, horizon 19\n", + "adding: mem time420, current time 438, horizon 18\n", + "adding: mem time421, current time 438, horizon 17\n", + "adding: mem time422, current time 438, horizon 16\n", + "adding: mem time423, current time 438, horizon 15\n", + "adding: mem time424, current time 438, horizon 14\n", + "adding: mem time425, current time 438, horizon 13\n", + "adding: mem time426, current time 438, horizon 12\n", + "adding: mem time427, current time 438, horizon 11\n", + "adding: mem time428, current time 438, horizon 10\n", + "adding: mem time429, current time 438, horizon 9\n", + "adding: mem time430, current time 438, horizon 8\n", + "adding: mem time431, current time 438, horizon 7\n", + "adding: mem time432, current time 438, horizon 6\n", + "adding: mem time433, current time 438, horizon 5\n", + "adding: mem time434, current time 438, horizon 4\n", + "adding: mem time435, current time 438, horizon 3\n", + "adding: mem time436, current time 438, horizon 2\n", + "adding: mem time437, current time 438, horizon 1\n", + "adding: mem time400, current time 439, horizon 39\n", + "adding: mem time401, current time 439, horizon 38\n", + "adding: mem time402, current time 439, horizon 37\n", + "adding: mem time403, current time 439, horizon 36\n", + "adding: mem time404, current time 439, horizon 35\n", + "adding: mem time405, current time 439, horizon 34\n", + "adding: mem time406, current time 439, horizon 33\n", + "adding: mem time407, current time 439, horizon 32\n", + "adding: mem time408, current time 439, horizon 31\n", + "adding: mem time409, current time 439, horizon 30\n", + "adding: mem time410, current time 439, horizon 29\n", + "adding: mem time411, current time 439, horizon 28\n", + "adding: mem time412, current time 439, horizon 27\n", + "adding: mem time413, current time 439, horizon 26\n", + "adding: mem time414, current time 439, horizon 25\n", + "adding: mem time415, current time 439, horizon 24\n", + "adding: mem time416, current time 439, horizon 23\n", + "adding: mem time417, current time 439, horizon 22\n", + "adding: mem time418, current time 439, horizon 21\n", + "adding: mem time419, current time 439, horizon 20\n", + "adding: mem time420, current time 439, horizon 19\n", + "adding: mem time421, current time 439, horizon 18\n", + "adding: mem time422, current time 439, horizon 17\n", + "adding: mem time423, current time 439, horizon 16\n", + "adding: mem time424, current time 439, horizon 15\n", + "adding: mem time425, current time 439, horizon 14\n", + "adding: mem time426, current time 439, horizon 13\n", + "adding: mem time427, current time 439, horizon 12\n", + "adding: mem time428, current time 439, horizon 11\n", + "adding: mem time429, current time 439, horizon 10\n", + "adding: mem time430, current time 439, horizon 9\n", + "adding: mem time431, current time 439, horizon 8\n", + "adding: mem time432, current time 439, horizon 7\n", + "adding: mem time433, current time 439, horizon 6\n", + "adding: mem time434, current time 439, horizon 5\n", + "adding: mem time435, current time 439, horizon 4\n", + "adding: mem time436, current time 439, horizon 3\n", + "adding: mem time437, current time 439, horizon 2\n", + "adding: mem time438, current time 439, horizon 1\n", + "adding: mem time400, current time 440, horizon 40\n", + "adding: mem time401, current time 440, horizon 39\n", + "adding: mem time402, current time 440, horizon 38\n", + "adding: mem time403, current time 440, horizon 37\n", + "adding: mem time404, current time 440, horizon 36\n", + "adding: mem time405, current time 440, horizon 35\n", + "adding: mem time406, current time 440, horizon 34\n", + "adding: mem time407, current time 440, horizon 33\n", + "adding: mem time408, current time 440, horizon 32\n", + "adding: mem time409, current time 440, horizon 31\n", + "adding: mem time410, current time 440, horizon 30\n", + "adding: mem time411, current time 440, horizon 29\n", + "adding: mem time412, current time 440, horizon 28\n", + "adding: mem time413, current time 440, horizon 27\n", + "adding: mem time414, current time 440, horizon 26\n", + "adding: mem time415, current time 440, horizon 25\n", + "adding: mem time416, current time 440, horizon 24\n", + "adding: mem time417, current time 440, horizon 23\n", + "adding: mem time418, current time 440, horizon 22\n", + "adding: mem time419, current time 440, horizon 21\n", + "adding: mem time420, current time 440, horizon 20\n", + "adding: mem time421, current time 440, horizon 19\n", + "adding: mem time422, current time 440, horizon 18\n", + "adding: mem time423, current time 440, horizon 17\n", + "adding: mem time424, current time 440, horizon 16\n", + "adding: mem time425, current time 440, horizon 15\n", + "adding: mem time426, current time 440, horizon 14\n", + "adding: mem time427, current time 440, horizon 13\n", + "adding: mem time428, current time 440, horizon 12\n", + "adding: mem time429, current time 440, horizon 11\n", + "adding: mem time430, current time 440, horizon 10\n", + "adding: mem time431, current time 440, horizon 9\n", + "adding: mem time432, current time 440, horizon 8\n", + "adding: mem time433, current time 440, horizon 7\n", + "adding: mem time434, current time 440, horizon 6\n", + "adding: mem time435, current time 440, horizon 5\n", + "adding: mem time436, current time 440, horizon 4\n", + "adding: mem time437, current time 440, horizon 3\n", + "adding: mem time438, current time 440, horizon 2\n", + "adding: mem time439, current time 440, horizon 1\n", + "adding: mem time400, current time 441, horizon 41\n", + "adding: mem time401, current time 441, horizon 40\n", + "adding: mem time402, current time 441, horizon 39\n", + "adding: mem time403, current time 441, horizon 38\n", + "adding: mem time404, current time 441, horizon 37\n", + "adding: mem time405, current time 441, horizon 36\n", + "adding: mem time406, current time 441, horizon 35\n", + "adding: mem time407, current time 441, horizon 34\n", + "adding: mem time408, current time 441, horizon 33\n", + "adding: mem time409, current time 441, horizon 32\n", + "adding: mem time410, current time 441, horizon 31\n", + "adding: mem time411, current time 441, horizon 30\n", + "adding: mem time412, current time 441, horizon 29\n", + "adding: mem time413, current time 441, horizon 28\n", + "adding: mem time414, current time 441, horizon 27\n", + "adding: mem time415, current time 441, horizon 26\n", + "adding: mem time416, current time 441, horizon 25\n", + "adding: mem time417, current time 441, horizon 24\n", + "adding: mem time418, current time 441, horizon 23\n", + "adding: mem time419, current time 441, horizon 22\n", + "adding: mem time420, current time 441, horizon 21\n", + "adding: mem time421, current time 441, horizon 20\n", + "adding: mem time422, current time 441, horizon 19\n", + "adding: mem time423, current time 441, horizon 18\n", + "adding: mem time424, current time 441, horizon 17\n", + "adding: mem time425, current time 441, horizon 16\n", + "adding: mem time426, current time 441, horizon 15\n", + "adding: mem time427, current time 441, horizon 14\n", + "adding: mem time428, current time 441, horizon 13\n", + "adding: mem time429, current time 441, horizon 12\n", + "adding: mem time430, current time 441, horizon 11\n", + "adding: mem time431, current time 441, horizon 10\n", + "adding: mem time432, current time 441, horizon 9\n", + "adding: mem time433, current time 441, horizon 8\n", + "adding: mem time434, current time 441, horizon 7\n", + "adding: mem time435, current time 441, horizon 6\n", + "adding: mem time436, current time 441, horizon 5\n", + "adding: mem time437, current time 441, horizon 4\n", + "adding: mem time438, current time 441, horizon 3\n", + "adding: mem time439, current time 441, horizon 2\n", + "adding: mem time440, current time 441, horizon 1\n", + "adding: mem time400, current time 442, horizon 42\n", + "adding: mem time401, current time 442, horizon 41\n", + "adding: mem time402, current time 442, horizon 40\n", + "adding: mem time403, current time 442, horizon 39\n", + "adding: mem time404, current time 442, horizon 38\n", + "adding: mem time405, current time 442, horizon 37\n", + "adding: mem time406, current time 442, horizon 36\n", + "adding: mem time407, current time 442, horizon 35\n", + "adding: mem time408, current time 442, horizon 34\n", + "adding: mem time409, current time 442, horizon 33\n", + "adding: mem time410, current time 442, horizon 32\n", + "adding: mem time411, current time 442, horizon 31\n", + "adding: mem time412, current time 442, horizon 30\n", + "adding: mem time413, current time 442, horizon 29\n", + "adding: mem time414, current time 442, horizon 28\n", + "adding: mem time415, current time 442, horizon 27\n", + "adding: mem time416, current time 442, horizon 26\n", + "adding: mem time417, current time 442, horizon 25\n", + "adding: mem time418, current time 442, horizon 24\n", + "adding: mem time419, current time 442, horizon 23\n", + "adding: mem time420, current time 442, horizon 22\n", + "adding: mem time421, current time 442, horizon 21\n", + "adding: mem time422, current time 442, horizon 20\n", + "adding: mem time423, current time 442, horizon 19\n", + "adding: mem time424, current time 442, horizon 18\n", + "adding: mem time425, current time 442, horizon 17\n", + "adding: mem time426, current time 442, horizon 16\n", + "adding: mem time427, current time 442, horizon 15\n", + "adding: mem time428, current time 442, horizon 14\n", + "adding: mem time429, current time 442, horizon 13\n", + "adding: mem time430, current time 442, horizon 12\n", + "adding: mem time431, current time 442, horizon 11\n", + "adding: mem time432, current time 442, horizon 10\n", + "adding: mem time433, current time 442, horizon 9\n", + "adding: mem time434, current time 442, horizon 8\n", + "adding: mem time435, current time 442, horizon 7\n", + "adding: mem time436, current time 442, horizon 6\n", + "adding: mem time437, current time 442, horizon 5\n", + "adding: mem time438, current time 442, horizon 4\n", + "adding: mem time439, current time 442, horizon 3\n", + "adding: mem time440, current time 442, horizon 2\n", + "adding: mem time441, current time 442, horizon 1\n", + "adding: mem time400, current time 443, horizon 43\n", + "adding: mem time401, current time 443, horizon 42\n", + "adding: mem time402, current time 443, horizon 41\n", + "adding: mem time403, current time 443, horizon 40\n", + "adding: mem time404, current time 443, horizon 39\n", + "adding: mem time405, current time 443, horizon 38\n", + "adding: mem time406, current time 443, horizon 37\n", + "adding: mem time407, current time 443, horizon 36\n", + "adding: mem time408, current time 443, horizon 35\n", + "adding: mem time409, current time 443, horizon 34\n", + "adding: mem time410, current time 443, horizon 33\n", + "adding: mem time411, current time 443, horizon 32\n", + "adding: mem time412, current time 443, horizon 31\n", + "adding: mem time413, current time 443, horizon 30\n", + "adding: mem time414, current time 443, horizon 29\n", + "adding: mem time415, current time 443, horizon 28\n", + "adding: mem time416, current time 443, horizon 27\n", + "adding: mem time417, current time 443, horizon 26\n", + "adding: mem time418, current time 443, horizon 25\n", + "adding: mem time419, current time 443, horizon 24\n", + "adding: mem time420, current time 443, horizon 23\n", + "adding: mem time421, current time 443, horizon 22\n", + "adding: mem time422, current time 443, horizon 21\n", + "adding: mem time423, current time 443, horizon 20\n", + "adding: mem time424, current time 443, horizon 19\n", + "adding: mem time425, current time 443, horizon 18\n", + "adding: mem time426, current time 443, horizon 17\n", + "adding: mem time427, current time 443, horizon 16\n", + "adding: mem time428, current time 443, horizon 15\n", + "adding: mem time429, current time 443, horizon 14\n", + "adding: mem time430, current time 443, horizon 13\n", + "adding: mem time431, current time 443, horizon 12\n", + "adding: mem time432, current time 443, horizon 11\n", + "adding: mem time433, current time 443, horizon 10\n", + "adding: mem time434, current time 443, horizon 9\n", + "adding: mem time435, current time 443, horizon 8\n", + "adding: mem time436, current time 443, horizon 7\n", + "adding: mem time437, current time 443, horizon 6\n", + "adding: mem time438, current time 443, horizon 5\n", + "adding: mem time439, current time 443, horizon 4\n", + "adding: mem time440, current time 443, horizon 3\n", + "adding: mem time441, current time 443, horizon 2\n", + "adding: mem time442, current time 443, horizon 1\n", + "adding: mem time400, current time 444, horizon 44\n", + "adding: mem time401, current time 444, horizon 43\n", + "adding: mem time402, current time 444, horizon 42\n", + "adding: mem time403, current time 444, horizon 41\n", + "adding: mem time404, current time 444, horizon 40\n", + "adding: mem time405, current time 444, horizon 39\n", + "adding: mem time406, current time 444, horizon 38\n", + "adding: mem time407, current time 444, horizon 37\n", + "adding: mem time408, current time 444, horizon 36\n", + "adding: mem time409, current time 444, horizon 35\n", + "adding: mem time410, current time 444, horizon 34\n", + "adding: mem time411, current time 444, horizon 33\n", + "adding: mem time412, current time 444, horizon 32\n", + "adding: mem time413, current time 444, horizon 31\n", + "adding: mem time414, current time 444, horizon 30\n", + "adding: mem time415, current time 444, horizon 29\n", + "adding: mem time416, current time 444, horizon 28\n", + "adding: mem time417, current time 444, horizon 27\n", + "adding: mem time418, current time 444, horizon 26\n", + "adding: mem time419, current time 444, horizon 25\n", + "adding: mem time420, current time 444, horizon 24\n", + "adding: mem time421, current time 444, horizon 23\n", + "adding: mem time422, current time 444, horizon 22\n", + "adding: mem time423, current time 444, horizon 21\n", + "adding: mem time424, current time 444, horizon 20\n", + "adding: mem time425, current time 444, horizon 19\n", + "adding: mem time426, current time 444, horizon 18\n", + "adding: mem time427, current time 444, horizon 17\n", + "adding: mem time428, current time 444, horizon 16\n", + "adding: mem time429, current time 444, horizon 15\n", + "adding: mem time430, current time 444, horizon 14\n", + "adding: mem time431, current time 444, horizon 13\n", + "adding: mem time432, current time 444, horizon 12\n", + "adding: mem time433, current time 444, horizon 11\n", + "adding: mem time434, current time 444, horizon 10\n", + "adding: mem time435, current time 444, horizon 9\n", + "adding: mem time436, current time 444, horizon 8\n", + "adding: mem time437, current time 444, horizon 7\n", + "adding: mem time438, current time 444, horizon 6\n", + "adding: mem time439, current time 444, horizon 5\n", + "adding: mem time440, current time 444, horizon 4\n", + "adding: mem time441, current time 444, horizon 3\n", + "adding: mem time442, current time 444, horizon 2\n", + "adding: mem time443, current time 444, horizon 1\n", + "adding: mem time400, current time 445, horizon 45\n", + "adding: mem time401, current time 445, horizon 44\n", + "adding: mem time402, current time 445, horizon 43\n", + "adding: mem time403, current time 445, horizon 42\n", + "adding: mem time404, current time 445, horizon 41\n", + "adding: mem time405, current time 445, horizon 40\n", + "adding: mem time406, current time 445, horizon 39\n", + "adding: mem time407, current time 445, horizon 38\n", + "adding: mem time408, current time 445, horizon 37\n", + "adding: mem time409, current time 445, horizon 36\n", + "adding: mem time410, current time 445, horizon 35\n", + "adding: mem time411, current time 445, horizon 34\n", + "adding: mem time412, current time 445, horizon 33\n", + "adding: mem time413, current time 445, horizon 32\n", + "adding: mem time414, current time 445, horizon 31\n", + "adding: mem time415, current time 445, horizon 30\n", + "adding: mem time416, current time 445, horizon 29\n", + "adding: mem time417, current time 445, horizon 28\n", + "adding: mem time418, current time 445, horizon 27\n", + "adding: mem time419, current time 445, horizon 26\n", + "adding: mem time420, current time 445, horizon 25\n", + "adding: mem time421, current time 445, horizon 24\n", + "adding: mem time422, current time 445, horizon 23\n", + "adding: mem time423, current time 445, horizon 22\n", + "adding: mem time424, current time 445, horizon 21\n", + "adding: mem time425, current time 445, horizon 20\n", + "adding: mem time426, current time 445, horizon 19\n", + "adding: mem time427, current time 445, horizon 18\n", + "adding: mem time428, current time 445, horizon 17\n", + "adding: mem time429, current time 445, horizon 16\n", + "adding: mem time430, current time 445, horizon 15\n", + "adding: mem time431, current time 445, horizon 14\n", + "adding: mem time432, current time 445, horizon 13\n", + "adding: mem time433, current time 445, horizon 12\n", + "adding: mem time434, current time 445, horizon 11\n", + "adding: mem time435, current time 445, horizon 10\n", + "adding: mem time436, current time 445, horizon 9\n", + "adding: mem time437, current time 445, horizon 8\n", + "adding: mem time438, current time 445, horizon 7\n", + "adding: mem time439, current time 445, horizon 6\n", + "adding: mem time440, current time 445, horizon 5\n", + "adding: mem time441, current time 445, horizon 4\n", + "adding: mem time442, current time 445, horizon 3\n", + "adding: mem time443, current time 445, horizon 2\n", + "adding: mem time444, current time 445, horizon 1\n", + "adding: mem time400, current time 446, horizon 46\n", + "adding: mem time401, current time 446, horizon 45\n", + "adding: mem time402, current time 446, horizon 44\n", + "adding: mem time403, current time 446, horizon 43\n", + "adding: mem time404, current time 446, horizon 42\n", + "adding: mem time405, current time 446, horizon 41\n", + "adding: mem time406, current time 446, horizon 40\n", + "adding: mem time407, current time 446, horizon 39\n", + "adding: mem time408, current time 446, horizon 38\n", + "adding: mem time409, current time 446, horizon 37\n", + "adding: mem time410, current time 446, horizon 36\n", + "adding: mem time411, current time 446, horizon 35\n", + "adding: mem time412, current time 446, horizon 34\n", + "adding: mem time413, current time 446, horizon 33\n", + "adding: mem time414, current time 446, horizon 32\n", + "adding: mem time415, current time 446, horizon 31\n", + "adding: mem time416, current time 446, horizon 30\n", + "adding: mem time417, current time 446, horizon 29\n", + "adding: mem time418, current time 446, horizon 28\n", + "adding: mem time419, current time 446, horizon 27\n", + "adding: mem time420, current time 446, horizon 26\n", + "adding: mem time421, current time 446, horizon 25\n", + "adding: mem time422, current time 446, horizon 24\n", + "adding: mem time423, current time 446, horizon 23\n", + "adding: mem time424, current time 446, horizon 22\n", + "adding: mem time425, current time 446, horizon 21\n", + "adding: mem time426, current time 446, horizon 20\n", + "adding: mem time427, current time 446, horizon 19\n", + "adding: mem time428, current time 446, horizon 18\n", + "adding: mem time429, current time 446, horizon 17\n", + "adding: mem time430, current time 446, horizon 16\n", + "adding: mem time431, current time 446, horizon 15\n", + "adding: mem time432, current time 446, horizon 14\n", + "adding: mem time433, current time 446, horizon 13\n", + "adding: mem time434, current time 446, horizon 12\n", + "adding: mem time435, current time 446, horizon 11\n", + "adding: mem time436, current time 446, horizon 10\n", + "adding: mem time437, current time 446, horizon 9\n", + "adding: mem time438, current time 446, horizon 8\n", + "adding: mem time439, current time 446, horizon 7\n", + "adding: mem time440, current time 446, horizon 6\n", + "adding: mem time441, current time 446, horizon 5\n", + "adding: mem time442, current time 446, horizon 4\n", + "adding: mem time443, current time 446, horizon 3\n", + "adding: mem time444, current time 446, horizon 2\n", + "adding: mem time445, current time 446, horizon 1\n", + "adding: mem time400, current time 447, horizon 47\n", + "adding: mem time401, current time 447, horizon 46\n", + "adding: mem time402, current time 447, horizon 45\n", + "adding: mem time403, current time 447, horizon 44\n", + "adding: mem time404, current time 447, horizon 43\n", + "adding: mem time405, current time 447, horizon 42\n", + "adding: mem time406, current time 447, horizon 41\n", + "adding: mem time407, current time 447, horizon 40\n", + "adding: mem time408, current time 447, horizon 39\n", + "adding: mem time409, current time 447, horizon 38\n", + "adding: mem time410, current time 447, horizon 37\n", + "adding: mem time411, current time 447, horizon 36\n", + "adding: mem time412, current time 447, horizon 35\n", + "adding: mem time413, current time 447, horizon 34\n", + "adding: mem time414, current time 447, horizon 33\n", + "adding: mem time415, current time 447, horizon 32\n", + "adding: mem time416, current time 447, horizon 31\n", + "adding: mem time417, current time 447, horizon 30\n", + "adding: mem time418, current time 447, horizon 29\n", + "adding: mem time419, current time 447, horizon 28\n", + "adding: mem time420, current time 447, horizon 27\n", + "adding: mem time421, current time 447, horizon 26\n", + "adding: mem time422, current time 447, horizon 25\n", + "adding: mem time423, current time 447, horizon 24\n", + "adding: mem time424, current time 447, horizon 23\n", + "adding: mem time425, current time 447, horizon 22\n", + "adding: mem time426, current time 447, horizon 21\n", + "adding: mem time427, current time 447, horizon 20\n", + "adding: mem time428, current time 447, horizon 19\n", + "adding: mem time429, current time 447, horizon 18\n", + "adding: mem time430, current time 447, horizon 17\n", + "adding: mem time431, current time 447, horizon 16\n", + "adding: mem time432, current time 447, horizon 15\n", + "adding: mem time433, current time 447, horizon 14\n", + "adding: mem time434, current time 447, horizon 13\n", + "adding: mem time435, current time 447, horizon 12\n", + "adding: mem time436, current time 447, horizon 11\n", + "adding: mem time437, current time 447, horizon 10\n", + "adding: mem time438, current time 447, horizon 9\n", + "adding: mem time439, current time 447, horizon 8\n", + "adding: mem time440, current time 447, horizon 7\n", + "adding: mem time441, current time 447, horizon 6\n", + "adding: mem time442, current time 447, horizon 5\n", + "adding: mem time443, current time 447, horizon 4\n", + "adding: mem time444, current time 447, horizon 3\n", + "adding: mem time445, current time 447, horizon 2\n", + "adding: mem time446, current time 447, horizon 1\n", + "adding: mem time400, current time 448, horizon 48\n", + "adding: mem time401, current time 448, horizon 47\n", + "adding: mem time402, current time 448, horizon 46\n", + "adding: mem time403, current time 448, horizon 45\n", + "adding: mem time404, current time 448, horizon 44\n", + "adding: mem time405, current time 448, horizon 43\n", + "adding: mem time406, current time 448, horizon 42\n", + "adding: mem time407, current time 448, horizon 41\n", + "adding: mem time408, current time 448, horizon 40\n", + "adding: mem time409, current time 448, horizon 39\n", + "adding: mem time410, current time 448, horizon 38\n", + "adding: mem time411, current time 448, horizon 37\n", + "adding: mem time412, current time 448, horizon 36\n", + "adding: mem time413, current time 448, horizon 35\n", + "adding: mem time414, current time 448, horizon 34\n", + "adding: mem time415, current time 448, horizon 33\n", + "adding: mem time416, current time 448, horizon 32\n", + "adding: mem time417, current time 448, horizon 31\n", + "adding: mem time418, current time 448, horizon 30\n", + "adding: mem time419, current time 448, horizon 29\n", + "adding: mem time420, current time 448, horizon 28\n", + "adding: mem time421, current time 448, horizon 27\n", + "adding: mem time422, current time 448, horizon 26\n", + "adding: mem time423, current time 448, horizon 25\n", + "adding: mem time424, current time 448, horizon 24\n", + "adding: mem time425, current time 448, horizon 23\n", + "adding: mem time426, current time 448, horizon 22\n", + "adding: mem time427, current time 448, horizon 21\n", + "adding: mem time428, current time 448, horizon 20\n", + "adding: mem time429, current time 448, horizon 19\n", + "adding: mem time430, current time 448, horizon 18\n", + "adding: mem time431, current time 448, horizon 17\n", + "adding: mem time432, current time 448, horizon 16\n", + "adding: mem time433, current time 448, horizon 15\n", + "adding: mem time434, current time 448, horizon 14\n", + "adding: mem time435, current time 448, horizon 13\n", + "adding: mem time436, current time 448, horizon 12\n", + "adding: mem time437, current time 448, horizon 11\n", + "adding: mem time438, current time 448, horizon 10\n", + "adding: mem time439, current time 448, horizon 9\n", + "adding: mem time440, current time 448, horizon 8\n", + "adding: mem time441, current time 448, horizon 7\n", + "adding: mem time442, current time 448, horizon 6\n", + "adding: mem time443, current time 448, horizon 5\n", + "adding: mem time444, current time 448, horizon 4\n", + "adding: mem time445, current time 448, horizon 3\n", + "adding: mem time446, current time 448, horizon 2\n", + "adding: mem time447, current time 448, horizon 1\n", + "adding: mem time400, current time 449, horizon 49\n", + "adding: mem time401, current time 449, horizon 48\n", + "adding: mem time402, current time 449, horizon 47\n", + "adding: mem time403, current time 449, horizon 46\n", + "adding: mem time404, current time 449, horizon 45\n", + "adding: mem time405, current time 449, horizon 44\n", + "adding: mem time406, current time 449, horizon 43\n", + "adding: mem time407, current time 449, horizon 42\n", + "adding: mem time408, current time 449, horizon 41\n", + "adding: mem time409, current time 449, horizon 40\n", + "adding: mem time410, current time 449, horizon 39\n", + "adding: mem time411, current time 449, horizon 38\n", + "adding: mem time412, current time 449, horizon 37\n", + "adding: mem time413, current time 449, horizon 36\n", + "adding: mem time414, current time 449, horizon 35\n", + "adding: mem time415, current time 449, horizon 34\n", + "adding: mem time416, current time 449, horizon 33\n", + "adding: mem time417, current time 449, horizon 32\n", + "adding: mem time418, current time 449, horizon 31\n", + "adding: mem time419, current time 449, horizon 30\n", + "adding: mem time420, current time 449, horizon 29\n", + "adding: mem time421, current time 449, horizon 28\n", + "adding: mem time422, current time 449, horizon 27\n", + "adding: mem time423, current time 449, horizon 26\n", + "adding: mem time424, current time 449, horizon 25\n", + "adding: mem time425, current time 449, horizon 24\n", + "adding: mem time426, current time 449, horizon 23\n", + "adding: mem time427, current time 449, horizon 22\n", + "adding: mem time428, current time 449, horizon 21\n", + "adding: mem time429, current time 449, horizon 20\n", + "adding: mem time430, current time 449, horizon 19\n", + "adding: mem time431, current time 449, horizon 18\n", + "adding: mem time432, current time 449, horizon 17\n", + "adding: mem time433, current time 449, horizon 16\n", + "adding: mem time434, current time 449, horizon 15\n", + "adding: mem time435, current time 449, horizon 14\n", + "adding: mem time436, current time 449, horizon 13\n", + "adding: mem time437, current time 449, horizon 12\n", + "adding: mem time438, current time 449, horizon 11\n", + "adding: mem time439, current time 449, horizon 10\n", + "adding: mem time440, current time 449, horizon 9\n", + "adding: mem time441, current time 449, horizon 8\n", + "adding: mem time442, current time 449, horizon 7\n", + "adding: mem time443, current time 449, horizon 6\n", + "adding: mem time444, current time 449, horizon 5\n", + "adding: mem time445, current time 449, horizon 4\n", + "adding: mem time446, current time 449, horizon 3\n", + "adding: mem time447, current time 449, horizon 2\n", + "adding: mem time448, current time 449, horizon 1\n", + "adding: mem time400, current time 450, horizon 50\n", + "adding: mem time401, current time 450, horizon 49\n", + "adding: mem time402, current time 450, horizon 48\n", + "adding: mem time403, current time 450, horizon 47\n", + "adding: mem time404, current time 450, horizon 46\n", + "adding: mem time405, current time 450, horizon 45\n", + "adding: mem time406, current time 450, horizon 44\n", + "adding: mem time407, current time 450, horizon 43\n", + "adding: mem time408, current time 450, horizon 42\n", + "adding: mem time409, current time 450, horizon 41\n", + "adding: mem time410, current time 450, horizon 40\n", + "adding: mem time411, current time 450, horizon 39\n", + "adding: mem time412, current time 450, horizon 38\n", + "adding: mem time413, current time 450, horizon 37\n", + "adding: mem time414, current time 450, horizon 36\n", + "adding: mem time415, current time 450, horizon 35\n", + "adding: mem time416, current time 450, horizon 34\n", + "adding: mem time417, current time 450, horizon 33\n", + "adding: mem time418, current time 450, horizon 32\n", + "adding: mem time419, current time 450, horizon 31\n", + "adding: mem time420, current time 450, horizon 30\n", + "adding: mem time421, current time 450, horizon 29\n", + "adding: mem time422, current time 450, horizon 28\n", + "adding: mem time423, current time 450, horizon 27\n", + "adding: mem time424, current time 450, horizon 26\n", + "adding: mem time425, current time 450, horizon 25\n", + "adding: mem time426, current time 450, horizon 24\n", + "adding: mem time427, current time 450, horizon 23\n", + "adding: mem time428, current time 450, horizon 22\n", + "adding: mem time429, current time 450, horizon 21\n", + "adding: mem time430, current time 450, horizon 20\n", + "adding: mem time431, current time 450, horizon 19\n", + "adding: mem time432, current time 450, horizon 18\n", + "adding: mem time433, current time 450, horizon 17\n", + "adding: mem time434, current time 450, horizon 16\n", + "adding: mem time435, current time 450, horizon 15\n", + "adding: mem time436, current time 450, horizon 14\n", + "adding: mem time437, current time 450, horizon 13\n", + "adding: mem time438, current time 450, horizon 12\n", + "adding: mem time439, current time 450, horizon 11\n", + "adding: mem time440, current time 450, horizon 10\n", + "adding: mem time441, current time 450, horizon 9\n", + "adding: mem time442, current time 450, horizon 8\n", + "adding: mem time443, current time 450, horizon 7\n", + "adding: mem time444, current time 450, horizon 6\n", + "adding: mem time445, current time 450, horizon 5\n", + "adding: mem time446, current time 450, horizon 4\n", + "adding: mem time447, current time 450, horizon 3\n", + "adding: mem time448, current time 450, horizon 2\n", + "adding: mem time449, current time 450, horizon 1\n", + "adding: mem time400, current time 451, horizon 51\n", + "adding: mem time401, current time 451, horizon 50\n", + "adding: mem time402, current time 451, horizon 49\n", + "adding: mem time403, current time 451, horizon 48\n", + "adding: mem time404, current time 451, horizon 47\n", + "adding: mem time405, current time 451, horizon 46\n", + "adding: mem time406, current time 451, horizon 45\n", + "adding: mem time407, current time 451, horizon 44\n", + "adding: mem time408, current time 451, horizon 43\n", + "adding: mem time409, current time 451, horizon 42\n", + "adding: mem time410, current time 451, horizon 41\n", + "adding: mem time411, current time 451, horizon 40\n", + "adding: mem time412, current time 451, horizon 39\n", + "adding: mem time413, current time 451, horizon 38\n", + "adding: mem time414, current time 451, horizon 37\n", + "adding: mem time415, current time 451, horizon 36\n", + "adding: mem time416, current time 451, horizon 35\n", + "adding: mem time417, current time 451, horizon 34\n", + "adding: mem time418, current time 451, horizon 33\n", + "adding: mem time419, current time 451, horizon 32\n", + "adding: mem time420, current time 451, horizon 31\n", + "adding: mem time421, current time 451, horizon 30\n", + "adding: mem time422, current time 451, horizon 29\n", + "adding: mem time423, current time 451, horizon 28\n", + "adding: mem time424, current time 451, horizon 27\n", + "adding: mem time425, current time 451, horizon 26\n", + "adding: mem time426, current time 451, horizon 25\n", + "adding: mem time427, current time 451, horizon 24\n", + "adding: mem time428, current time 451, horizon 23\n", + "adding: mem time429, current time 451, horizon 22\n", + "adding: mem time430, current time 451, horizon 21\n", + "adding: mem time431, current time 451, horizon 20\n", + "adding: mem time432, current time 451, horizon 19\n", + "adding: mem time433, current time 451, horizon 18\n", + "adding: mem time434, current time 451, horizon 17\n", + "adding: mem time435, current time 451, horizon 16\n", + "adding: mem time436, current time 451, horizon 15\n", + "adding: mem time437, current time 451, horizon 14\n", + "adding: mem time438, current time 451, horizon 13\n", + "adding: mem time439, current time 451, horizon 12\n", + "adding: mem time440, current time 451, horizon 11\n", + "adding: mem time441, current time 451, horizon 10\n", + "adding: mem time442, current time 451, horizon 9\n", + "adding: mem time443, current time 451, horizon 8\n", + "adding: mem time444, current time 451, horizon 7\n", + "adding: mem time445, current time 451, horizon 6\n", + "adding: mem time446, current time 451, horizon 5\n", + "adding: mem time447, current time 451, horizon 4\n", + "adding: mem time448, current time 451, horizon 3\n", + "adding: mem time449, current time 451, horizon 2\n", + "adding: mem time450, current time 451, horizon 1\n", + "adding: mem time400, current time 452, horizon 52\n", + "adding: mem time401, current time 452, horizon 51\n", + "adding: mem time402, current time 452, horizon 50\n", + "adding: mem time403, current time 452, horizon 49\n", + "adding: mem time404, current time 452, horizon 48\n", + "adding: mem time405, current time 452, horizon 47\n", + "adding: mem time406, current time 452, horizon 46\n", + "adding: mem time407, current time 452, horizon 45\n", + "adding: mem time408, current time 452, horizon 44\n", + "adding: mem time409, current time 452, horizon 43\n", + "adding: mem time410, current time 452, horizon 42\n", + "adding: mem time411, current time 452, horizon 41\n", + "adding: mem time412, current time 452, horizon 40\n", + "adding: mem time413, current time 452, horizon 39\n", + "adding: mem time414, current time 452, horizon 38\n", + "adding: mem time415, current time 452, horizon 37\n", + "adding: mem time416, current time 452, horizon 36\n", + "adding: mem time417, current time 452, horizon 35\n", + "adding: mem time418, current time 452, horizon 34\n", + "adding: mem time419, current time 452, horizon 33\n", + "adding: mem time420, current time 452, horizon 32\n", + "adding: mem time421, current time 452, horizon 31\n", + "adding: mem time422, current time 452, horizon 30\n", + "adding: mem time423, current time 452, horizon 29\n", + "adding: mem time424, current time 452, horizon 28\n", + "adding: mem time425, current time 452, horizon 27\n", + "adding: mem time426, current time 452, horizon 26\n", + "adding: mem time427, current time 452, horizon 25\n", + "adding: mem time428, current time 452, horizon 24\n", + "adding: mem time429, current time 452, horizon 23\n", + "adding: mem time430, current time 452, horizon 22\n", + "adding: mem time431, current time 452, horizon 21\n", + "adding: mem time432, current time 452, horizon 20\n", + "adding: mem time433, current time 452, horizon 19\n", + "adding: mem time434, current time 452, horizon 18\n", + "adding: mem time435, current time 452, horizon 17\n", + "adding: mem time436, current time 452, horizon 16\n", + "adding: mem time437, current time 452, horizon 15\n", + "adding: mem time438, current time 452, horizon 14\n", + "adding: mem time439, current time 452, horizon 13\n", + "adding: mem time440, current time 452, horizon 12\n", + "adding: mem time441, current time 452, horizon 11\n", + "adding: mem time442, current time 452, horizon 10\n", + "adding: mem time443, current time 452, horizon 9\n", + "adding: mem time444, current time 452, horizon 8\n", + "adding: mem time445, current time 452, horizon 7\n", + "adding: mem time446, current time 452, horizon 6\n", + "adding: mem time447, current time 452, horizon 5\n", + "adding: mem time448, current time 452, horizon 4\n", + "adding: mem time449, current time 452, horizon 3\n", + "adding: mem time450, current time 452, horizon 2\n", + "adding: mem time451, current time 452, horizon 1\n", + "adding: mem time400, current time 453, horizon 53\n", + "adding: mem time401, current time 453, horizon 52\n", + "adding: mem time402, current time 453, horizon 51\n", + "adding: mem time403, current time 453, horizon 50\n", + "adding: mem time404, current time 453, horizon 49\n", + "adding: mem time405, current time 453, horizon 48\n", + "adding: mem time406, current time 453, horizon 47\n", + "adding: mem time407, current time 453, horizon 46\n", + "adding: mem time408, current time 453, horizon 45\n", + "adding: mem time409, current time 453, horizon 44\n", + "adding: mem time410, current time 453, horizon 43\n", + "adding: mem time411, current time 453, horizon 42\n", + "adding: mem time412, current time 453, horizon 41\n", + "adding: mem time413, current time 453, horizon 40\n", + "adding: mem time414, current time 453, horizon 39\n", + "adding: mem time415, current time 453, horizon 38\n", + "adding: mem time416, current time 453, horizon 37\n", + "adding: mem time417, current time 453, horizon 36\n", + "adding: mem time418, current time 453, horizon 35\n", + "adding: mem time419, current time 453, horizon 34\n", + "adding: mem time420, current time 453, horizon 33\n", + "adding: mem time421, current time 453, horizon 32\n", + "adding: mem time422, current time 453, horizon 31\n", + "adding: mem time423, current time 453, horizon 30\n", + "adding: mem time424, current time 453, horizon 29\n", + "adding: mem time425, current time 453, horizon 28\n", + "adding: mem time426, current time 453, horizon 27\n", + "adding: mem time427, current time 453, horizon 26\n", + "adding: mem time428, current time 453, horizon 25\n", + "adding: mem time429, current time 453, horizon 24\n", + "adding: mem time430, current time 453, horizon 23\n", + "adding: mem time431, current time 453, horizon 22\n", + "adding: mem time432, current time 453, horizon 21\n", + "adding: mem time433, current time 453, horizon 20\n", + "adding: mem time434, current time 453, horizon 19\n", + "adding: mem time435, current time 453, horizon 18\n", + "adding: mem time436, current time 453, horizon 17\n", + "adding: mem time437, current time 453, horizon 16\n", + "adding: mem time438, current time 453, horizon 15\n", + "adding: mem time439, current time 453, horizon 14\n", + "adding: mem time440, current time 453, horizon 13\n", + "adding: mem time441, current time 453, horizon 12\n", + "adding: mem time442, current time 453, horizon 11\n", + "adding: mem time443, current time 453, horizon 10\n", + "adding: mem time444, current time 453, horizon 9\n", + "adding: mem time445, current time 453, horizon 8\n", + "adding: mem time446, current time 453, horizon 7\n", + "adding: mem time447, current time 453, horizon 6\n", + "adding: mem time448, current time 453, horizon 5\n", + "adding: mem time449, current time 453, horizon 4\n", + "adding: mem time450, current time 453, horizon 3\n", + "adding: mem time451, current time 453, horizon 2\n", + "adding: mem time452, current time 453, horizon 1\n", + "adding: mem time400, current time 454, horizon 54\n", + "adding: mem time401, current time 454, horizon 53\n", + "adding: mem time402, current time 454, horizon 52\n", + "adding: mem time403, current time 454, horizon 51\n", + "adding: mem time404, current time 454, horizon 50\n", + "adding: mem time405, current time 454, horizon 49\n", + "adding: mem time406, current time 454, horizon 48\n", + "adding: mem time407, current time 454, horizon 47\n", + "adding: mem time408, current time 454, horizon 46\n", + "adding: mem time409, current time 454, horizon 45\n", + "adding: mem time410, current time 454, horizon 44\n", + "adding: mem time411, current time 454, horizon 43\n", + "adding: mem time412, current time 454, horizon 42\n", + "adding: mem time413, current time 454, horizon 41\n", + "adding: mem time414, current time 454, horizon 40\n", + "adding: mem time415, current time 454, horizon 39\n", + "adding: mem time416, current time 454, horizon 38\n", + "adding: mem time417, current time 454, horizon 37\n", + "adding: mem time418, current time 454, horizon 36\n", + "adding: mem time419, current time 454, horizon 35\n", + "adding: mem time420, current time 454, horizon 34\n", + "adding: mem time421, current time 454, horizon 33\n", + "adding: mem time422, current time 454, horizon 32\n", + "adding: mem time423, current time 454, horizon 31\n", + "adding: mem time424, current time 454, horizon 30\n", + "adding: mem time425, current time 454, horizon 29\n", + "adding: mem time426, current time 454, horizon 28\n", + "adding: mem time427, current time 454, horizon 27\n", + "adding: mem time428, current time 454, horizon 26\n", + "adding: mem time429, current time 454, horizon 25\n", + "adding: mem time430, current time 454, horizon 24\n", + "adding: mem time431, current time 454, horizon 23\n", + "adding: mem time432, current time 454, horizon 22\n", + "adding: mem time433, current time 454, horizon 21\n", + "adding: mem time434, current time 454, horizon 20\n", + "adding: mem time435, current time 454, horizon 19\n", + "adding: mem time436, current time 454, horizon 18\n", + "adding: mem time437, current time 454, horizon 17\n", + "adding: mem time438, current time 454, horizon 16\n", + "adding: mem time439, current time 454, horizon 15\n", + "adding: mem time440, current time 454, horizon 14\n", + "adding: mem time441, current time 454, horizon 13\n", + "adding: mem time442, current time 454, horizon 12\n", + "adding: mem time443, current time 454, horizon 11\n", + "adding: mem time444, current time 454, horizon 10\n", + "adding: mem time445, current time 454, horizon 9\n", + "adding: mem time446, current time 454, horizon 8\n", + "adding: mem time447, current time 454, horizon 7\n", + "adding: mem time448, current time 454, horizon 6\n", + "adding: mem time449, current time 454, horizon 5\n", + "adding: mem time450, current time 454, horizon 4\n", + "adding: mem time451, current time 454, horizon 3\n", + "adding: mem time452, current time 454, horizon 2\n", + "adding: mem time453, current time 454, horizon 1\n", + "adding: mem time400, current time 455, horizon 55\n", + "adding: mem time401, current time 455, horizon 54\n", + "adding: mem time402, current time 455, horizon 53\n", + "adding: mem time403, current time 455, horizon 52\n", + "adding: mem time404, current time 455, horizon 51\n", + "adding: mem time405, current time 455, horizon 50\n", + "adding: mem time406, current time 455, horizon 49\n", + "adding: mem time407, current time 455, horizon 48\n", + "adding: mem time408, current time 455, horizon 47\n", + "adding: mem time409, current time 455, horizon 46\n", + "adding: mem time410, current time 455, horizon 45\n", + "adding: mem time411, current time 455, horizon 44\n", + "adding: mem time412, current time 455, horizon 43\n", + "adding: mem time413, current time 455, horizon 42\n", + "adding: mem time414, current time 455, horizon 41\n", + "adding: mem time415, current time 455, horizon 40\n", + "adding: mem time416, current time 455, horizon 39\n", + "adding: mem time417, current time 455, horizon 38\n", + "adding: mem time418, current time 455, horizon 37\n", + "adding: mem time419, current time 455, horizon 36\n", + "adding: mem time420, current time 455, horizon 35\n", + "adding: mem time421, current time 455, horizon 34\n", + "adding: mem time422, current time 455, horizon 33\n", + "adding: mem time423, current time 455, horizon 32\n", + "adding: mem time424, current time 455, horizon 31\n", + "adding: mem time425, current time 455, horizon 30\n", + "adding: mem time426, current time 455, horizon 29\n", + "adding: mem time427, current time 455, horizon 28\n", + "adding: mem time428, current time 455, horizon 27\n", + "adding: mem time429, current time 455, horizon 26\n", + "adding: mem time430, current time 455, horizon 25\n", + "adding: mem time431, current time 455, horizon 24\n", + "adding: mem time432, current time 455, horizon 23\n", + "adding: mem time433, current time 455, horizon 22\n", + "adding: mem time434, current time 455, horizon 21\n", + "adding: mem time435, current time 455, horizon 20\n", + "adding: mem time436, current time 455, horizon 19\n", + "adding: mem time437, current time 455, horizon 18\n", + "adding: mem time438, current time 455, horizon 17\n", + "adding: mem time439, current time 455, horizon 16\n", + "adding: mem time440, current time 455, horizon 15\n", + "adding: mem time441, current time 455, horizon 14\n", + "adding: mem time442, current time 455, horizon 13\n", + "adding: mem time443, current time 455, horizon 12\n", + "adding: mem time444, current time 455, horizon 11\n", + "adding: mem time445, current time 455, horizon 10\n", + "adding: mem time446, current time 455, horizon 9\n", + "adding: mem time447, current time 455, horizon 8\n", + "adding: mem time448, current time 455, horizon 7\n", + "adding: mem time449, current time 455, horizon 6\n", + "adding: mem time450, current time 455, horizon 5\n", + "adding: mem time451, current time 455, horizon 4\n", + "adding: mem time452, current time 455, horizon 3\n", + "adding: mem time453, current time 455, horizon 2\n", + "adding: mem time454, current time 455, horizon 1\n", + "adding: mem time400, current time 456, horizon 56\n", + "adding: mem time401, current time 456, horizon 55\n", + "adding: mem time402, current time 456, horizon 54\n", + "adding: mem time403, current time 456, horizon 53\n", + "adding: mem time404, current time 456, horizon 52\n", + "adding: mem time405, current time 456, horizon 51\n", + "adding: mem time406, current time 456, horizon 50\n", + "adding: mem time407, current time 456, horizon 49\n", + "adding: mem time408, current time 456, horizon 48\n", + "adding: mem time409, current time 456, horizon 47\n", + "adding: mem time410, current time 456, horizon 46\n", + "adding: mem time411, current time 456, horizon 45\n", + "adding: mem time412, current time 456, horizon 44\n", + "adding: mem time413, current time 456, horizon 43\n", + "adding: mem time414, current time 456, horizon 42\n", + "adding: mem time415, current time 456, horizon 41\n", + "adding: mem time416, current time 456, horizon 40\n", + "adding: mem time417, current time 456, horizon 39\n", + "adding: mem time418, current time 456, horizon 38\n", + "adding: mem time419, current time 456, horizon 37\n", + "adding: mem time420, current time 456, horizon 36\n", + "adding: mem time421, current time 456, horizon 35\n", + "adding: mem time422, current time 456, horizon 34\n", + "adding: mem time423, current time 456, horizon 33\n", + "adding: mem time424, current time 456, horizon 32\n", + "adding: mem time425, current time 456, horizon 31\n", + "adding: mem time426, current time 456, horizon 30\n", + "adding: mem time427, current time 456, horizon 29\n", + "adding: mem time428, current time 456, horizon 28\n", + "adding: mem time429, current time 456, horizon 27\n", + "adding: mem time430, current time 456, horizon 26\n", + "adding: mem time431, current time 456, horizon 25\n", + "adding: mem time432, current time 456, horizon 24\n", + "adding: mem time433, current time 456, horizon 23\n", + "adding: mem time434, current time 456, horizon 22\n", + "adding: mem time435, current time 456, horizon 21\n", + "adding: mem time436, current time 456, horizon 20\n", + "adding: mem time437, current time 456, horizon 19\n", + "adding: mem time438, current time 456, horizon 18\n", + "adding: mem time439, current time 456, horizon 17\n", + "adding: mem time440, current time 456, horizon 16\n", + "adding: mem time441, current time 456, horizon 15\n", + "adding: mem time442, current time 456, horizon 14\n", + "adding: mem time443, current time 456, horizon 13\n", + "adding: mem time444, current time 456, horizon 12\n", + "adding: mem time445, current time 456, horizon 11\n", + "adding: mem time446, current time 456, horizon 10\n", + "adding: mem time447, current time 456, horizon 9\n", + "adding: mem time448, current time 456, horizon 8\n", + "adding: mem time449, current time 456, horizon 7\n", + "adding: mem time450, current time 456, horizon 6\n", + "adding: mem time451, current time 456, horizon 5\n", + "adding: mem time452, current time 456, horizon 4\n", + "adding: mem time453, current time 456, horizon 3\n", + "adding: mem time454, current time 456, horizon 2\n", + "adding: mem time455, current time 456, horizon 1\n", + "adding: mem time400, current time 457, horizon 57\n", + "adding: mem time401, current time 457, horizon 56\n", + "adding: mem time402, current time 457, horizon 55\n", + "adding: mem time403, current time 457, horizon 54\n", + "adding: mem time404, current time 457, horizon 53\n", + "adding: mem time405, current time 457, horizon 52\n", + "adding: mem time406, current time 457, horizon 51\n", + "adding: mem time407, current time 457, horizon 50\n", + "adding: mem time408, current time 457, horizon 49\n", + "adding: mem time409, current time 457, horizon 48\n", + "adding: mem time410, current time 457, horizon 47\n", + "adding: mem time411, current time 457, horizon 46\n", + "adding: mem time412, current time 457, horizon 45\n", + "adding: mem time413, current time 457, horizon 44\n", + "adding: mem time414, current time 457, horizon 43\n", + "adding: mem time415, current time 457, horizon 42\n", + "adding: mem time416, current time 457, horizon 41\n", + "adding: mem time417, current time 457, horizon 40\n", + "adding: mem time418, current time 457, horizon 39\n", + "adding: mem time419, current time 457, horizon 38\n", + "adding: mem time420, current time 457, horizon 37\n", + "adding: mem time421, current time 457, horizon 36\n", + "adding: mem time422, current time 457, horizon 35\n", + "adding: mem time423, current time 457, horizon 34\n", + "adding: mem time424, current time 457, horizon 33\n", + "adding: mem time425, current time 457, horizon 32\n", + "adding: mem time426, current time 457, horizon 31\n", + "adding: mem time427, current time 457, horizon 30\n", + "adding: mem time428, current time 457, horizon 29\n", + "adding: mem time429, current time 457, horizon 28\n", + "adding: mem time430, current time 457, horizon 27\n", + "adding: mem time431, current time 457, horizon 26\n", + "adding: mem time432, current time 457, horizon 25\n", + "adding: mem time433, current time 457, horizon 24\n", + "adding: mem time434, current time 457, horizon 23\n", + "adding: mem time435, current time 457, horizon 22\n", + "adding: mem time436, current time 457, horizon 21\n", + "adding: mem time437, current time 457, horizon 20\n", + "adding: mem time438, current time 457, horizon 19\n", + "adding: mem time439, current time 457, horizon 18\n", + "adding: mem time440, current time 457, horizon 17\n", + "adding: mem time441, current time 457, horizon 16\n", + "adding: mem time442, current time 457, horizon 15\n", + "adding: mem time443, current time 457, horizon 14\n", + "adding: mem time444, current time 457, horizon 13\n", + "adding: mem time445, current time 457, horizon 12\n", + "adding: mem time446, current time 457, horizon 11\n", + "adding: mem time447, current time 457, horizon 10\n", + "adding: mem time448, current time 457, horizon 9\n", + "adding: mem time449, current time 457, horizon 8\n", + "adding: mem time450, current time 457, horizon 7\n", + "adding: mem time451, current time 457, horizon 6\n", + "adding: mem time452, current time 457, horizon 5\n", + "adding: mem time453, current time 457, horizon 4\n", + "adding: mem time454, current time 457, horizon 3\n", + "adding: mem time455, current time 457, horizon 2\n", + "adding: mem time456, current time 457, horizon 1\n", + "adding: mem time400, current time 458, horizon 58\n", + "adding: mem time401, current time 458, horizon 57\n", + "adding: mem time402, current time 458, horizon 56\n", + "adding: mem time403, current time 458, horizon 55\n", + "adding: mem time404, current time 458, horizon 54\n", + "adding: mem time405, current time 458, horizon 53\n", + "adding: mem time406, current time 458, horizon 52\n", + "adding: mem time407, current time 458, horizon 51\n", + "adding: mem time408, current time 458, horizon 50\n", + "adding: mem time409, current time 458, horizon 49\n", + "adding: mem time410, current time 458, horizon 48\n", + "adding: mem time411, current time 458, horizon 47\n", + "adding: mem time412, current time 458, horizon 46\n", + "adding: mem time413, current time 458, horizon 45\n", + "adding: mem time414, current time 458, horizon 44\n", + "adding: mem time415, current time 458, horizon 43\n", + "adding: mem time416, current time 458, horizon 42\n", + "adding: mem time417, current time 458, horizon 41\n", + "adding: mem time418, current time 458, horizon 40\n", + "adding: mem time419, current time 458, horizon 39\n", + "adding: mem time420, current time 458, horizon 38\n", + "adding: mem time421, current time 458, horizon 37\n", + "adding: mem time422, current time 458, horizon 36\n", + "adding: mem time423, current time 458, horizon 35\n", + "adding: mem time424, current time 458, horizon 34\n", + "adding: mem time425, current time 458, horizon 33\n", + "adding: mem time426, current time 458, horizon 32\n", + "adding: mem time427, current time 458, horizon 31\n", + "adding: mem time428, current time 458, horizon 30\n", + "adding: mem time429, current time 458, horizon 29\n", + "adding: mem time430, current time 458, horizon 28\n", + "adding: mem time431, current time 458, horizon 27\n", + "adding: mem time432, current time 458, horizon 26\n", + "adding: mem time433, current time 458, horizon 25\n", + "adding: mem time434, current time 458, horizon 24\n", + "adding: mem time435, current time 458, horizon 23\n", + "adding: mem time436, current time 458, horizon 22\n", + "adding: mem time437, current time 458, horizon 21\n", + "adding: mem time438, current time 458, horizon 20\n", + "adding: mem time439, current time 458, horizon 19\n", + "adding: mem time440, current time 458, horizon 18\n", + "adding: mem time441, current time 458, horizon 17\n", + "adding: mem time442, current time 458, horizon 16\n", + "adding: mem time443, current time 458, horizon 15\n", + "adding: mem time444, current time 458, horizon 14\n", + "adding: mem time445, current time 458, horizon 13\n", + "adding: mem time446, current time 458, horizon 12\n", + "adding: mem time447, current time 458, horizon 11\n", + "adding: mem time448, current time 458, horizon 10\n", + "adding: mem time449, current time 458, horizon 9\n", + "adding: mem time450, current time 458, horizon 8\n", + "adding: mem time451, current time 458, horizon 7\n", + "adding: mem time452, current time 458, horizon 6\n", + "adding: mem time453, current time 458, horizon 5\n", + "adding: mem time454, current time 458, horizon 4\n", + "adding: mem time455, current time 458, horizon 3\n", + "adding: mem time456, current time 458, horizon 2\n", + "adding: mem time457, current time 458, horizon 1\n", + "adding: mem time400, current time 459, horizon 59\n", + "adding: mem time401, current time 459, horizon 58\n", + "adding: mem time402, current time 459, horizon 57\n", + "adding: mem time403, current time 459, horizon 56\n", + "adding: mem time404, current time 459, horizon 55\n", + "adding: mem time405, current time 459, horizon 54\n", + "adding: mem time406, current time 459, horizon 53\n", + "adding: mem time407, current time 459, horizon 52\n", + "adding: mem time408, current time 459, horizon 51\n", + "adding: mem time409, current time 459, horizon 50\n", + "adding: mem time410, current time 459, horizon 49\n", + "adding: mem time411, current time 459, horizon 48\n", + "adding: mem time412, current time 459, horizon 47\n", + "adding: mem time413, current time 459, horizon 46\n", + "adding: mem time414, current time 459, horizon 45\n", + "adding: mem time415, current time 459, horizon 44\n", + "adding: mem time416, current time 459, horizon 43\n", + "adding: mem time417, current time 459, horizon 42\n", + "adding: mem time418, current time 459, horizon 41\n", + "adding: mem time419, current time 459, horizon 40\n", + "adding: mem time420, current time 459, horizon 39\n", + "adding: mem time421, current time 459, horizon 38\n", + "adding: mem time422, current time 459, horizon 37\n", + "adding: mem time423, current time 459, horizon 36\n", + "adding: mem time424, current time 459, horizon 35\n", + "adding: mem time425, current time 459, horizon 34\n", + "adding: mem time426, current time 459, horizon 33\n", + "adding: mem time427, current time 459, horizon 32\n", + "adding: mem time428, current time 459, horizon 31\n", + "adding: mem time429, current time 459, horizon 30\n", + "adding: mem time430, current time 459, horizon 29\n", + "adding: mem time431, current time 459, horizon 28\n", + "adding: mem time432, current time 459, horizon 27\n", + "adding: mem time433, current time 459, horizon 26\n", + "adding: mem time434, current time 459, horizon 25\n", + "adding: mem time435, current time 459, horizon 24\n", + "adding: mem time436, current time 459, horizon 23\n", + "adding: mem time437, current time 459, horizon 22\n", + "adding: mem time438, current time 459, horizon 21\n", + "adding: mem time439, current time 459, horizon 20\n", + "adding: mem time440, current time 459, horizon 19\n", + "adding: mem time441, current time 459, horizon 18\n", + "adding: mem time442, current time 459, horizon 17\n", + "adding: mem time443, current time 459, horizon 16\n", + "adding: mem time444, current time 459, horizon 15\n", + "adding: mem time445, current time 459, horizon 14\n", + "adding: mem time446, current time 459, horizon 13\n", + "adding: mem time447, current time 459, horizon 12\n", + "adding: mem time448, current time 459, horizon 11\n", + "adding: mem time449, current time 459, horizon 10\n", + "adding: mem time450, current time 459, horizon 9\n", + "adding: mem time451, current time 459, horizon 8\n", + "adding: mem time452, current time 459, horizon 7\n", + "adding: mem time453, current time 459, horizon 6\n", + "adding: mem time454, current time 459, horizon 5\n", + "adding: mem time455, current time 459, horizon 4\n", + "adding: mem time456, current time 459, horizon 3\n", + "adding: mem time457, current time 459, horizon 2\n", + "adding: mem time458, current time 459, horizon 1\n", + "adding: mem time400, current time 460, horizon 60\n", + "adding: mem time401, current time 460, horizon 59\n", + "adding: mem time402, current time 460, horizon 58\n", + "adding: mem time403, current time 460, horizon 57\n", + "adding: mem time404, current time 460, horizon 56\n", + "adding: mem time405, current time 460, horizon 55\n", + "adding: mem time406, current time 460, horizon 54\n", + "adding: mem time407, current time 460, horizon 53\n", + "adding: mem time408, current time 460, horizon 52\n", + "adding: mem time409, current time 460, horizon 51\n", + "adding: mem time410, current time 460, horizon 50\n", + "adding: mem time411, current time 460, horizon 49\n", + "adding: mem time412, current time 460, horizon 48\n", + "adding: mem time413, current time 460, horizon 47\n", + "adding: mem time414, current time 460, horizon 46\n", + "adding: mem time415, current time 460, horizon 45\n", + "adding: mem time416, current time 460, horizon 44\n", + "adding: mem time417, current time 460, horizon 43\n", + "adding: mem time418, current time 460, horizon 42\n", + "adding: mem time419, current time 460, horizon 41\n", + "adding: mem time420, current time 460, horizon 40\n", + "adding: mem time421, current time 460, horizon 39\n", + "adding: mem time422, current time 460, horizon 38\n", + "adding: mem time423, current time 460, horizon 37\n", + "adding: mem time424, current time 460, horizon 36\n", + "adding: mem time425, current time 460, horizon 35\n", + "adding: mem time426, current time 460, horizon 34\n", + "adding: mem time427, current time 460, horizon 33\n", + "adding: mem time428, current time 460, horizon 32\n", + "adding: mem time429, current time 460, horizon 31\n", + "adding: mem time430, current time 460, horizon 30\n", + "adding: mem time431, current time 460, horizon 29\n", + "adding: mem time432, current time 460, horizon 28\n", + "adding: mem time433, current time 460, horizon 27\n", + "adding: mem time434, current time 460, horizon 26\n", + "adding: mem time435, current time 460, horizon 25\n", + "adding: mem time436, current time 460, horizon 24\n", + "adding: mem time437, current time 460, horizon 23\n", + "adding: mem time438, current time 460, horizon 22\n", + "adding: mem time439, current time 460, horizon 21\n", + "adding: mem time440, current time 460, horizon 20\n", + "adding: mem time441, current time 460, horizon 19\n", + "adding: mem time442, current time 460, horizon 18\n", + "adding: mem time443, current time 460, horizon 17\n", + "adding: mem time444, current time 460, horizon 16\n", + "adding: mem time445, current time 460, horizon 15\n", + "adding: mem time446, current time 460, horizon 14\n", + "adding: mem time447, current time 460, horizon 13\n", + "adding: mem time448, current time 460, horizon 12\n", + "adding: mem time449, current time 460, horizon 11\n", + "adding: mem time450, current time 460, horizon 10\n", + "adding: mem time451, current time 460, horizon 9\n", + "adding: mem time452, current time 460, horizon 8\n", + "adding: mem time453, current time 460, horizon 7\n", + "adding: mem time454, current time 460, horizon 6\n", + "adding: mem time455, current time 460, horizon 5\n", + "adding: mem time456, current time 460, horizon 4\n", + "adding: mem time457, current time 460, horizon 3\n", + "adding: mem time458, current time 460, horizon 2\n", + "adding: mem time459, current time 460, horizon 1\n", + "adding: mem time400, current time 461, horizon 61\n", + "adding: mem time401, current time 461, horizon 60\n", + "adding: mem time402, current time 461, horizon 59\n", + "adding: mem time403, current time 461, horizon 58\n", + "adding: mem time404, current time 461, horizon 57\n", + "adding: mem time405, current time 461, horizon 56\n", + "adding: mem time406, current time 461, horizon 55\n", + "adding: mem time407, current time 461, horizon 54\n", + "adding: mem time408, current time 461, horizon 53\n", + "adding: mem time409, current time 461, horizon 52\n", + "adding: mem time410, current time 461, horizon 51\n", + "adding: mem time411, current time 461, horizon 50\n", + "adding: mem time412, current time 461, horizon 49\n", + "adding: mem time413, current time 461, horizon 48\n", + "adding: mem time414, current time 461, horizon 47\n", + "adding: mem time415, current time 461, horizon 46\n", + "adding: mem time416, current time 461, horizon 45\n", + "adding: mem time417, current time 461, horizon 44\n", + "adding: mem time418, current time 461, horizon 43\n", + "adding: mem time419, current time 461, horizon 42\n", + "adding: mem time420, current time 461, horizon 41\n", + "adding: mem time421, current time 461, horizon 40\n", + "adding: mem time422, current time 461, horizon 39\n", + "adding: mem time423, current time 461, horizon 38\n", + "adding: mem time424, current time 461, horizon 37\n", + "adding: mem time425, current time 461, horizon 36\n", + "adding: mem time426, current time 461, horizon 35\n", + "adding: mem time427, current time 461, horizon 34\n", + "adding: mem time428, current time 461, horizon 33\n", + "adding: mem time429, current time 461, horizon 32\n", + "adding: mem time430, current time 461, horizon 31\n", + "adding: mem time431, current time 461, horizon 30\n", + "adding: mem time432, current time 461, horizon 29\n", + "adding: mem time433, current time 461, horizon 28\n", + "adding: mem time434, current time 461, horizon 27\n", + "adding: mem time435, current time 461, horizon 26\n", + "adding: mem time436, current time 461, horizon 25\n", + "adding: mem time437, current time 461, horizon 24\n", + "adding: mem time438, current time 461, horizon 23\n", + "adding: mem time439, current time 461, horizon 22\n", + "adding: mem time440, current time 461, horizon 21\n", + "adding: mem time441, current time 461, horizon 20\n", + "adding: mem time442, current time 461, horizon 19\n", + "adding: mem time443, current time 461, horizon 18\n", + "adding: mem time444, current time 461, horizon 17\n", + "adding: mem time445, current time 461, horizon 16\n", + "adding: mem time446, current time 461, horizon 15\n", + "adding: mem time447, current time 461, horizon 14\n", + "adding: mem time448, current time 461, horizon 13\n", + "adding: mem time449, current time 461, horizon 12\n", + "adding: mem time450, current time 461, horizon 11\n", + "adding: mem time451, current time 461, horizon 10\n", + "adding: mem time452, current time 461, horizon 9\n", + "adding: mem time453, current time 461, horizon 8\n", + "adding: mem time454, current time 461, horizon 7\n", + "adding: mem time455, current time 461, horizon 6\n", + "adding: mem time456, current time 461, horizon 5\n", + "adding: mem time457, current time 461, horizon 4\n", + "adding: mem time458, current time 461, horizon 3\n", + "adding: mem time459, current time 461, horizon 2\n", + "adding: mem time460, current time 461, horizon 1\n", + "adding: mem time400, current time 462, horizon 62\n", + "adding: mem time401, current time 462, horizon 61\n", + "adding: mem time402, current time 462, horizon 60\n", + "adding: mem time403, current time 462, horizon 59\n", + "adding: mem time404, current time 462, horizon 58\n", + "adding: mem time405, current time 462, horizon 57\n", + "adding: mem time406, current time 462, horizon 56\n", + "adding: mem time407, current time 462, horizon 55\n", + "adding: mem time408, current time 462, horizon 54\n", + "adding: mem time409, current time 462, horizon 53\n", + "adding: mem time410, current time 462, horizon 52\n", + "adding: mem time411, current time 462, horizon 51\n", + "adding: mem time412, current time 462, horizon 50\n", + "adding: mem time413, current time 462, horizon 49\n", + "adding: mem time414, current time 462, horizon 48\n", + "adding: mem time415, current time 462, horizon 47\n", + "adding: mem time416, current time 462, horizon 46\n", + "adding: mem time417, current time 462, horizon 45\n", + "adding: mem time418, current time 462, horizon 44\n", + "adding: mem time419, current time 462, horizon 43\n", + "adding: mem time420, current time 462, horizon 42\n", + "adding: mem time421, current time 462, horizon 41\n", + "adding: mem time422, current time 462, horizon 40\n", + "adding: mem time423, current time 462, horizon 39\n", + "adding: mem time424, current time 462, horizon 38\n", + "adding: mem time425, current time 462, horizon 37\n", + "adding: mem time426, current time 462, horizon 36\n", + "adding: mem time427, current time 462, horizon 35\n", + "adding: mem time428, current time 462, horizon 34\n", + "adding: mem time429, current time 462, horizon 33\n", + "adding: mem time430, current time 462, horizon 32\n", + "adding: mem time431, current time 462, horizon 31\n", + "adding: mem time432, current time 462, horizon 30\n", + "adding: mem time433, current time 462, horizon 29\n", + "adding: mem time434, current time 462, horizon 28\n", + "adding: mem time435, current time 462, horizon 27\n", + "adding: mem time436, current time 462, horizon 26\n", + "adding: mem time437, current time 462, horizon 25\n", + "adding: mem time438, current time 462, horizon 24\n", + "adding: mem time439, current time 462, horizon 23\n", + "adding: mem time440, current time 462, horizon 22\n", + "adding: mem time441, current time 462, horizon 21\n", + "adding: mem time442, current time 462, horizon 20\n", + "adding: mem time443, current time 462, horizon 19\n", + "adding: mem time444, current time 462, horizon 18\n", + "adding: mem time445, current time 462, horizon 17\n", + "adding: mem time446, current time 462, horizon 16\n", + "adding: mem time447, current time 462, horizon 15\n", + "adding: mem time448, current time 462, horizon 14\n", + "adding: mem time449, current time 462, horizon 13\n", + "adding: mem time450, current time 462, horizon 12\n", + "adding: mem time451, current time 462, horizon 11\n", + "adding: mem time452, current time 462, horizon 10\n", + "adding: mem time453, current time 462, horizon 9\n", + "adding: mem time454, current time 462, horizon 8\n", + "adding: mem time455, current time 462, horizon 7\n", + "adding: mem time456, current time 462, horizon 6\n", + "adding: mem time457, current time 462, horizon 5\n", + "adding: mem time458, current time 462, horizon 4\n", + "adding: mem time459, current time 462, horizon 3\n", + "adding: mem time460, current time 462, horizon 2\n", + "adding: mem time461, current time 462, horizon 1\n", + "adding: mem time400, current time 463, horizon 63\n", + "adding: mem time401, current time 463, horizon 62\n", + "adding: mem time402, current time 463, horizon 61\n", + "adding: mem time403, current time 463, horizon 60\n", + "adding: mem time404, current time 463, horizon 59\n", + "adding: mem time405, current time 463, horizon 58\n", + "adding: mem time406, current time 463, horizon 57\n", + "adding: mem time407, current time 463, horizon 56\n", + "adding: mem time408, current time 463, horizon 55\n", + "adding: mem time409, current time 463, horizon 54\n", + "adding: mem time410, current time 463, horizon 53\n", + "adding: mem time411, current time 463, horizon 52\n", + "adding: mem time412, current time 463, horizon 51\n", + "adding: mem time413, current time 463, horizon 50\n", + "adding: mem time414, current time 463, horizon 49\n", + "adding: mem time415, current time 463, horizon 48\n", + "adding: mem time416, current time 463, horizon 47\n", + "adding: mem time417, current time 463, horizon 46\n", + "adding: mem time418, current time 463, horizon 45\n", + "adding: mem time419, current time 463, horizon 44\n", + "adding: mem time420, current time 463, horizon 43\n", + "adding: mem time421, current time 463, horizon 42\n", + "adding: mem time422, current time 463, horizon 41\n", + "adding: mem time423, current time 463, horizon 40\n", + "adding: mem time424, current time 463, horizon 39\n", + "adding: mem time425, current time 463, horizon 38\n", + "adding: mem time426, current time 463, horizon 37\n", + "adding: mem time427, current time 463, horizon 36\n", + "adding: mem time428, current time 463, horizon 35\n", + "adding: mem time429, current time 463, horizon 34\n", + "adding: mem time430, current time 463, horizon 33\n", + "adding: mem time431, current time 463, horizon 32\n", + "adding: mem time432, current time 463, horizon 31\n", + "adding: mem time433, current time 463, horizon 30\n", + "adding: mem time434, current time 463, horizon 29\n", + "adding: mem time435, current time 463, horizon 28\n", + "adding: mem time436, current time 463, horizon 27\n", + "adding: mem time437, current time 463, horizon 26\n", + "adding: mem time438, current time 463, horizon 25\n", + "adding: mem time439, current time 463, horizon 24\n", + "adding: mem time440, current time 463, horizon 23\n", + "adding: mem time441, current time 463, horizon 22\n", + "adding: mem time442, current time 463, horizon 21\n", + "adding: mem time443, current time 463, horizon 20\n", + "adding: mem time444, current time 463, horizon 19\n", + "adding: mem time445, current time 463, horizon 18\n", + "adding: mem time446, current time 463, horizon 17\n", + "adding: mem time447, current time 463, horizon 16\n", + "adding: mem time448, current time 463, horizon 15\n", + "adding: mem time449, current time 463, horizon 14\n", + "adding: mem time450, current time 463, horizon 13\n", + "adding: mem time451, current time 463, horizon 12\n", + "adding: mem time452, current time 463, horizon 11\n", + "adding: mem time453, current time 463, horizon 10\n", + "adding: mem time454, current time 463, horizon 9\n", + "adding: mem time455, current time 463, horizon 8\n", + "adding: mem time456, current time 463, horizon 7\n", + "adding: mem time457, current time 463, horizon 6\n", + "adding: mem time458, current time 463, horizon 5\n", + "adding: mem time459, current time 463, horizon 4\n", + "adding: mem time460, current time 463, horizon 3\n", + "adding: mem time461, current time 463, horizon 2\n", + "adding: mem time462, current time 463, horizon 1\n", + "adding: mem time400, current time 464, horizon 64\n", + "adding: mem time401, current time 464, horizon 63\n", + "adding: mem time402, current time 464, horizon 62\n", + "adding: mem time403, current time 464, horizon 61\n", + "adding: mem time404, current time 464, horizon 60\n", + "adding: mem time405, current time 464, horizon 59\n", + "adding: mem time406, current time 464, horizon 58\n", + "adding: mem time407, current time 464, horizon 57\n", + "adding: mem time408, current time 464, horizon 56\n", + "adding: mem time409, current time 464, horizon 55\n", + "adding: mem time410, current time 464, horizon 54\n", + "adding: mem time411, current time 464, horizon 53\n", + "adding: mem time412, current time 464, horizon 52\n", + "adding: mem time413, current time 464, horizon 51\n", + "adding: mem time414, current time 464, horizon 50\n", + "adding: mem time415, current time 464, horizon 49\n", + "adding: mem time416, current time 464, horizon 48\n", + "adding: mem time417, current time 464, horizon 47\n", + "adding: mem time418, current time 464, horizon 46\n", + "adding: mem time419, current time 464, horizon 45\n", + "adding: mem time420, current time 464, horizon 44\n", + "adding: mem time421, current time 464, horizon 43\n", + "adding: mem time422, current time 464, horizon 42\n", + "adding: mem time423, current time 464, horizon 41\n", + "adding: mem time424, current time 464, horizon 40\n", + "adding: mem time425, current time 464, horizon 39\n", + "adding: mem time426, current time 464, horizon 38\n", + "adding: mem time427, current time 464, horizon 37\n", + "adding: mem time428, current time 464, horizon 36\n", + "adding: mem time429, current time 464, horizon 35\n", + "adding: mem time430, current time 464, horizon 34\n", + "adding: mem time431, current time 464, horizon 33\n", + "adding: mem time432, current time 464, horizon 32\n", + "adding: mem time433, current time 464, horizon 31\n", + "adding: mem time434, current time 464, horizon 30\n", + "adding: mem time435, current time 464, horizon 29\n", + "adding: mem time436, current time 464, horizon 28\n", + "adding: mem time437, current time 464, horizon 27\n", + "adding: mem time438, current time 464, horizon 26\n", + "adding: mem time439, current time 464, horizon 25\n", + "adding: mem time440, current time 464, horizon 24\n", + "adding: mem time441, current time 464, horizon 23\n", + "adding: mem time442, current time 464, horizon 22\n", + "adding: mem time443, current time 464, horizon 21\n", + "adding: mem time444, current time 464, horizon 20\n", + "adding: mem time445, current time 464, horizon 19\n", + "adding: mem time446, current time 464, horizon 18\n", + "adding: mem time447, current time 464, horizon 17\n", + "adding: mem time448, current time 464, horizon 16\n", + "adding: mem time449, current time 464, horizon 15\n", + "adding: mem time450, current time 464, horizon 14\n", + "adding: mem time451, current time 464, horizon 13\n", + "adding: mem time452, current time 464, horizon 12\n", + "adding: mem time453, current time 464, horizon 11\n", + "adding: mem time454, current time 464, horizon 10\n", + "adding: mem time455, current time 464, horizon 9\n", + "adding: mem time456, current time 464, horizon 8\n", + "adding: mem time457, current time 464, horizon 7\n", + "adding: mem time458, current time 464, horizon 6\n", + "adding: mem time459, current time 464, horizon 5\n", + "adding: mem time460, current time 464, horizon 4\n", + "adding: mem time461, current time 464, horizon 3\n", + "adding: mem time462, current time 464, horizon 2\n", + "adding: mem time463, current time 464, horizon 1\n", + "adding: mem time400, current time 465, horizon 65\n", + "adding: mem time401, current time 465, horizon 64\n", + "adding: mem time402, current time 465, horizon 63\n", + "adding: mem time403, current time 465, horizon 62\n", + "adding: mem time404, current time 465, horizon 61\n", + "adding: mem time405, current time 465, horizon 60\n", + "adding: mem time406, current time 465, horizon 59\n", + "adding: mem time407, current time 465, horizon 58\n", + "adding: mem time408, current time 465, horizon 57\n", + "adding: mem time409, current time 465, horizon 56\n", + "adding: mem time410, current time 465, horizon 55\n", + "adding: mem time411, current time 465, horizon 54\n", + "adding: mem time412, current time 465, horizon 53\n", + "adding: mem time413, current time 465, horizon 52\n", + "adding: mem time414, current time 465, horizon 51\n", + "adding: mem time415, current time 465, horizon 50\n", + "adding: mem time416, current time 465, horizon 49\n", + "adding: mem time417, current time 465, horizon 48\n", + "adding: mem time418, current time 465, horizon 47\n", + "adding: mem time419, current time 465, horizon 46\n", + "adding: mem time420, current time 465, horizon 45\n", + "adding: mem time421, current time 465, horizon 44\n", + "adding: mem time422, current time 465, horizon 43\n", + "adding: mem time423, current time 465, horizon 42\n", + "adding: mem time424, current time 465, horizon 41\n", + "adding: mem time425, current time 465, horizon 40\n", + "adding: mem time426, current time 465, horizon 39\n", + "adding: mem time427, current time 465, horizon 38\n", + "adding: mem time428, current time 465, horizon 37\n", + "adding: mem time429, current time 465, horizon 36\n", + "adding: mem time430, current time 465, horizon 35\n", + "adding: mem time431, current time 465, horizon 34\n", + "adding: mem time432, current time 465, horizon 33\n", + "adding: mem time433, current time 465, horizon 32\n", + "adding: mem time434, current time 465, horizon 31\n", + "adding: mem time435, current time 465, horizon 30\n", + "adding: mem time436, current time 465, horizon 29\n", + "adding: mem time437, current time 465, horizon 28\n", + "adding: mem time438, current time 465, horizon 27\n", + "adding: mem time439, current time 465, horizon 26\n", + "adding: mem time440, current time 465, horizon 25\n", + "adding: mem time441, current time 465, horizon 24\n", + "adding: mem time442, current time 465, horizon 23\n", + "adding: mem time443, current time 465, horizon 22\n", + "adding: mem time444, current time 465, horizon 21\n", + "adding: mem time445, current time 465, horizon 20\n", + "adding: mem time446, current time 465, horizon 19\n", + "adding: mem time447, current time 465, horizon 18\n", + "adding: mem time448, current time 465, horizon 17\n", + "adding: mem time449, current time 465, horizon 16\n", + "adding: mem time450, current time 465, horizon 15\n", + "adding: mem time451, current time 465, horizon 14\n", + "adding: mem time452, current time 465, horizon 13\n", + "adding: mem time453, current time 465, horizon 12\n", + "adding: mem time454, current time 465, horizon 11\n", + "adding: mem time455, current time 465, horizon 10\n", + "adding: mem time456, current time 465, horizon 9\n", + "adding: mem time457, current time 465, horizon 8\n", + "adding: mem time458, current time 465, horizon 7\n", + "adding: mem time459, current time 465, horizon 6\n", + "adding: mem time460, current time 465, horizon 5\n", + "adding: mem time461, current time 465, horizon 4\n", + "adding: mem time462, current time 465, horizon 3\n", + "adding: mem time463, current time 465, horizon 2\n", + "adding: mem time464, current time 465, horizon 1\n", + "adding: mem time400, current time 466, horizon 66\n", + "adding: mem time401, current time 466, horizon 65\n", + "adding: mem time402, current time 466, horizon 64\n", + "adding: mem time403, current time 466, horizon 63\n", + "adding: mem time404, current time 466, horizon 62\n", + "adding: mem time405, current time 466, horizon 61\n", + "adding: mem time406, current time 466, horizon 60\n", + "adding: mem time407, current time 466, horizon 59\n", + "adding: mem time408, current time 466, horizon 58\n", + "adding: mem time409, current time 466, horizon 57\n", + "adding: mem time410, current time 466, horizon 56\n", + "adding: mem time411, current time 466, horizon 55\n", + "adding: mem time412, current time 466, horizon 54\n", + "adding: mem time413, current time 466, horizon 53\n", + "adding: mem time414, current time 466, horizon 52\n", + "adding: mem time415, current time 466, horizon 51\n", + "adding: mem time416, current time 466, horizon 50\n", + "adding: mem time417, current time 466, horizon 49\n", + "adding: mem time418, current time 466, horizon 48\n", + "adding: mem time419, current time 466, horizon 47\n", + "adding: mem time420, current time 466, horizon 46\n", + "adding: mem time421, current time 466, horizon 45\n", + "adding: mem time422, current time 466, horizon 44\n", + "adding: mem time423, current time 466, horizon 43\n", + "adding: mem time424, current time 466, horizon 42\n", + "adding: mem time425, current time 466, horizon 41\n", + "adding: mem time426, current time 466, horizon 40\n", + "adding: mem time427, current time 466, horizon 39\n", + "adding: mem time428, current time 466, horizon 38\n", + "adding: mem time429, current time 466, horizon 37\n", + "adding: mem time430, current time 466, horizon 36\n", + "adding: mem time431, current time 466, horizon 35\n", + "adding: mem time432, current time 466, horizon 34\n", + "adding: mem time433, current time 466, horizon 33\n", + "adding: mem time434, current time 466, horizon 32\n", + "adding: mem time435, current time 466, horizon 31\n", + "adding: mem time436, current time 466, horizon 30\n", + "adding: mem time437, current time 466, horizon 29\n", + "adding: mem time438, current time 466, horizon 28\n", + "adding: mem time439, current time 466, horizon 27\n", + "adding: mem time440, current time 466, horizon 26\n", + "adding: mem time441, current time 466, horizon 25\n", + "adding: mem time442, current time 466, horizon 24\n", + "adding: mem time443, current time 466, horizon 23\n", + "adding: mem time444, current time 466, horizon 22\n", + "adding: mem time445, current time 466, horizon 21\n", + "adding: mem time446, current time 466, horizon 20\n", + "adding: mem time447, current time 466, horizon 19\n", + "adding: mem time448, current time 466, horizon 18\n", + "adding: mem time449, current time 466, horizon 17\n", + "adding: mem time450, current time 466, horizon 16\n", + "adding: mem time451, current time 466, horizon 15\n", + "adding: mem time452, current time 466, horizon 14\n", + "adding: mem time453, current time 466, horizon 13\n", + "adding: mem time454, current time 466, horizon 12\n", + "adding: mem time455, current time 466, horizon 11\n", + "adding: mem time456, current time 466, horizon 10\n", + "adding: mem time457, current time 466, horizon 9\n", + "adding: mem time458, current time 466, horizon 8\n", + "adding: mem time459, current time 466, horizon 7\n", + "adding: mem time460, current time 466, horizon 6\n", + "adding: mem time461, current time 466, horizon 5\n", + "adding: mem time462, current time 466, horizon 4\n", + "adding: mem time463, current time 466, horizon 3\n", + "adding: mem time464, current time 466, horizon 2\n", + "adding: mem time465, current time 466, horizon 1\n", + "adding: mem time400, current time 467, horizon 67\n", + "adding: mem time401, current time 467, horizon 66\n", + "adding: mem time402, current time 467, horizon 65\n", + "adding: mem time403, current time 467, horizon 64\n", + "adding: mem time404, current time 467, horizon 63\n", + "adding: mem time405, current time 467, horizon 62\n", + "adding: mem time406, current time 467, horizon 61\n", + "adding: mem time407, current time 467, horizon 60\n", + "adding: mem time408, current time 467, horizon 59\n", + "adding: mem time409, current time 467, horizon 58\n", + "adding: mem time410, current time 467, horizon 57\n", + "adding: mem time411, current time 467, horizon 56\n", + "adding: mem time412, current time 467, horizon 55\n", + "adding: mem time413, current time 467, horizon 54\n", + "adding: mem time414, current time 467, horizon 53\n", + "adding: mem time415, current time 467, horizon 52\n", + "adding: mem time416, current time 467, horizon 51\n", + "adding: mem time417, current time 467, horizon 50\n", + "adding: mem time418, current time 467, horizon 49\n", + "adding: mem time419, current time 467, horizon 48\n", + "adding: mem time420, current time 467, horizon 47\n", + "adding: mem time421, current time 467, horizon 46\n", + "adding: mem time422, current time 467, horizon 45\n", + "adding: mem time423, current time 467, horizon 44\n", + "adding: mem time424, current time 467, horizon 43\n", + "adding: mem time425, current time 467, horizon 42\n", + "adding: mem time426, current time 467, horizon 41\n", + "adding: mem time427, current time 467, horizon 40\n", + "adding: mem time428, current time 467, horizon 39\n", + "adding: mem time429, current time 467, horizon 38\n", + "adding: mem time430, current time 467, horizon 37\n", + "adding: mem time431, current time 467, horizon 36\n", + "adding: mem time432, current time 467, horizon 35\n", + "adding: mem time433, current time 467, horizon 34\n", + "adding: mem time434, current time 467, horizon 33\n", + "adding: mem time435, current time 467, horizon 32\n", + "adding: mem time436, current time 467, horizon 31\n", + "adding: mem time437, current time 467, horizon 30\n", + "adding: mem time438, current time 467, horizon 29\n", + "adding: mem time439, current time 467, horizon 28\n", + "adding: mem time440, current time 467, horizon 27\n", + "adding: mem time441, current time 467, horizon 26\n", + "adding: mem time442, current time 467, horizon 25\n", + "adding: mem time443, current time 467, horizon 24\n", + "adding: mem time444, current time 467, horizon 23\n", + "adding: mem time445, current time 467, horizon 22\n", + "adding: mem time446, current time 467, horizon 21\n", + "adding: mem time447, current time 467, horizon 20\n", + "adding: mem time448, current time 467, horizon 19\n", + "adding: mem time449, current time 467, horizon 18\n", + "adding: mem time450, current time 467, horizon 17\n", + "adding: mem time451, current time 467, horizon 16\n", + "adding: mem time452, current time 467, horizon 15\n", + "adding: mem time453, current time 467, horizon 14\n", + "adding: mem time454, current time 467, horizon 13\n", + "adding: mem time455, current time 467, horizon 12\n", + "adding: mem time456, current time 467, horizon 11\n", + "adding: mem time457, current time 467, horizon 10\n", + "adding: mem time458, current time 467, horizon 9\n", + "adding: mem time459, current time 467, horizon 8\n", + "adding: mem time460, current time 467, horizon 7\n", + "adding: mem time461, current time 467, horizon 6\n", + "adding: mem time462, current time 467, horizon 5\n", + "adding: mem time463, current time 467, horizon 4\n", + "adding: mem time464, current time 467, horizon 3\n", + "adding: mem time465, current time 467, horizon 2\n", + "adding: mem time466, current time 467, horizon 1\n", + "adding: mem time400, current time 468, horizon 68\n", + "adding: mem time401, current time 468, horizon 67\n", + "adding: mem time402, current time 468, horizon 66\n", + "adding: mem time403, current time 468, horizon 65\n", + "adding: mem time404, current time 468, horizon 64\n", + "adding: mem time405, current time 468, horizon 63\n", + "adding: mem time406, current time 468, horizon 62\n", + "adding: mem time407, current time 468, horizon 61\n", + "adding: mem time408, current time 468, horizon 60\n", + "adding: mem time409, current time 468, horizon 59\n", + "adding: mem time410, current time 468, horizon 58\n", + "adding: mem time411, current time 468, horizon 57\n", + "adding: mem time412, current time 468, horizon 56\n", + "adding: mem time413, current time 468, horizon 55\n", + "adding: mem time414, current time 468, horizon 54\n", + "adding: mem time415, current time 468, horizon 53\n", + "adding: mem time416, current time 468, horizon 52\n", + "adding: mem time417, current time 468, horizon 51\n", + "adding: mem time418, current time 468, horizon 50\n", + "adding: mem time419, current time 468, horizon 49\n", + "adding: mem time420, current time 468, horizon 48\n", + "adding: mem time421, current time 468, horizon 47\n", + "adding: mem time422, current time 468, horizon 46\n", + "adding: mem time423, current time 468, horizon 45\n", + "adding: mem time424, current time 468, horizon 44\n", + "adding: mem time425, current time 468, horizon 43\n", + "adding: mem time426, current time 468, horizon 42\n", + "adding: mem time427, current time 468, horizon 41\n", + "adding: mem time428, current time 468, horizon 40\n", + "adding: mem time429, current time 468, horizon 39\n", + "adding: mem time430, current time 468, horizon 38\n", + "adding: mem time431, current time 468, horizon 37\n", + "adding: mem time432, current time 468, horizon 36\n", + "adding: mem time433, current time 468, horizon 35\n", + "adding: mem time434, current time 468, horizon 34\n", + "adding: mem time435, current time 468, horizon 33\n", + "adding: mem time436, current time 468, horizon 32\n", + "adding: mem time437, current time 468, horizon 31\n", + "adding: mem time438, current time 468, horizon 30\n", + "adding: mem time439, current time 468, horizon 29\n", + "adding: mem time440, current time 468, horizon 28\n", + "adding: mem time441, current time 468, horizon 27\n", + "adding: mem time442, current time 468, horizon 26\n", + "adding: mem time443, current time 468, horizon 25\n", + "adding: mem time444, current time 468, horizon 24\n", + "adding: mem time445, current time 468, horizon 23\n", + "adding: mem time446, current time 468, horizon 22\n", + "adding: mem time447, current time 468, horizon 21\n", + "adding: mem time448, current time 468, horizon 20\n", + "adding: mem time449, current time 468, horizon 19\n", + "adding: mem time450, current time 468, horizon 18\n", + "adding: mem time451, current time 468, horizon 17\n", + "adding: mem time452, current time 468, horizon 16\n", + "adding: mem time453, current time 468, horizon 15\n", + "adding: mem time454, current time 468, horizon 14\n", + "adding: mem time455, current time 468, horizon 13\n", + "adding: mem time456, current time 468, horizon 12\n", + "adding: mem time457, current time 468, horizon 11\n", + "adding: mem time458, current time 468, horizon 10\n", + "adding: mem time459, current time 468, horizon 9\n", + "adding: mem time460, current time 468, horizon 8\n", + "adding: mem time461, current time 468, horizon 7\n", + "adding: mem time462, current time 468, horizon 6\n", + "adding: mem time463, current time 468, horizon 5\n", + "adding: mem time464, current time 468, horizon 4\n", + "adding: mem time465, current time 468, horizon 3\n", + "adding: mem time466, current time 468, horizon 2\n", + "adding: mem time467, current time 468, horizon 1\n", + "adding: mem time400, current time 469, horizon 69\n", + "adding: mem time401, current time 469, horizon 68\n", + "adding: mem time402, current time 469, horizon 67\n", + "adding: mem time403, current time 469, horizon 66\n", + "adding: mem time404, current time 469, horizon 65\n", + "adding: mem time405, current time 469, horizon 64\n", + "adding: mem time406, current time 469, horizon 63\n", + "adding: mem time407, current time 469, horizon 62\n", + "adding: mem time408, current time 469, horizon 61\n", + "adding: mem time409, current time 469, horizon 60\n", + "adding: mem time410, current time 469, horizon 59\n", + "adding: mem time411, current time 469, horizon 58\n", + "adding: mem time412, current time 469, horizon 57\n", + "adding: mem time413, current time 469, horizon 56\n", + "adding: mem time414, current time 469, horizon 55\n", + "adding: mem time415, current time 469, horizon 54\n", + "adding: mem time416, current time 469, horizon 53\n", + "adding: mem time417, current time 469, horizon 52\n", + "adding: mem time418, current time 469, horizon 51\n", + "adding: mem time419, current time 469, horizon 50\n", + "adding: mem time420, current time 469, horizon 49\n", + "adding: mem time421, current time 469, horizon 48\n", + "adding: mem time422, current time 469, horizon 47\n", + "adding: mem time423, current time 469, horizon 46\n", + "adding: mem time424, current time 469, horizon 45\n", + "adding: mem time425, current time 469, horizon 44\n", + "adding: mem time426, current time 469, horizon 43\n", + "adding: mem time427, current time 469, horizon 42\n", + "adding: mem time428, current time 469, horizon 41\n", + "adding: mem time429, current time 469, horizon 40\n", + "adding: mem time430, current time 469, horizon 39\n", + "adding: mem time431, current time 469, horizon 38\n", + "adding: mem time432, current time 469, horizon 37\n", + "adding: mem time433, current time 469, horizon 36\n", + "adding: mem time434, current time 469, horizon 35\n", + "adding: mem time435, current time 469, horizon 34\n", + "adding: mem time436, current time 469, horizon 33\n", + "adding: mem time437, current time 469, horizon 32\n", + "adding: mem time438, current time 469, horizon 31\n", + "adding: mem time439, current time 469, horizon 30\n", + "adding: mem time440, current time 469, horizon 29\n", + "adding: mem time441, current time 469, horizon 28\n", + "adding: mem time442, current time 469, horizon 27\n", + "adding: mem time443, current time 469, horizon 26\n", + "adding: mem time444, current time 469, horizon 25\n", + "adding: mem time445, current time 469, horizon 24\n", + "adding: mem time446, current time 469, horizon 23\n", + "adding: mem time447, current time 469, horizon 22\n", + "adding: mem time448, current time 469, horizon 21\n", + "adding: mem time449, current time 469, horizon 20\n", + "adding: mem time450, current time 469, horizon 19\n", + "adding: mem time451, current time 469, horizon 18\n", + "adding: mem time452, current time 469, horizon 17\n", + "adding: mem time453, current time 469, horizon 16\n", + "adding: mem time454, current time 469, horizon 15\n", + "adding: mem time455, current time 469, horizon 14\n", + "adding: mem time456, current time 469, horizon 13\n", + "adding: mem time457, current time 469, horizon 12\n", + "adding: mem time458, current time 469, horizon 11\n", + "adding: mem time459, current time 469, horizon 10\n", + "adding: mem time460, current time 469, horizon 9\n", + "adding: mem time461, current time 469, horizon 8\n", + "adding: mem time462, current time 469, horizon 7\n", + "adding: mem time463, current time 469, horizon 6\n", + "adding: mem time464, current time 469, horizon 5\n", + "adding: mem time465, current time 469, horizon 4\n", + "adding: mem time466, current time 469, horizon 3\n", + "adding: mem time467, current time 469, horizon 2\n", + "adding: mem time468, current time 469, horizon 1\n", + "adding: mem time400, current time 470, horizon 70\n", + "adding: mem time401, current time 470, horizon 69\n", + "adding: mem time402, current time 470, horizon 68\n", + "adding: mem time403, current time 470, horizon 67\n", + "adding: mem time404, current time 470, horizon 66\n", + "adding: mem time405, current time 470, horizon 65\n", + "adding: mem time406, current time 470, horizon 64\n", + "adding: mem time407, current time 470, horizon 63\n", + "adding: mem time408, current time 470, horizon 62\n", + "adding: mem time409, current time 470, horizon 61\n", + "adding: mem time410, current time 470, horizon 60\n", + "adding: mem time411, current time 470, horizon 59\n", + "adding: mem time412, current time 470, horizon 58\n", + "adding: mem time413, current time 470, horizon 57\n", + "adding: mem time414, current time 470, horizon 56\n", + "adding: mem time415, current time 470, horizon 55\n", + "adding: mem time416, current time 470, horizon 54\n", + "adding: mem time417, current time 470, horizon 53\n", + "adding: mem time418, current time 470, horizon 52\n", + "adding: mem time419, current time 470, horizon 51\n", + "adding: mem time420, current time 470, horizon 50\n", + "adding: mem time421, current time 470, horizon 49\n", + "adding: mem time422, current time 470, horizon 48\n", + "adding: mem time423, current time 470, horizon 47\n", + "adding: mem time424, current time 470, horizon 46\n", + "adding: mem time425, current time 470, horizon 45\n", + "adding: mem time426, current time 470, horizon 44\n", + "adding: mem time427, current time 470, horizon 43\n", + "adding: mem time428, current time 470, horizon 42\n", + "adding: mem time429, current time 470, horizon 41\n", + "adding: mem time430, current time 470, horizon 40\n", + "adding: mem time431, current time 470, horizon 39\n", + "adding: mem time432, current time 470, horizon 38\n", + "adding: mem time433, current time 470, horizon 37\n", + "adding: mem time434, current time 470, horizon 36\n", + "adding: mem time435, current time 470, horizon 35\n", + "adding: mem time436, current time 470, horizon 34\n", + "adding: mem time437, current time 470, horizon 33\n", + "adding: mem time438, current time 470, horizon 32\n", + "adding: mem time439, current time 470, horizon 31\n", + "adding: mem time440, current time 470, horizon 30\n", + "adding: mem time441, current time 470, horizon 29\n", + "adding: mem time442, current time 470, horizon 28\n", + "adding: mem time443, current time 470, horizon 27\n", + "adding: mem time444, current time 470, horizon 26\n", + "adding: mem time445, current time 470, horizon 25\n", + "adding: mem time446, current time 470, horizon 24\n", + "adding: mem time447, current time 470, horizon 23\n", + "adding: mem time448, current time 470, horizon 22\n", + "adding: mem time449, current time 470, horizon 21\n", + "adding: mem time450, current time 470, horizon 20\n", + "adding: mem time451, current time 470, horizon 19\n", + "adding: mem time452, current time 470, horizon 18\n", + "adding: mem time453, current time 470, horizon 17\n", + "adding: mem time454, current time 470, horizon 16\n", + "adding: mem time455, current time 470, horizon 15\n", + "adding: mem time456, current time 470, horizon 14\n", + "adding: mem time457, current time 470, horizon 13\n", + "adding: mem time458, current time 470, horizon 12\n", + "adding: mem time459, current time 470, horizon 11\n", + "adding: mem time460, current time 470, horizon 10\n", + "adding: mem time461, current time 470, horizon 9\n", + "adding: mem time462, current time 470, horizon 8\n", + "adding: mem time463, current time 470, horizon 7\n", + "adding: mem time464, current time 470, horizon 6\n", + "adding: mem time465, current time 470, horizon 5\n", + "adding: mem time466, current time 470, horizon 4\n", + "adding: mem time467, current time 470, horizon 3\n", + "adding: mem time468, current time 470, horizon 2\n", + "adding: mem time469, current time 470, horizon 1\n", + "adding: mem time400, current time 471, horizon 71\n", + "adding: mem time401, current time 471, horizon 70\n", + "adding: mem time402, current time 471, horizon 69\n", + "adding: mem time403, current time 471, horizon 68\n", + "adding: mem time404, current time 471, horizon 67\n", + "adding: mem time405, current time 471, horizon 66\n", + "adding: mem time406, current time 471, horizon 65\n", + "adding: mem time407, current time 471, horizon 64\n", + "adding: mem time408, current time 471, horizon 63\n", + "adding: mem time409, current time 471, horizon 62\n", + "adding: mem time410, current time 471, horizon 61\n", + "adding: mem time411, current time 471, horizon 60\n", + "adding: mem time412, current time 471, horizon 59\n", + "adding: mem time413, current time 471, horizon 58\n", + "adding: mem time414, current time 471, horizon 57\n", + "adding: mem time415, current time 471, horizon 56\n", + "adding: mem time416, current time 471, horizon 55\n", + "adding: mem time417, current time 471, horizon 54\n", + "adding: mem time418, current time 471, horizon 53\n", + "adding: mem time419, current time 471, horizon 52\n", + "adding: mem time420, current time 471, horizon 51\n", + "adding: mem time421, current time 471, horizon 50\n", + "adding: mem time422, current time 471, horizon 49\n", + "adding: mem time423, current time 471, horizon 48\n", + "adding: mem time424, current time 471, horizon 47\n", + "adding: mem time425, current time 471, horizon 46\n", + "adding: mem time426, current time 471, horizon 45\n", + "adding: mem time427, current time 471, horizon 44\n", + "adding: mem time428, current time 471, horizon 43\n", + "adding: mem time429, current time 471, horizon 42\n", + "adding: mem time430, current time 471, horizon 41\n", + "adding: mem time431, current time 471, horizon 40\n", + "adding: mem time432, current time 471, horizon 39\n", + "adding: mem time433, current time 471, horizon 38\n", + "adding: mem time434, current time 471, horizon 37\n", + "adding: mem time435, current time 471, horizon 36\n", + "adding: mem time436, current time 471, horizon 35\n", + "adding: mem time437, current time 471, horizon 34\n", + "adding: mem time438, current time 471, horizon 33\n", + "adding: mem time439, current time 471, horizon 32\n", + "adding: mem time440, current time 471, horizon 31\n", + "adding: mem time441, current time 471, horizon 30\n", + "adding: mem time442, current time 471, horizon 29\n", + "adding: mem time443, current time 471, horizon 28\n", + "adding: mem time444, current time 471, horizon 27\n", + "adding: mem time445, current time 471, horizon 26\n", + "adding: mem time446, current time 471, horizon 25\n", + "adding: mem time447, current time 471, horizon 24\n", + "adding: mem time448, current time 471, horizon 23\n", + "adding: mem time449, current time 471, horizon 22\n", + "adding: mem time450, current time 471, horizon 21\n", + "adding: mem time451, current time 471, horizon 20\n", + "adding: mem time452, current time 471, horizon 19\n", + "adding: mem time453, current time 471, horizon 18\n", + "adding: mem time454, current time 471, horizon 17\n", + "adding: mem time455, current time 471, horizon 16\n", + "adding: mem time456, current time 471, horizon 15\n", + "adding: mem time457, current time 471, horizon 14\n", + "adding: mem time458, current time 471, horizon 13\n", + "adding: mem time459, current time 471, horizon 12\n", + "adding: mem time460, current time 471, horizon 11\n", + "adding: mem time461, current time 471, horizon 10\n", + "adding: mem time462, current time 471, horizon 9\n", + "adding: mem time463, current time 471, horizon 8\n", + "adding: mem time464, current time 471, horizon 7\n", + "adding: mem time465, current time 471, horizon 6\n", + "adding: mem time466, current time 471, horizon 5\n", + "adding: mem time467, current time 471, horizon 4\n", + "adding: mem time468, current time 471, horizon 3\n", + "adding: mem time469, current time 471, horizon 2\n", + "adding: mem time470, current time 471, horizon 1\n", + "adding: mem time400, current time 472, horizon 72\n", + "adding: mem time401, current time 472, horizon 71\n", + "adding: mem time402, current time 472, horizon 70\n", + "adding: mem time403, current time 472, horizon 69\n", + "adding: mem time404, current time 472, horizon 68\n", + "adding: mem time405, current time 472, horizon 67\n", + "adding: mem time406, current time 472, horizon 66\n", + "adding: mem time407, current time 472, horizon 65\n", + "adding: mem time408, current time 472, horizon 64\n", + "adding: mem time409, current time 472, horizon 63\n", + "adding: mem time410, current time 472, horizon 62\n", + "adding: mem time411, current time 472, horizon 61\n", + "adding: mem time412, current time 472, horizon 60\n", + "adding: mem time413, current time 472, horizon 59\n", + "adding: mem time414, current time 472, horizon 58\n", + "adding: mem time415, current time 472, horizon 57\n", + "adding: mem time416, current time 472, horizon 56\n", + "adding: mem time417, current time 472, horizon 55\n", + "adding: mem time418, current time 472, horizon 54\n", + "adding: mem time419, current time 472, horizon 53\n", + "adding: mem time420, current time 472, horizon 52\n", + "adding: mem time421, current time 472, horizon 51\n", + "adding: mem time422, current time 472, horizon 50\n", + "adding: mem time423, current time 472, horizon 49\n", + "adding: mem time424, current time 472, horizon 48\n", + "adding: mem time425, current time 472, horizon 47\n", + "adding: mem time426, current time 472, horizon 46\n", + "adding: mem time427, current time 472, horizon 45\n", + "adding: mem time428, current time 472, horizon 44\n", + "adding: mem time429, current time 472, horizon 43\n", + "adding: mem time430, current time 472, horizon 42\n", + "adding: mem time431, current time 472, horizon 41\n", + "adding: mem time432, current time 472, horizon 40\n", + "adding: mem time433, current time 472, horizon 39\n", + "adding: mem time434, current time 472, horizon 38\n", + "adding: mem time435, current time 472, horizon 37\n", + "adding: mem time436, current time 472, horizon 36\n", + "adding: mem time437, current time 472, horizon 35\n", + "adding: mem time438, current time 472, horizon 34\n", + "adding: mem time439, current time 472, horizon 33\n", + "adding: mem time440, current time 472, horizon 32\n", + "adding: mem time441, current time 472, horizon 31\n", + "adding: mem time442, current time 472, horizon 30\n", + "adding: mem time443, current time 472, horizon 29\n", + "adding: mem time444, current time 472, horizon 28\n", + "adding: mem time445, current time 472, horizon 27\n", + "adding: mem time446, current time 472, horizon 26\n", + "adding: mem time447, current time 472, horizon 25\n", + "adding: mem time448, current time 472, horizon 24\n", + "adding: mem time449, current time 472, horizon 23\n", + "adding: mem time450, current time 472, horizon 22\n", + "adding: mem time451, current time 472, horizon 21\n", + "adding: mem time452, current time 472, horizon 20\n", + "adding: mem time453, current time 472, horizon 19\n", + "adding: mem time454, current time 472, horizon 18\n", + "adding: mem time455, current time 472, horizon 17\n", + "adding: mem time456, current time 472, horizon 16\n", + "adding: mem time457, current time 472, horizon 15\n", + "adding: mem time458, current time 472, horizon 14\n", + "adding: mem time459, current time 472, horizon 13\n", + "adding: mem time460, current time 472, horizon 12\n", + "adding: mem time461, current time 472, horizon 11\n", + "adding: mem time462, current time 472, horizon 10\n", + "adding: mem time463, current time 472, horizon 9\n", + "adding: mem time464, current time 472, horizon 8\n", + "adding: mem time465, current time 472, horizon 7\n", + "adding: mem time466, current time 472, horizon 6\n", + "adding: mem time467, current time 472, horizon 5\n", + "adding: mem time468, current time 472, horizon 4\n", + "adding: mem time469, current time 472, horizon 3\n", + "adding: mem time470, current time 472, horizon 2\n", + "adding: mem time471, current time 472, horizon 1\n", + "adding: mem time400, current time 473, horizon 73\n", + "adding: mem time401, current time 473, horizon 72\n", + "adding: mem time402, current time 473, horizon 71\n", + "adding: mem time403, current time 473, horizon 70\n", + "adding: mem time404, current time 473, horizon 69\n", + "adding: mem time405, current time 473, horizon 68\n", + "adding: mem time406, current time 473, horizon 67\n", + "adding: mem time407, current time 473, horizon 66\n", + "adding: mem time408, current time 473, horizon 65\n", + "adding: mem time409, current time 473, horizon 64\n", + "adding: mem time410, current time 473, horizon 63\n", + "adding: mem time411, current time 473, horizon 62\n", + "adding: mem time412, current time 473, horizon 61\n", + "adding: mem time413, current time 473, horizon 60\n", + "adding: mem time414, current time 473, horizon 59\n", + "adding: mem time415, current time 473, horizon 58\n", + "adding: mem time416, current time 473, horizon 57\n", + "adding: mem time417, current time 473, horizon 56\n", + "adding: mem time418, current time 473, horizon 55\n", + "adding: mem time419, current time 473, horizon 54\n", + "adding: mem time420, current time 473, horizon 53\n", + "adding: mem time421, current time 473, horizon 52\n", + "adding: mem time422, current time 473, horizon 51\n", + "adding: mem time423, current time 473, horizon 50\n", + "adding: mem time424, current time 473, horizon 49\n", + "adding: mem time425, current time 473, horizon 48\n", + "adding: mem time426, current time 473, horizon 47\n", + "adding: mem time427, current time 473, horizon 46\n", + "adding: mem time428, current time 473, horizon 45\n", + "adding: mem time429, current time 473, horizon 44\n", + "adding: mem time430, current time 473, horizon 43\n", + "adding: mem time431, current time 473, horizon 42\n", + "adding: mem time432, current time 473, horizon 41\n", + "adding: mem time433, current time 473, horizon 40\n", + "adding: mem time434, current time 473, horizon 39\n", + "adding: mem time435, current time 473, horizon 38\n", + "adding: mem time436, current time 473, horizon 37\n", + "adding: mem time437, current time 473, horizon 36\n", + "adding: mem time438, current time 473, horizon 35\n", + "adding: mem time439, current time 473, horizon 34\n", + "adding: mem time440, current time 473, horizon 33\n", + "adding: mem time441, current time 473, horizon 32\n", + "adding: mem time442, current time 473, horizon 31\n", + "adding: mem time443, current time 473, horizon 30\n", + "adding: mem time444, current time 473, horizon 29\n", + "adding: mem time445, current time 473, horizon 28\n", + "adding: mem time446, current time 473, horizon 27\n", + "adding: mem time447, current time 473, horizon 26\n", + "adding: mem time448, current time 473, horizon 25\n", + "adding: mem time449, current time 473, horizon 24\n", + "adding: mem time450, current time 473, horizon 23\n", + "adding: mem time451, current time 473, horizon 22\n", + "adding: mem time452, current time 473, horizon 21\n", + "adding: mem time453, current time 473, horizon 20\n", + "adding: mem time454, current time 473, horizon 19\n", + "adding: mem time455, current time 473, horizon 18\n", + "adding: mem time456, current time 473, horizon 17\n", + "adding: mem time457, current time 473, horizon 16\n", + "adding: mem time458, current time 473, horizon 15\n", + "adding: mem time459, current time 473, horizon 14\n", + "adding: mem time460, current time 473, horizon 13\n", + "adding: mem time461, current time 473, horizon 12\n", + "adding: mem time462, current time 473, horizon 11\n", + "adding: mem time463, current time 473, horizon 10\n", + "adding: mem time464, current time 473, horizon 9\n", + "adding: mem time465, current time 473, horizon 8\n", + "adding: mem time466, current time 473, horizon 7\n", + "adding: mem time467, current time 473, horizon 6\n", + "adding: mem time468, current time 473, horizon 5\n", + "adding: mem time469, current time 473, horizon 4\n", + "adding: mem time470, current time 473, horizon 3\n", + "adding: mem time471, current time 473, horizon 2\n", + "adding: mem time472, current time 473, horizon 1\n", + "adding: mem time400, current time 474, horizon 74\n", + "adding: mem time401, current time 474, horizon 73\n", + "adding: mem time402, current time 474, horizon 72\n", + "adding: mem time403, current time 474, horizon 71\n", + "adding: mem time404, current time 474, horizon 70\n", + "adding: mem time405, current time 474, horizon 69\n", + "adding: mem time406, current time 474, horizon 68\n", + "adding: mem time407, current time 474, horizon 67\n", + "adding: mem time408, current time 474, horizon 66\n", + "adding: mem time409, current time 474, horizon 65\n", + "adding: mem time410, current time 474, horizon 64\n", + "adding: mem time411, current time 474, horizon 63\n", + "adding: mem time412, current time 474, horizon 62\n", + "adding: mem time413, current time 474, horizon 61\n", + "adding: mem time414, current time 474, horizon 60\n", + "adding: mem time415, current time 474, horizon 59\n", + "adding: mem time416, current time 474, horizon 58\n", + "adding: mem time417, current time 474, horizon 57\n", + "adding: mem time418, current time 474, horizon 56\n", + "adding: mem time419, current time 474, horizon 55\n", + "adding: mem time420, current time 474, horizon 54\n", + "adding: mem time421, current time 474, horizon 53\n", + "adding: mem time422, current time 474, horizon 52\n", + "adding: mem time423, current time 474, horizon 51\n", + "adding: mem time424, current time 474, horizon 50\n", + "adding: mem time425, current time 474, horizon 49\n", + "adding: mem time426, current time 474, horizon 48\n", + "adding: mem time427, current time 474, horizon 47\n", + "adding: mem time428, current time 474, horizon 46\n", + "adding: mem time429, current time 474, horizon 45\n", + "adding: mem time430, current time 474, horizon 44\n", + "adding: mem time431, current time 474, horizon 43\n", + "adding: mem time432, current time 474, horizon 42\n", + "adding: mem time433, current time 474, horizon 41\n", + "adding: mem time434, current time 474, horizon 40\n", + "adding: mem time435, current time 474, horizon 39\n", + "adding: mem time436, current time 474, horizon 38\n", + "adding: mem time437, current time 474, horizon 37\n", + "adding: mem time438, current time 474, horizon 36\n", + "adding: mem time439, current time 474, horizon 35\n", + "adding: mem time440, current time 474, horizon 34\n", + "adding: mem time441, current time 474, horizon 33\n", + "adding: mem time442, current time 474, horizon 32\n", + "adding: mem time443, current time 474, horizon 31\n", + "adding: mem time444, current time 474, horizon 30\n", + "adding: mem time445, current time 474, horizon 29\n", + "adding: mem time446, current time 474, horizon 28\n", + "adding: mem time447, current time 474, horizon 27\n", + "adding: mem time448, current time 474, horizon 26\n", + "adding: mem time449, current time 474, horizon 25\n", + "adding: mem time450, current time 474, horizon 24\n", + "adding: mem time451, current time 474, horizon 23\n", + "adding: mem time452, current time 474, horizon 22\n", + "adding: mem time453, current time 474, horizon 21\n", + "adding: mem time454, current time 474, horizon 20\n", + "adding: mem time455, current time 474, horizon 19\n", + "adding: mem time456, current time 474, horizon 18\n", + "adding: mem time457, current time 474, horizon 17\n", + "adding: mem time458, current time 474, horizon 16\n", + "adding: mem time459, current time 474, horizon 15\n", + "adding: mem time460, current time 474, horizon 14\n", + "adding: mem time461, current time 474, horizon 13\n", + "adding: mem time462, current time 474, horizon 12\n", + "adding: mem time463, current time 474, horizon 11\n", + "adding: mem time464, current time 474, horizon 10\n", + "adding: mem time465, current time 474, horizon 9\n", + "adding: mem time466, current time 474, horizon 8\n", + "adding: mem time467, current time 474, horizon 7\n", + "adding: mem time468, current time 474, horizon 6\n", + "adding: mem time469, current time 474, horizon 5\n", + "adding: mem time470, current time 474, horizon 4\n", + "adding: mem time471, current time 474, horizon 3\n", + "adding: mem time472, current time 474, horizon 2\n", + "adding: mem time473, current time 474, horizon 1\n", + "adding: mem time400, current time 475, horizon 75\n", + "adding: mem time401, current time 475, horizon 74\n", + "adding: mem time402, current time 475, horizon 73\n", + "adding: mem time403, current time 475, horizon 72\n", + "adding: mem time404, current time 475, horizon 71\n", + "adding: mem time405, current time 475, horizon 70\n", + "adding: mem time406, current time 475, horizon 69\n", + "adding: mem time407, current time 475, horizon 68\n", + "adding: mem time408, current time 475, horizon 67\n", + "adding: mem time409, current time 475, horizon 66\n", + "adding: mem time410, current time 475, horizon 65\n", + "adding: mem time411, current time 475, horizon 64\n", + "adding: mem time412, current time 475, horizon 63\n", + "adding: mem time413, current time 475, horizon 62\n", + "adding: mem time414, current time 475, horizon 61\n", + "adding: mem time415, current time 475, horizon 60\n", + "adding: mem time416, current time 475, horizon 59\n", + "adding: mem time417, current time 475, horizon 58\n", + "adding: mem time418, current time 475, horizon 57\n", + "adding: mem time419, current time 475, horizon 56\n", + "adding: mem time420, current time 475, horizon 55\n", + "adding: mem time421, current time 475, horizon 54\n", + "adding: mem time422, current time 475, horizon 53\n", + "adding: mem time423, current time 475, horizon 52\n", + "adding: mem time424, current time 475, horizon 51\n", + "adding: mem time425, current time 475, horizon 50\n", + "adding: mem time426, current time 475, horizon 49\n", + "adding: mem time427, current time 475, horizon 48\n", + "adding: mem time428, current time 475, horizon 47\n", + "adding: mem time429, current time 475, horizon 46\n", + "adding: mem time430, current time 475, horizon 45\n", + "adding: mem time431, current time 475, horizon 44\n", + "adding: mem time432, current time 475, horizon 43\n", + "adding: mem time433, current time 475, horizon 42\n", + "adding: mem time434, current time 475, horizon 41\n", + "adding: mem time435, current time 475, horizon 40\n", + "adding: mem time436, current time 475, horizon 39\n", + "adding: mem time437, current time 475, horizon 38\n", + "adding: mem time438, current time 475, horizon 37\n", + "adding: mem time439, current time 475, horizon 36\n", + "adding: mem time440, current time 475, horizon 35\n", + "adding: mem time441, current time 475, horizon 34\n", + "adding: mem time442, current time 475, horizon 33\n", + "adding: mem time443, current time 475, horizon 32\n", + "adding: mem time444, current time 475, horizon 31\n", + "adding: mem time445, current time 475, horizon 30\n", + "adding: mem time446, current time 475, horizon 29\n", + "adding: mem time447, current time 475, horizon 28\n", + "adding: mem time448, current time 475, horizon 27\n", + "adding: mem time449, current time 475, horizon 26\n", + "adding: mem time450, current time 475, horizon 25\n", + "adding: mem time451, current time 475, horizon 24\n", + "adding: mem time452, current time 475, horizon 23\n", + "adding: mem time453, current time 475, horizon 22\n", + "adding: mem time454, current time 475, horizon 21\n", + "adding: mem time455, current time 475, horizon 20\n", + "adding: mem time456, current time 475, horizon 19\n", + "adding: mem time457, current time 475, horizon 18\n", + "adding: mem time458, current time 475, horizon 17\n", + "adding: mem time459, current time 475, horizon 16\n", + "adding: mem time460, current time 475, horizon 15\n", + "adding: mem time461, current time 475, horizon 14\n", + "adding: mem time462, current time 475, horizon 13\n", + "adding: mem time463, current time 475, horizon 12\n", + "adding: mem time464, current time 475, horizon 11\n", + "adding: mem time465, current time 475, horizon 10\n", + "adding: mem time466, current time 475, horizon 9\n", + "adding: mem time467, current time 475, horizon 8\n", + "adding: mem time468, current time 475, horizon 7\n", + "adding: mem time469, current time 475, horizon 6\n", + "adding: mem time470, current time 475, horizon 5\n", + "adding: mem time471, current time 475, horizon 4\n", + "adding: mem time472, current time 475, horizon 3\n", + "adding: mem time473, current time 475, horizon 2\n", + "adding: mem time474, current time 475, horizon 1\n", + "adding: mem time400, current time 476, horizon 76\n", + "adding: mem time401, current time 476, horizon 75\n", + "adding: mem time402, current time 476, horizon 74\n", + "adding: mem time403, current time 476, horizon 73\n", + "adding: mem time404, current time 476, horizon 72\n", + "adding: mem time405, current time 476, horizon 71\n", + "adding: mem time406, current time 476, horizon 70\n", + "adding: mem time407, current time 476, horizon 69\n", + "adding: mem time408, current time 476, horizon 68\n", + "adding: mem time409, current time 476, horizon 67\n", + "adding: mem time410, current time 476, horizon 66\n", + "adding: mem time411, current time 476, horizon 65\n", + "adding: mem time412, current time 476, horizon 64\n", + "adding: mem time413, current time 476, horizon 63\n", + "adding: mem time414, current time 476, horizon 62\n", + "adding: mem time415, current time 476, horizon 61\n", + "adding: mem time416, current time 476, horizon 60\n", + "adding: mem time417, current time 476, horizon 59\n", + "adding: mem time418, current time 476, horizon 58\n", + "adding: mem time419, current time 476, horizon 57\n", + "adding: mem time420, current time 476, horizon 56\n", + "adding: mem time421, current time 476, horizon 55\n", + "adding: mem time422, current time 476, horizon 54\n", + "adding: mem time423, current time 476, horizon 53\n", + "adding: mem time424, current time 476, horizon 52\n", + "adding: mem time425, current time 476, horizon 51\n", + "adding: mem time426, current time 476, horizon 50\n", + "adding: mem time427, current time 476, horizon 49\n", + "adding: mem time428, current time 476, horizon 48\n", + "adding: mem time429, current time 476, horizon 47\n", + "adding: mem time430, current time 476, horizon 46\n", + "adding: mem time431, current time 476, horizon 45\n", + "adding: mem time432, current time 476, horizon 44\n", + "adding: mem time433, current time 476, horizon 43\n", + "adding: mem time434, current time 476, horizon 42\n", + "adding: mem time435, current time 476, horizon 41\n", + "adding: mem time436, current time 476, horizon 40\n", + "adding: mem time437, current time 476, horizon 39\n", + "adding: mem time438, current time 476, horizon 38\n", + "adding: mem time439, current time 476, horizon 37\n", + "adding: mem time440, current time 476, horizon 36\n", + "adding: mem time441, current time 476, horizon 35\n", + "adding: mem time442, current time 476, horizon 34\n", + "adding: mem time443, current time 476, horizon 33\n", + "adding: mem time444, current time 476, horizon 32\n", + "adding: mem time445, current time 476, horizon 31\n", + "adding: mem time446, current time 476, horizon 30\n", + "adding: mem time447, current time 476, horizon 29\n", + "adding: mem time448, current time 476, horizon 28\n", + "adding: mem time449, current time 476, horizon 27\n", + "adding: mem time450, current time 476, horizon 26\n", + "adding: mem time451, current time 476, horizon 25\n", + "adding: mem time452, current time 476, horizon 24\n", + "adding: mem time453, current time 476, horizon 23\n", + "adding: mem time454, current time 476, horizon 22\n", + "adding: mem time455, current time 476, horizon 21\n", + "adding: mem time456, current time 476, horizon 20\n", + "adding: mem time457, current time 476, horizon 19\n", + "adding: mem time458, current time 476, horizon 18\n", + "adding: mem time459, current time 476, horizon 17\n", + "adding: mem time460, current time 476, horizon 16\n", + "adding: mem time461, current time 476, horizon 15\n", + "adding: mem time462, current time 476, horizon 14\n", + "adding: mem time463, current time 476, horizon 13\n", + "adding: mem time464, current time 476, horizon 12\n", + "adding: mem time465, current time 476, horizon 11\n", + "adding: mem time466, current time 476, horizon 10\n", + "adding: mem time467, current time 476, horizon 9\n", + "adding: mem time468, current time 476, horizon 8\n", + "adding: mem time469, current time 476, horizon 7\n", + "adding: mem time470, current time 476, horizon 6\n", + "adding: mem time471, current time 476, horizon 5\n", + "adding: mem time472, current time 476, horizon 4\n", + "adding: mem time473, current time 476, horizon 3\n", + "adding: mem time474, current time 476, horizon 2\n", + "adding: mem time475, current time 476, horizon 1\n", + "adding: mem time400, current time 477, horizon 77\n", + "adding: mem time401, current time 477, horizon 76\n", + "adding: mem time402, current time 477, horizon 75\n", + "adding: mem time403, current time 477, horizon 74\n", + "adding: mem time404, current time 477, horizon 73\n", + "adding: mem time405, current time 477, horizon 72\n", + "adding: mem time406, current time 477, horizon 71\n", + "adding: mem time407, current time 477, horizon 70\n", + "adding: mem time408, current time 477, horizon 69\n", + "adding: mem time409, current time 477, horizon 68\n", + "adding: mem time410, current time 477, horizon 67\n", + "adding: mem time411, current time 477, horizon 66\n", + "adding: mem time412, current time 477, horizon 65\n", + "adding: mem time413, current time 477, horizon 64\n", + "adding: mem time414, current time 477, horizon 63\n", + "adding: mem time415, current time 477, horizon 62\n", + "adding: mem time416, current time 477, horizon 61\n", + "adding: mem time417, current time 477, horizon 60\n", + "adding: mem time418, current time 477, horizon 59\n", + "adding: mem time419, current time 477, horizon 58\n", + "adding: mem time420, current time 477, horizon 57\n", + "adding: mem time421, current time 477, horizon 56\n", + "adding: mem time422, current time 477, horizon 55\n", + "adding: mem time423, current time 477, horizon 54\n", + "adding: mem time424, current time 477, horizon 53\n", + "adding: mem time425, current time 477, horizon 52\n", + "adding: mem time426, current time 477, horizon 51\n", + "adding: mem time427, current time 477, horizon 50\n", + "adding: mem time428, current time 477, horizon 49\n", + "adding: mem time429, current time 477, horizon 48\n", + "adding: mem time430, current time 477, horizon 47\n", + "adding: mem time431, current time 477, horizon 46\n", + "adding: mem time432, current time 477, horizon 45\n", + "adding: mem time433, current time 477, horizon 44\n", + "adding: mem time434, current time 477, horizon 43\n", + "adding: mem time435, current time 477, horizon 42\n", + "adding: mem time436, current time 477, horizon 41\n", + "adding: mem time437, current time 477, horizon 40\n", + "adding: mem time438, current time 477, horizon 39\n", + "adding: mem time439, current time 477, horizon 38\n", + "adding: mem time440, current time 477, horizon 37\n", + "adding: mem time441, current time 477, horizon 36\n", + "adding: mem time442, current time 477, horizon 35\n", + "adding: mem time443, current time 477, horizon 34\n", + "adding: mem time444, current time 477, horizon 33\n", + "adding: mem time445, current time 477, horizon 32\n", + "adding: mem time446, current time 477, horizon 31\n", + "adding: mem time447, current time 477, horizon 30\n", + "adding: mem time448, current time 477, horizon 29\n", + "adding: mem time449, current time 477, horizon 28\n", + "adding: mem time450, current time 477, horizon 27\n", + "adding: mem time451, current time 477, horizon 26\n", + "adding: mem time452, current time 477, horizon 25\n", + "adding: mem time453, current time 477, horizon 24\n", + "adding: mem time454, current time 477, horizon 23\n", + "adding: mem time455, current time 477, horizon 22\n", + "adding: mem time456, current time 477, horizon 21\n", + "adding: mem time457, current time 477, horizon 20\n", + "adding: mem time458, current time 477, horizon 19\n", + "adding: mem time459, current time 477, horizon 18\n", + "adding: mem time460, current time 477, horizon 17\n", + "adding: mem time461, current time 477, horizon 16\n", + "adding: mem time462, current time 477, horizon 15\n", + "adding: mem time463, current time 477, horizon 14\n", + "adding: mem time464, current time 477, horizon 13\n", + "adding: mem time465, current time 477, horizon 12\n", + "adding: mem time466, current time 477, horizon 11\n", + "adding: mem time467, current time 477, horizon 10\n", + "adding: mem time468, current time 477, horizon 9\n", + "adding: mem time469, current time 477, horizon 8\n", + "adding: mem time470, current time 477, horizon 7\n", + "adding: mem time471, current time 477, horizon 6\n", + "adding: mem time472, current time 477, horizon 5\n", + "adding: mem time473, current time 477, horizon 4\n", + "adding: mem time474, current time 477, horizon 3\n", + "adding: mem time475, current time 477, horizon 2\n", + "adding: mem time476, current time 477, horizon 1\n", + "adding: mem time400, current time 478, horizon 78\n", + "adding: mem time401, current time 478, horizon 77\n", + "adding: mem time402, current time 478, horizon 76\n", + "adding: mem time403, current time 478, horizon 75\n", + "adding: mem time404, current time 478, horizon 74\n", + "adding: mem time405, current time 478, horizon 73\n", + "adding: mem time406, current time 478, horizon 72\n", + "adding: mem time407, current time 478, horizon 71\n", + "adding: mem time408, current time 478, horizon 70\n", + "adding: mem time409, current time 478, horizon 69\n", + "adding: mem time410, current time 478, horizon 68\n", + "adding: mem time411, current time 478, horizon 67\n", + "adding: mem time412, current time 478, horizon 66\n", + "adding: mem time413, current time 478, horizon 65\n", + "adding: mem time414, current time 478, horizon 64\n", + "adding: mem time415, current time 478, horizon 63\n", + "adding: mem time416, current time 478, horizon 62\n", + "adding: mem time417, current time 478, horizon 61\n", + "adding: mem time418, current time 478, horizon 60\n", + "adding: mem time419, current time 478, horizon 59\n", + "adding: mem time420, current time 478, horizon 58\n", + "adding: mem time421, current time 478, horizon 57\n", + "adding: mem time422, current time 478, horizon 56\n", + "adding: mem time423, current time 478, horizon 55\n", + "adding: mem time424, current time 478, horizon 54\n", + "adding: mem time425, current time 478, horizon 53\n", + "adding: mem time426, current time 478, horizon 52\n", + "adding: mem time427, current time 478, horizon 51\n", + "adding: mem time428, current time 478, horizon 50\n", + "adding: mem time429, current time 478, horizon 49\n", + "adding: mem time430, current time 478, horizon 48\n", + "adding: mem time431, current time 478, horizon 47\n", + "adding: mem time432, current time 478, horizon 46\n", + "adding: mem time433, current time 478, horizon 45\n", + "adding: mem time434, current time 478, horizon 44\n", + "adding: mem time435, current time 478, horizon 43\n", + "adding: mem time436, current time 478, horizon 42\n", + "adding: mem time437, current time 478, horizon 41\n", + "adding: mem time438, current time 478, horizon 40\n", + "adding: mem time439, current time 478, horizon 39\n", + "adding: mem time440, current time 478, horizon 38\n", + "adding: mem time441, current time 478, horizon 37\n", + "adding: mem time442, current time 478, horizon 36\n", + "adding: mem time443, current time 478, horizon 35\n", + "adding: mem time444, current time 478, horizon 34\n", + "adding: mem time445, current time 478, horizon 33\n", + "adding: mem time446, current time 478, horizon 32\n", + "adding: mem time447, current time 478, horizon 31\n", + "adding: mem time448, current time 478, horizon 30\n", + "adding: mem time449, current time 478, horizon 29\n", + "adding: mem time450, current time 478, horizon 28\n", + "adding: mem time451, current time 478, horizon 27\n", + "adding: mem time452, current time 478, horizon 26\n", + "adding: mem time453, current time 478, horizon 25\n", + "adding: mem time454, current time 478, horizon 24\n", + "adding: mem time455, current time 478, horizon 23\n", + "adding: mem time456, current time 478, horizon 22\n", + "adding: mem time457, current time 478, horizon 21\n", + "adding: mem time458, current time 478, horizon 20\n", + "adding: mem time459, current time 478, horizon 19\n", + "adding: mem time460, current time 478, horizon 18\n", + "adding: mem time461, current time 478, horizon 17\n", + "adding: mem time462, current time 478, horizon 16\n", + "adding: mem time463, current time 478, horizon 15\n", + "adding: mem time464, current time 478, horizon 14\n", + "adding: mem time465, current time 478, horizon 13\n", + "adding: mem time466, current time 478, horizon 12\n", + "adding: mem time467, current time 478, horizon 11\n", + "adding: mem time468, current time 478, horizon 10\n", + "adding: mem time469, current time 478, horizon 9\n", + "adding: mem time470, current time 478, horizon 8\n", + "adding: mem time471, current time 478, horizon 7\n", + "adding: mem time472, current time 478, horizon 6\n", + "adding: mem time473, current time 478, horizon 5\n", + "adding: mem time474, current time 478, horizon 4\n", + "adding: mem time475, current time 478, horizon 3\n", + "adding: mem time476, current time 478, horizon 2\n", + "adding: mem time477, current time 478, horizon 1\n", + "adding: mem time400, current time 479, horizon 79\n", + "adding: mem time401, current time 479, horizon 78\n", + "adding: mem time402, current time 479, horizon 77\n", + "adding: mem time403, current time 479, horizon 76\n", + "adding: mem time404, current time 479, horizon 75\n", + "adding: mem time405, current time 479, horizon 74\n", + "adding: mem time406, current time 479, horizon 73\n", + "adding: mem time407, current time 479, horizon 72\n", + "adding: mem time408, current time 479, horizon 71\n", + "adding: mem time409, current time 479, horizon 70\n", + "adding: mem time410, current time 479, horizon 69\n", + "adding: mem time411, current time 479, horizon 68\n", + "adding: mem time412, current time 479, horizon 67\n", + "adding: mem time413, current time 479, horizon 66\n", + "adding: mem time414, current time 479, horizon 65\n", + "adding: mem time415, current time 479, horizon 64\n", + "adding: mem time416, current time 479, horizon 63\n", + "adding: mem time417, current time 479, horizon 62\n", + "adding: mem time418, current time 479, horizon 61\n", + "adding: mem time419, current time 479, horizon 60\n", + "adding: mem time420, current time 479, horizon 59\n", + "adding: mem time421, current time 479, horizon 58\n", + "adding: mem time422, current time 479, horizon 57\n", + "adding: mem time423, current time 479, horizon 56\n", + "adding: mem time424, current time 479, horizon 55\n", + "adding: mem time425, current time 479, horizon 54\n", + "adding: mem time426, current time 479, horizon 53\n", + "adding: mem time427, current time 479, horizon 52\n", + "adding: mem time428, current time 479, horizon 51\n", + "adding: mem time429, current time 479, horizon 50\n", + "adding: mem time430, current time 479, horizon 49\n", + "adding: mem time431, current time 479, horizon 48\n", + "adding: mem time432, current time 479, horizon 47\n", + "adding: mem time433, current time 479, horizon 46\n", + "adding: mem time434, current time 479, horizon 45\n", + "adding: mem time435, current time 479, horizon 44\n", + "adding: mem time436, current time 479, horizon 43\n", + "adding: mem time437, current time 479, horizon 42\n", + "adding: mem time438, current time 479, horizon 41\n", + "adding: mem time439, current time 479, horizon 40\n", + "adding: mem time440, current time 479, horizon 39\n", + "adding: mem time441, current time 479, horizon 38\n", + "adding: mem time442, current time 479, horizon 37\n", + "adding: mem time443, current time 479, horizon 36\n", + "adding: mem time444, current time 479, horizon 35\n", + "adding: mem time445, current time 479, horizon 34\n", + "adding: mem time446, current time 479, horizon 33\n", + "adding: mem time447, current time 479, horizon 32\n", + "adding: mem time448, current time 479, horizon 31\n", + "adding: mem time449, current time 479, horizon 30\n", + "adding: mem time450, current time 479, horizon 29\n", + "adding: mem time451, current time 479, horizon 28\n", + "adding: mem time452, current time 479, horizon 27\n", + "adding: mem time453, current time 479, horizon 26\n", + "adding: mem time454, current time 479, horizon 25\n", + "adding: mem time455, current time 479, horizon 24\n", + "adding: mem time456, current time 479, horizon 23\n", + "adding: mem time457, current time 479, horizon 22\n", + "adding: mem time458, current time 479, horizon 21\n", + "adding: mem time459, current time 479, horizon 20\n", + "adding: mem time460, current time 479, horizon 19\n", + "adding: mem time461, current time 479, horizon 18\n", + "adding: mem time462, current time 479, horizon 17\n", + "adding: mem time463, current time 479, horizon 16\n", + "adding: mem time464, current time 479, horizon 15\n", + "adding: mem time465, current time 479, horizon 14\n", + "adding: mem time466, current time 479, horizon 13\n", + "adding: mem time467, current time 479, horizon 12\n", + "adding: mem time468, current time 479, horizon 11\n", + "adding: mem time469, current time 479, horizon 10\n", + "adding: mem time470, current time 479, horizon 9\n", + "adding: mem time471, current time 479, horizon 8\n", + "adding: mem time472, current time 479, horizon 7\n", + "adding: mem time473, current time 479, horizon 6\n", + "adding: mem time474, current time 479, horizon 5\n", + "adding: mem time475, current time 479, horizon 4\n", + "adding: mem time476, current time 479, horizon 3\n", + "adding: mem time477, current time 479, horizon 2\n", + "adding: mem time478, current time 479, horizon 1\n", + "adding: mem time400, current time 480, horizon 80\n", + "adding: mem time401, current time 480, horizon 79\n", + "adding: mem time402, current time 480, horizon 78\n", + "adding: mem time403, current time 480, horizon 77\n", + "adding: mem time404, current time 480, horizon 76\n", + "adding: mem time405, current time 480, horizon 75\n", + "adding: mem time406, current time 480, horizon 74\n", + "adding: mem time407, current time 480, horizon 73\n", + "adding: mem time408, current time 480, horizon 72\n", + "adding: mem time409, current time 480, horizon 71\n", + "adding: mem time410, current time 480, horizon 70\n", + "adding: mem time411, current time 480, horizon 69\n", + "adding: mem time412, current time 480, horizon 68\n", + "adding: mem time413, current time 480, horizon 67\n", + "adding: mem time414, current time 480, horizon 66\n", + "adding: mem time415, current time 480, horizon 65\n", + "adding: mem time416, current time 480, horizon 64\n", + "adding: mem time417, current time 480, horizon 63\n", + "adding: mem time418, current time 480, horizon 62\n", + "adding: mem time419, current time 480, horizon 61\n", + "adding: mem time420, current time 480, horizon 60\n", + "adding: mem time421, current time 480, horizon 59\n", + "adding: mem time422, current time 480, horizon 58\n", + "adding: mem time423, current time 480, horizon 57\n", + "adding: mem time424, current time 480, horizon 56\n", + "adding: mem time425, current time 480, horizon 55\n", + "adding: mem time426, current time 480, horizon 54\n", + "adding: mem time427, current time 480, horizon 53\n", + "adding: mem time428, current time 480, horizon 52\n", + "adding: mem time429, current time 480, horizon 51\n", + "adding: mem time430, current time 480, horizon 50\n", + "adding: mem time431, current time 480, horizon 49\n", + "adding: mem time432, current time 480, horizon 48\n", + "adding: mem time433, current time 480, horizon 47\n", + "adding: mem time434, current time 480, horizon 46\n", + "adding: mem time435, current time 480, horizon 45\n", + "adding: mem time436, current time 480, horizon 44\n", + "adding: mem time437, current time 480, horizon 43\n", + "adding: mem time438, current time 480, horizon 42\n", + "adding: mem time439, current time 480, horizon 41\n", + "adding: mem time440, current time 480, horizon 40\n", + "adding: mem time441, current time 480, horizon 39\n", + "adding: mem time442, current time 480, horizon 38\n", + "adding: mem time443, current time 480, horizon 37\n", + "adding: mem time444, current time 480, horizon 36\n", + "adding: mem time445, current time 480, horizon 35\n", + "adding: mem time446, current time 480, horizon 34\n", + "adding: mem time447, current time 480, horizon 33\n", + "adding: mem time448, current time 480, horizon 32\n", + "adding: mem time449, current time 480, horizon 31\n", + "adding: mem time450, current time 480, horizon 30\n", + "adding: mem time451, current time 480, horizon 29\n", + "adding: mem time452, current time 480, horizon 28\n", + "adding: mem time453, current time 480, horizon 27\n", + "adding: mem time454, current time 480, horizon 26\n", + "adding: mem time455, current time 480, horizon 25\n", + "adding: mem time456, current time 480, horizon 24\n", + "adding: mem time457, current time 480, horizon 23\n", + "adding: mem time458, current time 480, horizon 22\n", + "adding: mem time459, current time 480, horizon 21\n", + "adding: mem time460, current time 480, horizon 20\n", + "adding: mem time461, current time 480, horizon 19\n", + "adding: mem time462, current time 480, horizon 18\n", + "adding: mem time463, current time 480, horizon 17\n", + "adding: mem time464, current time 480, horizon 16\n", + "adding: mem time465, current time 480, horizon 15\n", + "adding: mem time466, current time 480, horizon 14\n", + "adding: mem time467, current time 480, horizon 13\n", + "adding: mem time468, current time 480, horizon 12\n", + "adding: mem time469, current time 480, horizon 11\n", + "adding: mem time470, current time 480, horizon 10\n", + "adding: mem time471, current time 480, horizon 9\n", + "adding: mem time472, current time 480, horizon 8\n", + "adding: mem time473, current time 480, horizon 7\n", + "adding: mem time474, current time 480, horizon 6\n", + "adding: mem time475, current time 480, horizon 5\n", + "adding: mem time476, current time 480, horizon 4\n", + "adding: mem time477, current time 480, horizon 3\n", + "adding: mem time478, current time 480, horizon 2\n", + "adding: mem time479, current time 480, horizon 1\n", + "adding: mem time400, current time 481, horizon 81\n", + "adding: mem time401, current time 481, horizon 80\n", + "adding: mem time402, current time 481, horizon 79\n", + "adding: mem time403, current time 481, horizon 78\n", + "adding: mem time404, current time 481, horizon 77\n", + "adding: mem time405, current time 481, horizon 76\n", + "adding: mem time406, current time 481, horizon 75\n", + "adding: mem time407, current time 481, horizon 74\n", + "adding: mem time408, current time 481, horizon 73\n", + "adding: mem time409, current time 481, horizon 72\n", + "adding: mem time410, current time 481, horizon 71\n", + "adding: mem time411, current time 481, horizon 70\n", + "adding: mem time412, current time 481, horizon 69\n", + "adding: mem time413, current time 481, horizon 68\n", + "adding: mem time414, current time 481, horizon 67\n", + "adding: mem time415, current time 481, horizon 66\n", + "adding: mem time416, current time 481, horizon 65\n", + "adding: mem time417, current time 481, horizon 64\n", + "adding: mem time418, current time 481, horizon 63\n", + "adding: mem time419, current time 481, horizon 62\n", + "adding: mem time420, current time 481, horizon 61\n", + "adding: mem time421, current time 481, horizon 60\n", + "adding: mem time422, current time 481, horizon 59\n", + "adding: mem time423, current time 481, horizon 58\n", + "adding: mem time424, current time 481, horizon 57\n", + "adding: mem time425, current time 481, horizon 56\n", + "adding: mem time426, current time 481, horizon 55\n", + "adding: mem time427, current time 481, horizon 54\n", + "adding: mem time428, current time 481, horizon 53\n", + "adding: mem time429, current time 481, horizon 52\n", + "adding: mem time430, current time 481, horizon 51\n", + "adding: mem time431, current time 481, horizon 50\n", + "adding: mem time432, current time 481, horizon 49\n", + "adding: mem time433, current time 481, horizon 48\n", + "adding: mem time434, current time 481, horizon 47\n", + "adding: mem time435, current time 481, horizon 46\n", + "adding: mem time436, current time 481, horizon 45\n", + "adding: mem time437, current time 481, horizon 44\n", + "adding: mem time438, current time 481, horizon 43\n", + "adding: mem time439, current time 481, horizon 42\n", + "adding: mem time440, current time 481, horizon 41\n", + "adding: mem time441, current time 481, horizon 40\n", + "adding: mem time442, current time 481, horizon 39\n", + "adding: mem time443, current time 481, horizon 38\n", + "adding: mem time444, current time 481, horizon 37\n", + "adding: mem time445, current time 481, horizon 36\n", + "adding: mem time446, current time 481, horizon 35\n", + "adding: mem time447, current time 481, horizon 34\n", + "adding: mem time448, current time 481, horizon 33\n", + "adding: mem time449, current time 481, horizon 32\n", + "adding: mem time450, current time 481, horizon 31\n", + "adding: mem time451, current time 481, horizon 30\n", + "adding: mem time452, current time 481, horizon 29\n", + "adding: mem time453, current time 481, horizon 28\n", + "adding: mem time454, current time 481, horizon 27\n", + "adding: mem time455, current time 481, horizon 26\n", + "adding: mem time456, current time 481, horizon 25\n", + "adding: mem time457, current time 481, horizon 24\n", + "adding: mem time458, current time 481, horizon 23\n", + "adding: mem time459, current time 481, horizon 22\n", + "adding: mem time460, current time 481, horizon 21\n", + "adding: mem time461, current time 481, horizon 20\n", + "adding: mem time462, current time 481, horizon 19\n", + "adding: mem time463, current time 481, horizon 18\n", + "adding: mem time464, current time 481, horizon 17\n", + "adding: mem time465, current time 481, horizon 16\n", + "adding: mem time466, current time 481, horizon 15\n", + "adding: mem time467, current time 481, horizon 14\n", + "adding: mem time468, current time 481, horizon 13\n", + "adding: mem time469, current time 481, horizon 12\n", + "adding: mem time470, current time 481, horizon 11\n", + "adding: mem time471, current time 481, horizon 10\n", + "adding: mem time472, current time 481, horizon 9\n", + "adding: mem time473, current time 481, horizon 8\n", + "adding: mem time474, current time 481, horizon 7\n", + "adding: mem time475, current time 481, horizon 6\n", + "adding: mem time476, current time 481, horizon 5\n", + "adding: mem time477, current time 481, horizon 4\n", + "adding: mem time478, current time 481, horizon 3\n", + "adding: mem time479, current time 481, horizon 2\n", + "adding: mem time480, current time 481, horizon 1\n", + "adding: mem time400, current time 482, horizon 82\n", + "adding: mem time401, current time 482, horizon 81\n", + "adding: mem time402, current time 482, horizon 80\n", + "adding: mem time403, current time 482, horizon 79\n", + "adding: mem time404, current time 482, horizon 78\n", + "adding: mem time405, current time 482, horizon 77\n", + "adding: mem time406, current time 482, horizon 76\n", + "adding: mem time407, current time 482, horizon 75\n", + "adding: mem time408, current time 482, horizon 74\n", + "adding: mem time409, current time 482, horizon 73\n", + "adding: mem time410, current time 482, horizon 72\n", + "adding: mem time411, current time 482, horizon 71\n", + "adding: mem time412, current time 482, horizon 70\n", + "adding: mem time413, current time 482, horizon 69\n", + "adding: mem time414, current time 482, horizon 68\n", + "adding: mem time415, current time 482, horizon 67\n", + "adding: mem time416, current time 482, horizon 66\n", + "adding: mem time417, current time 482, horizon 65\n", + "adding: mem time418, current time 482, horizon 64\n", + "adding: mem time419, current time 482, horizon 63\n", + "adding: mem time420, current time 482, horizon 62\n", + "adding: mem time421, current time 482, horizon 61\n", + "adding: mem time422, current time 482, horizon 60\n", + "adding: mem time423, current time 482, horizon 59\n", + "adding: mem time424, current time 482, horizon 58\n", + "adding: mem time425, current time 482, horizon 57\n", + "adding: mem time426, current time 482, horizon 56\n", + "adding: mem time427, current time 482, horizon 55\n", + "adding: mem time428, current time 482, horizon 54\n", + "adding: mem time429, current time 482, horizon 53\n", + "adding: mem time430, current time 482, horizon 52\n", + "adding: mem time431, current time 482, horizon 51\n", + "adding: mem time432, current time 482, horizon 50\n", + "adding: mem time433, current time 482, horizon 49\n", + "adding: mem time434, current time 482, horizon 48\n", + "adding: mem time435, current time 482, horizon 47\n", + "adding: mem time436, current time 482, horizon 46\n", + "adding: mem time437, current time 482, horizon 45\n", + "adding: mem time438, current time 482, horizon 44\n", + "adding: mem time439, current time 482, horizon 43\n", + "adding: mem time440, current time 482, horizon 42\n", + "adding: mem time441, current time 482, horizon 41\n", + "adding: mem time442, current time 482, horizon 40\n", + "adding: mem time443, current time 482, horizon 39\n", + "adding: mem time444, current time 482, horizon 38\n", + "adding: mem time445, current time 482, horizon 37\n", + "adding: mem time446, current time 482, horizon 36\n", + "adding: mem time447, current time 482, horizon 35\n", + "adding: mem time448, current time 482, horizon 34\n", + "adding: mem time449, current time 482, horizon 33\n", + "adding: mem time450, current time 482, horizon 32\n", + "adding: mem time451, current time 482, horizon 31\n", + "adding: mem time452, current time 482, horizon 30\n", + "adding: mem time453, current time 482, horizon 29\n", + "adding: mem time454, current time 482, horizon 28\n", + "adding: mem time455, current time 482, horizon 27\n", + "adding: mem time456, current time 482, horizon 26\n", + "adding: mem time457, current time 482, horizon 25\n", + "adding: mem time458, current time 482, horizon 24\n", + "adding: mem time459, current time 482, horizon 23\n", + "adding: mem time460, current time 482, horizon 22\n", + "adding: mem time461, current time 482, horizon 21\n", + "adding: mem time462, current time 482, horizon 20\n", + "adding: mem time463, current time 482, horizon 19\n", + "adding: mem time464, current time 482, horizon 18\n", + "adding: mem time465, current time 482, horizon 17\n", + "adding: mem time466, current time 482, horizon 16\n", + "adding: mem time467, current time 482, horizon 15\n", + "adding: mem time468, current time 482, horizon 14\n", + "adding: mem time469, current time 482, horizon 13\n", + "adding: mem time470, current time 482, horizon 12\n", + "adding: mem time471, current time 482, horizon 11\n", + "adding: mem time472, current time 482, horizon 10\n", + "adding: mem time473, current time 482, horizon 9\n", + "adding: mem time474, current time 482, horizon 8\n", + "adding: mem time475, current time 482, horizon 7\n", + "adding: mem time476, current time 482, horizon 6\n", + "adding: mem time477, current time 482, horizon 5\n", + "adding: mem time478, current time 482, horizon 4\n", + "adding: mem time479, current time 482, horizon 3\n", + "adding: mem time480, current time 482, horizon 2\n", + "adding: mem time481, current time 482, horizon 1\n", + "adding: mem time400, current time 483, horizon 83\n", + "adding: mem time401, current time 483, horizon 82\n", + "adding: mem time402, current time 483, horizon 81\n", + "adding: mem time403, current time 483, horizon 80\n", + "adding: mem time404, current time 483, horizon 79\n", + "adding: mem time405, current time 483, horizon 78\n", + "adding: mem time406, current time 483, horizon 77\n", + "adding: mem time407, current time 483, horizon 76\n", + "adding: mem time408, current time 483, horizon 75\n", + "adding: mem time409, current time 483, horizon 74\n", + "adding: mem time410, current time 483, horizon 73\n", + "adding: mem time411, current time 483, horizon 72\n", + "adding: mem time412, current time 483, horizon 71\n", + "adding: mem time413, current time 483, horizon 70\n", + "adding: mem time414, current time 483, horizon 69\n", + "adding: mem time415, current time 483, horizon 68\n", + "adding: mem time416, current time 483, horizon 67\n", + "adding: mem time417, current time 483, horizon 66\n", + "adding: mem time418, current time 483, horizon 65\n", + "adding: mem time419, current time 483, horizon 64\n", + "adding: mem time420, current time 483, horizon 63\n", + "adding: mem time421, current time 483, horizon 62\n", + "adding: mem time422, current time 483, horizon 61\n", + "adding: mem time423, current time 483, horizon 60\n", + "adding: mem time424, current time 483, horizon 59\n", + "adding: mem time425, current time 483, horizon 58\n", + "adding: mem time426, current time 483, horizon 57\n", + "adding: mem time427, current time 483, horizon 56\n", + "adding: mem time428, current time 483, horizon 55\n", + "adding: mem time429, current time 483, horizon 54\n", + "adding: mem time430, current time 483, horizon 53\n", + "adding: mem time431, current time 483, horizon 52\n", + "adding: mem time432, current time 483, horizon 51\n", + "adding: mem time433, current time 483, horizon 50\n", + "adding: mem time434, current time 483, horizon 49\n", + "adding: mem time435, current time 483, horizon 48\n", + "adding: mem time436, current time 483, horizon 47\n", + "adding: mem time437, current time 483, horizon 46\n", + "adding: mem time438, current time 483, horizon 45\n", + "adding: mem time439, current time 483, horizon 44\n", + "adding: mem time440, current time 483, horizon 43\n", + "adding: mem time441, current time 483, horizon 42\n", + "adding: mem time442, current time 483, horizon 41\n", + "adding: mem time443, current time 483, horizon 40\n", + "adding: mem time444, current time 483, horizon 39\n", + "adding: mem time445, current time 483, horizon 38\n", + "adding: mem time446, current time 483, horizon 37\n", + "adding: mem time447, current time 483, horizon 36\n", + "adding: mem time448, current time 483, horizon 35\n", + "adding: mem time449, current time 483, horizon 34\n", + "adding: mem time450, current time 483, horizon 33\n", + "adding: mem time451, current time 483, horizon 32\n", + "adding: mem time452, current time 483, horizon 31\n", + "adding: mem time453, current time 483, horizon 30\n", + "adding: mem time454, current time 483, horizon 29\n", + "adding: mem time455, current time 483, horizon 28\n", + "adding: mem time456, current time 483, horizon 27\n", + "adding: mem time457, current time 483, horizon 26\n", + "adding: mem time458, current time 483, horizon 25\n", + "adding: mem time459, current time 483, horizon 24\n", + "adding: mem time460, current time 483, horizon 23\n", + "adding: mem time461, current time 483, horizon 22\n", + "adding: mem time462, current time 483, horizon 21\n", + "adding: mem time463, current time 483, horizon 20\n", + "adding: mem time464, current time 483, horizon 19\n", + "adding: mem time465, current time 483, horizon 18\n", + "adding: mem time466, current time 483, horizon 17\n", + "adding: mem time467, current time 483, horizon 16\n", + "adding: mem time468, current time 483, horizon 15\n", + "adding: mem time469, current time 483, horizon 14\n", + "adding: mem time470, current time 483, horizon 13\n", + "adding: mem time471, current time 483, horizon 12\n", + "adding: mem time472, current time 483, horizon 11\n", + "adding: mem time473, current time 483, horizon 10\n", + "adding: mem time474, current time 483, horizon 9\n", + "adding: mem time475, current time 483, horizon 8\n", + "adding: mem time476, current time 483, horizon 7\n", + "adding: mem time477, current time 483, horizon 6\n", + "adding: mem time478, current time 483, horizon 5\n", + "adding: mem time479, current time 483, horizon 4\n", + "adding: mem time480, current time 483, horizon 3\n", + "adding: mem time481, current time 483, horizon 2\n", + "adding: mem time482, current time 483, horizon 1\n", + "adding: mem time400, current time 484, horizon 84\n", + "adding: mem time401, current time 484, horizon 83\n", + "adding: mem time402, current time 484, horizon 82\n", + "adding: mem time403, current time 484, horizon 81\n", + "adding: mem time404, current time 484, horizon 80\n", + "adding: mem time405, current time 484, horizon 79\n", + "adding: mem time406, current time 484, horizon 78\n", + "adding: mem time407, current time 484, horizon 77\n", + "adding: mem time408, current time 484, horizon 76\n", + "adding: mem time409, current time 484, horizon 75\n", + "adding: mem time410, current time 484, horizon 74\n", + "adding: mem time411, current time 484, horizon 73\n", + "adding: mem time412, current time 484, horizon 72\n", + "adding: mem time413, current time 484, horizon 71\n", + "adding: mem time414, current time 484, horizon 70\n", + "adding: mem time415, current time 484, horizon 69\n", + "adding: mem time416, current time 484, horizon 68\n", + "adding: mem time417, current time 484, horizon 67\n", + "adding: mem time418, current time 484, horizon 66\n", + "adding: mem time419, current time 484, horizon 65\n", + "adding: mem time420, current time 484, horizon 64\n", + "adding: mem time421, current time 484, horizon 63\n", + "adding: mem time422, current time 484, horizon 62\n", + "adding: mem time423, current time 484, horizon 61\n", + "adding: mem time424, current time 484, horizon 60\n", + "adding: mem time425, current time 484, horizon 59\n", + "adding: mem time426, current time 484, horizon 58\n", + "adding: mem time427, current time 484, horizon 57\n", + "adding: mem time428, current time 484, horizon 56\n", + "adding: mem time429, current time 484, horizon 55\n", + "adding: mem time430, current time 484, horizon 54\n", + "adding: mem time431, current time 484, horizon 53\n", + "adding: mem time432, current time 484, horizon 52\n", + "adding: mem time433, current time 484, horizon 51\n", + "adding: mem time434, current time 484, horizon 50\n", + "adding: mem time435, current time 484, horizon 49\n", + "adding: mem time436, current time 484, horizon 48\n", + "adding: mem time437, current time 484, horizon 47\n", + "adding: mem time438, current time 484, horizon 46\n", + "adding: mem time439, current time 484, horizon 45\n", + "adding: mem time440, current time 484, horizon 44\n", + "adding: mem time441, current time 484, horizon 43\n", + "adding: mem time442, current time 484, horizon 42\n", + "adding: mem time443, current time 484, horizon 41\n", + "adding: mem time444, current time 484, horizon 40\n", + "adding: mem time445, current time 484, horizon 39\n", + "adding: mem time446, current time 484, horizon 38\n", + "adding: mem time447, current time 484, horizon 37\n", + "adding: mem time448, current time 484, horizon 36\n", + "adding: mem time449, current time 484, horizon 35\n", + "adding: mem time450, current time 484, horizon 34\n", + "adding: mem time451, current time 484, horizon 33\n", + "adding: mem time452, current time 484, horizon 32\n", + "adding: mem time453, current time 484, horizon 31\n", + "adding: mem time454, current time 484, horizon 30\n", + "adding: mem time455, current time 484, horizon 29\n", + "adding: mem time456, current time 484, horizon 28\n", + "adding: mem time457, current time 484, horizon 27\n", + "adding: mem time458, current time 484, horizon 26\n", + "adding: mem time459, current time 484, horizon 25\n", + "adding: mem time460, current time 484, horizon 24\n", + "adding: mem time461, current time 484, horizon 23\n", + "adding: mem time462, current time 484, horizon 22\n", + "adding: mem time463, current time 484, horizon 21\n", + "adding: mem time464, current time 484, horizon 20\n", + "adding: mem time465, current time 484, horizon 19\n", + "adding: mem time466, current time 484, horizon 18\n", + "adding: mem time467, current time 484, horizon 17\n", + "adding: mem time468, current time 484, horizon 16\n", + "adding: mem time469, current time 484, horizon 15\n", + "adding: mem time470, current time 484, horizon 14\n", + "adding: mem time471, current time 484, horizon 13\n", + "adding: mem time472, current time 484, horizon 12\n", + "adding: mem time473, current time 484, horizon 11\n", + "adding: mem time474, current time 484, horizon 10\n", + "adding: mem time475, current time 484, horizon 9\n", + "adding: mem time476, current time 484, horizon 8\n", + "adding: mem time477, current time 484, horizon 7\n", + "adding: mem time478, current time 484, horizon 6\n", + "adding: mem time479, current time 484, horizon 5\n", + "adding: mem time480, current time 484, horizon 4\n", + "adding: mem time481, current time 484, horizon 3\n", + "adding: mem time482, current time 484, horizon 2\n", + "adding: mem time483, current time 484, horizon 1\n", + "adding: mem time400, current time 485, horizon 85\n", + "adding: mem time401, current time 485, horizon 84\n", + "adding: mem time402, current time 485, horizon 83\n", + "adding: mem time403, current time 485, horizon 82\n", + "adding: mem time404, current time 485, horizon 81\n", + "adding: mem time405, current time 485, horizon 80\n", + "adding: mem time406, current time 485, horizon 79\n", + "adding: mem time407, current time 485, horizon 78\n", + "adding: mem time408, current time 485, horizon 77\n", + "adding: mem time409, current time 485, horizon 76\n", + "adding: mem time410, current time 485, horizon 75\n", + "adding: mem time411, current time 485, horizon 74\n", + "adding: mem time412, current time 485, horizon 73\n", + "adding: mem time413, current time 485, horizon 72\n", + "adding: mem time414, current time 485, horizon 71\n", + "adding: mem time415, current time 485, horizon 70\n", + "adding: mem time416, current time 485, horizon 69\n", + "adding: mem time417, current time 485, horizon 68\n", + "adding: mem time418, current time 485, horizon 67\n", + "adding: mem time419, current time 485, horizon 66\n", + "adding: mem time420, current time 485, horizon 65\n", + "adding: mem time421, current time 485, horizon 64\n", + "adding: mem time422, current time 485, horizon 63\n", + "adding: mem time423, current time 485, horizon 62\n", + "adding: mem time424, current time 485, horizon 61\n", + "adding: mem time425, current time 485, horizon 60\n", + "adding: mem time426, current time 485, horizon 59\n", + "adding: mem time427, current time 485, horizon 58\n", + "adding: mem time428, current time 485, horizon 57\n", + "adding: mem time429, current time 485, horizon 56\n", + "adding: mem time430, current time 485, horizon 55\n", + "adding: mem time431, current time 485, horizon 54\n", + "adding: mem time432, current time 485, horizon 53\n", + "adding: mem time433, current time 485, horizon 52\n", + "adding: mem time434, current time 485, horizon 51\n", + "adding: mem time435, current time 485, horizon 50\n", + "adding: mem time436, current time 485, horizon 49\n", + "adding: mem time437, current time 485, horizon 48\n", + "adding: mem time438, current time 485, horizon 47\n", + "adding: mem time439, current time 485, horizon 46\n", + "adding: mem time440, current time 485, horizon 45\n", + "adding: mem time441, current time 485, horizon 44\n", + "adding: mem time442, current time 485, horizon 43\n", + "adding: mem time443, current time 485, horizon 42\n", + "adding: mem time444, current time 485, horizon 41\n", + "adding: mem time445, current time 485, horizon 40\n", + "adding: mem time446, current time 485, horizon 39\n", + "adding: mem time447, current time 485, horizon 38\n", + "adding: mem time448, current time 485, horizon 37\n", + "adding: mem time449, current time 485, horizon 36\n", + "adding: mem time450, current time 485, horizon 35\n", + "adding: mem time451, current time 485, horizon 34\n", + "adding: mem time452, current time 485, horizon 33\n", + "adding: mem time453, current time 485, horizon 32\n", + "adding: mem time454, current time 485, horizon 31\n", + "adding: mem time455, current time 485, horizon 30\n", + "adding: mem time456, current time 485, horizon 29\n", + "adding: mem time457, current time 485, horizon 28\n", + "adding: mem time458, current time 485, horizon 27\n", + "adding: mem time459, current time 485, horizon 26\n", + "adding: mem time460, current time 485, horizon 25\n", + "adding: mem time461, current time 485, horizon 24\n", + "adding: mem time462, current time 485, horizon 23\n", + "adding: mem time463, current time 485, horizon 22\n", + "adding: mem time464, current time 485, horizon 21\n", + "adding: mem time465, current time 485, horizon 20\n", + "adding: mem time466, current time 485, horizon 19\n", + "adding: mem time467, current time 485, horizon 18\n", + "adding: mem time468, current time 485, horizon 17\n", + "adding: mem time469, current time 485, horizon 16\n", + "adding: mem time470, current time 485, horizon 15\n", + "adding: mem time471, current time 485, horizon 14\n", + "adding: mem time472, current time 485, horizon 13\n", + "adding: mem time473, current time 485, horizon 12\n", + "adding: mem time474, current time 485, horizon 11\n", + "adding: mem time475, current time 485, horizon 10\n", + "adding: mem time476, current time 485, horizon 9\n", + "adding: mem time477, current time 485, horizon 8\n", + "adding: mem time478, current time 485, horizon 7\n", + "adding: mem time479, current time 485, horizon 6\n", + "adding: mem time480, current time 485, horizon 5\n", + "adding: mem time481, current time 485, horizon 4\n", + "adding: mem time482, current time 485, horizon 3\n", + "adding: mem time483, current time 485, horizon 2\n", + "adding: mem time484, current time 485, horizon 1\n", + "adding: mem time400, current time 486, horizon 86\n", + "adding: mem time401, current time 486, horizon 85\n", + "adding: mem time402, current time 486, horizon 84\n", + "adding: mem time403, current time 486, horizon 83\n", + "adding: mem time404, current time 486, horizon 82\n", + "adding: mem time405, current time 486, horizon 81\n", + "adding: mem time406, current time 486, horizon 80\n", + "adding: mem time407, current time 486, horizon 79\n", + "adding: mem time408, current time 486, horizon 78\n", + "adding: mem time409, current time 486, horizon 77\n", + "adding: mem time410, current time 486, horizon 76\n", + "adding: mem time411, current time 486, horizon 75\n", + "adding: mem time412, current time 486, horizon 74\n", + "adding: mem time413, current time 486, horizon 73\n", + "adding: mem time414, current time 486, horizon 72\n", + "adding: mem time415, current time 486, horizon 71\n", + "adding: mem time416, current time 486, horizon 70\n", + "adding: mem time417, current time 486, horizon 69\n", + "adding: mem time418, current time 486, horizon 68\n", + "adding: mem time419, current time 486, horizon 67\n", + "adding: mem time420, current time 486, horizon 66\n", + "adding: mem time421, current time 486, horizon 65\n", + "adding: mem time422, current time 486, horizon 64\n", + "adding: mem time423, current time 486, horizon 63\n", + "adding: mem time424, current time 486, horizon 62\n", + "adding: mem time425, current time 486, horizon 61\n", + "adding: mem time426, current time 486, horizon 60\n", + "adding: mem time427, current time 486, horizon 59\n", + "adding: mem time428, current time 486, horizon 58\n", + "adding: mem time429, current time 486, horizon 57\n", + "adding: mem time430, current time 486, horizon 56\n", + "adding: mem time431, current time 486, horizon 55\n", + "adding: mem time432, current time 486, horizon 54\n", + "adding: mem time433, current time 486, horizon 53\n", + "adding: mem time434, current time 486, horizon 52\n", + "adding: mem time435, current time 486, horizon 51\n", + "adding: mem time436, current time 486, horizon 50\n", + "adding: mem time437, current time 486, horizon 49\n", + "adding: mem time438, current time 486, horizon 48\n", + "adding: mem time439, current time 486, horizon 47\n", + "adding: mem time440, current time 486, horizon 46\n", + "adding: mem time441, current time 486, horizon 45\n", + "adding: mem time442, current time 486, horizon 44\n", + "adding: mem time443, current time 486, horizon 43\n", + "adding: mem time444, current time 486, horizon 42\n", + "adding: mem time445, current time 486, horizon 41\n", + "adding: mem time446, current time 486, horizon 40\n", + "adding: mem time447, current time 486, horizon 39\n", + "adding: mem time448, current time 486, horizon 38\n", + "adding: mem time449, current time 486, horizon 37\n", + "adding: mem time450, current time 486, horizon 36\n", + "adding: mem time451, current time 486, horizon 35\n", + "adding: mem time452, current time 486, horizon 34\n", + "adding: mem time453, current time 486, horizon 33\n", + "adding: mem time454, current time 486, horizon 32\n", + "adding: mem time455, current time 486, horizon 31\n", + "adding: mem time456, current time 486, horizon 30\n", + "adding: mem time457, current time 486, horizon 29\n", + "adding: mem time458, current time 486, horizon 28\n", + "adding: mem time459, current time 486, horizon 27\n", + "adding: mem time460, current time 486, horizon 26\n", + "adding: mem time461, current time 486, horizon 25\n", + "adding: mem time462, current time 486, horizon 24\n", + "adding: mem time463, current time 486, horizon 23\n", + "adding: mem time464, current time 486, horizon 22\n", + "adding: mem time465, current time 486, horizon 21\n", + "adding: mem time466, current time 486, horizon 20\n", + "adding: mem time467, current time 486, horizon 19\n", + "adding: mem time468, current time 486, horizon 18\n", + "adding: mem time469, current time 486, horizon 17\n", + "adding: mem time470, current time 486, horizon 16\n", + "adding: mem time471, current time 486, horizon 15\n", + "adding: mem time472, current time 486, horizon 14\n", + "adding: mem time473, current time 486, horizon 13\n", + "adding: mem time474, current time 486, horizon 12\n", + "adding: mem time475, current time 486, horizon 11\n", + "adding: mem time476, current time 486, horizon 10\n", + "adding: mem time477, current time 486, horizon 9\n", + "adding: mem time478, current time 486, horizon 8\n", + "adding: mem time479, current time 486, horizon 7\n", + "adding: mem time480, current time 486, horizon 6\n", + "adding: mem time481, current time 486, horizon 5\n", + "adding: mem time482, current time 486, horizon 4\n", + "adding: mem time483, current time 486, horizon 3\n", + "adding: mem time484, current time 486, horizon 2\n", + "adding: mem time485, current time 486, horizon 1\n", + "adding: mem time400, current time 487, horizon 87\n", + "adding: mem time401, current time 487, horizon 86\n", + "adding: mem time402, current time 487, horizon 85\n", + "adding: mem time403, current time 487, horizon 84\n", + "adding: mem time404, current time 487, horizon 83\n", + "adding: mem time405, current time 487, horizon 82\n", + "adding: mem time406, current time 487, horizon 81\n", + "adding: mem time407, current time 487, horizon 80\n", + "adding: mem time408, current time 487, horizon 79\n", + "adding: mem time409, current time 487, horizon 78\n", + "adding: mem time410, current time 487, horizon 77\n", + "adding: mem time411, current time 487, horizon 76\n", + "adding: mem time412, current time 487, horizon 75\n", + "adding: mem time413, current time 487, horizon 74\n", + "adding: mem time414, current time 487, horizon 73\n", + "adding: mem time415, current time 487, horizon 72\n", + "adding: mem time416, current time 487, horizon 71\n", + "adding: mem time417, current time 487, horizon 70\n", + "adding: mem time418, current time 487, horizon 69\n", + "adding: mem time419, current time 487, horizon 68\n", + "adding: mem time420, current time 487, horizon 67\n", + "adding: mem time421, current time 487, horizon 66\n", + "adding: mem time422, current time 487, horizon 65\n", + "adding: mem time423, current time 487, horizon 64\n", + "adding: mem time424, current time 487, horizon 63\n", + "adding: mem time425, current time 487, horizon 62\n", + "adding: mem time426, current time 487, horizon 61\n", + "adding: mem time427, current time 487, horizon 60\n", + "adding: mem time428, current time 487, horizon 59\n", + "adding: mem time429, current time 487, horizon 58\n", + "adding: mem time430, current time 487, horizon 57\n", + "adding: mem time431, current time 487, horizon 56\n", + "adding: mem time432, current time 487, horizon 55\n", + "adding: mem time433, current time 487, horizon 54\n", + "adding: mem time434, current time 487, horizon 53\n", + "adding: mem time435, current time 487, horizon 52\n", + "adding: mem time436, current time 487, horizon 51\n", + "adding: mem time437, current time 487, horizon 50\n", + "adding: mem time438, current time 487, horizon 49\n", + "adding: mem time439, current time 487, horizon 48\n", + "adding: mem time440, current time 487, horizon 47\n", + "adding: mem time441, current time 487, horizon 46\n", + "adding: mem time442, current time 487, horizon 45\n", + "adding: mem time443, current time 487, horizon 44\n", + "adding: mem time444, current time 487, horizon 43\n", + "adding: mem time445, current time 487, horizon 42\n", + "adding: mem time446, current time 487, horizon 41\n", + "adding: mem time447, current time 487, horizon 40\n", + "adding: mem time448, current time 487, horizon 39\n", + "adding: mem time449, current time 487, horizon 38\n", + "adding: mem time450, current time 487, horizon 37\n", + "adding: mem time451, current time 487, horizon 36\n", + "adding: mem time452, current time 487, horizon 35\n", + "adding: mem time453, current time 487, horizon 34\n", + "adding: mem time454, current time 487, horizon 33\n", + "adding: mem time455, current time 487, horizon 32\n", + "adding: mem time456, current time 487, horizon 31\n", + "adding: mem time457, current time 487, horizon 30\n", + "adding: mem time458, current time 487, horizon 29\n", + "adding: mem time459, current time 487, horizon 28\n", + "adding: mem time460, current time 487, horizon 27\n", + "adding: mem time461, current time 487, horizon 26\n", + "adding: mem time462, current time 487, horizon 25\n", + "adding: mem time463, current time 487, horizon 24\n", + "adding: mem time464, current time 487, horizon 23\n", + "adding: mem time465, current time 487, horizon 22\n", + "adding: mem time466, current time 487, horizon 21\n", + "adding: mem time467, current time 487, horizon 20\n", + "adding: mem time468, current time 487, horizon 19\n", + "adding: mem time469, current time 487, horizon 18\n", + "adding: mem time470, current time 487, horizon 17\n", + "adding: mem time471, current time 487, horizon 16\n", + "adding: mem time472, current time 487, horizon 15\n", + "adding: mem time473, current time 487, horizon 14\n", + "adding: mem time474, current time 487, horizon 13\n", + "adding: mem time475, current time 487, horizon 12\n", + "adding: mem time476, current time 487, horizon 11\n", + "adding: mem time477, current time 487, horizon 10\n", + "adding: mem time478, current time 487, horizon 9\n", + "adding: mem time479, current time 487, horizon 8\n", + "adding: mem time480, current time 487, horizon 7\n", + "adding: mem time481, current time 487, horizon 6\n", + "adding: mem time482, current time 487, horizon 5\n", + "adding: mem time483, current time 487, horizon 4\n", + "adding: mem time484, current time 487, horizon 3\n", + "adding: mem time485, current time 487, horizon 2\n", + "adding: mem time486, current time 487, horizon 1\n", + "adding: mem time400, current time 488, horizon 88\n", + "adding: mem time401, current time 488, horizon 87\n", + "adding: mem time402, current time 488, horizon 86\n", + "adding: mem time403, current time 488, horizon 85\n", + "adding: mem time404, current time 488, horizon 84\n", + "adding: mem time405, current time 488, horizon 83\n", + "adding: mem time406, current time 488, horizon 82\n", + "adding: mem time407, current time 488, horizon 81\n", + "adding: mem time408, current time 488, horizon 80\n", + "adding: mem time409, current time 488, horizon 79\n", + "adding: mem time410, current time 488, horizon 78\n", + "adding: mem time411, current time 488, horizon 77\n", + "adding: mem time412, current time 488, horizon 76\n", + "adding: mem time413, current time 488, horizon 75\n", + "adding: mem time414, current time 488, horizon 74\n", + "adding: mem time415, current time 488, horizon 73\n", + "adding: mem time416, current time 488, horizon 72\n", + "adding: mem time417, current time 488, horizon 71\n", + "adding: mem time418, current time 488, horizon 70\n", + "adding: mem time419, current time 488, horizon 69\n", + "adding: mem time420, current time 488, horizon 68\n", + "adding: mem time421, current time 488, horizon 67\n", + "adding: mem time422, current time 488, horizon 66\n", + "adding: mem time423, current time 488, horizon 65\n", + "adding: mem time424, current time 488, horizon 64\n", + "adding: mem time425, current time 488, horizon 63\n", + "adding: mem time426, current time 488, horizon 62\n", + "adding: mem time427, current time 488, horizon 61\n", + "adding: mem time428, current time 488, horizon 60\n", + "adding: mem time429, current time 488, horizon 59\n", + "adding: mem time430, current time 488, horizon 58\n", + "adding: mem time431, current time 488, horizon 57\n", + "adding: mem time432, current time 488, horizon 56\n", + "adding: mem time433, current time 488, horizon 55\n", + "adding: mem time434, current time 488, horizon 54\n", + "adding: mem time435, current time 488, horizon 53\n", + "adding: mem time436, current time 488, horizon 52\n", + "adding: mem time437, current time 488, horizon 51\n", + "adding: mem time438, current time 488, horizon 50\n", + "adding: mem time439, current time 488, horizon 49\n", + "adding: mem time440, current time 488, horizon 48\n", + "adding: mem time441, current time 488, horizon 47\n", + "adding: mem time442, current time 488, horizon 46\n", + "adding: mem time443, current time 488, horizon 45\n", + "adding: mem time444, current time 488, horizon 44\n", + "adding: mem time445, current time 488, horizon 43\n", + "adding: mem time446, current time 488, horizon 42\n", + "adding: mem time447, current time 488, horizon 41\n", + "adding: mem time448, current time 488, horizon 40\n", + "adding: mem time449, current time 488, horizon 39\n", + "adding: mem time450, current time 488, horizon 38\n", + "adding: mem time451, current time 488, horizon 37\n", + "adding: mem time452, current time 488, horizon 36\n", + "adding: mem time453, current time 488, horizon 35\n", + "adding: mem time454, current time 488, horizon 34\n", + "adding: mem time455, current time 488, horizon 33\n", + "adding: mem time456, current time 488, horizon 32\n", + "adding: mem time457, current time 488, horizon 31\n", + "adding: mem time458, current time 488, horizon 30\n", + "adding: mem time459, current time 488, horizon 29\n", + "adding: mem time460, current time 488, horizon 28\n", + "adding: mem time461, current time 488, horizon 27\n", + "adding: mem time462, current time 488, horizon 26\n", + "adding: mem time463, current time 488, horizon 25\n", + "adding: mem time464, current time 488, horizon 24\n", + "adding: mem time465, current time 488, horizon 23\n", + "adding: mem time466, current time 488, horizon 22\n", + "adding: mem time467, current time 488, horizon 21\n", + "adding: mem time468, current time 488, horizon 20\n", + "adding: mem time469, current time 488, horizon 19\n", + "adding: mem time470, current time 488, horizon 18\n", + "adding: mem time471, current time 488, horizon 17\n", + "adding: mem time472, current time 488, horizon 16\n", + "adding: mem time473, current time 488, horizon 15\n", + "adding: mem time474, current time 488, horizon 14\n", + "adding: mem time475, current time 488, horizon 13\n", + "adding: mem time476, current time 488, horizon 12\n", + "adding: mem time477, current time 488, horizon 11\n", + "adding: mem time478, current time 488, horizon 10\n", + "adding: mem time479, current time 488, horizon 9\n", + "adding: mem time480, current time 488, horizon 8\n", + "adding: mem time481, current time 488, horizon 7\n", + "adding: mem time482, current time 488, horizon 6\n", + "adding: mem time483, current time 488, horizon 5\n", + "adding: mem time484, current time 488, horizon 4\n", + "adding: mem time485, current time 488, horizon 3\n", + "adding: mem time486, current time 488, horizon 2\n", + "adding: mem time487, current time 488, horizon 1\n", + "adding: mem time400, current time 489, horizon 89\n", + "adding: mem time401, current time 489, horizon 88\n", + "adding: mem time402, current time 489, horizon 87\n", + "adding: mem time403, current time 489, horizon 86\n", + "adding: mem time404, current time 489, horizon 85\n", + "adding: mem time405, current time 489, horizon 84\n", + "adding: mem time406, current time 489, horizon 83\n", + "adding: mem time407, current time 489, horizon 82\n", + "adding: mem time408, current time 489, horizon 81\n", + "adding: mem time409, current time 489, horizon 80\n", + "adding: mem time410, current time 489, horizon 79\n", + "adding: mem time411, current time 489, horizon 78\n", + "adding: mem time412, current time 489, horizon 77\n", + "adding: mem time413, current time 489, horizon 76\n", + "adding: mem time414, current time 489, horizon 75\n", + "adding: mem time415, current time 489, horizon 74\n", + "adding: mem time416, current time 489, horizon 73\n", + "adding: mem time417, current time 489, horizon 72\n", + "adding: mem time418, current time 489, horizon 71\n", + "adding: mem time419, current time 489, horizon 70\n", + "adding: mem time420, current time 489, horizon 69\n", + "adding: mem time421, current time 489, horizon 68\n", + "adding: mem time422, current time 489, horizon 67\n", + "adding: mem time423, current time 489, horizon 66\n", + "adding: mem time424, current time 489, horizon 65\n", + "adding: mem time425, current time 489, horizon 64\n", + "adding: mem time426, current time 489, horizon 63\n", + "adding: mem time427, current time 489, horizon 62\n", + "adding: mem time428, current time 489, horizon 61\n", + "adding: mem time429, current time 489, horizon 60\n", + "adding: mem time430, current time 489, horizon 59\n", + "adding: mem time431, current time 489, horizon 58\n", + "adding: mem time432, current time 489, horizon 57\n", + "adding: mem time433, current time 489, horizon 56\n", + "adding: mem time434, current time 489, horizon 55\n", + "adding: mem time435, current time 489, horizon 54\n", + "adding: mem time436, current time 489, horizon 53\n", + "adding: mem time437, current time 489, horizon 52\n", + "adding: mem time438, current time 489, horizon 51\n", + "adding: mem time439, current time 489, horizon 50\n", + "adding: mem time440, current time 489, horizon 49\n", + "adding: mem time441, current time 489, horizon 48\n", + "adding: mem time442, current time 489, horizon 47\n", + "adding: mem time443, current time 489, horizon 46\n", + "adding: mem time444, current time 489, horizon 45\n", + "adding: mem time445, current time 489, horizon 44\n", + "adding: mem time446, current time 489, horizon 43\n", + "adding: mem time447, current time 489, horizon 42\n", + "adding: mem time448, current time 489, horizon 41\n", + "adding: mem time449, current time 489, horizon 40\n", + "adding: mem time450, current time 489, horizon 39\n", + "adding: mem time451, current time 489, horizon 38\n", + "adding: mem time452, current time 489, horizon 37\n", + "adding: mem time453, current time 489, horizon 36\n", + "adding: mem time454, current time 489, horizon 35\n", + "adding: mem time455, current time 489, horizon 34\n", + "adding: mem time456, current time 489, horizon 33\n", + "adding: mem time457, current time 489, horizon 32\n", + "adding: mem time458, current time 489, horizon 31\n", + "adding: mem time459, current time 489, horizon 30\n", + "adding: mem time460, current time 489, horizon 29\n", + "adding: mem time461, current time 489, horizon 28\n", + "adding: mem time462, current time 489, horizon 27\n", + "adding: mem time463, current time 489, horizon 26\n", + "adding: mem time464, current time 489, horizon 25\n", + "adding: mem time465, current time 489, horizon 24\n", + "adding: mem time466, current time 489, horizon 23\n", + "adding: mem time467, current time 489, horizon 22\n", + "adding: mem time468, current time 489, horizon 21\n", + "adding: mem time469, current time 489, horizon 20\n", + "adding: mem time470, current time 489, horizon 19\n", + "adding: mem time471, current time 489, horizon 18\n", + "adding: mem time472, current time 489, horizon 17\n", + "adding: mem time473, current time 489, horizon 16\n", + "adding: mem time474, current time 489, horizon 15\n", + "adding: mem time475, current time 489, horizon 14\n", + "adding: mem time476, current time 489, horizon 13\n", + "adding: mem time477, current time 489, horizon 12\n", + "adding: mem time478, current time 489, horizon 11\n", + "adding: mem time479, current time 489, horizon 10\n", + "adding: mem time480, current time 489, horizon 9\n", + "adding: mem time481, current time 489, horizon 8\n", + "adding: mem time482, current time 489, horizon 7\n", + "adding: mem time483, current time 489, horizon 6\n", + "adding: mem time484, current time 489, horizon 5\n", + "adding: mem time485, current time 489, horizon 4\n", + "adding: mem time486, current time 489, horizon 3\n", + "adding: mem time487, current time 489, horizon 2\n", + "adding: mem time488, current time 489, horizon 1\n", + "adding: mem time400, current time 490, horizon 90\n", + "adding: mem time401, current time 490, horizon 89\n", + "adding: mem time402, current time 490, horizon 88\n", + "adding: mem time403, current time 490, horizon 87\n", + "adding: mem time404, current time 490, horizon 86\n", + "adding: mem time405, current time 490, horizon 85\n", + "adding: mem time406, current time 490, horizon 84\n", + "adding: mem time407, current time 490, horizon 83\n", + "adding: mem time408, current time 490, horizon 82\n", + "adding: mem time409, current time 490, horizon 81\n", + "adding: mem time410, current time 490, horizon 80\n", + "adding: mem time411, current time 490, horizon 79\n", + "adding: mem time412, current time 490, horizon 78\n", + "adding: mem time413, current time 490, horizon 77\n", + "adding: mem time414, current time 490, horizon 76\n", + "adding: mem time415, current time 490, horizon 75\n", + "adding: mem time416, current time 490, horizon 74\n", + "adding: mem time417, current time 490, horizon 73\n", + "adding: mem time418, current time 490, horizon 72\n", + "adding: mem time419, current time 490, horizon 71\n", + "adding: mem time420, current time 490, horizon 70\n", + "adding: mem time421, current time 490, horizon 69\n", + "adding: mem time422, current time 490, horizon 68\n", + "adding: mem time423, current time 490, horizon 67\n", + "adding: mem time424, current time 490, horizon 66\n", + "adding: mem time425, current time 490, horizon 65\n", + "adding: mem time426, current time 490, horizon 64\n", + "adding: mem time427, current time 490, horizon 63\n", + "adding: mem time428, current time 490, horizon 62\n", + "adding: mem time429, current time 490, horizon 61\n", + "adding: mem time430, current time 490, horizon 60\n", + "adding: mem time431, current time 490, horizon 59\n", + "adding: mem time432, current time 490, horizon 58\n", + "adding: mem time433, current time 490, horizon 57\n", + "adding: mem time434, current time 490, horizon 56\n", + "adding: mem time435, current time 490, horizon 55\n", + "adding: mem time436, current time 490, horizon 54\n", + "adding: mem time437, current time 490, horizon 53\n", + "adding: mem time438, current time 490, horizon 52\n", + "adding: mem time439, current time 490, horizon 51\n", + "adding: mem time440, current time 490, horizon 50\n", + "adding: mem time441, current time 490, horizon 49\n", + "adding: mem time442, current time 490, horizon 48\n", + "adding: mem time443, current time 490, horizon 47\n", + "adding: mem time444, current time 490, horizon 46\n", + "adding: mem time445, current time 490, horizon 45\n", + "adding: mem time446, current time 490, horizon 44\n", + "adding: mem time447, current time 490, horizon 43\n", + "adding: mem time448, current time 490, horizon 42\n", + "adding: mem time449, current time 490, horizon 41\n", + "adding: mem time450, current time 490, horizon 40\n", + "adding: mem time451, current time 490, horizon 39\n", + "adding: mem time452, current time 490, horizon 38\n", + "adding: mem time453, current time 490, horizon 37\n", + "adding: mem time454, current time 490, horizon 36\n", + "adding: mem time455, current time 490, horizon 35\n", + "adding: mem time456, current time 490, horizon 34\n", + "adding: mem time457, current time 490, horizon 33\n", + "adding: mem time458, current time 490, horizon 32\n", + "adding: mem time459, current time 490, horizon 31\n", + "adding: mem time460, current time 490, horizon 30\n", + "adding: mem time461, current time 490, horizon 29\n", + "adding: mem time462, current time 490, horizon 28\n", + "adding: mem time463, current time 490, horizon 27\n", + "adding: mem time464, current time 490, horizon 26\n", + "adding: mem time465, current time 490, horizon 25\n", + "adding: mem time466, current time 490, horizon 24\n", + "adding: mem time467, current time 490, horizon 23\n", + "adding: mem time468, current time 490, horizon 22\n", + "adding: mem time469, current time 490, horizon 21\n", + "adding: mem time470, current time 490, horizon 20\n", + "adding: mem time471, current time 490, horizon 19\n", + "adding: mem time472, current time 490, horizon 18\n", + "adding: mem time473, current time 490, horizon 17\n", + "adding: mem time474, current time 490, horizon 16\n", + "adding: mem time475, current time 490, horizon 15\n", + "adding: mem time476, current time 490, horizon 14\n", + "adding: mem time477, current time 490, horizon 13\n", + "adding: mem time478, current time 490, horizon 12\n", + "adding: mem time479, current time 490, horizon 11\n", + "adding: mem time480, current time 490, horizon 10\n", + "adding: mem time481, current time 490, horizon 9\n", + "adding: mem time482, current time 490, horizon 8\n", + "adding: mem time483, current time 490, horizon 7\n", + "adding: mem time484, current time 490, horizon 6\n", + "adding: mem time485, current time 490, horizon 5\n", + "adding: mem time486, current time 490, horizon 4\n", + "adding: mem time487, current time 490, horizon 3\n", + "adding: mem time488, current time 490, horizon 2\n", + "adding: mem time489, current time 490, horizon 1\n", + "adding: mem time400, current time 491, horizon 91\n", + "adding: mem time401, current time 491, horizon 90\n", + "adding: mem time402, current time 491, horizon 89\n", + "adding: mem time403, current time 491, horizon 88\n", + "adding: mem time404, current time 491, horizon 87\n", + "adding: mem time405, current time 491, horizon 86\n", + "adding: mem time406, current time 491, horizon 85\n", + "adding: mem time407, current time 491, horizon 84\n", + "adding: mem time408, current time 491, horizon 83\n", + "adding: mem time409, current time 491, horizon 82\n", + "adding: mem time410, current time 491, horizon 81\n", + "adding: mem time411, current time 491, horizon 80\n", + "adding: mem time412, current time 491, horizon 79\n", + "adding: mem time413, current time 491, horizon 78\n", + "adding: mem time414, current time 491, horizon 77\n", + "adding: mem time415, current time 491, horizon 76\n", + "adding: mem time416, current time 491, horizon 75\n", + "adding: mem time417, current time 491, horizon 74\n", + "adding: mem time418, current time 491, horizon 73\n", + "adding: mem time419, current time 491, horizon 72\n", + "adding: mem time420, current time 491, horizon 71\n", + "adding: mem time421, current time 491, horizon 70\n", + "adding: mem time422, current time 491, horizon 69\n", + "adding: mem time423, current time 491, horizon 68\n", + "adding: mem time424, current time 491, horizon 67\n", + "adding: mem time425, current time 491, horizon 66\n", + "adding: mem time426, current time 491, horizon 65\n", + "adding: mem time427, current time 491, horizon 64\n", + "adding: mem time428, current time 491, horizon 63\n", + "adding: mem time429, current time 491, horizon 62\n", + "adding: mem time430, current time 491, horizon 61\n", + "adding: mem time431, current time 491, horizon 60\n", + "adding: mem time432, current time 491, horizon 59\n", + "adding: mem time433, current time 491, horizon 58\n", + "adding: mem time434, current time 491, horizon 57\n", + "adding: mem time435, current time 491, horizon 56\n", + "adding: mem time436, current time 491, horizon 55\n", + "adding: mem time437, current time 491, horizon 54\n", + "adding: mem time438, current time 491, horizon 53\n", + "adding: mem time439, current time 491, horizon 52\n", + "adding: mem time440, current time 491, horizon 51\n", + "adding: mem time441, current time 491, horizon 50\n", + "adding: mem time442, current time 491, horizon 49\n", + "adding: mem time443, current time 491, horizon 48\n", + "adding: mem time444, current time 491, horizon 47\n", + "adding: mem time445, current time 491, horizon 46\n", + "adding: mem time446, current time 491, horizon 45\n", + "adding: mem time447, current time 491, horizon 44\n", + "adding: mem time448, current time 491, horizon 43\n", + "adding: mem time449, current time 491, horizon 42\n", + "adding: mem time450, current time 491, horizon 41\n", + "adding: mem time451, current time 491, horizon 40\n", + "adding: mem time452, current time 491, horizon 39\n", + "adding: mem time453, current time 491, horizon 38\n", + "adding: mem time454, current time 491, horizon 37\n", + "adding: mem time455, current time 491, horizon 36\n", + "adding: mem time456, current time 491, horizon 35\n", + "adding: mem time457, current time 491, horizon 34\n", + "adding: mem time458, current time 491, horizon 33\n", + "adding: mem time459, current time 491, horizon 32\n", + "adding: mem time460, current time 491, horizon 31\n", + "adding: mem time461, current time 491, horizon 30\n", + "adding: mem time462, current time 491, horizon 29\n", + "adding: mem time463, current time 491, horizon 28\n", + "adding: mem time464, current time 491, horizon 27\n", + "adding: mem time465, current time 491, horizon 26\n", + "adding: mem time466, current time 491, horizon 25\n", + "adding: mem time467, current time 491, horizon 24\n", + "adding: mem time468, current time 491, horizon 23\n", + "adding: mem time469, current time 491, horizon 22\n", + "adding: mem time470, current time 491, horizon 21\n", + "adding: mem time471, current time 491, horizon 20\n", + "adding: mem time472, current time 491, horizon 19\n", + "adding: mem time473, current time 491, horizon 18\n", + "adding: mem time474, current time 491, horizon 17\n", + "adding: mem time475, current time 491, horizon 16\n", + "adding: mem time476, current time 491, horizon 15\n", + "adding: mem time477, current time 491, horizon 14\n", + "adding: mem time478, current time 491, horizon 13\n", + "adding: mem time479, current time 491, horizon 12\n", + "adding: mem time480, current time 491, horizon 11\n", + "adding: mem time481, current time 491, horizon 10\n", + "adding: mem time482, current time 491, horizon 9\n", + "adding: mem time483, current time 491, horizon 8\n", + "adding: mem time484, current time 491, horizon 7\n", + "adding: mem time485, current time 491, horizon 6\n", + "adding: mem time486, current time 491, horizon 5\n", + "adding: mem time487, current time 491, horizon 4\n", + "adding: mem time488, current time 491, horizon 3\n", + "adding: mem time489, current time 491, horizon 2\n", + "adding: mem time490, current time 491, horizon 1\n", + "adding: mem time400, current time 492, horizon 92\n", + "adding: mem time401, current time 492, horizon 91\n", + "adding: mem time402, current time 492, horizon 90\n", + "adding: mem time403, current time 492, horizon 89\n", + "adding: mem time404, current time 492, horizon 88\n", + "adding: mem time405, current time 492, horizon 87\n", + "adding: mem time406, current time 492, horizon 86\n", + "adding: mem time407, current time 492, horizon 85\n", + "adding: mem time408, current time 492, horizon 84\n", + "adding: mem time409, current time 492, horizon 83\n", + "adding: mem time410, current time 492, horizon 82\n", + "adding: mem time411, current time 492, horizon 81\n", + "adding: mem time412, current time 492, horizon 80\n", + "adding: mem time413, current time 492, horizon 79\n", + "adding: mem time414, current time 492, horizon 78\n", + "adding: mem time415, current time 492, horizon 77\n", + "adding: mem time416, current time 492, horizon 76\n", + "adding: mem time417, current time 492, horizon 75\n", + "adding: mem time418, current time 492, horizon 74\n", + "adding: mem time419, current time 492, horizon 73\n", + "adding: mem time420, current time 492, horizon 72\n", + "adding: mem time421, current time 492, horizon 71\n", + "adding: mem time422, current time 492, horizon 70\n", + "adding: mem time423, current time 492, horizon 69\n", + "adding: mem time424, current time 492, horizon 68\n", + "adding: mem time425, current time 492, horizon 67\n", + "adding: mem time426, current time 492, horizon 66\n", + "adding: mem time427, current time 492, horizon 65\n", + "adding: mem time428, current time 492, horizon 64\n", + "adding: mem time429, current time 492, horizon 63\n", + "adding: mem time430, current time 492, horizon 62\n", + "adding: mem time431, current time 492, horizon 61\n", + "adding: mem time432, current time 492, horizon 60\n", + "adding: mem time433, current time 492, horizon 59\n", + "adding: mem time434, current time 492, horizon 58\n", + "adding: mem time435, current time 492, horizon 57\n", + "adding: mem time436, current time 492, horizon 56\n", + "adding: mem time437, current time 492, horizon 55\n", + "adding: mem time438, current time 492, horizon 54\n", + "adding: mem time439, current time 492, horizon 53\n", + "adding: mem time440, current time 492, horizon 52\n", + "adding: mem time441, current time 492, horizon 51\n", + "adding: mem time442, current time 492, horizon 50\n", + "adding: mem time443, current time 492, horizon 49\n", + "adding: mem time444, current time 492, horizon 48\n", + "adding: mem time445, current time 492, horizon 47\n", + "adding: mem time446, current time 492, horizon 46\n", + "adding: mem time447, current time 492, horizon 45\n", + "adding: mem time448, current time 492, horizon 44\n", + "adding: mem time449, current time 492, horizon 43\n", + "adding: mem time450, current time 492, horizon 42\n", + "adding: mem time451, current time 492, horizon 41\n", + "adding: mem time452, current time 492, horizon 40\n", + "adding: mem time453, current time 492, horizon 39\n", + "adding: mem time454, current time 492, horizon 38\n", + "adding: mem time455, current time 492, horizon 37\n", + "adding: mem time456, current time 492, horizon 36\n", + "adding: mem time457, current time 492, horizon 35\n", + "adding: mem time458, current time 492, horizon 34\n", + "adding: mem time459, current time 492, horizon 33\n", + "adding: mem time460, current time 492, horizon 32\n", + "adding: mem time461, current time 492, horizon 31\n", + "adding: mem time462, current time 492, horizon 30\n", + "adding: mem time463, current time 492, horizon 29\n", + "adding: mem time464, current time 492, horizon 28\n", + "adding: mem time465, current time 492, horizon 27\n", + "adding: mem time466, current time 492, horizon 26\n", + "adding: mem time467, current time 492, horizon 25\n", + "adding: mem time468, current time 492, horizon 24\n", + "adding: mem time469, current time 492, horizon 23\n", + "adding: mem time470, current time 492, horizon 22\n", + "adding: mem time471, current time 492, horizon 21\n", + "adding: mem time472, current time 492, horizon 20\n", + "adding: mem time473, current time 492, horizon 19\n", + "adding: mem time474, current time 492, horizon 18\n", + "adding: mem time475, current time 492, horizon 17\n", + "adding: mem time476, current time 492, horizon 16\n", + "adding: mem time477, current time 492, horizon 15\n", + "adding: mem time478, current time 492, horizon 14\n", + "adding: mem time479, current time 492, horizon 13\n", + "adding: mem time480, current time 492, horizon 12\n", + "adding: mem time481, current time 492, horizon 11\n", + "adding: mem time482, current time 492, horizon 10\n", + "adding: mem time483, current time 492, horizon 9\n", + "adding: mem time484, current time 492, horizon 8\n", + "adding: mem time485, current time 492, horizon 7\n", + "adding: mem time486, current time 492, horizon 6\n", + "adding: mem time487, current time 492, horizon 5\n", + "adding: mem time488, current time 492, horizon 4\n", + "adding: mem time489, current time 492, horizon 3\n", + "adding: mem time490, current time 492, horizon 2\n", + "adding: mem time491, current time 492, horizon 1\n", + "adding: mem time400, current time 493, horizon 93\n", + "adding: mem time401, current time 493, horizon 92\n", + "adding: mem time402, current time 493, horizon 91\n", + "adding: mem time403, current time 493, horizon 90\n", + "adding: mem time404, current time 493, horizon 89\n", + "adding: mem time405, current time 493, horizon 88\n", + "adding: mem time406, current time 493, horizon 87\n", + "adding: mem time407, current time 493, horizon 86\n", + "adding: mem time408, current time 493, horizon 85\n", + "adding: mem time409, current time 493, horizon 84\n", + "adding: mem time410, current time 493, horizon 83\n", + "adding: mem time411, current time 493, horizon 82\n", + "adding: mem time412, current time 493, horizon 81\n", + "adding: mem time413, current time 493, horizon 80\n", + "adding: mem time414, current time 493, horizon 79\n", + "adding: mem time415, current time 493, horizon 78\n", + "adding: mem time416, current time 493, horizon 77\n", + "adding: mem time417, current time 493, horizon 76\n", + "adding: mem time418, current time 493, horizon 75\n", + "adding: mem time419, current time 493, horizon 74\n", + "adding: mem time420, current time 493, horizon 73\n", + "adding: mem time421, current time 493, horizon 72\n", + "adding: mem time422, current time 493, horizon 71\n", + "adding: mem time423, current time 493, horizon 70\n", + "adding: mem time424, current time 493, horizon 69\n", + "adding: mem time425, current time 493, horizon 68\n", + "adding: mem time426, current time 493, horizon 67\n", + "adding: mem time427, current time 493, horizon 66\n", + "adding: mem time428, current time 493, horizon 65\n", + "adding: mem time429, current time 493, horizon 64\n", + "adding: mem time430, current time 493, horizon 63\n", + "adding: mem time431, current time 493, horizon 62\n", + "adding: mem time432, current time 493, horizon 61\n", + "adding: mem time433, current time 493, horizon 60\n", + "adding: mem time434, current time 493, horizon 59\n", + "adding: mem time435, current time 493, horizon 58\n", + "adding: mem time436, current time 493, horizon 57\n", + "adding: mem time437, current time 493, horizon 56\n", + "adding: mem time438, current time 493, horizon 55\n", + "adding: mem time439, current time 493, horizon 54\n", + "adding: mem time440, current time 493, horizon 53\n", + "adding: mem time441, current time 493, horizon 52\n", + "adding: mem time442, current time 493, horizon 51\n", + "adding: mem time443, current time 493, horizon 50\n", + "adding: mem time444, current time 493, horizon 49\n", + "adding: mem time445, current time 493, horizon 48\n", + "adding: mem time446, current time 493, horizon 47\n", + "adding: mem time447, current time 493, horizon 46\n", + "adding: mem time448, current time 493, horizon 45\n", + "adding: mem time449, current time 493, horizon 44\n", + "adding: mem time450, current time 493, horizon 43\n", + "adding: mem time451, current time 493, horizon 42\n", + "adding: mem time452, current time 493, horizon 41\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IOPub data rate exceeded.\n", + "The notebook server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--NotebookApp.iopub_data_rate_limit`.\n", + "\n", + "Current values:\n", + "NotebookApp.iopub_data_rate_limit=1000000.0 (bytes/sec)\n", + "NotebookApp.rate_limit_window=3.0 (secs)\n", + "\n" + ] } ], "source": [ - "# Create a trainer for the model\n", - "model_trainer = models.ModelTrainer(dynamics_model, optim_lr=1e-3, weight_decay=5e-5)\n", + "num_trials = 10\n", "\n", - "# Create visualization objects\n", - "fig, axs = plt.subplots(1, 2, figsize=(14, 3.75), gridspec_kw={\"width_ratios\": [1, 1]})\n", - "ax_text = axs[0].text(300, 50, \"\")\n", - " \n", - "# Main PETS loop\n", - "all_rewards = [0]\n", - "for trial in range(num_trials):\n", - " obs = env.reset() \n", + "step = 0\n", + "trial = 0\n", + "total_rewards = []\n", + "callback = None\n", + "while trial < num_trials:\n", + " traj = []\n", + " obs = env.reset()\n", " agent.reset()\n", - " \n", " done = False\n", " total_reward = 0.0\n", - " steps_trial = 0\n", - " update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n", " while not done:\n", - " # --------------- Model Training -----------------\n", - " if steps_trial == 0:\n", - " dynamics_model.update_normalizer(replay_buffer.get_all()) # update normalizer stats\n", - " \n", - " dataset_train, dataset_val = common_util.get_basic_buffer_iterators(\n", - " replay_buffer,\n", - " batch_size=cfg.overrides.model_batch_size,\n", - " val_ratio=cfg.overrides.validation_ratio,\n", - " ensemble_size=ensemble_size,\n", - " shuffle_each_epoch=True,\n", - " bootstrap_permutes=False, # build bootstrap dataset using sampling with replacement\n", - " )\n", - " \n", - " model_trainer.train(\n", - " dataset_train, \n", - " dataset_val=dataset_val, \n", - " num_epochs=50, \n", - " patience=50, \n", - " callback=train_callback,\n", - " silent=True)\n", + " action = agent.act(obs)\n", + " next_obs, reward, done, info = env.step(action)\n", + " if callback:\n", + " callback((obs, action, next_obs, reward, done))\n", "\n", - " # --- Doing env step using the agent and adding to model dataset ---\n", - " next_obs, reward, done, _ = common_util.step_env_and_add_to_buffer(\n", - " env, obs, agent, {}, replay_buffer)\n", - " \n", - " update_axes(\n", - " axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n", - " \n", " obs = next_obs\n", - " total_reward += reward\n", - " steps_trial += 1\n", + " traj.append((obs, step))\n", " \n", - " if steps_trial == trial_length:\n", - " break\n", - " \n", - " all_rewards.append(total_reward)\n", + " # if not the first step, iterate through memory and append each sub-trajectory\n", + " if len(traj[:-1]) > 0:\n", + " for obs_t, t in traj[:-1]:\n", + " print(f\"adding: mem time {t}, current time {step}, horizon {step-t}\")\n", + " replay_buffer.add(obs_t, np.concatenate((agent.get_parameters(), np.array([step-t,]))), next_obs, reward, done)\n", "\n", - "update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards, force_update=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Finally, below we check the results of the trainer callback, which show the training loss and validation score across all calls to ``model_trainer.train()``." + " total_reward += reward\n", + " step += 1\n", + " \n", + " if not collect_full_trajectories and step == steps_or_trials_to_collect:\n", + " total_rewards.append(total_reward)\n", + " break\n", + " if trial_length and step % trial_length == 0:\n", + " if collect_full_trajectories and not done and replay_buffer is not None:\n", + " replay_buffer.close_trajectory()\n", + " break\n", + " trial += 1\n", + " total_rewards.append(total_reward)\n", + " \n" ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, + "execution_count": 65, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "2200" ] }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "fig, ax = plt.subplots(2, 1, figsize=(12, 10))\n", - "ax[0].plot(train_losses)\n", - "ax[0].set_xlabel(\"Total training epochs\")\n", - "ax[0].set_ylabel(\"Training loss (avg. NLL)\")\n", - "ax[1].plot(val_scores)\n", - "ax[1].set_xlabel(\"Total training epochs\")\n", - "ax[1].set_ylabel(\"Validation score (avg. MSE)\")\n", - "plt.show()" + "len(replay_buffer)" ] }, { @@ -548,30 +44525,40 @@ } }, "source": [ - "# Where to learn more about MBRL?" + "# Training the Trajectory Based Model" ] }, { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 4.32284387, 4.42208292, 3.3031029 , 4.17837783, 0.24627421,\n", + " 1.60552719, 1.59221673, 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0.59455814,\n", + " 0.84819036, 0.91022234, 0.83308917, 0.30861847, 0.7820293 ,\n", + " 0.89154524, 0.40239062, -0.2175147 , 0.8519179 , -0.5969506 ,\n", + " -0.89464083, 0.32461422, -0.24695989])" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" } - }, + ], "source": [ - "To learn about the other features of the library, please check out our [documentation](https://facebookresearch.github.io/mbrl-lib/). Also take a look at our provided implementations of [PETS](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/pets.py), [MBPO](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/mbpo.py), and [PlaNet](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/planet.py), and their configuration [files](https://github.com/facebookresearch/mbrl-lib/tree/main/mbrl/examples/conf)." + "agent.get_parameters().flatten()" ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting Results" + ] } ], "metadata": { @@ -590,9 +44577,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.9.12" } }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} From bd9aa622962e9a3c141fafe29c437d648a3917a9 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Tue, 9 Aug 2022 19:48:28 -0700 Subject: [PATCH 04/24] notebook loss goes down --- notebooks/traj_based_model.ipynb | 44433 +---------------------------- 1 file changed, 152 insertions(+), 44281 deletions(-) diff --git a/notebooks/traj_based_model.ipynb b/notebooks/traj_based_model.ipynb index 6b1988d2..7ebeb12b 100644 --- a/notebooks/traj_based_model.ipynb +++ b/notebooks/traj_based_model.ipynb @@ -15,14 +15,23 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 83, "metadata": { "pycharm": { "is_executing": true, "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "from IPython import display\n", "%matplotlib inline\n", @@ -49,28 +58,6 @@ "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'" ] }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "pycharm": { - "is_executing": true, - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n" - ] - } - ], - "source": [ - "print(1+1)" - ] - }, { "cell_type": "markdown", "metadata": { @@ -104,6 +91,48 @@ "act_shape = env.action_space.shape\n" ] }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# PID Agent\n", + "\n", + "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "def create_pid_agent(action_dim):\n", + " P = np.random.rand(action_dim) * 5\n", + " I = np.zeros(action_dim)\n", + " D = np.random.rand(action_dim)\n", + " target = np.random.rand(action_dim) * 2 - 1\n", + "\n", + " agent = planning.PIDAgent(dim=action_dim, Kp=P, Ki=I, Kd=D, target=target)\n", + " return agent" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "agent = create_pid_agent(env.action_space.shape[0])" + ] + }, { "cell_type": "markdown", "metadata": { @@ -119,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 109, "metadata": { "pycharm": { "name": "#%%\n" @@ -127,9 +156,10 @@ }, "outputs": [], "source": [ - "trial_length = 200\n", - "num_trials = 10\n", + "trial_length = 100\n", + "num_trials = 100\n", "ensemble_size = 5\n", + "param_shape = (len(agent.get_parameters())+1,)\n", "\n", "# Everything with \"???\" indicates an option with a missing value.\n", "# Our utility functions will fill in these details using the \n", @@ -137,13 +167,13 @@ "cfg_dict = {\n", " # dynamics model configuration\n", " \"dynamics_model\": {\n", - " \"_target_\": \"mbrl.models.TrajBasedMLP\",\n", + " \"_target_\": \"mbrl.models.GaussianMLP\",\n", " \"device\": device,\n", " \"num_layers\": 3,\n", " \"ensemble_size\": ensemble_size,\n", " \"hid_size\": 200,\n", - " \"in_size\": \"???\",\n", - " \"out_size\": \"???\",\n", + " \"in_size\": param_shape[0]+obs_shape[0], # control params, horizon, state_0\n", + " \"out_size\": obs_shape[0], # state time 0+h\n", " \"deterministic\": False,\n", " \"propagation_method\": \"fixed_model\",\n", " # can also configure activation function for GaussianMLP\n", @@ -184,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 110, "metadata": { "pycharm": { "name": "#%%\n" @@ -193,52 +223,7 @@ "outputs": [], "source": [ "# Create a 1-D dynamics model for this environment\n", - "# dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n", - "\n", - "# Create a gym-like environment to encapsulate the model\n", - "# model_env = models.ModelEnv(env, dynamics_model, term_fn, reward_fn, generator=generator)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "# PID Agent\n", - "\n", - "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "def create_pid_agent(action_dim):\n", - " P = np.random.rand(action_dim) * 5\n", - " I = np.zeros(action_dim)\n", - " D = np.random.rand(action_dim)\n", - " target = np.random.rand(action_dim) * 2 - 1\n", - "\n", - " agent = planning.PIDAgent(dim=action_dim, Kp=P, Ki=I, Kd=D, target=target)\n", - " return agent" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "agent = create_pid_agent(env.action_space.shape[0])" + "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n" ] }, { @@ -256,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 111, "metadata": { "pycharm": { "name": "#%%\n" @@ -264,14 +249,12 @@ }, "outputs": [], "source": [ - "param_shape = (len(agent.get_parameters())+1,)\n", "collect_full_trajectories = True\n", "replay_buffer = common_util.create_replay_buffer(cfg, \n", " obs_shape, \n", " param_shape, \n", " rng=rng, \n", - " collect_trajectories=collect_full_trajectories)\n", - "\n" + " collect_trajectories=collect_full_trajectories)" ] }, { @@ -287,44176 +270,14 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 112, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "adding: mem time0, current time 1, horizon 1\n", - "adding: mem time0, current time 2, horizon 2\n", - "adding: mem time1, current time 2, horizon 1\n", - "adding: mem time0, current time 3, horizon 3\n", - "adding: mem time1, current time 3, horizon 2\n", - "adding: mem time2, current time 3, horizon 1\n", - "adding: mem time0, current time 4, horizon 4\n", - "adding: mem time1, current time 4, horizon 3\n", - "adding: mem time2, current time 4, horizon 2\n", - "adding: mem time3, current time 4, horizon 1\n", - "adding: mem time0, current time 5, horizon 5\n", - "adding: mem time1, current time 5, horizon 4\n", - "adding: mem time2, current time 5, horizon 3\n", - "adding: mem time3, current time 5, horizon 2\n", - "adding: mem time4, current time 5, horizon 1\n", - "adding: mem time0, current time 6, horizon 6\n", - "adding: mem time1, current time 6, horizon 5\n", - "adding: mem time2, current time 6, horizon 4\n", - "adding: mem time3, current time 6, horizon 3\n", - "adding: mem time4, current time 6, horizon 2\n", - "adding: mem time5, current time 6, horizon 1\n", - "adding: mem time0, current time 7, horizon 7\n", - "adding: mem time1, current time 7, horizon 6\n", - "adding: mem time2, current time 7, horizon 5\n", - "adding: mem time3, current time 7, horizon 4\n", - "adding: mem time4, current time 7, horizon 3\n", - "adding: mem time5, current time 7, horizon 2\n", - "adding: mem time6, current time 7, horizon 1\n", - "adding: mem time0, current time 8, horizon 8\n", - "adding: mem time1, current time 8, horizon 7\n", - "adding: mem time2, current time 8, horizon 6\n", - "adding: mem time3, current time 8, horizon 5\n", - "adding: mem time4, current time 8, horizon 4\n", - "adding: mem time5, current time 8, horizon 3\n", - "adding: mem time6, current time 8, horizon 2\n", - "adding: mem time7, current time 8, horizon 1\n", - "adding: mem time0, current time 9, horizon 9\n", - "adding: mem time1, current time 9, horizon 8\n", - "adding: mem time2, current time 9, horizon 7\n", - "adding: mem time3, current time 9, horizon 6\n", - "adding: mem time4, current time 9, horizon 5\n", - "adding: mem time5, current time 9, horizon 4\n", - "adding: mem time6, current time 9, horizon 3\n", - "adding: mem time7, current time 9, horizon 2\n", - "adding: mem time8, current time 9, horizon 1\n", - "adding: mem time0, current time 10, horizon 10\n", - "adding: mem time1, current time 10, horizon 9\n", - "adding: mem time2, current time 10, horizon 8\n", - "adding: mem time3, current time 10, horizon 7\n", - "adding: mem time4, current time 10, horizon 6\n", - "adding: mem time5, current time 10, horizon 5\n", - "adding: mem time6, current time 10, horizon 4\n", - "adding: mem time7, current time 10, horizon 3\n", - "adding: mem time8, current time 10, horizon 2\n", - "adding: mem time9, current time 10, horizon 1\n", - "adding: mem time0, current time 11, horizon 11\n", - "adding: mem time1, current time 11, horizon 10\n", - "adding: mem time2, current time 11, horizon 9\n", - "adding: mem time3, current time 11, horizon 8\n", - "adding: mem time4, current time 11, horizon 7\n", - "adding: mem time5, current time 11, horizon 6\n", - "adding: mem time6, current time 11, horizon 5\n", - "adding: mem time7, current time 11, horizon 4\n", - "adding: mem time8, current time 11, horizon 3\n", - "adding: mem time9, current time 11, horizon 2\n", - "adding: mem time10, current time 11, horizon 1\n", - "adding: mem time0, current time 12, horizon 12\n", - "adding: mem time1, current time 12, horizon 11\n", - "adding: mem time2, current time 12, horizon 10\n", - "adding: mem time3, current time 12, horizon 9\n", - "adding: mem time4, current time 12, horizon 8\n", - "adding: mem time5, current time 12, horizon 7\n", - "adding: mem time6, current time 12, horizon 6\n", - "adding: mem time7, current time 12, horizon 5\n", - "adding: mem time8, current time 12, horizon 4\n", - "adding: mem time9, current time 12, horizon 3\n", - "adding: mem time10, current time 12, horizon 2\n", - "adding: mem time11, current time 12, horizon 1\n", - "adding: mem time0, current time 13, horizon 13\n", - "adding: mem time1, current time 13, horizon 12\n", - "adding: mem time2, current time 13, horizon 11\n", - "adding: mem time3, current time 13, horizon 10\n", - "adding: mem time4, current time 13, horizon 9\n", - "adding: mem time5, current time 13, horizon 8\n", - "adding: mem time6, current time 13, horizon 7\n", - "adding: mem time7, current time 13, horizon 6\n", - "adding: mem time8, current time 13, horizon 5\n", - "adding: mem time9, current time 13, horizon 4\n", - "adding: mem time10, current time 13, horizon 3\n", - "adding: mem time11, current time 13, horizon 2\n", - "adding: mem time12, current time 13, horizon 1\n", - "adding: mem time0, current time 14, horizon 14\n", - "adding: mem time1, current time 14, horizon 13\n", - "adding: mem time2, current time 14, horizon 12\n", - "adding: mem time3, current time 14, horizon 11\n", - "adding: mem time4, current time 14, horizon 10\n", - "adding: mem time5, current time 14, horizon 9\n", - "adding: mem time6, current time 14, horizon 8\n", - "adding: mem time7, current time 14, horizon 7\n", - "adding: mem time8, current time 14, horizon 6\n", - "adding: mem time9, current time 14, horizon 5\n", - "adding: mem time10, current time 14, horizon 4\n", - "adding: mem time11, current time 14, horizon 3\n", - "adding: mem time12, current time 14, horizon 2\n", - "adding: mem time13, current time 14, horizon 1\n", - "adding: mem time0, current time 15, horizon 15\n", - "adding: mem time1, current time 15, horizon 14\n", - "adding: mem time2, current time 15, horizon 13\n", - "adding: mem time3, current time 15, horizon 12\n", - "adding: mem time4, current time 15, horizon 11\n", - "adding: mem time5, current time 15, horizon 10\n", - "adding: mem time6, current time 15, horizon 9\n", - "adding: mem time7, current time 15, horizon 8\n", - "adding: mem time8, current time 15, horizon 7\n", - "adding: mem time9, current time 15, horizon 6\n", - "adding: mem time10, current time 15, horizon 5\n", - "adding: mem time11, current time 15, horizon 4\n", - "adding: mem time12, current time 15, horizon 3\n", - "adding: mem time13, current time 15, horizon 2\n", - "adding: mem time14, current time 15, horizon 1\n", - "adding: mem time0, current time 16, horizon 16\n", - "adding: mem time1, current time 16, horizon 15\n", - "adding: mem time2, current time 16, horizon 14\n", - "adding: mem time3, current time 16, horizon 13\n", - "adding: mem time4, current time 16, horizon 12\n", - "adding: mem time5, current time 16, horizon 11\n", - "adding: mem time6, current time 16, horizon 10\n", - "adding: mem time7, current time 16, horizon 9\n", - "adding: mem time8, current time 16, horizon 8\n", - "adding: mem time9, current time 16, horizon 7\n", - "adding: mem time10, current time 16, horizon 6\n", - "adding: mem time11, current time 16, horizon 5\n", - "adding: mem time12, current time 16, horizon 4\n", - "adding: mem time13, current time 16, horizon 3\n", - "adding: mem time14, current time 16, horizon 2\n", - "adding: mem time15, current time 16, horizon 1\n", - "adding: mem time0, current time 17, horizon 17\n", - "adding: mem time1, current time 17, horizon 16\n", - "adding: mem time2, current time 17, horizon 15\n", - "adding: mem time3, current time 17, horizon 14\n", - "adding: mem time4, current time 17, horizon 13\n", - "adding: mem time5, current time 17, horizon 12\n", - "adding: mem time6, current time 17, horizon 11\n", - "adding: mem time7, current time 17, horizon 10\n", - "adding: mem time8, current time 17, horizon 9\n", - "adding: mem time9, current time 17, horizon 8\n", - "adding: mem time10, current time 17, horizon 7\n", - "adding: mem time11, current time 17, horizon 6\n", - "adding: mem time12, current time 17, horizon 5\n", - "adding: mem time13, current time 17, horizon 4\n", - "adding: mem time14, current time 17, horizon 3\n", - "adding: mem time15, current time 17, horizon 2\n", - "adding: mem time16, current time 17, horizon 1\n", - "adding: mem time0, current time 18, horizon 18\n", - "adding: mem time1, current time 18, horizon 17\n", - "adding: mem time2, current time 18, horizon 16\n", - "adding: mem time3, current time 18, horizon 15\n", - "adding: mem time4, current time 18, horizon 14\n", - "adding: mem time5, current time 18, horizon 13\n", - "adding: mem time6, current time 18, horizon 12\n", - "adding: mem time7, current time 18, horizon 11\n", - "adding: mem time8, current time 18, horizon 10\n", - "adding: mem time9, current time 18, horizon 9\n", - "adding: mem time10, current time 18, horizon 8\n", - "adding: mem time11, current time 18, horizon 7\n", - "adding: mem time12, current time 18, horizon 6\n", - "adding: mem time13, current time 18, horizon 5\n", - "adding: mem time14, current time 18, horizon 4\n", - "adding: mem time15, current time 18, horizon 3\n", - "adding: mem time16, current time 18, horizon 2\n", - "adding: mem time17, current time 18, horizon 1\n", - "adding: mem time0, current time 19, horizon 19\n", - "adding: mem time1, current time 19, horizon 18\n", - "adding: mem time2, current time 19, horizon 17\n", - "adding: mem time3, current time 19, horizon 16\n", - "adding: mem time4, current time 19, horizon 15\n", - "adding: mem time5, current time 19, horizon 14\n", - "adding: mem time6, current time 19, horizon 13\n", - "adding: mem time7, current time 19, horizon 12\n", - "adding: mem time8, current time 19, horizon 11\n", - "adding: mem time9, current time 19, horizon 10\n", - "adding: mem time10, current time 19, horizon 9\n", - "adding: mem time11, current time 19, horizon 8\n", - "adding: mem time12, current time 19, horizon 7\n", - "adding: mem time13, current time 19, horizon 6\n", - "adding: mem time14, current time 19, horizon 5\n", - "adding: mem time15, current time 19, horizon 4\n", - "adding: mem time16, current time 19, horizon 3\n", - "adding: mem time17, current time 19, horizon 2\n", - "adding: mem time18, current time 19, horizon 1\n", - "adding: mem time0, current time 20, horizon 20\n", - "adding: mem time1, current time 20, horizon 19\n", - "adding: mem time2, current time 20, horizon 18\n", - "adding: mem time3, current time 20, horizon 17\n", - "adding: mem time4, current time 20, horizon 16\n", - "adding: mem time5, current time 20, horizon 15\n", - "adding: mem time6, current time 20, horizon 14\n", - "adding: mem time7, current time 20, horizon 13\n", - "adding: mem time8, current time 20, horizon 12\n", - "adding: mem time9, current time 20, horizon 11\n", - "adding: mem time10, current time 20, horizon 10\n", - "adding: mem time11, current time 20, horizon 9\n", - "adding: mem time12, current time 20, horizon 8\n", - "adding: mem time13, current time 20, horizon 7\n", - "adding: mem time14, current time 20, horizon 6\n", - "adding: mem time15, current time 20, horizon 5\n", - "adding: mem time16, current time 20, horizon 4\n", - "adding: mem time17, current time 20, horizon 3\n", - "adding: mem time18, current time 20, horizon 2\n", - "adding: mem time19, current time 20, horizon 1\n", - "adding: mem time0, current time 21, horizon 21\n", - "adding: mem time1, current time 21, horizon 20\n", - "adding: mem time2, current time 21, horizon 19\n", - "adding: mem time3, current time 21, horizon 18\n", - "adding: mem time4, current time 21, horizon 17\n", - "adding: mem time5, current time 21, horizon 16\n", - "adding: mem time6, current time 21, horizon 15\n", - "adding: mem time7, current time 21, horizon 14\n", - "adding: mem time8, current time 21, horizon 13\n", - "adding: mem time9, current time 21, horizon 12\n", - "adding: mem time10, current time 21, horizon 11\n", - "adding: mem time11, current time 21, horizon 10\n", - "adding: mem time12, current time 21, horizon 9\n", - "adding: mem time13, current time 21, horizon 8\n", - "adding: mem time14, current time 21, horizon 7\n", - "adding: mem time15, current time 21, horizon 6\n", - "adding: mem time16, current time 21, horizon 5\n", - "adding: mem time17, current time 21, horizon 4\n", - "adding: mem time18, current time 21, horizon 3\n", - "adding: mem time19, current time 21, horizon 2\n", - "adding: mem time20, current time 21, horizon 1\n", - "adding: mem time0, current time 22, horizon 22\n", - "adding: mem time1, current time 22, horizon 21\n", - "adding: mem time2, current time 22, horizon 20\n", - "adding: mem time3, current time 22, horizon 19\n", - "adding: mem time4, current time 22, horizon 18\n", - "adding: mem time5, current time 22, horizon 17\n", - "adding: mem time6, current time 22, horizon 16\n", - "adding: mem time7, current time 22, horizon 15\n", - "adding: mem time8, current time 22, horizon 14\n", - "adding: mem time9, current time 22, horizon 13\n", - "adding: mem time10, current time 22, horizon 12\n", - "adding: mem time11, current time 22, horizon 11\n", - "adding: mem time12, current time 22, horizon 10\n", - "adding: mem time13, current time 22, horizon 9\n", - "adding: mem time14, current time 22, horizon 8\n", - "adding: mem time15, current time 22, horizon 7\n", - "adding: mem time16, current time 22, horizon 6\n", - "adding: mem time17, current time 22, horizon 5\n", - "adding: mem time18, current time 22, horizon 4\n", - "adding: mem time19, current time 22, horizon 3\n", - "adding: mem time20, current time 22, horizon 2\n", - "adding: mem time21, current time 22, horizon 1\n", - "adding: mem time0, current time 23, horizon 23\n", - "adding: mem time1, current time 23, horizon 22\n", - "adding: mem time2, current time 23, horizon 21\n", - "adding: mem time3, current time 23, horizon 20\n", - "adding: mem time4, current time 23, horizon 19\n", - "adding: mem time5, current time 23, horizon 18\n", - "adding: mem time6, current time 23, horizon 17\n", - "adding: mem time7, current time 23, horizon 16\n", - "adding: mem time8, current time 23, horizon 15\n", - "adding: mem time9, current time 23, horizon 14\n", - "adding: mem time10, current time 23, horizon 13\n", - "adding: mem time11, current time 23, horizon 12\n", - "adding: mem time12, current time 23, horizon 11\n", - "adding: mem time13, current time 23, horizon 10\n", - "adding: mem time14, current time 23, horizon 9\n", - "adding: mem time15, current time 23, horizon 8\n", - "adding: mem time16, current time 23, horizon 7\n", - "adding: mem time17, current time 23, horizon 6\n", - "adding: mem time18, current time 23, horizon 5\n", - "adding: mem time19, current time 23, horizon 4\n", - "adding: mem time20, current time 23, horizon 3\n", - "adding: mem time21, current time 23, horizon 2\n", - "adding: mem time22, current time 23, horizon 1\n", - "adding: mem time0, current time 24, horizon 24\n", - "adding: mem time1, current time 24, horizon 23\n", - "adding: mem time2, current time 24, horizon 22\n", - "adding: mem time3, current time 24, horizon 21\n", - "adding: mem time4, current time 24, horizon 20\n", - "adding: mem time5, current time 24, horizon 19\n", - "adding: mem time6, current time 24, horizon 18\n", - "adding: mem time7, current time 24, horizon 17\n", - "adding: mem time8, current time 24, horizon 16\n", - "adding: mem time9, current time 24, horizon 15\n", - "adding: mem time10, current time 24, horizon 14\n", - "adding: mem time11, current time 24, horizon 13\n", - "adding: mem time12, current time 24, horizon 12\n", - "adding: mem time13, current time 24, horizon 11\n", - "adding: mem time14, current time 24, horizon 10\n", - "adding: mem time15, current time 24, horizon 9\n", - "adding: mem time16, current time 24, horizon 8\n", - "adding: mem time17, current time 24, horizon 7\n", - "adding: mem time18, current time 24, horizon 6\n", - "adding: mem time19, current time 24, horizon 5\n", - "adding: mem time20, current time 24, horizon 4\n", - "adding: mem time21, current time 24, horizon 3\n", - "adding: mem time22, current time 24, horizon 2\n", - "adding: mem time23, current time 24, horizon 1\n", - "adding: mem time0, current time 25, horizon 25\n", - "adding: mem time1, current time 25, horizon 24\n", - "adding: mem time2, current time 25, horizon 23\n", - "adding: mem time3, current time 25, horizon 22\n", - "adding: mem time4, current time 25, horizon 21\n", - "adding: mem time5, current time 25, horizon 20\n", - "adding: mem time6, current time 25, horizon 19\n", - "adding: mem time7, current time 25, horizon 18\n", - "adding: mem time8, current time 25, horizon 17\n", - "adding: mem time9, current time 25, horizon 16\n", - "adding: mem time10, current time 25, horizon 15\n", - "adding: mem time11, current time 25, horizon 14\n", - "adding: mem time12, current time 25, horizon 13\n", - "adding: mem time13, current time 25, horizon 12\n", - "adding: mem time14, current time 25, horizon 11\n", - "adding: mem time15, current time 25, horizon 10\n", - "adding: mem time16, current time 25, horizon 9\n", - "adding: mem time17, current time 25, horizon 8\n", - "adding: mem time18, current time 25, horizon 7\n", - "adding: mem time19, current time 25, horizon 6\n", - "adding: mem time20, current time 25, horizon 5\n", - "adding: mem time21, current time 25, horizon 4\n", - "adding: mem time22, current time 25, horizon 3\n", - "adding: mem time23, current time 25, horizon 2\n", - "adding: mem time24, current time 25, horizon 1\n", - "adding: mem time0, current time 26, horizon 26\n", - "adding: mem time1, current time 26, horizon 25\n", - "adding: mem time2, current time 26, horizon 24\n", - "adding: mem time3, current time 26, horizon 23\n", - "adding: mem time4, current time 26, horizon 22\n", - "adding: mem time5, current time 26, horizon 21\n", - "adding: mem time6, current time 26, horizon 20\n", - "adding: mem time7, current time 26, horizon 19\n", - "adding: mem time8, current time 26, horizon 18\n", - "adding: mem time9, current time 26, horizon 17\n", - "adding: mem time10, current time 26, horizon 16\n", - "adding: mem time11, current time 26, horizon 15\n", - "adding: mem time12, current time 26, horizon 14\n", - "adding: mem time13, current time 26, horizon 13\n", - "adding: mem time14, current time 26, horizon 12\n", - "adding: mem time15, current time 26, horizon 11\n", - "adding: mem time16, current time 26, horizon 10\n", - "adding: mem time17, current time 26, horizon 9\n", - "adding: mem time18, current time 26, horizon 8\n", - "adding: mem time19, current time 26, horizon 7\n", - "adding: mem time20, current time 26, horizon 6\n", - "adding: mem time21, current time 26, horizon 5\n", - "adding: mem time22, current time 26, horizon 4\n", - "adding: mem time23, current time 26, horizon 3\n", - "adding: mem time24, current time 26, horizon 2\n", - "adding: mem time25, current time 26, horizon 1\n", - "adding: mem time0, current time 27, horizon 27\n", - "adding: mem time1, current time 27, horizon 26\n", - "adding: mem time2, current time 27, horizon 25\n", - "adding: mem time3, current time 27, horizon 24\n", - "adding: mem time4, current time 27, horizon 23\n", - "adding: mem time5, current time 27, horizon 22\n", - "adding: mem time6, current time 27, horizon 21\n", - "adding: mem time7, current time 27, horizon 20\n", - "adding: mem time8, current time 27, horizon 19\n", - "adding: mem time9, current time 27, horizon 18\n", - "adding: mem time10, current time 27, horizon 17\n", - "adding: mem time11, current time 27, horizon 16\n", - "adding: mem time12, current time 27, horizon 15\n", - "adding: mem time13, current time 27, horizon 14\n", - "adding: mem time14, current time 27, horizon 13\n", - "adding: mem time15, current time 27, horizon 12\n", - "adding: mem time16, current time 27, horizon 11\n", - "adding: mem time17, current time 27, horizon 10\n", - "adding: mem time18, current time 27, horizon 9\n", - "adding: mem time19, current time 27, horizon 8\n", - "adding: mem time20, current time 27, horizon 7\n", - "adding: mem time21, current time 27, horizon 6\n", - "adding: mem time22, current time 27, horizon 5\n", - "adding: mem time23, current time 27, horizon 4\n", - "adding: mem time24, current time 27, horizon 3\n", - "adding: mem time25, current time 27, horizon 2\n", - "adding: mem time26, current time 27, horizon 1\n", - "adding: mem time0, current time 28, horizon 28\n", - "adding: mem time1, current time 28, horizon 27\n", - "adding: mem time2, current time 28, horizon 26\n", - "adding: mem time3, current time 28, horizon 25\n", - "adding: mem time4, current time 28, horizon 24\n", - "adding: mem time5, current time 28, horizon 23\n", - "adding: mem time6, current time 28, horizon 22\n", - "adding: mem time7, current time 28, horizon 21\n", - "adding: mem time8, current time 28, horizon 20\n", - "adding: mem time9, current time 28, horizon 19\n", - "adding: mem time10, current time 28, horizon 18\n", - "adding: mem time11, current time 28, horizon 17\n", - "adding: mem time12, current time 28, horizon 16\n", - "adding: mem time13, current time 28, horizon 15\n", - "adding: mem time14, current time 28, horizon 14\n", - "adding: mem time15, current time 28, horizon 13\n", - "adding: mem time16, current time 28, horizon 12\n", - "adding: mem time17, current time 28, horizon 11\n", - "adding: mem time18, current time 28, horizon 10\n", - "adding: mem time19, current time 28, horizon 9\n", - "adding: mem time20, current time 28, horizon 8\n", - "adding: mem time21, current time 28, horizon 7\n", - "adding: mem time22, current time 28, horizon 6\n", - "adding: mem time23, current time 28, horizon 5\n", - "adding: mem time24, current time 28, horizon 4\n", - "adding: mem time25, current time 28, horizon 3\n", - "adding: mem time26, current time 28, horizon 2\n", - "adding: mem time27, current time 28, horizon 1\n", - "adding: mem time0, current time 29, horizon 29\n", - "adding: mem time1, current time 29, horizon 28\n", - "adding: mem time2, current time 29, horizon 27\n", - "adding: mem time3, current time 29, horizon 26\n", - "adding: mem time4, current time 29, horizon 25\n", - "adding: mem time5, current time 29, horizon 24\n", - "adding: mem time6, current time 29, horizon 23\n", - "adding: mem time7, current time 29, horizon 22\n", - "adding: mem time8, current time 29, horizon 21\n", - "adding: mem time9, current time 29, horizon 20\n", - "adding: mem time10, current time 29, horizon 19\n", - "adding: mem time11, current time 29, horizon 18\n", - "adding: mem time12, current time 29, horizon 17\n", - "adding: mem time13, current time 29, horizon 16\n", - "adding: mem time14, current time 29, horizon 15\n", - "adding: mem time15, current time 29, horizon 14\n", - "adding: mem time16, current time 29, horizon 13\n", - "adding: mem time17, current time 29, horizon 12\n", - "adding: mem time18, current time 29, horizon 11\n", - "adding: mem time19, current time 29, horizon 10\n", - "adding: mem time20, current time 29, horizon 9\n", - "adding: mem time21, current time 29, horizon 8\n", - "adding: mem time22, current time 29, horizon 7\n", - "adding: mem time23, current time 29, horizon 6\n", - "adding: mem time24, current time 29, horizon 5\n", - "adding: mem time25, current time 29, horizon 4\n", - "adding: mem time26, current time 29, horizon 3\n", - "adding: mem time27, current time 29, horizon 2\n", - "adding: mem time28, current time 29, horizon 1\n", - "adding: mem time0, current time 30, horizon 30\n", - "adding: mem time1, current time 30, horizon 29\n", - "adding: mem time2, current time 30, horizon 28\n", - "adding: mem time3, current time 30, horizon 27\n", - "adding: mem time4, current time 30, horizon 26\n", - "adding: mem time5, current time 30, horizon 25\n", - "adding: mem time6, current time 30, horizon 24\n", - "adding: mem time7, current time 30, horizon 23\n", - "adding: mem time8, current time 30, horizon 22\n", - "adding: mem time9, current time 30, horizon 21\n", - "adding: mem time10, current time 30, horizon 20\n", - "adding: mem time11, current time 30, horizon 19\n", - "adding: mem time12, current time 30, horizon 18\n", - "adding: mem time13, current time 30, horizon 17\n", - "adding: mem time14, current time 30, horizon 16\n", - "adding: mem time15, current time 30, horizon 15\n", - "adding: mem time16, current time 30, horizon 14\n", - "adding: mem time17, current time 30, horizon 13\n", - "adding: mem time18, current time 30, horizon 12\n", - "adding: mem time19, current time 30, horizon 11\n", - "adding: mem time20, current time 30, horizon 10\n", - "adding: mem time21, current time 30, horizon 9\n", - "adding: mem time22, current time 30, horizon 8\n", - "adding: mem time23, current time 30, horizon 7\n", - "adding: mem time24, current time 30, horizon 6\n", - "adding: mem time25, current time 30, horizon 5\n", - "adding: mem time26, current time 30, horizon 4\n", - "adding: mem time27, current time 30, horizon 3\n", - "adding: mem time28, current time 30, horizon 2\n", - "adding: mem time29, current time 30, horizon 1\n", - "adding: mem time0, current time 31, horizon 31\n", - "adding: mem time1, current time 31, horizon 30\n", - "adding: mem time2, current time 31, horizon 29\n", - "adding: mem time3, current time 31, horizon 28\n", - "adding: mem time4, current time 31, horizon 27\n", - "adding: mem time5, current time 31, horizon 26\n", - "adding: mem time6, current time 31, horizon 25\n", - "adding: mem time7, current time 31, horizon 24\n", - "adding: mem time8, current time 31, horizon 23\n", - "adding: mem time9, current time 31, horizon 22\n", - "adding: mem time10, current time 31, horizon 21\n", - "adding: mem time11, current time 31, horizon 20\n", - "adding: mem time12, current time 31, horizon 19\n", - "adding: mem time13, current time 31, horizon 18\n", - "adding: mem time14, current time 31, horizon 17\n", - "adding: mem time15, current time 31, horizon 16\n", - "adding: mem time16, current time 31, horizon 15\n", - "adding: mem time17, current time 31, horizon 14\n", - "adding: mem time18, current time 31, horizon 13\n", - "adding: mem time19, current time 31, horizon 12\n", - "adding: mem time20, current time 31, horizon 11\n", - "adding: mem time21, current time 31, horizon 10\n", - "adding: mem time22, current time 31, horizon 9\n", - "adding: mem time23, current time 31, horizon 8\n", - "adding: mem time24, current time 31, horizon 7\n", - "adding: mem time25, current time 31, horizon 6\n", - "adding: mem time26, current time 31, horizon 5\n", - "adding: mem time27, current time 31, horizon 4\n", - "adding: mem time28, current time 31, horizon 3\n", - "adding: mem time29, current time 31, horizon 2\n", - "adding: mem time30, current time 31, horizon 1\n", - "adding: mem time0, current time 32, horizon 32\n", - "adding: mem time1, current time 32, horizon 31\n", - "adding: mem time2, current time 32, horizon 30\n", - "adding: mem time3, current time 32, horizon 29\n", - "adding: mem time4, current time 32, horizon 28\n", - "adding: mem time5, current time 32, horizon 27\n", - "adding: mem time6, current time 32, horizon 26\n", - "adding: mem time7, current time 32, horizon 25\n", - "adding: mem time8, current time 32, horizon 24\n", - "adding: mem time9, current time 32, horizon 23\n", - "adding: mem time10, current time 32, horizon 22\n", - "adding: mem time11, current time 32, horizon 21\n", - "adding: mem time12, current time 32, horizon 20\n", - "adding: mem time13, current time 32, horizon 19\n", - "adding: mem time14, current time 32, horizon 18\n", - "adding: mem time15, current time 32, horizon 17\n", - "adding: mem time16, current time 32, horizon 16\n", - "adding: mem time17, current time 32, horizon 15\n", - "adding: mem time18, current time 32, horizon 14\n", - "adding: mem time19, current time 32, horizon 13\n", - "adding: mem time20, current time 32, horizon 12\n", - "adding: mem time21, current time 32, horizon 11\n", - "adding: mem time22, current time 32, horizon 10\n", - "adding: mem time23, current time 32, horizon 9\n", - "adding: mem time24, current time 32, horizon 8\n", - "adding: mem time25, current time 32, horizon 7\n", - "adding: mem time26, current time 32, horizon 6\n", - "adding: mem time27, current time 32, horizon 5\n", - "adding: mem time28, current time 32, horizon 4\n", - "adding: mem time29, current time 32, horizon 3\n", - "adding: mem time30, current time 32, horizon 2\n", - "adding: mem time31, current time 32, horizon 1\n", - "adding: mem time0, current time 33, horizon 33\n", - "adding: mem time1, current time 33, horizon 32\n", - "adding: mem time2, current time 33, horizon 31\n", - "adding: mem time3, current time 33, horizon 30\n", - "adding: mem time4, current time 33, horizon 29\n", - "adding: mem time5, current time 33, horizon 28\n", - "adding: mem time6, current time 33, horizon 27\n", - "adding: mem time7, current time 33, horizon 26\n", - "adding: mem time8, current time 33, horizon 25\n", - "adding: mem time9, current time 33, horizon 24\n", - "adding: mem time10, current time 33, horizon 23\n", - "adding: mem time11, current time 33, horizon 22\n", - "adding: mem time12, current time 33, horizon 21\n", - "adding: mem time13, current time 33, horizon 20\n", - "adding: mem time14, current time 33, horizon 19\n", - "adding: mem time15, current time 33, horizon 18\n", - "adding: mem time16, current time 33, horizon 17\n", - "adding: mem time17, current time 33, horizon 16\n", - "adding: mem time18, current time 33, horizon 15\n", - "adding: mem time19, current time 33, horizon 14\n", - "adding: mem time20, current time 33, horizon 13\n", - "adding: mem time21, current time 33, horizon 12\n", - "adding: mem time22, current time 33, horizon 11\n", - "adding: mem time23, current time 33, horizon 10\n", - "adding: mem time24, current time 33, horizon 9\n", - "adding: mem time25, current time 33, horizon 8\n", - "adding: mem time26, current time 33, horizon 7\n", - "adding: mem time27, current time 33, horizon 6\n", - "adding: mem time28, current time 33, horizon 5\n", - "adding: mem time29, current time 33, horizon 4\n", - "adding: mem time30, current time 33, horizon 3\n", - "adding: mem time31, current time 33, horizon 2\n", - "adding: mem time32, current time 33, horizon 1\n", - "adding: mem time0, current time 34, horizon 34\n", - "adding: mem time1, current time 34, horizon 33\n", - "adding: mem time2, current time 34, horizon 32\n", - "adding: mem time3, current time 34, horizon 31\n", - "adding: mem time4, current time 34, horizon 30\n", - "adding: mem time5, current time 34, horizon 29\n", - "adding: mem time6, current time 34, horizon 28\n", - "adding: mem time7, current time 34, horizon 27\n", - "adding: mem time8, current time 34, horizon 26\n", - "adding: mem time9, current time 34, horizon 25\n", - "adding: mem time10, current time 34, horizon 24\n", - "adding: mem time11, current time 34, horizon 23\n", - "adding: mem time12, current time 34, horizon 22\n", - "adding: mem time13, current time 34, horizon 21\n", - "adding: mem time14, current time 34, horizon 20\n", - "adding: mem time15, current time 34, horizon 19\n", - "adding: mem time16, current time 34, horizon 18\n", - "adding: mem time17, current time 34, horizon 17\n", - "adding: mem time18, current time 34, horizon 16\n", - "adding: mem time19, current time 34, horizon 15\n", - "adding: mem time20, current time 34, horizon 14\n", - "adding: mem time21, current time 34, horizon 13\n", - "adding: mem time22, current time 34, horizon 12\n", - "adding: mem time23, current time 34, horizon 11\n", - "adding: mem time24, current time 34, horizon 10\n", - "adding: mem time25, current time 34, horizon 9\n", - "adding: mem time26, current time 34, horizon 8\n", - "adding: mem time27, current time 34, horizon 7\n", - "adding: mem time28, current time 34, horizon 6\n", - "adding: mem time29, current time 34, horizon 5\n", - "adding: mem time30, current time 34, horizon 4\n", - "adding: mem time31, current time 34, horizon 3\n", - "adding: mem time32, current time 34, horizon 2\n", - "adding: mem time33, current time 34, horizon 1\n", - "adding: mem time0, current time 35, horizon 35\n", - "adding: mem time1, current time 35, horizon 34\n", - "adding: mem time2, current time 35, horizon 33\n", - "adding: mem time3, current time 35, horizon 32\n", - "adding: mem time4, current time 35, horizon 31\n", - "adding: mem time5, current time 35, horizon 30\n", - "adding: mem time6, current time 35, horizon 29\n", - "adding: mem time7, current time 35, horizon 28\n", - "adding: mem time8, current time 35, horizon 27\n", - "adding: mem time9, current time 35, horizon 26\n", - "adding: mem time10, current time 35, horizon 25\n", - "adding: mem time11, current time 35, horizon 24\n", - "adding: mem time12, current time 35, horizon 23\n", - "adding: mem time13, current time 35, horizon 22\n", - "adding: mem time14, current time 35, horizon 21\n", - "adding: mem time15, current time 35, horizon 20\n", - "adding: mem time16, current time 35, horizon 19\n", - "adding: mem time17, current time 35, horizon 18\n", - "adding: mem time18, current time 35, horizon 17\n", - "adding: mem time19, current time 35, horizon 16\n", - "adding: mem time20, current time 35, horizon 15\n", - "adding: mem time21, current time 35, horizon 14\n", - "adding: mem time22, current time 35, horizon 13\n", - "adding: mem time23, current time 35, horizon 12\n", - "adding: mem time24, current time 35, horizon 11\n", - "adding: mem time25, current time 35, horizon 10\n", - "adding: mem time26, current time 35, horizon 9\n", - "adding: mem time27, current time 35, horizon 8\n", - "adding: mem time28, current time 35, horizon 7\n", - "adding: mem time29, current time 35, horizon 6\n", - "adding: mem time30, current time 35, horizon 5\n", - "adding: mem time31, current time 35, horizon 4\n", - "adding: mem time32, current time 35, horizon 3\n", - "adding: mem time33, current time 35, horizon 2\n", - "adding: mem time34, current time 35, horizon 1\n", - "adding: mem time0, current time 36, horizon 36\n", - "adding: mem time1, current time 36, horizon 35\n", - "adding: mem time2, current time 36, horizon 34\n", - "adding: mem time3, current time 36, horizon 33\n", - "adding: mem time4, current time 36, horizon 32\n", - "adding: mem time5, current time 36, horizon 31\n", - "adding: mem time6, current time 36, horizon 30\n", - "adding: mem time7, current time 36, horizon 29\n", - "adding: mem time8, current time 36, horizon 28\n", - "adding: mem time9, current time 36, horizon 27\n", - "adding: mem time10, current time 36, horizon 26\n", - "adding: mem time11, current time 36, horizon 25\n", - "adding: mem time12, current time 36, horizon 24\n", - "adding: mem time13, current time 36, horizon 23\n", - "adding: mem time14, current time 36, horizon 22\n", - "adding: mem time15, current time 36, horizon 21\n", - "adding: mem time16, current time 36, horizon 20\n", - "adding: mem time17, current time 36, horizon 19\n", - "adding: mem time18, current time 36, horizon 18\n", - "adding: mem time19, current time 36, horizon 17\n", - "adding: mem time20, current time 36, horizon 16\n", - "adding: mem time21, current time 36, horizon 15\n", - "adding: mem time22, current time 36, horizon 14\n", - "adding: mem time23, current time 36, horizon 13\n", - "adding: mem time24, current time 36, horizon 12\n", - "adding: mem time25, current time 36, horizon 11\n", - "adding: mem time26, current time 36, horizon 10\n", - "adding: mem time27, current time 36, horizon 9\n", - "adding: mem time28, current time 36, horizon 8\n", - "adding: mem time29, current time 36, horizon 7\n", - "adding: mem time30, current time 36, horizon 6\n", - "adding: mem time31, current time 36, horizon 5\n", - "adding: mem time32, current time 36, horizon 4\n", - "adding: mem time33, current time 36, horizon 3\n", - "adding: mem time34, current time 36, horizon 2\n", - "adding: mem time35, current time 36, horizon 1\n", - "adding: mem time0, current time 37, horizon 37\n", - "adding: mem time1, current time 37, horizon 36\n", - "adding: mem time2, current time 37, horizon 35\n", - "adding: mem time3, current time 37, horizon 34\n", - "adding: mem time4, current time 37, horizon 33\n", - "adding: mem time5, current time 37, horizon 32\n", - "adding: mem time6, current time 37, horizon 31\n", - "adding: mem time7, current time 37, horizon 30\n", - "adding: mem time8, current time 37, horizon 29\n", - "adding: mem time9, current time 37, horizon 28\n", - "adding: mem time10, current time 37, horizon 27\n", - "adding: mem time11, current time 37, horizon 26\n", - "adding: mem time12, current time 37, horizon 25\n", - "adding: mem time13, current time 37, horizon 24\n", - "adding: mem time14, current time 37, horizon 23\n", - "adding: mem time15, current time 37, horizon 22\n", - "adding: mem time16, current time 37, horizon 21\n", - "adding: mem time17, current time 37, horizon 20\n", - "adding: mem time18, current time 37, horizon 19\n", - "adding: mem time19, current time 37, horizon 18\n", - "adding: mem time20, current time 37, horizon 17\n", - "adding: mem time21, current time 37, horizon 16\n", - "adding: mem time22, current time 37, horizon 15\n", - "adding: mem time23, current time 37, horizon 14\n", - "adding: mem time24, current time 37, horizon 13\n", - "adding: mem time25, current time 37, horizon 12\n", - "adding: mem time26, current time 37, horizon 11\n", - "adding: mem time27, current time 37, horizon 10\n", - "adding: mem time28, current time 37, horizon 9\n", - "adding: mem time29, current time 37, horizon 8\n", - "adding: mem time30, current time 37, horizon 7\n", - "adding: mem time31, current time 37, horizon 6\n", - "adding: mem time32, current time 37, horizon 5\n", - "adding: mem time33, current time 37, horizon 4\n", - "adding: mem time34, current time 37, horizon 3\n", - "adding: mem time35, current time 37, horizon 2\n", - "adding: mem time36, current time 37, horizon 1\n", - "adding: mem time0, current time 38, horizon 38\n", - "adding: mem time1, current time 38, horizon 37\n", - "adding: mem time2, current time 38, horizon 36\n", - "adding: mem time3, current time 38, horizon 35\n", - "adding: mem time4, current time 38, horizon 34\n", - "adding: mem time5, current time 38, horizon 33\n", - "adding: mem time6, current time 38, horizon 32\n", - "adding: mem time7, current time 38, horizon 31\n", - "adding: mem time8, current time 38, horizon 30\n", - "adding: mem time9, current time 38, horizon 29\n", - "adding: mem time10, current time 38, horizon 28\n", - "adding: mem time11, current time 38, horizon 27\n", - "adding: mem time12, current time 38, horizon 26\n", - "adding: mem time13, current time 38, horizon 25\n", - "adding: mem time14, current time 38, horizon 24\n", - "adding: mem time15, current time 38, horizon 23\n", - "adding: mem time16, current time 38, horizon 22\n", - "adding: mem time17, current time 38, horizon 21\n", - "adding: mem time18, current time 38, horizon 20\n", - "adding: mem time19, current time 38, horizon 19\n", - "adding: mem time20, current time 38, horizon 18\n", - "adding: mem time21, current time 38, horizon 17\n", - "adding: mem time22, current time 38, horizon 16\n", - "adding: mem time23, current time 38, horizon 15\n", - "adding: mem time24, current time 38, horizon 14\n", - "adding: mem time25, current time 38, horizon 13\n", - "adding: mem time26, current time 38, horizon 12\n", - "adding: mem time27, current time 38, horizon 11\n", - "adding: mem time28, current time 38, horizon 10\n", - "adding: mem time29, current time 38, horizon 9\n", - "adding: mem time30, current time 38, horizon 8\n", - "adding: mem time31, current time 38, horizon 7\n", - "adding: mem time32, current time 38, horizon 6\n", - "adding: mem time33, current time 38, horizon 5\n", - "adding: mem time34, current time 38, horizon 4\n", - "adding: mem time35, current time 38, horizon 3\n", - "adding: mem time36, current time 38, horizon 2\n", - "adding: mem time37, current time 38, horizon 1\n", - "adding: mem time0, current time 39, horizon 39\n", - "adding: mem time1, current time 39, horizon 38\n", - "adding: mem time2, current time 39, horizon 37\n", - "adding: mem time3, current time 39, horizon 36\n", - "adding: mem time4, current time 39, horizon 35\n", - "adding: mem time5, current time 39, horizon 34\n", - "adding: mem time6, current time 39, horizon 33\n", - "adding: mem time7, current time 39, horizon 32\n", - "adding: mem time8, current time 39, horizon 31\n", - "adding: mem time9, current time 39, horizon 30\n", - "adding: mem time10, current time 39, horizon 29\n", - "adding: mem time11, current time 39, horizon 28\n", - "adding: mem time12, current time 39, horizon 27\n", - "adding: mem time13, current time 39, horizon 26\n", - "adding: mem time14, current time 39, horizon 25\n", - "adding: mem time15, current time 39, horizon 24\n", - "adding: mem time16, current time 39, horizon 23\n", - "adding: mem time17, current time 39, horizon 22\n", - "adding: mem time18, current time 39, horizon 21\n", - "adding: mem time19, current time 39, horizon 20\n", - "adding: mem time20, current time 39, horizon 19\n", - "adding: mem time21, current time 39, horizon 18\n", - "adding: mem time22, current time 39, horizon 17\n", - "adding: mem time23, current time 39, horizon 16\n", - "adding: mem time24, current time 39, horizon 15\n", - "adding: mem time25, current time 39, horizon 14\n", - "adding: mem time26, current time 39, horizon 13\n", - "adding: mem time27, current time 39, horizon 12\n", - "adding: mem time28, current time 39, horizon 11\n", - "adding: mem time29, current time 39, horizon 10\n", - "adding: mem time30, current time 39, horizon 9\n", - "adding: mem time31, current time 39, horizon 8\n", - "adding: mem time32, current time 39, horizon 7\n", - "adding: mem time33, current time 39, horizon 6\n", - "adding: mem time34, current time 39, horizon 5\n", - "adding: mem time35, current time 39, horizon 4\n", - "adding: mem time36, current time 39, horizon 3\n", - "adding: mem time37, current time 39, horizon 2\n", - "adding: mem time38, current time 39, horizon 1\n", - "adding: mem time0, current time 40, horizon 40\n", - "adding: mem time1, current time 40, horizon 39\n", - "adding: mem time2, current time 40, horizon 38\n", - "adding: mem time3, current time 40, horizon 37\n", - "adding: mem time4, current time 40, horizon 36\n", - "adding: mem time5, current time 40, horizon 35\n", - "adding: mem time6, current time 40, horizon 34\n", - "adding: mem time7, current time 40, horizon 33\n", - "adding: mem time8, current time 40, horizon 32\n", - "adding: mem time9, current time 40, horizon 31\n", - "adding: mem time10, current time 40, horizon 30\n", - "adding: mem time11, current time 40, horizon 29\n", - "adding: mem time12, current time 40, horizon 28\n", - "adding: mem time13, current time 40, horizon 27\n", - "adding: mem time14, current time 40, horizon 26\n", - "adding: mem time15, current time 40, horizon 25\n", - "adding: mem time16, current time 40, horizon 24\n", - "adding: mem time17, current time 40, horizon 23\n", - "adding: mem time18, current time 40, horizon 22\n", - "adding: mem time19, current time 40, horizon 21\n", - "adding: mem time20, current time 40, horizon 20\n", - "adding: mem time21, current time 40, horizon 19\n", - "adding: mem time22, current time 40, horizon 18\n", - "adding: mem time23, current time 40, horizon 17\n", - "adding: mem time24, current time 40, horizon 16\n", - "adding: mem time25, current time 40, horizon 15\n", - "adding: mem time26, current time 40, horizon 14\n", - "adding: mem time27, current time 40, horizon 13\n", - "adding: mem time28, current time 40, horizon 12\n", - "adding: mem time29, current time 40, horizon 11\n", - "adding: mem time30, current time 40, horizon 10\n", - "adding: mem time31, current time 40, horizon 9\n", - "adding: mem time32, current time 40, horizon 8\n", - "adding: mem time33, current time 40, horizon 7\n", - "adding: mem time34, current time 40, horizon 6\n", - "adding: mem time35, current time 40, horizon 5\n", - "adding: mem time36, current time 40, horizon 4\n", - "adding: mem time37, current time 40, horizon 3\n", - "adding: mem time38, current time 40, horizon 2\n", - "adding: mem time39, current time 40, horizon 1\n", - "adding: mem time0, current time 41, horizon 41\n", - "adding: mem time1, current time 41, horizon 40\n", - "adding: mem time2, current time 41, horizon 39\n", - "adding: mem time3, current time 41, horizon 38\n", - "adding: mem time4, current time 41, horizon 37\n", - "adding: mem time5, current time 41, horizon 36\n", - "adding: mem time6, current time 41, horizon 35\n", - "adding: mem time7, current time 41, horizon 34\n", - "adding: mem time8, current time 41, horizon 33\n", - "adding: mem time9, current time 41, horizon 32\n", - "adding: mem time10, current time 41, horizon 31\n", - "adding: mem time11, current time 41, horizon 30\n", - "adding: mem time12, current time 41, horizon 29\n", - "adding: mem time13, current time 41, horizon 28\n", - "adding: mem time14, current time 41, horizon 27\n", - "adding: mem time15, current time 41, horizon 26\n", - "adding: mem time16, current time 41, horizon 25\n", - "adding: mem time17, current time 41, horizon 24\n", - "adding: mem time18, current time 41, horizon 23\n", - "adding: mem time19, current time 41, horizon 22\n", - "adding: mem time20, current time 41, horizon 21\n", - "adding: mem time21, current time 41, horizon 20\n", - "adding: mem time22, current time 41, horizon 19\n", - "adding: mem time23, current time 41, horizon 18\n", - "adding: mem time24, current time 41, horizon 17\n", - "adding: mem time25, current time 41, horizon 16\n", - "adding: mem time26, current time 41, horizon 15\n", - "adding: mem time27, current time 41, horizon 14\n", - "adding: mem time28, current time 41, horizon 13\n", - "adding: mem time29, current time 41, horizon 12\n", - "adding: mem time30, current time 41, horizon 11\n", - "adding: mem time31, current time 41, horizon 10\n", - "adding: mem time32, current time 41, horizon 9\n", - "adding: mem time33, current time 41, horizon 8\n", - "adding: mem time34, current time 41, horizon 7\n", - "adding: mem time35, current time 41, horizon 6\n", - "adding: mem time36, current time 41, horizon 5\n", - "adding: mem time37, current time 41, horizon 4\n", - "adding: mem time38, current time 41, horizon 3\n", - "adding: mem time39, current time 41, horizon 2\n", - "adding: mem time40, current time 41, horizon 1\n", - "adding: mem time0, current time 42, horizon 42\n", - "adding: mem time1, current time 42, horizon 41\n", - "adding: mem time2, current time 42, horizon 40\n", - "adding: mem time3, current time 42, horizon 39\n", - "adding: mem time4, current time 42, horizon 38\n", - "adding: mem time5, current time 42, horizon 37\n", - "adding: mem time6, current time 42, horizon 36\n", - "adding: mem time7, current time 42, horizon 35\n", - "adding: mem time8, current time 42, horizon 34\n", - "adding: mem time9, current time 42, horizon 33\n", - "adding: mem time10, current time 42, horizon 32\n", - "adding: mem time11, current time 42, horizon 31\n", - "adding: mem time12, current time 42, horizon 30\n", - "adding: mem time13, current time 42, horizon 29\n", - "adding: mem time14, current time 42, horizon 28\n", - "adding: mem time15, current time 42, horizon 27\n", - "adding: mem time16, current time 42, horizon 26\n", - "adding: mem time17, current time 42, horizon 25\n", - "adding: mem time18, current time 42, horizon 24\n", - "adding: mem time19, current time 42, horizon 23\n", - "adding: mem time20, current time 42, horizon 22\n", - "adding: mem time21, current time 42, horizon 21\n", - "adding: mem time22, current time 42, horizon 20\n", - "adding: mem time23, current time 42, horizon 19\n", - "adding: mem time24, current time 42, horizon 18\n", - "adding: mem time25, current time 42, horizon 17\n", - "adding: mem time26, current time 42, horizon 16\n", - "adding: mem time27, current time 42, horizon 15\n", - "adding: mem time28, current time 42, horizon 14\n", - "adding: mem time29, current time 42, horizon 13\n", - "adding: mem time30, current time 42, horizon 12\n", - "adding: mem time31, current time 42, horizon 11\n", - "adding: mem time32, current time 42, horizon 10\n", - "adding: mem time33, current time 42, horizon 9\n", - "adding: mem time34, current time 42, horizon 8\n", - "adding: mem time35, current time 42, horizon 7\n", - "adding: mem time36, current time 42, horizon 6\n", - "adding: mem time37, current time 42, horizon 5\n", - "adding: mem time38, current time 42, horizon 4\n", - "adding: mem time39, current time 42, horizon 3\n", - "adding: mem time40, current time 42, horizon 2\n", - "adding: mem time41, current time 42, horizon 1\n", - "adding: mem time0, current time 43, horizon 43\n", - "adding: mem time1, current time 43, horizon 42\n", - "adding: mem time2, current time 43, horizon 41\n", - "adding: mem time3, current time 43, horizon 40\n", - "adding: mem time4, current time 43, horizon 39\n", - "adding: mem time5, current time 43, horizon 38\n", - "adding: mem time6, current time 43, horizon 37\n", - "adding: mem time7, current time 43, horizon 36\n", - "adding: mem time8, current time 43, horizon 35\n", - "adding: mem time9, current time 43, horizon 34\n", - "adding: mem time10, current time 43, horizon 33\n", - "adding: mem time11, current time 43, horizon 32\n", - "adding: mem time12, current time 43, horizon 31\n", - "adding: mem time13, current time 43, horizon 30\n", - "adding: mem time14, current time 43, horizon 29\n", - "adding: mem time15, current time 43, horizon 28\n", - "adding: mem time16, current time 43, horizon 27\n", - "adding: mem time17, current time 43, horizon 26\n", - "adding: mem time18, current time 43, horizon 25\n", - "adding: mem time19, current time 43, horizon 24\n", - "adding: mem time20, current time 43, horizon 23\n", - "adding: mem time21, current time 43, horizon 22\n", - "adding: mem time22, current time 43, horizon 21\n", - "adding: mem time23, current time 43, horizon 20\n", - "adding: mem time24, current time 43, horizon 19\n", - "adding: mem time25, current time 43, horizon 18\n", - "adding: mem time26, current time 43, horizon 17\n", - "adding: mem time27, current time 43, horizon 16\n", - "adding: mem time28, current time 43, horizon 15\n", - "adding: mem time29, current time 43, horizon 14\n", - "adding: mem time30, current time 43, horizon 13\n", - "adding: mem time31, current time 43, horizon 12\n", - "adding: mem time32, current time 43, horizon 11\n", - "adding: mem time33, current time 43, horizon 10\n", - "adding: mem time34, current time 43, horizon 9\n", - "adding: mem time35, current time 43, horizon 8\n", - "adding: mem time36, current time 43, horizon 7\n", - "adding: mem time37, current time 43, horizon 6\n", - "adding: mem time38, current time 43, horizon 5\n", - "adding: mem time39, current time 43, horizon 4\n", - "adding: mem time40, current time 43, horizon 3\n", - "adding: mem time41, current time 43, horizon 2\n", - "adding: mem time42, current time 43, horizon 1\n", - "adding: mem time0, current time 44, horizon 44\n", - "adding: mem time1, current time 44, horizon 43\n", - "adding: mem time2, current time 44, horizon 42\n", - "adding: mem time3, current time 44, horizon 41\n", - "adding: mem time4, current time 44, horizon 40\n", - "adding: mem time5, current time 44, horizon 39\n", - "adding: mem time6, current time 44, horizon 38\n", - "adding: mem time7, current time 44, horizon 37\n", - "adding: mem time8, current time 44, horizon 36\n", - "adding: mem time9, current time 44, horizon 35\n", - "adding: mem time10, current time 44, horizon 34\n", - "adding: mem time11, current time 44, horizon 33\n", - "adding: mem time12, current time 44, horizon 32\n", - "adding: mem time13, current time 44, horizon 31\n", - "adding: mem time14, current time 44, horizon 30\n", - "adding: mem time15, current time 44, horizon 29\n", - "adding: mem time16, current time 44, horizon 28\n", - "adding: mem time17, current time 44, horizon 27\n", - "adding: mem time18, current time 44, horizon 26\n", - "adding: mem time19, current time 44, horizon 25\n", - "adding: mem time20, current time 44, horizon 24\n", - "adding: mem time21, current time 44, horizon 23\n", - "adding: mem time22, current time 44, horizon 22\n", - "adding: mem time23, current time 44, horizon 21\n", - "adding: mem time24, current time 44, horizon 20\n", - "adding: mem time25, current time 44, horizon 19\n", - "adding: mem time26, current time 44, horizon 18\n", - "adding: mem time27, current time 44, horizon 17\n", - "adding: mem time28, current time 44, horizon 16\n", - "adding: mem time29, current time 44, horizon 15\n", - "adding: mem time30, current time 44, horizon 14\n", - "adding: mem time31, current time 44, horizon 13\n", - "adding: mem time32, current time 44, horizon 12\n", - "adding: mem time33, current time 44, horizon 11\n", - "adding: mem time34, current time 44, horizon 10\n", - "adding: mem time35, current time 44, horizon 9\n", - "adding: mem time36, current time 44, horizon 8\n", - "adding: mem time37, current time 44, horizon 7\n", - "adding: mem time38, current time 44, horizon 6\n", - "adding: mem time39, current time 44, horizon 5\n", - "adding: mem time40, current time 44, horizon 4\n", - "adding: mem time41, current time 44, horizon 3\n", - "adding: mem time42, current time 44, horizon 2\n", - "adding: mem time43, current time 44, horizon 1\n", - "adding: mem time0, current time 45, horizon 45\n", - "adding: mem time1, current time 45, horizon 44\n", - "adding: mem time2, current time 45, horizon 43\n", - "adding: mem time3, current time 45, horizon 42\n", - "adding: mem time4, current time 45, horizon 41\n", - "adding: mem time5, current time 45, horizon 40\n", - "adding: mem time6, current time 45, horizon 39\n", - "adding: mem time7, current time 45, horizon 38\n", - "adding: mem time8, current time 45, horizon 37\n", - "adding: mem time9, current time 45, horizon 36\n", - "adding: mem time10, current time 45, horizon 35\n", - "adding: mem time11, current time 45, horizon 34\n", - "adding: mem time12, current time 45, horizon 33\n", - "adding: mem time13, current time 45, horizon 32\n", - "adding: mem time14, current time 45, horizon 31\n", - "adding: mem time15, current time 45, horizon 30\n", - "adding: mem time16, current time 45, horizon 29\n", - "adding: mem time17, current time 45, horizon 28\n", - "adding: mem time18, current time 45, horizon 27\n", - "adding: mem time19, current time 45, horizon 26\n", - "adding: mem time20, current time 45, horizon 25\n", - "adding: mem time21, current time 45, horizon 24\n", - "adding: mem time22, current time 45, horizon 23\n", - "adding: mem time23, current time 45, horizon 22\n", - "adding: mem time24, current time 45, horizon 21\n", - "adding: mem time25, current time 45, horizon 20\n", - "adding: mem time26, current time 45, horizon 19\n", - "adding: mem time27, current time 45, horizon 18\n", - "adding: mem time28, current time 45, horizon 17\n", - "adding: mem time29, current time 45, horizon 16\n", - "adding: mem time30, current time 45, horizon 15\n", - "adding: mem time31, current time 45, horizon 14\n", - "adding: mem time32, current time 45, horizon 13\n", - "adding: mem time33, current time 45, horizon 12\n", - "adding: mem time34, current time 45, horizon 11\n", - "adding: mem time35, current time 45, horizon 10\n", - "adding: mem time36, current time 45, horizon 9\n", - "adding: mem time37, current time 45, horizon 8\n", - "adding: mem time38, current time 45, horizon 7\n", - "adding: mem time39, current time 45, horizon 6\n", - "adding: mem time40, current time 45, horizon 5\n", - "adding: mem time41, current time 45, horizon 4\n", - "adding: mem time42, current time 45, horizon 3\n", - "adding: mem time43, current time 45, horizon 2\n", - "adding: mem time44, current time 45, horizon 1\n", - "adding: mem time0, current time 46, horizon 46\n", - "adding: mem time1, current time 46, horizon 45\n", - "adding: mem time2, current time 46, horizon 44\n", - "adding: mem time3, current time 46, horizon 43\n", - "adding: mem time4, current time 46, horizon 42\n", - "adding: mem time5, current time 46, horizon 41\n", - "adding: mem time6, current time 46, horizon 40\n", - "adding: mem time7, current time 46, horizon 39\n", - "adding: mem time8, current time 46, horizon 38\n", - "adding: mem time9, current time 46, horizon 37\n", - "adding: mem time10, current time 46, horizon 36\n", - "adding: mem time11, current time 46, horizon 35\n", - "adding: mem time12, current time 46, horizon 34\n", - "adding: mem time13, current time 46, horizon 33\n", - "adding: mem time14, current time 46, horizon 32\n", - "adding: mem time15, current time 46, horizon 31\n", - "adding: mem time16, current time 46, horizon 30\n", - "adding: mem time17, current time 46, horizon 29\n", - "adding: mem time18, current time 46, horizon 28\n", - "adding: mem time19, current time 46, horizon 27\n", - "adding: mem time20, current time 46, horizon 26\n", - "adding: mem time21, current time 46, horizon 25\n", - "adding: mem time22, current time 46, horizon 24\n", - "adding: mem time23, current time 46, horizon 23\n", - "adding: mem time24, current time 46, horizon 22\n", - "adding: mem time25, current time 46, horizon 21\n", - "adding: mem time26, current time 46, horizon 20\n", - "adding: mem time27, current time 46, horizon 19\n", - "adding: mem time28, current time 46, horizon 18\n", - "adding: mem time29, current time 46, horizon 17\n", - "adding: mem time30, current time 46, horizon 16\n", - "adding: mem time31, current time 46, horizon 15\n", - "adding: mem time32, current time 46, horizon 14\n", - "adding: mem time33, current time 46, horizon 13\n", - "adding: mem time34, current time 46, horizon 12\n", - "adding: mem time35, current time 46, horizon 11\n", - "adding: mem time36, current time 46, horizon 10\n", - "adding: mem time37, current time 46, horizon 9\n", - "adding: mem time38, current time 46, horizon 8\n", - "adding: mem time39, current time 46, horizon 7\n", - "adding: mem time40, current time 46, horizon 6\n", - "adding: mem time41, current time 46, horizon 5\n", - "adding: mem time42, current time 46, horizon 4\n", - "adding: mem time43, current time 46, horizon 3\n", - "adding: mem time44, current time 46, horizon 2\n", - "adding: mem time45, current time 46, horizon 1\n", - "adding: mem time0, current time 47, horizon 47\n", - "adding: mem time1, current time 47, horizon 46\n", - "adding: mem time2, current time 47, horizon 45\n", - "adding: mem time3, current time 47, horizon 44\n", - "adding: mem time4, current time 47, horizon 43\n", - "adding: mem time5, current time 47, horizon 42\n", - "adding: mem time6, current time 47, horizon 41\n", - "adding: mem time7, current time 47, horizon 40\n", - "adding: mem time8, current time 47, horizon 39\n", - "adding: mem time9, current time 47, horizon 38\n", - "adding: mem time10, current time 47, horizon 37\n", - "adding: mem time11, current time 47, horizon 36\n", - "adding: mem time12, current time 47, horizon 35\n", - "adding: mem time13, current time 47, horizon 34\n", - "adding: mem time14, current time 47, horizon 33\n", - "adding: mem time15, current time 47, horizon 32\n", - "adding: mem time16, current time 47, horizon 31\n", - "adding: mem time17, current time 47, horizon 30\n", - "adding: mem time18, current time 47, horizon 29\n", - "adding: mem time19, current time 47, horizon 28\n", - "adding: mem time20, current time 47, horizon 27\n", - "adding: mem time21, current time 47, horizon 26\n", - "adding: mem time22, current time 47, horizon 25\n", - "adding: mem time23, current time 47, horizon 24\n", - "adding: mem time24, current time 47, horizon 23\n", - "adding: mem time25, current time 47, horizon 22\n", - "adding: mem time26, current time 47, horizon 21\n", - "adding: mem time27, current time 47, horizon 20\n", - "adding: mem time28, current time 47, horizon 19\n", - "adding: mem time29, current time 47, horizon 18\n", - "adding: mem time30, current time 47, horizon 17\n", - "adding: mem time31, current time 47, horizon 16\n", - "adding: mem time32, current time 47, horizon 15\n", - "adding: mem time33, current time 47, horizon 14\n", - "adding: mem time34, current time 47, horizon 13\n", - "adding: mem time35, current time 47, horizon 12\n", - "adding: mem time36, current time 47, horizon 11\n", - "adding: mem time37, current time 47, horizon 10\n", - "adding: mem time38, current time 47, horizon 9\n", - "adding: mem time39, current time 47, horizon 8\n", - "adding: mem time40, current time 47, horizon 7\n", - "adding: mem time41, current time 47, horizon 6\n", - "adding: mem time42, current time 47, horizon 5\n", - "adding: mem time43, current time 47, horizon 4\n", - "adding: mem time44, current time 47, horizon 3\n", - "adding: mem time45, current time 47, horizon 2\n", - "adding: mem time46, current time 47, horizon 1\n", - "adding: mem time0, current time 48, horizon 48\n", - "adding: mem time1, current time 48, horizon 47\n", - "adding: mem time2, current time 48, horizon 46\n", - "adding: mem time3, current time 48, horizon 45\n", - "adding: mem time4, current time 48, horizon 44\n", - "adding: mem time5, current time 48, horizon 43\n", - "adding: mem time6, current time 48, horizon 42\n", - "adding: mem time7, current time 48, horizon 41\n", - "adding: mem time8, current time 48, horizon 40\n", - "adding: mem time9, current time 48, horizon 39\n", - "adding: mem time10, current time 48, horizon 38\n", - "adding: mem time11, current time 48, horizon 37\n", - "adding: mem time12, current time 48, horizon 36\n", - "adding: mem time13, current time 48, horizon 35\n", - "adding: mem time14, current time 48, horizon 34\n", - "adding: mem time15, current time 48, horizon 33\n", - "adding: mem time16, current time 48, horizon 32\n", - "adding: mem time17, current time 48, horizon 31\n", - "adding: mem time18, current time 48, horizon 30\n", - "adding: mem time19, current time 48, horizon 29\n", - "adding: mem time20, current time 48, horizon 28\n", - "adding: mem time21, current time 48, horizon 27\n", - "adding: mem time22, current time 48, horizon 26\n", - "adding: mem time23, current time 48, horizon 25\n", - "adding: mem time24, current time 48, horizon 24\n", - "adding: mem time25, current time 48, horizon 23\n", - "adding: mem time26, current time 48, horizon 22\n", - "adding: mem time27, current time 48, horizon 21\n", - "adding: mem time28, current time 48, horizon 20\n", - "adding: mem time29, current time 48, horizon 19\n", - "adding: mem time30, current time 48, horizon 18\n", - "adding: mem time31, current time 48, horizon 17\n", - "adding: mem time32, current time 48, horizon 16\n", - "adding: mem time33, current time 48, horizon 15\n", - "adding: mem time34, current time 48, horizon 14\n", - "adding: mem time35, current time 48, horizon 13\n", - "adding: mem time36, current time 48, horizon 12\n", - "adding: mem time37, current time 48, horizon 11\n", - "adding: mem time38, current time 48, horizon 10\n", - "adding: mem time39, current time 48, horizon 9\n", - "adding: mem time40, current time 48, horizon 8\n", - "adding: mem time41, current time 48, horizon 7\n", - "adding: mem time42, current time 48, horizon 6\n", - "adding: mem time43, current time 48, horizon 5\n", - "adding: mem time44, current time 48, horizon 4\n", - "adding: mem time45, current time 48, horizon 3\n", - "adding: mem time46, current time 48, horizon 2\n", - "adding: mem time47, current time 48, horizon 1\n", - "adding: mem time0, current time 49, horizon 49\n", - "adding: mem time1, current time 49, horizon 48\n", - "adding: mem time2, current time 49, horizon 47\n", - "adding: mem time3, current time 49, horizon 46\n", - "adding: mem time4, current time 49, horizon 45\n", - "adding: mem time5, current time 49, horizon 44\n", - "adding: mem time6, current time 49, horizon 43\n", - "adding: mem time7, current time 49, horizon 42\n", - "adding: mem time8, current time 49, horizon 41\n", - "adding: mem time9, current time 49, horizon 40\n", - "adding: mem time10, current time 49, horizon 39\n", - "adding: mem time11, current time 49, horizon 38\n", - "adding: mem time12, current time 49, horizon 37\n", - "adding: mem time13, current time 49, horizon 36\n", - "adding: mem time14, current time 49, horizon 35\n", - "adding: mem time15, current time 49, horizon 34\n", - "adding: mem time16, current time 49, horizon 33\n", - "adding: mem time17, current time 49, horizon 32\n", - "adding: mem time18, current time 49, horizon 31\n", - "adding: mem time19, current time 49, horizon 30\n", - "adding: mem time20, current time 49, horizon 29\n", - "adding: mem time21, current time 49, horizon 28\n", - "adding: mem time22, current time 49, horizon 27\n", - "adding: mem time23, current time 49, horizon 26\n", - "adding: mem time24, current time 49, horizon 25\n", - "adding: mem time25, current time 49, horizon 24\n", - "adding: mem time26, current time 49, horizon 23\n", - "adding: mem time27, current time 49, horizon 22\n", - "adding: mem time28, current time 49, horizon 21\n", - "adding: mem time29, current time 49, horizon 20\n", - "adding: mem time30, current time 49, horizon 19\n", - "adding: mem time31, current time 49, horizon 18\n", - "adding: mem time32, current time 49, horizon 17\n", - "adding: mem time33, current time 49, horizon 16\n", - "adding: mem time34, current time 49, horizon 15\n", - "adding: mem time35, current time 49, horizon 14\n", - "adding: mem time36, current time 49, horizon 13\n", - "adding: mem time37, current time 49, horizon 12\n", - "adding: mem time38, current time 49, horizon 11\n", - "adding: mem time39, current time 49, horizon 10\n", - "adding: mem time40, current time 49, horizon 9\n", - "adding: mem time41, current time 49, horizon 8\n", - "adding: mem time42, current time 49, horizon 7\n", - "adding: mem time43, current time 49, horizon 6\n", - "adding: mem time44, current time 49, horizon 5\n", - "adding: mem time45, current time 49, horizon 4\n", - "adding: mem time46, current time 49, horizon 3\n", - "adding: mem time47, current time 49, horizon 2\n", - "adding: mem time48, current time 49, horizon 1\n", - "adding: mem time0, current time 50, horizon 50\n", - "adding: mem time1, current time 50, horizon 49\n", - "adding: mem time2, current time 50, horizon 48\n", - "adding: mem time3, current time 50, horizon 47\n", - "adding: mem time4, current time 50, horizon 46\n", - "adding: mem time5, current time 50, horizon 45\n", - "adding: mem time6, current time 50, horizon 44\n", - "adding: mem time7, current time 50, horizon 43\n", - "adding: mem time8, current time 50, horizon 42\n", - "adding: mem time9, current time 50, horizon 41\n", - "adding: mem time10, current time 50, horizon 40\n", - "adding: mem time11, current time 50, horizon 39\n", - "adding: mem time12, current time 50, horizon 38\n", - "adding: mem time13, current time 50, horizon 37\n", - "adding: mem time14, current time 50, horizon 36\n", - "adding: mem time15, current time 50, horizon 35\n", - "adding: mem time16, current time 50, horizon 34\n", - "adding: mem time17, current time 50, horizon 33\n", - "adding: mem time18, current time 50, horizon 32\n", - "adding: mem time19, current time 50, horizon 31\n", - "adding: mem time20, current time 50, horizon 30\n", - "adding: mem time21, current time 50, horizon 29\n", - "adding: mem time22, current time 50, horizon 28\n", - "adding: mem time23, current time 50, horizon 27\n", - "adding: mem time24, current time 50, horizon 26\n", - "adding: mem time25, current time 50, horizon 25\n", - "adding: mem time26, current time 50, horizon 24\n", - "adding: mem time27, current time 50, horizon 23\n", - "adding: mem time28, current time 50, horizon 22\n", - "adding: mem time29, current time 50, horizon 21\n", - "adding: mem time30, current time 50, horizon 20\n", - "adding: mem time31, current time 50, horizon 19\n", - "adding: mem time32, current time 50, horizon 18\n", - "adding: mem time33, current time 50, horizon 17\n", - "adding: mem time34, current time 50, horizon 16\n", - "adding: mem time35, current time 50, horizon 15\n", - "adding: mem time36, current time 50, horizon 14\n", - "adding: mem time37, current time 50, horizon 13\n", - "adding: mem time38, current time 50, horizon 12\n", - "adding: mem time39, current time 50, horizon 11\n", - "adding: mem time40, current time 50, horizon 10\n", - "adding: mem time41, current time 50, horizon 9\n", - "adding: mem time42, current time 50, horizon 8\n", - "adding: mem time43, current time 50, horizon 7\n", - "adding: mem time44, current time 50, horizon 6\n", - "adding: mem time45, current time 50, horizon 5\n", - "adding: mem time46, current time 50, horizon 4\n", - "adding: mem time47, current time 50, horizon 3\n", - "adding: mem time48, current time 50, horizon 2\n", - "adding: mem time49, current time 50, horizon 1\n", - "adding: mem time0, current time 51, horizon 51\n", - "adding: mem time1, current time 51, horizon 50\n", - "adding: mem time2, current time 51, horizon 49\n", - "adding: mem time3, current time 51, horizon 48\n", - "adding: mem time4, current time 51, horizon 47\n", - "adding: mem time5, current time 51, horizon 46\n", - "adding: mem time6, current time 51, horizon 45\n", - "adding: mem time7, current time 51, horizon 44\n", - "adding: mem time8, current time 51, horizon 43\n", - "adding: mem time9, current time 51, horizon 42\n", - "adding: mem time10, current time 51, horizon 41\n", - "adding: mem time11, current time 51, horizon 40\n", - "adding: mem time12, current time 51, horizon 39\n", - "adding: mem time13, current time 51, horizon 38\n", - "adding: mem time14, current time 51, horizon 37\n", - "adding: mem time15, current time 51, horizon 36\n", - "adding: mem time16, current time 51, horizon 35\n", - "adding: mem time17, current time 51, horizon 34\n", - "adding: mem time18, current time 51, horizon 33\n", - "adding: mem time19, current time 51, horizon 32\n", - "adding: mem time20, current time 51, horizon 31\n", - "adding: mem time21, current time 51, horizon 30\n", - "adding: mem time22, current time 51, horizon 29\n", - "adding: mem time23, current time 51, horizon 28\n", - "adding: mem time24, current time 51, horizon 27\n", - "adding: mem time25, current time 51, horizon 26\n", - "adding: mem time26, current time 51, horizon 25\n", - "adding: mem time27, current time 51, horizon 24\n", - "adding: mem time28, current time 51, horizon 23\n", - "adding: mem time29, current time 51, horizon 22\n", - "adding: mem time30, current time 51, horizon 21\n", - "adding: mem time31, current time 51, horizon 20\n", - "adding: mem time32, current time 51, horizon 19\n", - "adding: mem time33, current time 51, horizon 18\n", - "adding: mem time34, current time 51, horizon 17\n", - "adding: mem time35, current time 51, horizon 16\n", - "adding: mem time36, current time 51, horizon 15\n", - "adding: mem time37, current time 51, horizon 14\n", - "adding: mem time38, current time 51, horizon 13\n", - "adding: mem time39, current time 51, horizon 12\n", - "adding: mem time40, current time 51, horizon 11\n", - "adding: mem time41, current time 51, horizon 10\n", - "adding: mem time42, current time 51, horizon 9\n", - "adding: mem time43, current time 51, horizon 8\n", - "adding: mem time44, current time 51, horizon 7\n", - "adding: mem time45, current time 51, horizon 6\n", - "adding: mem time46, current time 51, horizon 5\n", - "adding: mem time47, current time 51, horizon 4\n", - "adding: mem time48, current time 51, horizon 3\n", - "adding: mem time49, current time 51, horizon 2\n", - "adding: mem time50, current time 51, horizon 1\n", - "adding: mem time0, current time 52, horizon 52\n", - "adding: mem time1, current time 52, horizon 51\n", - "adding: mem time2, current time 52, horizon 50\n", - "adding: mem time3, current time 52, horizon 49\n", - "adding: mem time4, current time 52, horizon 48\n", - "adding: mem time5, current time 52, horizon 47\n", - "adding: mem time6, current time 52, horizon 46\n", - "adding: mem time7, current time 52, horizon 45\n", - "adding: mem time8, current time 52, horizon 44\n", - "adding: mem time9, current time 52, horizon 43\n", - "adding: mem time10, current time 52, horizon 42\n", - "adding: mem time11, current time 52, horizon 41\n", - "adding: mem time12, current time 52, horizon 40\n", - "adding: mem time13, current time 52, horizon 39\n", - "adding: mem time14, current time 52, horizon 38\n", - "adding: mem time15, current time 52, horizon 37\n", - "adding: mem time16, current time 52, horizon 36\n", - "adding: mem time17, current time 52, horizon 35\n", - "adding: mem time18, current time 52, horizon 34\n", - "adding: mem time19, current time 52, horizon 33\n", - "adding: mem time20, current time 52, horizon 32\n", - "adding: mem time21, current time 52, horizon 31\n", - "adding: mem time22, current time 52, horizon 30\n", - "adding: mem time23, current time 52, horizon 29\n", - "adding: mem time24, current time 52, horizon 28\n", - "adding: mem time25, current time 52, horizon 27\n", - "adding: mem time26, current time 52, horizon 26\n", - "adding: mem time27, current time 52, horizon 25\n", - "adding: mem time28, current time 52, horizon 24\n", - "adding: mem time29, current time 52, horizon 23\n", - "adding: mem time30, current time 52, horizon 22\n", - "adding: mem time31, current time 52, horizon 21\n", - "adding: mem time32, current time 52, horizon 20\n", - "adding: mem time33, current time 52, horizon 19\n", - "adding: mem time34, current time 52, horizon 18\n", - "adding: mem time35, current time 52, horizon 17\n", - "adding: mem time36, current time 52, horizon 16\n", - "adding: mem time37, current time 52, horizon 15\n", - "adding: mem time38, current time 52, horizon 14\n", - "adding: mem time39, current time 52, horizon 13\n", - "adding: mem time40, current time 52, horizon 12\n", - "adding: mem time41, current time 52, horizon 11\n", - "adding: mem time42, current time 52, horizon 10\n", - "adding: mem time43, current time 52, horizon 9\n", - "adding: mem time44, current time 52, horizon 8\n", - "adding: mem time45, current time 52, horizon 7\n", - "adding: mem time46, current time 52, horizon 6\n", - "adding: mem time47, current time 52, horizon 5\n", - "adding: mem time48, current time 52, horizon 4\n", - "adding: mem time49, current time 52, horizon 3\n", - "adding: mem time50, current time 52, horizon 2\n", - "adding: mem time51, current time 52, horizon 1\n", - "adding: mem time0, current time 53, horizon 53\n", - "adding: mem time1, current time 53, horizon 52\n", - "adding: mem time2, current time 53, horizon 51\n", - "adding: mem time3, current time 53, horizon 50\n", - "adding: mem time4, current time 53, horizon 49\n", - "adding: mem time5, current time 53, horizon 48\n", - "adding: mem time6, current time 53, horizon 47\n", - "adding: mem time7, current time 53, horizon 46\n", - "adding: mem time8, current time 53, horizon 45\n", - "adding: mem time9, current time 53, horizon 44\n", - "adding: mem time10, current time 53, horizon 43\n", - "adding: mem time11, current time 53, horizon 42\n", - "adding: mem time12, current time 53, horizon 41\n", - "adding: mem time13, current time 53, horizon 40\n", - "adding: mem time14, current time 53, horizon 39\n", - "adding: mem time15, current time 53, horizon 38\n", - "adding: mem time16, current time 53, horizon 37\n", - "adding: mem time17, current time 53, horizon 36\n", - "adding: mem time18, current time 53, horizon 35\n", - "adding: mem time19, current time 53, horizon 34\n", - "adding: mem time20, current time 53, horizon 33\n", - "adding: mem time21, current time 53, horizon 32\n", - "adding: mem time22, current time 53, horizon 31\n", - "adding: mem time23, current time 53, horizon 30\n", - "adding: mem time24, current time 53, horizon 29\n", - "adding: mem time25, current time 53, horizon 28\n", - "adding: mem time26, current time 53, horizon 27\n", - "adding: mem time27, current time 53, horizon 26\n", - "adding: mem time28, current time 53, horizon 25\n", - "adding: mem time29, current time 53, horizon 24\n", - "adding: mem time30, current time 53, horizon 23\n", - "adding: mem time31, current time 53, horizon 22\n", - "adding: mem time32, current time 53, horizon 21\n", - "adding: mem time33, current time 53, horizon 20\n", - "adding: mem time34, current time 53, horizon 19\n", - "adding: mem time35, current time 53, horizon 18\n", - "adding: mem time36, current time 53, horizon 17\n", - "adding: mem time37, current time 53, horizon 16\n", - "adding: mem time38, current time 53, horizon 15\n", - "adding: mem time39, current time 53, horizon 14\n", - "adding: mem time40, current time 53, horizon 13\n", - "adding: mem time41, current time 53, horizon 12\n", - "adding: mem time42, current time 53, horizon 11\n", - "adding: mem time43, current time 53, horizon 10\n", - "adding: mem time44, current time 53, horizon 9\n", - "adding: mem time45, current time 53, horizon 8\n", - "adding: mem time46, current time 53, horizon 7\n", - "adding: mem time47, current time 53, horizon 6\n", - "adding: mem time48, current time 53, horizon 5\n", - "adding: mem time49, current time 53, horizon 4\n", - "adding: mem time50, current time 53, horizon 3\n", - "adding: mem time51, current time 53, horizon 2\n", - "adding: mem time52, current time 53, horizon 1\n", - "adding: mem time0, current time 54, horizon 54\n", - "adding: mem time1, current time 54, horizon 53\n", - "adding: mem time2, current time 54, horizon 52\n", - "adding: mem time3, current time 54, horizon 51\n", - "adding: mem time4, current time 54, horizon 50\n", - "adding: mem time5, current time 54, horizon 49\n", - "adding: mem time6, current time 54, horizon 48\n", - "adding: mem time7, current time 54, horizon 47\n", - "adding: mem time8, current time 54, horizon 46\n", - "adding: mem time9, current time 54, horizon 45\n", - "adding: mem time10, current time 54, horizon 44\n", - "adding: mem time11, current time 54, horizon 43\n", - "adding: mem time12, current time 54, horizon 42\n", - "adding: mem time13, current time 54, horizon 41\n", - "adding: mem time14, current time 54, horizon 40\n", - "adding: mem time15, current time 54, horizon 39\n", - "adding: mem time16, current time 54, horizon 38\n", - "adding: mem time17, current time 54, horizon 37\n", - "adding: mem time18, current time 54, horizon 36\n", - "adding: mem time19, current time 54, horizon 35\n", - "adding: mem time20, current time 54, horizon 34\n", - "adding: mem time21, current time 54, horizon 33\n", - "adding: mem time22, current time 54, horizon 32\n", - "adding: mem time23, current time 54, horizon 31\n", - "adding: mem time24, current time 54, horizon 30\n", - "adding: mem time25, current time 54, horizon 29\n", - "adding: mem time26, current time 54, horizon 28\n", - "adding: mem time27, current time 54, horizon 27\n", - "adding: mem time28, current time 54, horizon 26\n", - "adding: mem time29, current time 54, horizon 25\n", - "adding: mem time30, current time 54, horizon 24\n", - "adding: mem time31, current time 54, horizon 23\n", - "adding: mem time32, current time 54, horizon 22\n", - "adding: mem time33, current time 54, horizon 21\n", - "adding: mem time34, current time 54, horizon 20\n", - "adding: mem time35, current time 54, horizon 19\n", - "adding: mem time36, current time 54, horizon 18\n", - "adding: mem time37, current time 54, horizon 17\n", - "adding: mem time38, current time 54, horizon 16\n", - "adding: mem time39, current time 54, horizon 15\n", - "adding: mem time40, current time 54, horizon 14\n", - "adding: mem time41, current time 54, horizon 13\n", - "adding: mem time42, current time 54, horizon 12\n", - "adding: mem time43, current time 54, horizon 11\n", - "adding: mem time44, current time 54, horizon 10\n", - "adding: mem time45, current time 54, horizon 9\n", - "adding: mem time46, current time 54, horizon 8\n", - "adding: mem time47, current time 54, horizon 7\n", - "adding: mem time48, current time 54, horizon 6\n", - "adding: mem time49, current time 54, horizon 5\n", - "adding: mem time50, current time 54, horizon 4\n", - "adding: mem time51, current time 54, horizon 3\n", - "adding: mem time52, current time 54, horizon 2\n", - "adding: mem time53, current time 54, horizon 1\n", - "adding: mem time0, current time 55, horizon 55\n", - "adding: mem time1, current time 55, horizon 54\n", - "adding: mem time2, current time 55, horizon 53\n", - "adding: mem time3, current time 55, horizon 52\n", - "adding: mem time4, current time 55, horizon 51\n", - "adding: mem time5, current time 55, horizon 50\n", - "adding: mem time6, current time 55, horizon 49\n", - "adding: mem time7, current time 55, horizon 48\n", - "adding: mem time8, current time 55, horizon 47\n", - "adding: mem time9, current time 55, horizon 46\n", - "adding: mem time10, current time 55, horizon 45\n", - "adding: mem time11, current time 55, horizon 44\n", - "adding: mem time12, current time 55, horizon 43\n", - "adding: mem time13, current time 55, horizon 42\n", - "adding: mem time14, current time 55, horizon 41\n", - "adding: mem time15, current time 55, horizon 40\n", - "adding: mem time16, current time 55, horizon 39\n", - "adding: mem time17, current time 55, horizon 38\n", - "adding: mem time18, current time 55, horizon 37\n", - "adding: mem time19, current time 55, horizon 36\n", - "adding: mem time20, current time 55, horizon 35\n", - "adding: mem time21, current time 55, horizon 34\n", - "adding: mem time22, current time 55, horizon 33\n", - "adding: mem time23, current time 55, horizon 32\n", - "adding: mem time24, current time 55, horizon 31\n", - "adding: mem time25, current time 55, horizon 30\n", - "adding: mem time26, current time 55, horizon 29\n", - "adding: mem time27, current time 55, horizon 28\n", - "adding: mem time28, current time 55, horizon 27\n", - "adding: mem time29, current time 55, horizon 26\n", - "adding: mem time30, current time 55, horizon 25\n", - "adding: mem time31, current time 55, horizon 24\n", - "adding: mem time32, current time 55, horizon 23\n", - "adding: mem time33, current time 55, horizon 22\n", - "adding: mem time34, current time 55, horizon 21\n", - "adding: mem time35, current time 55, horizon 20\n", - "adding: mem time36, current time 55, horizon 19\n", - "adding: mem time37, current time 55, horizon 18\n", - "adding: mem time38, current time 55, horizon 17\n", - "adding: mem time39, current time 55, horizon 16\n", - "adding: mem time40, current time 55, horizon 15\n", - "adding: mem time41, current time 55, horizon 14\n", - "adding: mem time42, current time 55, horizon 13\n", - "adding: mem time43, current time 55, horizon 12\n", - "adding: mem time44, current time 55, horizon 11\n", - "adding: mem time45, current time 55, horizon 10\n", - "adding: mem time46, current time 55, horizon 9\n", - "adding: mem time47, current time 55, horizon 8\n", - "adding: mem time48, current time 55, horizon 7\n", - "adding: mem time49, current time 55, horizon 6\n", - "adding: mem time50, current time 55, horizon 5\n", - "adding: mem time51, current time 55, horizon 4\n", - "adding: mem time52, current time 55, horizon 3\n", - "adding: mem time53, current time 55, horizon 2\n", - "adding: mem time54, current time 55, horizon 1\n", - "adding: mem time0, current time 56, horizon 56\n", - "adding: mem time1, current time 56, horizon 55\n", - "adding: mem time2, current time 56, horizon 54\n", - "adding: mem time3, current time 56, horizon 53\n", - "adding: mem time4, current time 56, horizon 52\n", - "adding: mem time5, current time 56, horizon 51\n", - "adding: mem time6, current time 56, horizon 50\n", - "adding: mem time7, current time 56, horizon 49\n", - "adding: mem time8, current time 56, horizon 48\n", - "adding: mem time9, current time 56, horizon 47\n", - "adding: mem time10, current time 56, horizon 46\n", - "adding: mem time11, current time 56, horizon 45\n", - "adding: mem time12, current time 56, horizon 44\n", - "adding: mem time13, current time 56, horizon 43\n", - "adding: mem time14, current time 56, horizon 42\n", - "adding: mem time15, current time 56, horizon 41\n", - "adding: mem time16, current time 56, horizon 40\n", - "adding: mem time17, current time 56, horizon 39\n", - "adding: mem time18, current time 56, horizon 38\n", - "adding: mem time19, current time 56, horizon 37\n", - "adding: mem time20, current time 56, horizon 36\n", - "adding: mem time21, current time 56, horizon 35\n", - "adding: mem time22, current time 56, horizon 34\n", - "adding: mem time23, current time 56, horizon 33\n", - "adding: mem time24, current time 56, horizon 32\n", - "adding: mem time25, current time 56, horizon 31\n", - "adding: mem time26, current time 56, horizon 30\n", - "adding: mem time27, current time 56, horizon 29\n", - "adding: mem time28, current time 56, horizon 28\n", - "adding: mem time29, current time 56, horizon 27\n", - "adding: mem time30, current time 56, horizon 26\n", - "adding: mem time31, current time 56, horizon 25\n", - "adding: mem time32, current time 56, horizon 24\n", - "adding: mem time33, current time 56, horizon 23\n", - "adding: mem time34, current time 56, horizon 22\n", - "adding: mem time35, current time 56, horizon 21\n", - "adding: mem time36, current time 56, horizon 20\n", - "adding: mem time37, current time 56, horizon 19\n", - "adding: mem time38, current time 56, horizon 18\n", - "adding: mem time39, current time 56, horizon 17\n", - "adding: mem time40, current time 56, horizon 16\n", - "adding: mem time41, current time 56, horizon 15\n", - "adding: mem time42, current time 56, horizon 14\n", - "adding: mem time43, current time 56, horizon 13\n", - "adding: mem time44, current time 56, horizon 12\n", - "adding: mem time45, current time 56, horizon 11\n", - "adding: mem time46, current time 56, horizon 10\n", - "adding: mem time47, current time 56, horizon 9\n", - "adding: mem time48, current time 56, horizon 8\n", - "adding: mem time49, current time 56, horizon 7\n", - "adding: mem time50, current time 56, horizon 6\n", - "adding: mem time51, current time 56, horizon 5\n", - "adding: mem time52, current time 56, horizon 4\n", - "adding: mem time53, current time 56, horizon 3\n", - "adding: mem time54, current time 56, horizon 2\n", - "adding: mem time55, current time 56, horizon 1\n", - "adding: mem time0, current time 57, horizon 57\n", - "adding: mem time1, current time 57, horizon 56\n", - "adding: mem time2, current time 57, horizon 55\n", - "adding: mem time3, current time 57, horizon 54\n", - "adding: mem time4, current time 57, horizon 53\n", - "adding: mem time5, current time 57, horizon 52\n", - "adding: mem time6, current time 57, horizon 51\n", - "adding: mem time7, current time 57, horizon 50\n", - "adding: mem time8, current time 57, horizon 49\n", - "adding: mem time9, current time 57, horizon 48\n", - "adding: mem time10, current time 57, horizon 47\n", - "adding: mem time11, current time 57, horizon 46\n", - "adding: mem time12, current time 57, horizon 45\n", - "adding: mem time13, current time 57, horizon 44\n", - "adding: mem time14, current time 57, horizon 43\n", - "adding: mem time15, current time 57, horizon 42\n", - "adding: mem time16, current time 57, horizon 41\n", - "adding: mem time17, current time 57, horizon 40\n", - "adding: mem time18, current time 57, horizon 39\n", - "adding: mem time19, current time 57, horizon 38\n", - "adding: mem time20, current time 57, horizon 37\n", - "adding: mem time21, current time 57, horizon 36\n", - "adding: mem time22, current time 57, horizon 35\n", - "adding: mem time23, current time 57, horizon 34\n", - "adding: mem time24, current time 57, horizon 33\n", - "adding: mem time25, current time 57, horizon 32\n", - "adding: mem time26, current time 57, horizon 31\n", - "adding: mem time27, current time 57, horizon 30\n", - "adding: mem time28, current time 57, horizon 29\n", - "adding: mem time29, current time 57, horizon 28\n", - "adding: mem time30, current time 57, horizon 27\n", - "adding: mem time31, current time 57, horizon 26\n", - "adding: mem time32, current time 57, horizon 25\n", - "adding: mem time33, current time 57, horizon 24\n", - "adding: mem time34, current time 57, horizon 23\n", - "adding: mem time35, current time 57, horizon 22\n", - "adding: mem time36, current time 57, horizon 21\n", - "adding: mem time37, current time 57, horizon 20\n", - "adding: mem time38, current time 57, horizon 19\n", - "adding: mem time39, current time 57, horizon 18\n", - "adding: mem time40, current time 57, horizon 17\n", - "adding: mem time41, current time 57, horizon 16\n", - "adding: mem time42, current time 57, horizon 15\n", - "adding: mem time43, current time 57, horizon 14\n", - "adding: mem time44, current time 57, horizon 13\n", - "adding: mem time45, current time 57, horizon 12\n", - "adding: mem time46, current time 57, horizon 11\n", - "adding: mem time47, current time 57, horizon 10\n", - "adding: mem time48, current time 57, horizon 9\n", - "adding: mem time49, current time 57, horizon 8\n", - "adding: mem time50, current time 57, horizon 7\n", - "adding: mem time51, current time 57, horizon 6\n", - "adding: mem time52, current time 57, horizon 5\n", - "adding: mem time53, current time 57, horizon 4\n", - "adding: mem time54, current time 57, horizon 3\n", - "adding: mem time55, current time 57, horizon 2\n", - "adding: mem time56, current time 57, horizon 1\n", - "adding: mem time0, current time 58, horizon 58\n", - "adding: mem time1, current time 58, horizon 57\n", - "adding: mem time2, current time 58, horizon 56\n", - "adding: mem time3, current time 58, horizon 55\n", - "adding: mem time4, current time 58, horizon 54\n", - "adding: mem time5, current time 58, horizon 53\n", - "adding: mem time6, current time 58, horizon 52\n", - "adding: mem time7, current time 58, horizon 51\n", - "adding: mem time8, current time 58, horizon 50\n", - "adding: mem time9, current time 58, horizon 49\n", - "adding: mem time10, current time 58, horizon 48\n", - "adding: mem time11, current time 58, horizon 47\n", - "adding: mem time12, current time 58, horizon 46\n", - "adding: mem time13, current time 58, horizon 45\n", - "adding: mem time14, current time 58, horizon 44\n", - "adding: mem time15, current time 58, horizon 43\n", - "adding: mem time16, current time 58, horizon 42\n", - "adding: mem time17, current time 58, horizon 41\n", - "adding: mem time18, current time 58, horizon 40\n", - "adding: mem time19, current time 58, horizon 39\n", - "adding: mem time20, current time 58, horizon 38\n", - "adding: mem time21, current time 58, horizon 37\n", - "adding: mem time22, current time 58, horizon 36\n", - "adding: mem time23, current time 58, horizon 35\n", - "adding: mem time24, current time 58, horizon 34\n", - "adding: mem time25, current time 58, horizon 33\n", - "adding: mem time26, current time 58, horizon 32\n", - "adding: mem time27, current time 58, horizon 31\n", - "adding: mem time28, current time 58, horizon 30\n", - "adding: mem time29, current time 58, horizon 29\n", - "adding: mem time30, current time 58, horizon 28\n", - "adding: mem time31, current time 58, horizon 27\n", - "adding: mem time32, current time 58, horizon 26\n", - "adding: mem time33, current time 58, horizon 25\n", - "adding: mem time34, current time 58, horizon 24\n", - "adding: mem time35, current time 58, horizon 23\n", - "adding: mem time36, current time 58, horizon 22\n", - "adding: mem time37, current time 58, horizon 21\n", - "adding: mem time38, current time 58, horizon 20\n", - "adding: mem time39, current time 58, horizon 19\n", - "adding: mem time40, current time 58, horizon 18\n", - "adding: mem time41, current time 58, horizon 17\n", - "adding: mem time42, current time 58, horizon 16\n", - "adding: mem time43, current time 58, horizon 15\n", - "adding: mem time44, current time 58, horizon 14\n", - "adding: mem time45, current time 58, horizon 13\n", - "adding: mem time46, current time 58, horizon 12\n", - "adding: mem time47, current time 58, horizon 11\n", - "adding: mem time48, current time 58, horizon 10\n", - "adding: mem time49, current time 58, horizon 9\n", - "adding: mem time50, current time 58, horizon 8\n", - "adding: mem time51, current time 58, horizon 7\n", - "adding: mem time52, current time 58, horizon 6\n", - "adding: mem time53, current time 58, horizon 5\n", - "adding: mem time54, current time 58, horizon 4\n", - "adding: mem time55, current time 58, horizon 3\n", - "adding: mem time56, current time 58, horizon 2\n", - "adding: mem time57, current time 58, horizon 1\n", - "adding: mem time0, current time 59, horizon 59\n", - "adding: mem time1, current time 59, horizon 58\n", - "adding: mem time2, current time 59, horizon 57\n", - "adding: mem time3, current time 59, horizon 56\n", - "adding: mem time4, current time 59, horizon 55\n", - "adding: mem time5, current time 59, horizon 54\n", - "adding: mem time6, current time 59, horizon 53\n", - "adding: mem time7, current time 59, horizon 52\n", - "adding: mem time8, current time 59, horizon 51\n", - "adding: mem time9, current time 59, horizon 50\n", - "adding: mem time10, current time 59, horizon 49\n", - "adding: mem time11, current time 59, horizon 48\n", - "adding: mem time12, current time 59, horizon 47\n", - "adding: mem time13, current time 59, horizon 46\n", - "adding: mem time14, current time 59, horizon 45\n", - "adding: mem time15, current time 59, horizon 44\n", - "adding: mem time16, current time 59, horizon 43\n", - "adding: mem time17, current time 59, horizon 42\n", - "adding: mem time18, current time 59, horizon 41\n", - "adding: mem time19, current time 59, horizon 40\n", - "adding: mem time20, current time 59, horizon 39\n", - "adding: mem time21, current time 59, horizon 38\n", - "adding: mem time22, current time 59, horizon 37\n", - "adding: mem time23, current time 59, horizon 36\n", - "adding: mem time24, current time 59, horizon 35\n", - "adding: mem time25, current time 59, horizon 34\n", - "adding: mem time26, current time 59, horizon 33\n", - "adding: mem time27, current time 59, horizon 32\n", - "adding: mem time28, current time 59, horizon 31\n", - "adding: mem time29, current time 59, horizon 30\n", - "adding: mem time30, current time 59, horizon 29\n", - "adding: mem time31, current time 59, horizon 28\n", - "adding: mem time32, current time 59, horizon 27\n", - "adding: mem time33, current time 59, horizon 26\n", - "adding: mem time34, current time 59, horizon 25\n", - "adding: mem time35, current time 59, horizon 24\n", - "adding: mem time36, current time 59, horizon 23\n", - "adding: mem time37, current time 59, horizon 22\n", - "adding: mem time38, current time 59, horizon 21\n", - "adding: mem time39, current time 59, horizon 20\n", - "adding: mem time40, current time 59, horizon 19\n", - "adding: mem time41, current time 59, horizon 18\n", - "adding: mem time42, current time 59, horizon 17\n", - "adding: mem time43, current time 59, horizon 16\n", - "adding: mem time44, current time 59, horizon 15\n", - "adding: mem time45, current time 59, horizon 14\n", - "adding: mem time46, current time 59, horizon 13\n", - "adding: mem time47, current time 59, horizon 12\n", - "adding: mem time48, current time 59, horizon 11\n", - "adding: mem time49, current time 59, horizon 10\n", - "adding: mem time50, current time 59, horizon 9\n", - "adding: mem time51, current time 59, horizon 8\n", - "adding: mem time52, current time 59, horizon 7\n", - "adding: mem time53, current time 59, horizon 6\n", - "adding: mem time54, current time 59, horizon 5\n", - "adding: mem time55, current time 59, horizon 4\n", - "adding: mem time56, current time 59, horizon 3\n", - "adding: mem time57, current time 59, horizon 2\n", - "adding: mem time58, current time 59, horizon 1\n", - "adding: mem time0, current time 60, horizon 60\n", - "adding: mem time1, current time 60, horizon 59\n", - "adding: mem time2, current time 60, horizon 58\n", - "adding: mem time3, current time 60, horizon 57\n", - "adding: mem time4, current time 60, horizon 56\n", - "adding: mem time5, current time 60, horizon 55\n", - "adding: mem time6, current time 60, horizon 54\n", - "adding: mem time7, current time 60, horizon 53\n", - "adding: mem time8, current time 60, horizon 52\n", - "adding: mem time9, current time 60, horizon 51\n", - "adding: mem time10, current time 60, horizon 50\n", - "adding: mem time11, current time 60, horizon 49\n", - "adding: mem time12, current time 60, horizon 48\n", - "adding: mem time13, current time 60, horizon 47\n", - "adding: mem time14, current time 60, horizon 46\n", - "adding: mem time15, current time 60, horizon 45\n", - "adding: mem time16, current time 60, horizon 44\n", - "adding: mem time17, current time 60, horizon 43\n", - "adding: mem time18, current time 60, horizon 42\n", - "adding: mem time19, current time 60, horizon 41\n", - "adding: mem time20, current time 60, horizon 40\n", - "adding: mem time21, current time 60, horizon 39\n", - "adding: mem time22, current time 60, horizon 38\n", - "adding: mem time23, current time 60, horizon 37\n", - "adding: mem time24, current time 60, horizon 36\n", - "adding: mem time25, current time 60, horizon 35\n", - "adding: mem time26, current time 60, horizon 34\n", - "adding: mem time27, current time 60, horizon 33\n", - "adding: mem time28, current time 60, horizon 32\n", - "adding: mem time29, current time 60, horizon 31\n", - "adding: mem time30, current time 60, horizon 30\n", - "adding: mem time31, current time 60, horizon 29\n", - "adding: mem time32, current time 60, horizon 28\n", - "adding: mem time33, current time 60, horizon 27\n", - "adding: mem time34, current time 60, horizon 26\n", - "adding: mem time35, current time 60, horizon 25\n", - "adding: mem time36, current time 60, horizon 24\n", - "adding: mem time37, current time 60, horizon 23\n", - "adding: mem time38, current time 60, horizon 22\n", - "adding: mem time39, current time 60, horizon 21\n", - "adding: mem time40, current time 60, horizon 20\n", - "adding: mem time41, current time 60, horizon 19\n", - "adding: mem time42, current time 60, horizon 18\n", - "adding: mem time43, current time 60, horizon 17\n", - "adding: mem time44, current time 60, horizon 16\n", - "adding: mem time45, current time 60, horizon 15\n", - "adding: mem time46, current time 60, horizon 14\n", - "adding: mem time47, current time 60, horizon 13\n", - "adding: mem time48, current time 60, horizon 12\n", - "adding: mem time49, current time 60, horizon 11\n", - "adding: mem time50, current time 60, horizon 10\n", - "adding: mem time51, current time 60, horizon 9\n", - "adding: mem time52, current time 60, horizon 8\n", - "adding: mem time53, current time 60, horizon 7\n", - "adding: mem time54, current time 60, horizon 6\n", - "adding: mem time55, current time 60, horizon 5\n", - "adding: mem time56, current time 60, horizon 4\n", - "adding: mem time57, current time 60, horizon 3\n", - "adding: mem time58, current time 60, horizon 2\n", - "adding: mem time59, current time 60, horizon 1\n", - "adding: mem time0, current time 61, horizon 61\n", - "adding: mem time1, current time 61, horizon 60\n", - "adding: mem time2, current time 61, horizon 59\n", - "adding: mem time3, current time 61, horizon 58\n", - "adding: mem time4, current time 61, horizon 57\n", - "adding: mem time5, current time 61, horizon 56\n", - "adding: mem time6, current time 61, horizon 55\n", - "adding: mem time7, current time 61, horizon 54\n", - "adding: mem time8, current time 61, horizon 53\n", - "adding: mem time9, current time 61, horizon 52\n", - "adding: mem time10, current time 61, horizon 51\n", - "adding: mem time11, current time 61, horizon 50\n", - "adding: mem time12, current time 61, horizon 49\n", - "adding: mem time13, current time 61, horizon 48\n", - "adding: mem time14, current time 61, horizon 47\n", - "adding: mem time15, current time 61, horizon 46\n", - "adding: mem time16, current time 61, horizon 45\n", - "adding: mem time17, current time 61, horizon 44\n", - "adding: mem time18, current time 61, horizon 43\n", - "adding: mem time19, current time 61, horizon 42\n", - "adding: mem time20, current time 61, horizon 41\n", - "adding: mem time21, current time 61, horizon 40\n", - "adding: mem time22, current time 61, horizon 39\n", - "adding: mem time23, current time 61, horizon 38\n", - "adding: mem time24, current time 61, horizon 37\n", - "adding: mem time25, current time 61, horizon 36\n", - "adding: mem time26, current time 61, horizon 35\n", - "adding: mem time27, current time 61, horizon 34\n", - "adding: mem time28, current time 61, horizon 33\n", - "adding: mem time29, current time 61, horizon 32\n", - "adding: mem time30, current time 61, horizon 31\n", - "adding: mem time31, current time 61, horizon 30\n", - "adding: mem time32, current time 61, horizon 29\n", - "adding: mem time33, current time 61, horizon 28\n", - "adding: mem time34, current time 61, horizon 27\n", - "adding: mem time35, current time 61, horizon 26\n", - "adding: mem time36, current time 61, horizon 25\n", - "adding: mem time37, current time 61, horizon 24\n", - "adding: mem time38, current time 61, horizon 23\n", - "adding: mem time39, current time 61, horizon 22\n", - "adding: mem time40, current time 61, horizon 21\n", - "adding: mem time41, current time 61, horizon 20\n", - "adding: mem time42, current time 61, horizon 19\n", - "adding: mem time43, current time 61, horizon 18\n", - "adding: mem time44, current time 61, horizon 17\n", - "adding: mem time45, current time 61, horizon 16\n", - "adding: mem time46, current time 61, horizon 15\n", - "adding: mem time47, current time 61, horizon 14\n", - "adding: mem time48, current time 61, horizon 13\n", - "adding: mem time49, current time 61, horizon 12\n", - "adding: mem time50, current time 61, horizon 11\n", - "adding: mem time51, current time 61, horizon 10\n", - "adding: mem time52, current time 61, horizon 9\n", - "adding: mem time53, current time 61, horizon 8\n", - "adding: mem time54, current time 61, horizon 7\n", - "adding: mem time55, current time 61, horizon 6\n", - "adding: mem time56, current time 61, horizon 5\n", - "adding: mem time57, current time 61, horizon 4\n", - "adding: mem time58, current time 61, horizon 3\n", - "adding: mem time59, current time 61, horizon 2\n", - "adding: mem time60, current time 61, horizon 1\n", - "adding: mem time0, current time 62, horizon 62\n", - "adding: mem time1, current time 62, horizon 61\n", - "adding: mem time2, current time 62, horizon 60\n", - "adding: mem time3, current time 62, horizon 59\n", - "adding: mem time4, current time 62, horizon 58\n", - "adding: mem time5, current time 62, horizon 57\n", - "adding: mem time6, current time 62, horizon 56\n", - "adding: mem time7, current time 62, horizon 55\n", - "adding: mem time8, current time 62, horizon 54\n", - "adding: mem time9, current time 62, horizon 53\n", - "adding: mem time10, current time 62, horizon 52\n", - "adding: mem time11, current time 62, horizon 51\n", - "adding: mem time12, current time 62, horizon 50\n", - "adding: mem time13, current time 62, horizon 49\n", - "adding: mem time14, current time 62, horizon 48\n", - "adding: mem time15, current time 62, horizon 47\n", - "adding: mem time16, current time 62, horizon 46\n", - "adding: mem time17, current time 62, horizon 45\n", - "adding: mem time18, current time 62, horizon 44\n", - "adding: mem time19, current time 62, horizon 43\n", - "adding: mem time20, current time 62, horizon 42\n", - "adding: mem time21, current time 62, horizon 41\n", - "adding: mem time22, current time 62, horizon 40\n", - "adding: mem time23, current time 62, horizon 39\n", - "adding: mem time24, current time 62, horizon 38\n", - "adding: mem time25, current time 62, horizon 37\n", - "adding: mem time26, current time 62, horizon 36\n", - "adding: mem time27, current time 62, horizon 35\n", - "adding: mem time28, current time 62, horizon 34\n", - "adding: mem time29, current time 62, horizon 33\n", - "adding: mem time30, current time 62, horizon 32\n", - "adding: mem time31, current time 62, horizon 31\n", - "adding: mem time32, current time 62, horizon 30\n", - "adding: mem time33, current time 62, horizon 29\n", - "adding: mem time34, current time 62, horizon 28\n", - "adding: mem time35, current time 62, horizon 27\n", - "adding: mem time36, current time 62, horizon 26\n", - "adding: mem time37, current time 62, horizon 25\n", - "adding: mem time38, current time 62, horizon 24\n", - "adding: mem time39, current time 62, horizon 23\n", - "adding: mem time40, current time 62, horizon 22\n", - "adding: mem time41, current time 62, horizon 21\n", - "adding: mem time42, current time 62, horizon 20\n", - "adding: mem time43, current time 62, horizon 19\n", - "adding: mem time44, current time 62, horizon 18\n", - "adding: mem time45, current time 62, horizon 17\n", - "adding: mem time46, current time 62, horizon 16\n", - "adding: mem time47, current time 62, horizon 15\n", - "adding: mem time48, current time 62, horizon 14\n", - "adding: mem time49, current time 62, horizon 13\n", - "adding: mem time50, current time 62, horizon 12\n", - "adding: mem time51, current time 62, horizon 11\n", - "adding: mem time52, current time 62, horizon 10\n", - "adding: mem time53, current time 62, horizon 9\n", - "adding: mem time54, current time 62, horizon 8\n", - "adding: mem time55, current time 62, horizon 7\n", - "adding: mem time56, current time 62, horizon 6\n", - "adding: mem time57, current time 62, horizon 5\n", - "adding: mem time58, current time 62, horizon 4\n", - "adding: mem time59, current time 62, horizon 3\n", - "adding: mem time60, current time 62, horizon 2\n", - "adding: mem time61, current time 62, horizon 1\n", - "adding: mem time0, current time 63, horizon 63\n", - "adding: mem time1, current time 63, horizon 62\n", - "adding: mem time2, current time 63, horizon 61\n", - "adding: mem time3, current time 63, horizon 60\n", - "adding: mem time4, current time 63, horizon 59\n", - "adding: mem time5, current time 63, horizon 58\n", - "adding: mem time6, current time 63, horizon 57\n", - "adding: mem time7, current time 63, horizon 56\n", - "adding: mem time8, current time 63, horizon 55\n", - "adding: mem time9, current time 63, horizon 54\n", - "adding: mem time10, current time 63, horizon 53\n", - "adding: mem time11, current time 63, horizon 52\n", - "adding: mem time12, current time 63, horizon 51\n", - "adding: mem time13, current time 63, horizon 50\n", - "adding: mem time14, current time 63, horizon 49\n", - "adding: mem time15, current time 63, horizon 48\n", - "adding: mem time16, current time 63, horizon 47\n", - "adding: mem time17, current time 63, horizon 46\n", - "adding: mem time18, current time 63, horizon 45\n", - "adding: mem time19, current time 63, horizon 44\n", - "adding: mem time20, current time 63, horizon 43\n", - "adding: mem time21, current time 63, horizon 42\n", - "adding: mem time22, current time 63, horizon 41\n", - "adding: mem time23, current time 63, horizon 40\n", - "adding: mem time24, current time 63, horizon 39\n", - "adding: mem time25, current time 63, horizon 38\n", - "adding: mem time26, current time 63, horizon 37\n", - "adding: mem time27, current time 63, horizon 36\n", - "adding: mem time28, current time 63, horizon 35\n", - "adding: mem time29, current time 63, horizon 34\n", - "adding: mem time30, current time 63, horizon 33\n", - "adding: mem time31, current time 63, horizon 32\n", - "adding: mem time32, current time 63, horizon 31\n", - "adding: mem time33, current time 63, horizon 30\n", - "adding: mem time34, current time 63, horizon 29\n", - "adding: mem time35, current time 63, horizon 28\n", - "adding: mem time36, current time 63, horizon 27\n", - "adding: mem time37, current time 63, horizon 26\n", - "adding: mem time38, current time 63, horizon 25\n", - "adding: mem time39, current time 63, horizon 24\n", - "adding: mem time40, current time 63, horizon 23\n", - "adding: mem time41, current time 63, horizon 22\n", - "adding: mem time42, current time 63, horizon 21\n", - "adding: mem time43, current time 63, horizon 20\n", - "adding: mem time44, current time 63, horizon 19\n", - "adding: mem time45, current time 63, horizon 18\n", - "adding: mem time46, current time 63, horizon 17\n", - "adding: mem time47, current time 63, horizon 16\n", - "adding: mem time48, current time 63, horizon 15\n", - "adding: mem time49, current time 63, horizon 14\n", - "adding: mem time50, current time 63, horizon 13\n", - "adding: mem time51, current time 63, horizon 12\n", - "adding: mem time52, current time 63, horizon 11\n", - "adding: mem time53, current time 63, horizon 10\n", - "adding: mem time54, current time 63, horizon 9\n", - "adding: mem time55, current time 63, horizon 8\n", - "adding: mem time56, current time 63, horizon 7\n", - "adding: mem time57, current time 63, horizon 6\n", - "adding: mem time58, current time 63, horizon 5\n", - "adding: mem time59, current time 63, horizon 4\n", - "adding: mem time60, current time 63, horizon 3\n", - "adding: mem time61, current time 63, horizon 2\n", - "adding: mem time62, current time 63, horizon 1\n", - "adding: mem time0, current time 64, horizon 64\n", - "adding: mem time1, current time 64, horizon 63\n", - "adding: mem time2, current time 64, horizon 62\n", - "adding: mem time3, current time 64, horizon 61\n", - "adding: mem time4, current time 64, horizon 60\n", - "adding: mem time5, current time 64, horizon 59\n", - "adding: mem time6, current time 64, horizon 58\n", - "adding: mem time7, current time 64, horizon 57\n", - "adding: mem time8, current time 64, horizon 56\n", - "adding: mem time9, current time 64, horizon 55\n", - "adding: mem time10, current time 64, horizon 54\n", - "adding: mem time11, current time 64, horizon 53\n", - "adding: mem time12, current time 64, horizon 52\n", - "adding: mem time13, current time 64, horizon 51\n", - "adding: mem time14, current time 64, horizon 50\n", - "adding: mem time15, current time 64, horizon 49\n", - "adding: mem time16, current time 64, horizon 48\n", - "adding: mem time17, current time 64, horizon 47\n", - "adding: mem time18, current time 64, horizon 46\n", - "adding: mem time19, current time 64, horizon 45\n", - "adding: mem time20, current time 64, horizon 44\n", - "adding: mem time21, current time 64, horizon 43\n", - "adding: mem time22, current time 64, horizon 42\n", - "adding: mem time23, current time 64, horizon 41\n", - "adding: mem time24, current time 64, horizon 40\n", - "adding: mem time25, current time 64, horizon 39\n", - "adding: mem time26, current time 64, horizon 38\n", - "adding: mem time27, current time 64, horizon 37\n", - "adding: mem time28, current time 64, horizon 36\n", - "adding: mem time29, current time 64, horizon 35\n", - "adding: mem time30, current time 64, horizon 34\n", - "adding: mem time31, current time 64, horizon 33\n", - "adding: mem time32, current time 64, horizon 32\n", - "adding: mem time33, current time 64, horizon 31\n", - "adding: mem time34, current time 64, horizon 30\n", - "adding: mem time35, current time 64, horizon 29\n", - "adding: mem time36, current time 64, horizon 28\n", - "adding: mem time37, current time 64, horizon 27\n", - "adding: mem time38, current time 64, horizon 26\n", - "adding: mem time39, current time 64, horizon 25\n", - "adding: mem time40, current time 64, horizon 24\n", - "adding: mem time41, current time 64, horizon 23\n", - "adding: mem time42, current time 64, horizon 22\n", - "adding: mem time43, current time 64, horizon 21\n", - "adding: mem time44, current time 64, horizon 20\n", - "adding: mem time45, current time 64, horizon 19\n", - "adding: mem time46, current time 64, horizon 18\n", - "adding: mem time47, current time 64, horizon 17\n", - "adding: mem time48, current time 64, horizon 16\n", - "adding: mem time49, current time 64, horizon 15\n", - "adding: mem time50, current time 64, horizon 14\n", - "adding: mem time51, current time 64, horizon 13\n", - "adding: mem time52, current time 64, horizon 12\n", - "adding: mem time53, current time 64, horizon 11\n", - "adding: mem time54, current time 64, horizon 10\n", - "adding: mem time55, current time 64, horizon 9\n", - "adding: mem time56, current time 64, horizon 8\n", - "adding: mem time57, current time 64, horizon 7\n", - "adding: mem time58, current time 64, horizon 6\n", - "adding: mem time59, current time 64, horizon 5\n", - "adding: mem time60, current time 64, horizon 4\n", - "adding: mem time61, current time 64, horizon 3\n", - "adding: mem time62, current time 64, horizon 2\n", - "adding: mem time63, current time 64, horizon 1\n", - "adding: mem time0, current time 65, horizon 65\n", - "adding: mem time1, current time 65, horizon 64\n", - "adding: mem time2, current time 65, horizon 63\n", - "adding: mem time3, current time 65, horizon 62\n", - "adding: mem time4, current time 65, horizon 61\n", - "adding: mem time5, current time 65, horizon 60\n", - "adding: mem time6, current time 65, horizon 59\n", - "adding: mem time7, current time 65, horizon 58\n", - "adding: mem time8, current time 65, horizon 57\n", - "adding: mem time9, current time 65, horizon 56\n", - "adding: mem time10, current time 65, horizon 55\n", - "adding: mem time11, current time 65, horizon 54\n", - "adding: mem time12, current time 65, horizon 53\n", - "adding: mem time13, current time 65, horizon 52\n", - "adding: mem time14, current time 65, horizon 51\n", - "adding: mem time15, current time 65, horizon 50\n", - "adding: mem time16, current time 65, horizon 49\n", - "adding: mem time17, current time 65, horizon 48\n", - "adding: mem time18, current time 65, horizon 47\n", - "adding: mem time19, current time 65, horizon 46\n", - "adding: mem time20, current time 65, horizon 45\n", - "adding: mem time21, current time 65, horizon 44\n", - "adding: mem time22, current time 65, horizon 43\n", - "adding: mem time23, current time 65, horizon 42\n", - "adding: mem time24, current time 65, horizon 41\n", - "adding: mem time25, current time 65, horizon 40\n", - "adding: mem time26, current time 65, horizon 39\n", - "adding: mem time27, current time 65, horizon 38\n", - "adding: mem time28, current time 65, horizon 37\n", - "adding: mem time29, current time 65, horizon 36\n", - "adding: mem time30, current time 65, horizon 35\n", - "adding: mem time31, current time 65, horizon 34\n", - "adding: mem time32, current time 65, horizon 33\n", - "adding: mem time33, current time 65, horizon 32\n", - "adding: mem time34, current time 65, horizon 31\n", - "adding: mem time35, current time 65, horizon 30\n", - "adding: mem time36, current time 65, horizon 29\n", - "adding: mem time37, current time 65, horizon 28\n", - "adding: mem time38, current time 65, horizon 27\n", - "adding: mem time39, current time 65, horizon 26\n", - "adding: mem time40, current time 65, horizon 25\n", - "adding: mem time41, current time 65, horizon 24\n", - "adding: mem time42, current time 65, horizon 23\n", - "adding: mem time43, current time 65, horizon 22\n", - "adding: mem time44, current time 65, horizon 21\n", - "adding: mem time45, current time 65, horizon 20\n", - "adding: mem time46, current time 65, horizon 19\n", - "adding: mem time47, current time 65, horizon 18\n", - "adding: mem time48, current time 65, horizon 17\n", - "adding: mem time49, current time 65, horizon 16\n", - "adding: mem time50, current time 65, horizon 15\n", - "adding: mem time51, current time 65, horizon 14\n", - "adding: mem time52, current time 65, horizon 13\n", - "adding: mem time53, current time 65, horizon 12\n", - "adding: mem time54, current time 65, horizon 11\n", - "adding: mem time55, current time 65, horizon 10\n", - "adding: mem time56, current time 65, horizon 9\n", - "adding: mem time57, current time 65, horizon 8\n", - "adding: mem time58, current time 65, horizon 7\n", - "adding: mem time59, current time 65, horizon 6\n", - "adding: mem time60, current time 65, horizon 5\n", - "adding: mem time61, current time 65, horizon 4\n", - "adding: mem time62, current time 65, horizon 3\n", - "adding: mem time63, current time 65, horizon 2\n", - "adding: mem time64, current time 65, horizon 1\n", - "adding: mem time0, current time 66, horizon 66\n", - "adding: mem time1, current time 66, horizon 65\n", - "adding: mem time2, current time 66, horizon 64\n", - "adding: mem time3, current time 66, horizon 63\n", - "adding: mem time4, current time 66, horizon 62\n", - "adding: mem time5, current time 66, horizon 61\n", - "adding: mem time6, current time 66, horizon 60\n", - "adding: mem time7, current time 66, horizon 59\n", - "adding: mem time8, current time 66, horizon 58\n", - "adding: mem time9, current time 66, horizon 57\n", - "adding: mem time10, current time 66, horizon 56\n", - "adding: mem time11, current time 66, horizon 55\n", - "adding: mem time12, current time 66, horizon 54\n", - "adding: mem time13, current time 66, horizon 53\n", - "adding: mem time14, current time 66, horizon 52\n", - "adding: mem time15, current time 66, horizon 51\n", - "adding: mem time16, current time 66, horizon 50\n", - "adding: mem time17, current time 66, horizon 49\n", - "adding: mem time18, current time 66, horizon 48\n", - "adding: mem time19, current time 66, horizon 47\n", - "adding: mem time20, current time 66, horizon 46\n", - "adding: mem time21, current time 66, horizon 45\n", - "adding: mem time22, current time 66, horizon 44\n", - "adding: mem time23, current time 66, horizon 43\n", - "adding: mem time24, current time 66, horizon 42\n", - "adding: mem time25, current time 66, horizon 41\n", - "adding: mem time26, current time 66, horizon 40\n", - "adding: mem time27, current time 66, horizon 39\n", - "adding: mem time28, current time 66, horizon 38\n", - "adding: mem time29, current time 66, horizon 37\n", - "adding: mem time30, current time 66, horizon 36\n", - "adding: mem time31, current time 66, horizon 35\n", - "adding: mem time32, current time 66, horizon 34\n", - "adding: mem time33, current time 66, horizon 33\n", - "adding: mem time34, current time 66, horizon 32\n", - "adding: mem time35, current time 66, horizon 31\n", - "adding: mem time36, current time 66, horizon 30\n", - "adding: mem time37, current time 66, horizon 29\n", - "adding: mem time38, current time 66, horizon 28\n", - "adding: mem time39, current time 66, horizon 27\n", - "adding: mem time40, current time 66, horizon 26\n", - "adding: mem time41, current time 66, horizon 25\n", - "adding: mem time42, current time 66, horizon 24\n", - "adding: mem time43, current time 66, horizon 23\n", - "adding: mem time44, current time 66, horizon 22\n", - "adding: mem time45, current time 66, horizon 21\n", - "adding: mem time46, current time 66, horizon 20\n", - "adding: mem time47, current time 66, horizon 19\n", - "adding: mem time48, current time 66, horizon 18\n", - "adding: mem time49, current time 66, horizon 17\n", - "adding: mem time50, current time 66, horizon 16\n", - "adding: mem time51, current time 66, horizon 15\n", - "adding: mem time52, current time 66, horizon 14\n", - "adding: mem time53, current time 66, horizon 13\n", - "adding: mem time54, current time 66, horizon 12\n", - "adding: mem time55, current time 66, horizon 11\n", - "adding: mem time56, current time 66, horizon 10\n", - "adding: mem time57, current time 66, horizon 9\n", - "adding: mem time58, current time 66, horizon 8\n", - "adding: mem time59, current time 66, horizon 7\n", - "adding: mem time60, current time 66, horizon 6\n", - "adding: mem time61, current time 66, horizon 5\n", - "adding: mem time62, current time 66, horizon 4\n", - "adding: mem time63, current time 66, horizon 3\n", - "adding: mem time64, current time 66, horizon 2\n", - "adding: mem time65, current time 66, horizon 1\n", - "adding: mem time0, current time 67, horizon 67\n", - "adding: mem time1, current time 67, horizon 66\n", - "adding: mem time2, current time 67, horizon 65\n", - "adding: mem time3, current time 67, horizon 64\n", - "adding: mem time4, current time 67, horizon 63\n", - "adding: mem time5, current time 67, horizon 62\n", - "adding: mem time6, current time 67, horizon 61\n", - "adding: mem time7, current time 67, horizon 60\n", - "adding: mem time8, current time 67, horizon 59\n", - "adding: mem time9, current time 67, horizon 58\n", - "adding: mem time10, current time 67, horizon 57\n", - "adding: mem time11, current time 67, horizon 56\n", - "adding: mem time12, current time 67, horizon 55\n", - "adding: mem time13, current time 67, horizon 54\n", - "adding: mem time14, current time 67, horizon 53\n", - "adding: mem time15, current time 67, horizon 52\n", - "adding: mem time16, current time 67, horizon 51\n", - "adding: mem time17, current time 67, horizon 50\n", - "adding: mem time18, current time 67, horizon 49\n", - "adding: mem time19, current time 67, horizon 48\n", - "adding: mem time20, current time 67, horizon 47\n", - "adding: mem time21, current time 67, horizon 46\n", - "adding: mem time22, current time 67, horizon 45\n", - "adding: mem time23, current time 67, horizon 44\n", - "adding: mem time24, current time 67, horizon 43\n", - "adding: mem time25, current time 67, horizon 42\n", - "adding: mem time26, current time 67, horizon 41\n", - "adding: mem time27, current time 67, horizon 40\n", - "adding: mem time28, current time 67, horizon 39\n", - "adding: mem time29, current time 67, horizon 38\n", - "adding: mem time30, current time 67, horizon 37\n", - "adding: mem time31, current time 67, horizon 36\n", - "adding: mem time32, current time 67, horizon 35\n", - "adding: mem time33, current time 67, horizon 34\n", - "adding: mem time34, current time 67, horizon 33\n", - "adding: mem time35, current time 67, horizon 32\n", - "adding: mem time36, current time 67, horizon 31\n", - "adding: mem time37, current time 67, horizon 30\n", - "adding: mem time38, current time 67, horizon 29\n", - "adding: mem time39, current time 67, horizon 28\n", - "adding: mem time40, current time 67, horizon 27\n", - "adding: mem time41, current time 67, horizon 26\n", - "adding: mem time42, current time 67, horizon 25\n", - "adding: mem time43, current time 67, horizon 24\n", - "adding: mem time44, current time 67, horizon 23\n", - "adding: mem time45, current time 67, horizon 22\n", - "adding: mem time46, current time 67, horizon 21\n", - "adding: mem time47, current time 67, horizon 20\n", - "adding: mem time48, current time 67, horizon 19\n", - "adding: mem time49, current time 67, horizon 18\n", - "adding: mem time50, current time 67, horizon 17\n", - "adding: mem time51, current time 67, horizon 16\n", - "adding: mem time52, current time 67, horizon 15\n", - "adding: mem time53, current time 67, horizon 14\n", - "adding: mem time54, current time 67, horizon 13\n", - "adding: mem time55, current time 67, horizon 12\n", - "adding: mem time56, current time 67, horizon 11\n", - "adding: mem time57, current time 67, horizon 10\n", - "adding: mem time58, current time 67, horizon 9\n", - "adding: mem time59, current time 67, horizon 8\n", - "adding: mem time60, current time 67, horizon 7\n", - "adding: mem time61, current time 67, horizon 6\n", - "adding: mem time62, current time 67, horizon 5\n", - "adding: mem time63, current time 67, horizon 4\n", - "adding: mem time64, current time 67, horizon 3\n", - "adding: mem time65, current time 67, horizon 2\n", - "adding: mem time66, current time 67, horizon 1\n", - "adding: mem time0, current time 68, horizon 68\n", - "adding: mem time1, current time 68, horizon 67\n", - "adding: mem time2, current time 68, horizon 66\n", - "adding: mem time3, current time 68, horizon 65\n", - "adding: mem time4, current time 68, horizon 64\n", - "adding: mem time5, current time 68, horizon 63\n", - "adding: mem time6, current time 68, horizon 62\n", - "adding: mem time7, current time 68, horizon 61\n", - "adding: mem time8, current time 68, horizon 60\n", - "adding: mem time9, current time 68, horizon 59\n", - "adding: mem time10, current time 68, horizon 58\n", - "adding: mem time11, current time 68, horizon 57\n", - "adding: mem time12, current time 68, horizon 56\n", - "adding: mem time13, current time 68, horizon 55\n", - "adding: mem time14, current time 68, horizon 54\n", - "adding: mem time15, current time 68, horizon 53\n", - "adding: mem time16, current time 68, horizon 52\n", - "adding: mem time17, current time 68, horizon 51\n", - "adding: mem time18, current time 68, horizon 50\n", - "adding: mem time19, current time 68, horizon 49\n", - "adding: mem time20, current time 68, horizon 48\n", - "adding: mem time21, current time 68, horizon 47\n", - "adding: mem time22, current time 68, horizon 46\n", - "adding: mem time23, current time 68, horizon 45\n", - "adding: mem time24, current time 68, horizon 44\n", - "adding: mem time25, current time 68, horizon 43\n", - "adding: mem time26, current time 68, horizon 42\n", - "adding: mem time27, current time 68, horizon 41\n", - "adding: mem time28, current time 68, horizon 40\n", - "adding: mem time29, current time 68, horizon 39\n", - "adding: mem time30, current time 68, horizon 38\n", - "adding: mem time31, current time 68, horizon 37\n", - "adding: mem time32, current time 68, horizon 36\n", - "adding: mem time33, current time 68, horizon 35\n", - "adding: mem time34, current time 68, horizon 34\n", - "adding: mem time35, current time 68, horizon 33\n", - "adding: mem time36, current time 68, horizon 32\n", - "adding: mem time37, current time 68, horizon 31\n", - "adding: mem time38, current time 68, horizon 30\n", - "adding: mem time39, current time 68, horizon 29\n", - "adding: mem time40, current time 68, horizon 28\n", - "adding: mem time41, current time 68, horizon 27\n", - "adding: mem time42, current time 68, horizon 26\n", - "adding: mem time43, current time 68, horizon 25\n", - "adding: mem time44, current time 68, horizon 24\n", - "adding: mem time45, current time 68, horizon 23\n", - "adding: mem time46, current time 68, horizon 22\n", - "adding: mem time47, current time 68, horizon 21\n", - "adding: mem time48, current time 68, horizon 20\n", - "adding: mem time49, current time 68, horizon 19\n", - "adding: mem time50, current time 68, horizon 18\n", - "adding: mem time51, current time 68, horizon 17\n", - "adding: mem time52, current time 68, horizon 16\n", - "adding: mem time53, current time 68, horizon 15\n", - "adding: mem time54, current time 68, horizon 14\n", - "adding: mem time55, current time 68, horizon 13\n", - "adding: mem time56, current time 68, horizon 12\n", - "adding: mem time57, current time 68, horizon 11\n", - "adding: mem time58, current time 68, horizon 10\n", - "adding: mem time59, current time 68, horizon 9\n", - "adding: mem time60, current time 68, horizon 8\n", - "adding: mem time61, current time 68, horizon 7\n", - "adding: mem time62, current time 68, horizon 6\n", - "adding: mem time63, current time 68, horizon 5\n", - "adding: mem time64, current time 68, horizon 4\n", - "adding: mem time65, current time 68, horizon 3\n", - "adding: mem time66, current time 68, horizon 2\n", - "adding: mem time67, current time 68, horizon 1\n", - "adding: mem time0, current time 69, horizon 69\n", - "adding: mem time1, current time 69, horizon 68\n", - "adding: mem time2, current time 69, horizon 67\n", - "adding: mem time3, current time 69, horizon 66\n", - "adding: mem time4, current time 69, horizon 65\n", - "adding: mem time5, current time 69, horizon 64\n", - "adding: mem time6, current time 69, horizon 63\n", - "adding: mem time7, current time 69, horizon 62\n", - "adding: mem time8, current time 69, horizon 61\n", - "adding: mem time9, current time 69, horizon 60\n", - "adding: mem time10, current time 69, horizon 59\n", - "adding: mem time11, current time 69, horizon 58\n", - "adding: mem time12, current time 69, horizon 57\n", - "adding: mem time13, current time 69, horizon 56\n", - "adding: mem time14, current time 69, horizon 55\n", - "adding: mem time15, current time 69, horizon 54\n", - "adding: mem time16, current time 69, horizon 53\n", - "adding: mem time17, current time 69, horizon 52\n", - "adding: mem time18, current time 69, horizon 51\n", - "adding: mem time19, current time 69, horizon 50\n", - "adding: mem time20, current time 69, horizon 49\n", - "adding: mem time21, current time 69, horizon 48\n", - "adding: mem time22, current time 69, horizon 47\n", - "adding: mem time23, current time 69, horizon 46\n", - "adding: mem time24, current time 69, horizon 45\n", - "adding: mem time25, current time 69, horizon 44\n", - "adding: mem time26, current time 69, horizon 43\n", - "adding: mem time27, current time 69, horizon 42\n", - "adding: mem time28, current time 69, horizon 41\n", - "adding: mem time29, current time 69, horizon 40\n", - "adding: mem time30, current time 69, horizon 39\n", - "adding: mem time31, current time 69, horizon 38\n", - "adding: mem time32, current time 69, horizon 37\n", - "adding: mem time33, current time 69, horizon 36\n", - "adding: mem time34, current time 69, horizon 35\n", - "adding: mem time35, current time 69, horizon 34\n", - "adding: mem time36, current time 69, horizon 33\n", - "adding: mem time37, current time 69, horizon 32\n", - "adding: mem time38, current time 69, horizon 31\n", - "adding: mem time39, current time 69, horizon 30\n", - "adding: mem time40, current time 69, horizon 29\n", - "adding: mem time41, current time 69, horizon 28\n", - "adding: mem time42, current time 69, horizon 27\n", - "adding: mem time43, current time 69, horizon 26\n", - "adding: mem time44, current time 69, horizon 25\n", - "adding: mem time45, current time 69, horizon 24\n", - "adding: mem time46, current time 69, horizon 23\n", - "adding: mem time47, current time 69, horizon 22\n", - "adding: mem time48, current time 69, horizon 21\n", - "adding: mem time49, current time 69, horizon 20\n", - "adding: mem time50, current time 69, horizon 19\n", - "adding: mem time51, current time 69, horizon 18\n", - "adding: mem time52, current time 69, horizon 17\n", - "adding: mem time53, current time 69, horizon 16\n", - "adding: mem time54, current time 69, horizon 15\n", - "adding: mem time55, current time 69, horizon 14\n", - "adding: mem time56, current time 69, horizon 13\n", - "adding: mem time57, current time 69, horizon 12\n", - "adding: mem time58, current time 69, horizon 11\n", - "adding: mem time59, current time 69, horizon 10\n", - "adding: mem time60, current time 69, horizon 9\n", - "adding: mem time61, current time 69, horizon 8\n", - "adding: mem time62, current time 69, horizon 7\n", - "adding: mem time63, current time 69, horizon 6\n", - "adding: mem time64, current time 69, horizon 5\n", - "adding: mem time65, current time 69, horizon 4\n", - "adding: mem time66, current time 69, horizon 3\n", - "adding: mem time67, current time 69, horizon 2\n", - "adding: mem time68, current time 69, horizon 1\n", - "adding: mem time0, current time 70, horizon 70\n", - "adding: mem time1, current time 70, horizon 69\n", - "adding: mem time2, current time 70, horizon 68\n", - "adding: mem time3, current time 70, horizon 67\n", - "adding: mem time4, current time 70, horizon 66\n", - "adding: mem time5, current time 70, horizon 65\n", - "adding: mem time6, current time 70, horizon 64\n", - "adding: mem time7, current time 70, horizon 63\n", - "adding: mem time8, current time 70, horizon 62\n", - "adding: mem time9, current time 70, horizon 61\n", - "adding: mem time10, current time 70, horizon 60\n", - "adding: mem time11, current time 70, horizon 59\n", - "adding: mem time12, current time 70, horizon 58\n", - "adding: mem time13, current time 70, horizon 57\n", - "adding: mem time14, current time 70, horizon 56\n", - "adding: mem time15, current time 70, horizon 55\n", - "adding: mem time16, current time 70, horizon 54\n", - "adding: mem time17, current time 70, horizon 53\n", - "adding: mem time18, current time 70, horizon 52\n", - "adding: mem time19, current time 70, horizon 51\n", - "adding: mem time20, current time 70, horizon 50\n", - "adding: mem time21, current time 70, horizon 49\n", - "adding: mem time22, current time 70, horizon 48\n", - "adding: mem time23, current time 70, horizon 47\n", - "adding: mem time24, current time 70, horizon 46\n", - "adding: mem time25, current time 70, horizon 45\n", - "adding: mem time26, current time 70, horizon 44\n", - "adding: mem time27, current time 70, horizon 43\n", - "adding: mem time28, current time 70, horizon 42\n", - "adding: mem time29, current time 70, horizon 41\n", - "adding: mem time30, current time 70, horizon 40\n", - "adding: mem time31, current time 70, horizon 39\n", - "adding: mem time32, current time 70, horizon 38\n", - "adding: mem time33, current time 70, horizon 37\n", - "adding: mem time34, current time 70, horizon 36\n", - "adding: mem time35, current time 70, horizon 35\n", - "adding: mem time36, current time 70, horizon 34\n", - "adding: mem time37, current time 70, horizon 33\n", - "adding: mem time38, current time 70, horizon 32\n", - "adding: mem time39, current time 70, horizon 31\n", - "adding: mem time40, current time 70, horizon 30\n", - "adding: mem time41, current time 70, horizon 29\n", - "adding: mem time42, current time 70, horizon 28\n", - "adding: mem time43, current time 70, horizon 27\n", - "adding: mem time44, current time 70, horizon 26\n", - "adding: mem time45, current time 70, horizon 25\n", - "adding: mem time46, current time 70, horizon 24\n", - "adding: mem time47, current time 70, horizon 23\n", - "adding: mem time48, current time 70, horizon 22\n", - "adding: mem time49, current time 70, horizon 21\n", - "adding: mem time50, current time 70, horizon 20\n", - "adding: mem time51, current time 70, horizon 19\n", - "adding: mem time52, current time 70, horizon 18\n", - "adding: mem time53, current time 70, horizon 17\n", - "adding: mem time54, current time 70, horizon 16\n", - "adding: mem time55, current time 70, horizon 15\n", - "adding: mem time56, current time 70, horizon 14\n", - "adding: mem time57, current time 70, horizon 13\n", - "adding: mem time58, current time 70, horizon 12\n", - "adding: mem time59, current time 70, horizon 11\n", - "adding: mem time60, current time 70, horizon 10\n", - "adding: mem time61, current time 70, horizon 9\n", - "adding: mem time62, current time 70, horizon 8\n", - "adding: mem time63, current time 70, horizon 7\n", - "adding: mem time64, current time 70, horizon 6\n", - "adding: mem time65, current time 70, horizon 5\n", - "adding: mem time66, current time 70, horizon 4\n", - "adding: mem time67, current time 70, horizon 3\n", - "adding: mem time68, current time 70, horizon 2\n", - "adding: mem time69, current time 70, horizon 1\n", - "adding: mem time0, current time 71, horizon 71\n", - "adding: mem time1, current time 71, horizon 70\n", - "adding: mem time2, current time 71, horizon 69\n", - "adding: mem time3, current time 71, horizon 68\n", - "adding: mem time4, current time 71, horizon 67\n", - "adding: mem time5, current time 71, horizon 66\n", - "adding: mem time6, current time 71, horizon 65\n", - "adding: mem time7, current time 71, horizon 64\n", - "adding: mem time8, current time 71, horizon 63\n", - "adding: mem time9, current time 71, horizon 62\n", - "adding: mem time10, current time 71, horizon 61\n", - "adding: mem time11, current time 71, horizon 60\n", - "adding: mem time12, current time 71, horizon 59\n", - "adding: mem time13, current time 71, horizon 58\n", - "adding: mem time14, current time 71, horizon 57\n", - "adding: mem time15, current time 71, horizon 56\n", - "adding: mem time16, current time 71, horizon 55\n", - "adding: mem time17, current time 71, horizon 54\n", - "adding: mem time18, current time 71, horizon 53\n", - "adding: mem time19, current time 71, horizon 52\n", - "adding: mem time20, current time 71, horizon 51\n", - "adding: mem time21, current time 71, horizon 50\n", - "adding: mem time22, current time 71, horizon 49\n", - "adding: mem time23, current time 71, horizon 48\n", - "adding: mem time24, current time 71, horizon 47\n", - "adding: mem time25, current time 71, horizon 46\n", - "adding: mem time26, current time 71, horizon 45\n", - "adding: mem time27, current time 71, horizon 44\n", - "adding: mem time28, current time 71, horizon 43\n", - "adding: mem time29, current time 71, horizon 42\n", - "adding: mem time30, current time 71, horizon 41\n", - "adding: mem time31, current time 71, horizon 40\n", - "adding: mem time32, current time 71, horizon 39\n", - "adding: mem time33, current time 71, horizon 38\n", - "adding: mem time34, current time 71, horizon 37\n", - "adding: mem time35, current time 71, horizon 36\n", - "adding: mem time36, current time 71, horizon 35\n", - "adding: mem time37, current time 71, horizon 34\n", - "adding: mem time38, current time 71, horizon 33\n", - "adding: mem time39, current time 71, horizon 32\n", - "adding: mem time40, current time 71, horizon 31\n", - "adding: mem time41, current time 71, horizon 30\n", - "adding: mem time42, current time 71, horizon 29\n", - "adding: mem time43, current time 71, horizon 28\n", - "adding: mem time44, current time 71, horizon 27\n", - "adding: mem time45, current time 71, horizon 26\n", - "adding: mem time46, current time 71, horizon 25\n", - "adding: mem time47, current time 71, horizon 24\n", - "adding: mem time48, current time 71, horizon 23\n", - "adding: mem time49, current time 71, horizon 22\n", - "adding: mem time50, current time 71, horizon 21\n", - "adding: mem time51, current time 71, horizon 20\n", - "adding: mem time52, current time 71, horizon 19\n", - "adding: mem time53, current time 71, horizon 18\n", - "adding: mem time54, current time 71, horizon 17\n", - "adding: mem time55, current time 71, horizon 16\n", - "adding: mem time56, current time 71, horizon 15\n", - "adding: mem time57, current time 71, horizon 14\n", - "adding: mem time58, current time 71, horizon 13\n", - "adding: mem time59, current time 71, horizon 12\n", - "adding: mem time60, current time 71, horizon 11\n", - "adding: mem time61, current time 71, horizon 10\n", - "adding: mem time62, current time 71, horizon 9\n", - "adding: mem time63, current time 71, horizon 8\n", - "adding: mem time64, current time 71, horizon 7\n", - "adding: mem time65, current time 71, horizon 6\n", - "adding: mem time66, current time 71, horizon 5\n", - "adding: mem time67, current time 71, horizon 4\n", - "adding: mem time68, current time 71, horizon 3\n", - "adding: mem time69, current time 71, horizon 2\n", - "adding: mem time70, current time 71, horizon 1\n", - "adding: mem time0, current time 72, horizon 72\n", - "adding: mem time1, current time 72, horizon 71\n", - "adding: mem time2, current time 72, horizon 70\n", - "adding: mem time3, current time 72, horizon 69\n", - "adding: mem time4, current time 72, horizon 68\n", - "adding: mem time5, current time 72, horizon 67\n", - "adding: mem time6, current time 72, horizon 66\n", - "adding: mem time7, current time 72, horizon 65\n", - "adding: mem time8, current time 72, horizon 64\n", - "adding: mem time9, current time 72, horizon 63\n", - "adding: mem time10, current time 72, horizon 62\n", - "adding: mem time11, current time 72, horizon 61\n", - "adding: mem time12, current time 72, horizon 60\n", - "adding: mem time13, current time 72, horizon 59\n", - "adding: mem time14, current time 72, horizon 58\n", - "adding: mem time15, current time 72, horizon 57\n", - "adding: mem time16, current time 72, horizon 56\n", - "adding: mem time17, current time 72, horizon 55\n", - "adding: mem time18, current time 72, horizon 54\n", - "adding: mem time19, current time 72, horizon 53\n", - "adding: mem time20, current time 72, horizon 52\n", - "adding: mem time21, current time 72, horizon 51\n", - "adding: mem time22, current time 72, horizon 50\n", - "adding: mem time23, current time 72, horizon 49\n", - "adding: mem time24, current time 72, horizon 48\n", - "adding: mem time25, current time 72, horizon 47\n", - "adding: mem time26, current time 72, horizon 46\n", - "adding: mem time27, current time 72, horizon 45\n", - "adding: mem time28, current time 72, horizon 44\n", - "adding: mem time29, current time 72, horizon 43\n", - "adding: mem time30, current time 72, horizon 42\n", - "adding: mem time31, current time 72, horizon 41\n", - "adding: mem time32, current time 72, horizon 40\n", - "adding: mem time33, current time 72, horizon 39\n", - "adding: mem time34, current time 72, horizon 38\n", - "adding: mem time35, current time 72, horizon 37\n", - "adding: mem time36, current time 72, horizon 36\n", - "adding: mem time37, current time 72, horizon 35\n", - "adding: mem time38, current time 72, horizon 34\n", - "adding: mem time39, current time 72, horizon 33\n", - "adding: mem time40, current time 72, horizon 32\n", - "adding: mem time41, current time 72, horizon 31\n", - "adding: mem time42, current time 72, horizon 30\n", - "adding: mem time43, current time 72, horizon 29\n", - "adding: mem time44, current time 72, horizon 28\n", - "adding: mem time45, current time 72, horizon 27\n", - "adding: mem time46, current time 72, horizon 26\n", - "adding: mem time47, current time 72, horizon 25\n", - "adding: mem time48, current time 72, horizon 24\n", - "adding: mem time49, current time 72, horizon 23\n", - "adding: mem time50, current time 72, horizon 22\n", - "adding: mem time51, current time 72, horizon 21\n", - "adding: mem time52, current time 72, horizon 20\n", - "adding: mem time53, current time 72, horizon 19\n", - "adding: mem time54, current time 72, horizon 18\n", - "adding: mem time55, current time 72, horizon 17\n", - "adding: mem time56, current time 72, horizon 16\n", - "adding: mem time57, current time 72, horizon 15\n", - "adding: mem time58, current time 72, horizon 14\n", - "adding: mem time59, current time 72, horizon 13\n", - "adding: mem time60, current time 72, horizon 12\n", - "adding: mem time61, current time 72, horizon 11\n", - "adding: mem time62, current time 72, horizon 10\n", - "adding: mem time63, current time 72, horizon 9\n", - "adding: mem time64, current time 72, horizon 8\n", - "adding: mem time65, current time 72, horizon 7\n", - "adding: mem time66, current time 72, horizon 6\n", - "adding: mem time67, current time 72, horizon 5\n", - "adding: mem time68, current time 72, horizon 4\n", - "adding: mem time69, current time 72, horizon 3\n", - "adding: mem time70, current time 72, horizon 2\n", - "adding: mem time71, current time 72, horizon 1\n", - "adding: mem time0, current time 73, horizon 73\n", - "adding: mem time1, current time 73, horizon 72\n", - "adding: mem time2, current time 73, horizon 71\n", - "adding: mem time3, current time 73, horizon 70\n", - "adding: mem time4, current time 73, horizon 69\n", - "adding: mem time5, current time 73, horizon 68\n", - "adding: mem time6, current time 73, horizon 67\n", - "adding: mem time7, current time 73, horizon 66\n", - "adding: mem time8, current time 73, horizon 65\n", - "adding: mem time9, current time 73, horizon 64\n", - "adding: mem time10, current time 73, horizon 63\n", - "adding: mem time11, current time 73, horizon 62\n", - "adding: mem time12, current time 73, horizon 61\n", - "adding: mem time13, current time 73, horizon 60\n", - "adding: mem time14, current time 73, horizon 59\n", - "adding: mem time15, current time 73, horizon 58\n", - "adding: mem time16, current time 73, horizon 57\n", - "adding: mem time17, current time 73, horizon 56\n", - "adding: mem time18, current time 73, horizon 55\n", - "adding: mem time19, current time 73, horizon 54\n", - "adding: mem time20, current time 73, horizon 53\n", - "adding: mem time21, current time 73, horizon 52\n", - "adding: mem time22, current time 73, horizon 51\n", - "adding: mem time23, current time 73, horizon 50\n", - "adding: mem time24, current time 73, horizon 49\n", - "adding: mem time25, current time 73, horizon 48\n", - "adding: mem time26, current time 73, horizon 47\n", - "adding: mem time27, current time 73, horizon 46\n", - "adding: mem time28, current time 73, horizon 45\n", - "adding: mem time29, current time 73, horizon 44\n", - "adding: mem time30, current time 73, horizon 43\n", - "adding: mem time31, current time 73, horizon 42\n", - "adding: mem time32, current time 73, horizon 41\n", - "adding: mem time33, current time 73, horizon 40\n", - "adding: mem time34, current time 73, horizon 39\n", - "adding: mem time35, current time 73, horizon 38\n", - "adding: mem time36, current time 73, horizon 37\n", - "adding: mem time37, current time 73, horizon 36\n", - "adding: mem time38, current time 73, horizon 35\n", - "adding: mem time39, current time 73, horizon 34\n", - "adding: mem time40, current time 73, horizon 33\n", - "adding: mem time41, current time 73, horizon 32\n", - "adding: mem time42, current time 73, horizon 31\n", - "adding: mem time43, current time 73, horizon 30\n", - "adding: mem time44, current time 73, horizon 29\n", - "adding: mem time45, current time 73, horizon 28\n", - "adding: mem time46, current time 73, horizon 27\n", - "adding: mem time47, current time 73, horizon 26\n", - "adding: mem time48, current time 73, horizon 25\n", - "adding: mem time49, current time 73, horizon 24\n", - "adding: mem time50, current time 73, horizon 23\n", - "adding: mem time51, current time 73, horizon 22\n", - "adding: mem time52, current time 73, horizon 21\n", - "adding: mem time53, current time 73, horizon 20\n", - "adding: mem time54, current time 73, horizon 19\n", - "adding: mem time55, current time 73, horizon 18\n", - "adding: mem time56, current time 73, horizon 17\n", - "adding: mem time57, current time 73, horizon 16\n", - "adding: mem time58, current time 73, horizon 15\n", - "adding: mem time59, current time 73, horizon 14\n", - "adding: mem time60, current time 73, horizon 13\n", - "adding: mem time61, current time 73, horizon 12\n", - "adding: mem time62, current time 73, horizon 11\n", - "adding: mem time63, current time 73, horizon 10\n", - "adding: mem time64, current time 73, horizon 9\n", - "adding: mem time65, current time 73, horizon 8\n", - "adding: mem time66, current time 73, horizon 7\n", - "adding: mem time67, current time 73, horizon 6\n", - "adding: mem time68, current time 73, horizon 5\n", - "adding: mem time69, current time 73, horizon 4\n", - "adding: mem time70, current time 73, horizon 3\n", - "adding: mem time71, current time 73, horizon 2\n", - "adding: mem time72, current time 73, horizon 1\n", - "adding: mem time0, current time 74, horizon 74\n", - "adding: mem time1, current time 74, horizon 73\n", - "adding: mem time2, current time 74, horizon 72\n", - "adding: mem time3, current time 74, horizon 71\n", - "adding: mem time4, current time 74, horizon 70\n", - "adding: mem time5, current time 74, horizon 69\n", - "adding: mem time6, current time 74, horizon 68\n", - "adding: mem time7, current time 74, horizon 67\n", - "adding: mem time8, current time 74, horizon 66\n", - "adding: mem time9, current time 74, horizon 65\n", - "adding: mem time10, current time 74, horizon 64\n", - "adding: mem time11, current time 74, horizon 63\n", - "adding: mem time12, current time 74, horizon 62\n", - "adding: mem time13, current time 74, horizon 61\n", - "adding: mem time14, current time 74, horizon 60\n", - "adding: mem time15, current time 74, horizon 59\n", - "adding: mem time16, current time 74, horizon 58\n", - "adding: mem time17, current time 74, horizon 57\n", - "adding: mem time18, current time 74, horizon 56\n", - "adding: mem time19, current time 74, horizon 55\n", - "adding: mem time20, current time 74, horizon 54\n", - "adding: mem time21, current time 74, horizon 53\n", - "adding: mem time22, current time 74, horizon 52\n", - "adding: mem time23, current time 74, horizon 51\n", - "adding: mem time24, current time 74, horizon 50\n", - "adding: mem time25, current time 74, horizon 49\n", - "adding: mem time26, current time 74, horizon 48\n", - "adding: mem time27, current time 74, horizon 47\n", - "adding: mem time28, current time 74, horizon 46\n", - "adding: mem time29, current time 74, horizon 45\n", - "adding: mem time30, current time 74, horizon 44\n", - "adding: mem time31, current time 74, horizon 43\n", - "adding: mem time32, current time 74, horizon 42\n", - "adding: mem time33, current time 74, horizon 41\n", - "adding: mem time34, current time 74, horizon 40\n", - "adding: mem time35, current time 74, horizon 39\n", - "adding: mem time36, current time 74, horizon 38\n", - "adding: mem time37, current time 74, horizon 37\n", - "adding: mem time38, current time 74, horizon 36\n", - "adding: mem time39, current time 74, horizon 35\n", - "adding: mem time40, current time 74, horizon 34\n", - "adding: mem time41, current time 74, horizon 33\n", - "adding: mem time42, current time 74, horizon 32\n", - "adding: mem time43, current time 74, horizon 31\n", - "adding: mem time44, current time 74, horizon 30\n", - "adding: mem time45, current time 74, horizon 29\n", - "adding: mem time46, current time 74, horizon 28\n", - "adding: mem time47, current time 74, horizon 27\n", - "adding: mem time48, current time 74, horizon 26\n", - "adding: mem time49, current time 74, horizon 25\n", - "adding: mem time50, current time 74, horizon 24\n", - "adding: mem time51, current time 74, horizon 23\n", - "adding: mem time52, current time 74, horizon 22\n", - "adding: mem time53, current time 74, horizon 21\n", - "adding: mem time54, current time 74, horizon 20\n", - "adding: mem time55, current time 74, horizon 19\n", - "adding: mem time56, current time 74, horizon 18\n", - "adding: mem time57, current time 74, horizon 17\n", - "adding: mem time58, current time 74, horizon 16\n", - "adding: mem time59, current time 74, horizon 15\n", - "adding: mem time60, current time 74, horizon 14\n", - "adding: mem time61, current time 74, horizon 13\n", - "adding: mem time62, current time 74, horizon 12\n", - "adding: mem time63, current time 74, horizon 11\n", - "adding: mem time64, current time 74, horizon 10\n", - "adding: mem time65, current time 74, horizon 9\n", - "adding: mem time66, current time 74, horizon 8\n", - "adding: mem time67, current time 74, horizon 7\n", - "adding: mem time68, current time 74, horizon 6\n", - "adding: mem time69, current time 74, horizon 5\n", - "adding: mem time70, current time 74, horizon 4\n", - "adding: mem time71, current time 74, horizon 3\n", - "adding: mem time72, current time 74, horizon 2\n", - "adding: mem time73, current time 74, horizon 1\n", - "adding: mem time0, current time 75, horizon 75\n", - "adding: mem time1, current time 75, horizon 74\n", - "adding: mem time2, current time 75, horizon 73\n", - "adding: mem time3, current time 75, horizon 72\n", - "adding: mem time4, current time 75, horizon 71\n", - "adding: mem time5, current time 75, horizon 70\n", - "adding: mem time6, current time 75, horizon 69\n", - "adding: mem time7, current time 75, horizon 68\n", - "adding: mem time8, current time 75, horizon 67\n", - "adding: mem time9, current time 75, horizon 66\n", - "adding: mem time10, current time 75, horizon 65\n", - "adding: mem time11, current time 75, horizon 64\n", - "adding: mem time12, current time 75, horizon 63\n", - "adding: mem time13, current time 75, horizon 62\n", - "adding: mem time14, current time 75, horizon 61\n", - "adding: mem time15, current time 75, horizon 60\n", - "adding: mem time16, current time 75, horizon 59\n", - "adding: mem time17, current time 75, horizon 58\n", - "adding: mem time18, current time 75, horizon 57\n", - "adding: mem time19, current time 75, horizon 56\n", - "adding: mem time20, current time 75, horizon 55\n", - "adding: mem time21, current time 75, horizon 54\n", - "adding: mem time22, current time 75, horizon 53\n", - "adding: mem time23, current time 75, horizon 52\n", - "adding: mem time24, current time 75, horizon 51\n", - "adding: mem time25, current time 75, horizon 50\n", - "adding: mem time26, current time 75, horizon 49\n", - "adding: mem time27, current time 75, horizon 48\n", - "adding: mem time28, current time 75, horizon 47\n", - "adding: mem time29, current time 75, horizon 46\n", - "adding: mem time30, current time 75, horizon 45\n", - "adding: mem time31, current time 75, horizon 44\n", - "adding: mem time32, current time 75, horizon 43\n", - "adding: mem time33, current time 75, horizon 42\n", - "adding: mem time34, current time 75, horizon 41\n", - "adding: mem time35, current time 75, horizon 40\n", - "adding: mem time36, current time 75, horizon 39\n", - "adding: mem time37, current time 75, horizon 38\n", - "adding: mem time38, current time 75, horizon 37\n", - "adding: mem time39, current time 75, horizon 36\n", - "adding: mem time40, current time 75, horizon 35\n", - "adding: mem time41, current time 75, horizon 34\n", - "adding: mem time42, current time 75, horizon 33\n", - "adding: mem time43, current time 75, horizon 32\n", - "adding: mem time44, current time 75, horizon 31\n", - "adding: mem time45, current time 75, horizon 30\n", - "adding: mem time46, current time 75, horizon 29\n", - "adding: mem time47, current time 75, horizon 28\n", - "adding: mem time48, current time 75, horizon 27\n", - "adding: mem time49, current time 75, horizon 26\n", - "adding: mem time50, current time 75, horizon 25\n", - "adding: mem time51, current time 75, horizon 24\n", - "adding: mem time52, current time 75, horizon 23\n", - "adding: mem time53, current time 75, horizon 22\n", - "adding: mem time54, current time 75, horizon 21\n", - "adding: mem time55, current time 75, horizon 20\n", - "adding: mem time56, current time 75, horizon 19\n", - "adding: mem time57, current time 75, horizon 18\n", - "adding: mem time58, current time 75, horizon 17\n", - "adding: mem time59, current time 75, horizon 16\n", - "adding: mem time60, current time 75, horizon 15\n", - "adding: mem time61, current time 75, horizon 14\n", - "adding: mem time62, current time 75, horizon 13\n", - "adding: mem time63, current time 75, horizon 12\n", - "adding: mem time64, current time 75, horizon 11\n", - "adding: mem time65, current time 75, horizon 10\n", - "adding: mem time66, current time 75, horizon 9\n", - "adding: mem time67, current time 75, horizon 8\n", - "adding: mem time68, current time 75, horizon 7\n", - "adding: mem time69, current time 75, horizon 6\n", - "adding: mem time70, current time 75, horizon 5\n", - "adding: mem time71, current time 75, horizon 4\n", - "adding: mem time72, current time 75, horizon 3\n", - "adding: mem time73, current time 75, horizon 2\n", - "adding: mem time74, current time 75, horizon 1\n", - "adding: mem time0, current time 76, horizon 76\n", - "adding: mem time1, current time 76, horizon 75\n", - "adding: mem time2, current time 76, horizon 74\n", - "adding: mem time3, current time 76, horizon 73\n", - "adding: mem time4, current time 76, horizon 72\n", - "adding: mem time5, current time 76, horizon 71\n", - "adding: mem time6, current time 76, horizon 70\n", - "adding: mem time7, current time 76, horizon 69\n", - "adding: mem time8, current time 76, horizon 68\n", - "adding: mem time9, current time 76, horizon 67\n", - "adding: mem time10, current time 76, horizon 66\n", - "adding: mem time11, current time 76, horizon 65\n", - "adding: mem time12, current time 76, horizon 64\n", - "adding: mem time13, current time 76, horizon 63\n", - "adding: mem time14, current time 76, horizon 62\n", - "adding: mem time15, current time 76, horizon 61\n", - "adding: mem time16, current time 76, horizon 60\n", - "adding: mem time17, current time 76, horizon 59\n", - "adding: mem time18, current time 76, horizon 58\n", - "adding: mem time19, current time 76, horizon 57\n", - "adding: mem time20, current time 76, horizon 56\n", - "adding: mem time21, current time 76, horizon 55\n", - "adding: mem time22, current time 76, horizon 54\n", - "adding: mem time23, current time 76, horizon 53\n", - "adding: mem time24, current time 76, horizon 52\n", - "adding: mem time25, current time 76, horizon 51\n", - "adding: mem time26, current time 76, horizon 50\n", - "adding: mem time27, current time 76, horizon 49\n", - "adding: mem time28, current time 76, horizon 48\n", - "adding: mem time29, current time 76, horizon 47\n", - "adding: mem time30, current time 76, horizon 46\n", - "adding: mem time31, current time 76, horizon 45\n", - "adding: mem time32, current time 76, horizon 44\n", - "adding: mem time33, current time 76, horizon 43\n", - "adding: mem time34, current time 76, horizon 42\n", - "adding: mem time35, current time 76, horizon 41\n", - "adding: mem time36, current time 76, horizon 40\n", - "adding: mem time37, current time 76, horizon 39\n", - "adding: mem time38, current time 76, horizon 38\n", - "adding: mem time39, current time 76, horizon 37\n", - "adding: mem time40, current time 76, horizon 36\n", - "adding: mem time41, current time 76, horizon 35\n", - "adding: mem time42, current time 76, horizon 34\n", - "adding: mem time43, current time 76, horizon 33\n", - "adding: mem time44, current time 76, horizon 32\n", - "adding: mem time45, current time 76, horizon 31\n", - "adding: mem time46, current time 76, horizon 30\n", - "adding: mem time47, current time 76, horizon 29\n", - "adding: mem time48, current time 76, horizon 28\n", - "adding: mem time49, current time 76, horizon 27\n", - "adding: mem time50, current time 76, horizon 26\n", - "adding: mem time51, current time 76, horizon 25\n", - "adding: mem time52, current time 76, horizon 24\n", - "adding: mem time53, current time 76, horizon 23\n", - "adding: mem time54, current time 76, horizon 22\n", - "adding: mem time55, current time 76, horizon 21\n", - "adding: mem time56, current time 76, horizon 20\n", - "adding: mem time57, current time 76, horizon 19\n", - "adding: mem time58, current time 76, horizon 18\n", - "adding: mem time59, current time 76, horizon 17\n", - "adding: mem time60, current time 76, horizon 16\n", - "adding: mem time61, current time 76, horizon 15\n", - "adding: mem time62, current time 76, horizon 14\n", - "adding: mem time63, current time 76, horizon 13\n", - "adding: mem time64, current time 76, horizon 12\n", - "adding: mem time65, current time 76, horizon 11\n", - "adding: mem time66, current time 76, horizon 10\n", - "adding: mem time67, current time 76, horizon 9\n", - "adding: mem time68, current time 76, horizon 8\n", - "adding: mem time69, current time 76, horizon 7\n", - "adding: mem time70, current time 76, horizon 6\n", - "adding: mem time71, current time 76, horizon 5\n", - "adding: mem time72, current time 76, horizon 4\n", - "adding: mem time73, current time 76, horizon 3\n", - "adding: mem time74, current time 76, horizon 2\n", - "adding: mem time75, current time 76, horizon 1\n", - "adding: mem time0, current time 77, horizon 77\n", - "adding: mem time1, current time 77, horizon 76\n", - "adding: mem time2, current time 77, horizon 75\n", - "adding: mem time3, current time 77, horizon 74\n", - "adding: mem time4, current time 77, horizon 73\n", - "adding: mem time5, current time 77, horizon 72\n", - "adding: mem time6, current time 77, horizon 71\n", - "adding: mem time7, current time 77, horizon 70\n", - "adding: mem time8, current time 77, horizon 69\n", - "adding: mem time9, current time 77, horizon 68\n", - "adding: mem time10, current time 77, horizon 67\n", - "adding: mem time11, current time 77, horizon 66\n", - "adding: mem time12, current time 77, horizon 65\n", - "adding: mem time13, current time 77, horizon 64\n", - "adding: mem time14, current time 77, horizon 63\n", - "adding: mem time15, current time 77, horizon 62\n", - "adding: mem time16, current time 77, horizon 61\n", - "adding: mem time17, current time 77, horizon 60\n", - "adding: mem time18, current time 77, horizon 59\n", - "adding: mem time19, current time 77, horizon 58\n", - "adding: mem time20, current time 77, horizon 57\n", - "adding: mem time21, current time 77, horizon 56\n", - "adding: mem time22, current time 77, horizon 55\n", - "adding: mem time23, current time 77, horizon 54\n", - "adding: mem time24, current time 77, horizon 53\n", - "adding: mem time25, current time 77, horizon 52\n", - "adding: mem time26, current time 77, horizon 51\n", - "adding: mem time27, current time 77, horizon 50\n", - "adding: mem time28, current time 77, horizon 49\n", - "adding: mem time29, current time 77, horizon 48\n", - "adding: mem time30, current time 77, horizon 47\n", - "adding: mem time31, current time 77, horizon 46\n", - "adding: mem time32, current time 77, horizon 45\n", - "adding: mem time33, current time 77, horizon 44\n", - "adding: mem time34, current time 77, horizon 43\n", - "adding: mem time35, current time 77, horizon 42\n", - "adding: mem time36, current time 77, horizon 41\n", - "adding: mem time37, current time 77, horizon 40\n", - "adding: mem time38, current time 77, horizon 39\n", - "adding: mem time39, current time 77, horizon 38\n", - "adding: mem time40, current time 77, horizon 37\n", - "adding: mem time41, current time 77, horizon 36\n", - "adding: mem time42, current time 77, horizon 35\n", - "adding: mem time43, current time 77, horizon 34\n", - "adding: mem time44, current time 77, horizon 33\n", - "adding: mem time45, current time 77, horizon 32\n", - "adding: mem time46, current time 77, horizon 31\n", - "adding: mem time47, current time 77, horizon 30\n", - "adding: mem time48, current time 77, horizon 29\n", - "adding: mem time49, current time 77, horizon 28\n", - "adding: mem time50, current time 77, horizon 27\n", - "adding: mem time51, current time 77, horizon 26\n", - "adding: mem time52, current time 77, horizon 25\n", - "adding: mem time53, current time 77, horizon 24\n", - "adding: mem time54, current time 77, horizon 23\n", - "adding: mem time55, current time 77, horizon 22\n", - "adding: mem time56, current time 77, horizon 21\n", - "adding: mem time57, current time 77, horizon 20\n", - "adding: mem time58, current time 77, horizon 19\n", - "adding: mem time59, current time 77, horizon 18\n", - "adding: mem time60, current time 77, horizon 17\n", - "adding: mem time61, current time 77, horizon 16\n", - "adding: mem time62, current time 77, horizon 15\n", - "adding: mem time63, current time 77, horizon 14\n", - "adding: mem time64, current time 77, horizon 13\n", - "adding: mem time65, current time 77, horizon 12\n", - "adding: mem time66, current time 77, horizon 11\n", - "adding: mem time67, current time 77, horizon 10\n", - "adding: mem time68, current time 77, horizon 9\n", - "adding: mem time69, current time 77, horizon 8\n", - "adding: mem time70, current time 77, horizon 7\n", - "adding: mem time71, current time 77, horizon 6\n", - "adding: mem time72, current time 77, horizon 5\n", - "adding: mem time73, current time 77, horizon 4\n", - "adding: mem time74, current time 77, horizon 3\n", - "adding: mem time75, current time 77, horizon 2\n", - "adding: mem time76, current time 77, horizon 1\n", - "adding: mem time0, current time 78, horizon 78\n", - "adding: mem time1, current time 78, horizon 77\n", - "adding: mem time2, current time 78, horizon 76\n", - "adding: mem time3, current time 78, horizon 75\n", - "adding: mem time4, current time 78, horizon 74\n", - "adding: mem time5, current time 78, horizon 73\n", - "adding: mem time6, current time 78, horizon 72\n", - "adding: mem time7, current time 78, horizon 71\n", - "adding: mem time8, current time 78, horizon 70\n", - "adding: mem time9, current time 78, horizon 69\n", - "adding: mem time10, current time 78, horizon 68\n", - "adding: mem time11, current time 78, horizon 67\n", - "adding: mem time12, current time 78, horizon 66\n", - "adding: mem time13, current time 78, horizon 65\n", - "adding: mem time14, current time 78, horizon 64\n", - "adding: mem time15, current time 78, horizon 63\n", - "adding: mem time16, current time 78, horizon 62\n", - "adding: mem time17, current time 78, horizon 61\n", - "adding: mem time18, current time 78, horizon 60\n", - "adding: mem time19, current time 78, horizon 59\n", - "adding: mem time20, current time 78, horizon 58\n", - "adding: mem time21, current time 78, horizon 57\n", - "adding: mem time22, current time 78, horizon 56\n", - "adding: mem time23, current time 78, horizon 55\n", - "adding: mem time24, current time 78, horizon 54\n", - "adding: mem time25, current time 78, horizon 53\n", - "adding: mem time26, current time 78, horizon 52\n", - "adding: mem time27, current time 78, horizon 51\n", - "adding: mem time28, current time 78, horizon 50\n", - "adding: mem time29, current time 78, horizon 49\n", - "adding: mem time30, current time 78, horizon 48\n", - "adding: mem time31, current time 78, horizon 47\n", - "adding: mem time32, current time 78, horizon 46\n", - "adding: mem time33, current time 78, horizon 45\n", - "adding: mem time34, current time 78, horizon 44\n", - "adding: mem time35, current time 78, horizon 43\n", - "adding: mem time36, current time 78, horizon 42\n", - "adding: mem time37, current time 78, horizon 41\n", - "adding: mem time38, current time 78, horizon 40\n", - "adding: mem time39, current time 78, horizon 39\n", - "adding: mem time40, current time 78, horizon 38\n", - "adding: mem time41, current time 78, horizon 37\n", - "adding: mem time42, current time 78, horizon 36\n", - "adding: mem time43, current time 78, horizon 35\n", - "adding: mem time44, current time 78, horizon 34\n", - "adding: mem time45, current time 78, horizon 33\n", - "adding: mem time46, current time 78, horizon 32\n", - "adding: mem time47, current time 78, horizon 31\n", - "adding: mem time48, current time 78, horizon 30\n", - "adding: mem time49, current time 78, horizon 29\n", - "adding: mem time50, current time 78, horizon 28\n", - "adding: mem time51, current time 78, horizon 27\n", - "adding: mem time52, current time 78, horizon 26\n", - "adding: mem time53, current time 78, horizon 25\n", - "adding: mem time54, current time 78, horizon 24\n", - "adding: mem time55, current time 78, horizon 23\n", - "adding: mem time56, current time 78, horizon 22\n", - "adding: mem time57, current time 78, horizon 21\n", - "adding: mem time58, current time 78, horizon 20\n", - "adding: mem time59, current time 78, horizon 19\n", - "adding: mem time60, current time 78, horizon 18\n", - "adding: mem time61, current time 78, horizon 17\n", - "adding: mem time62, current time 78, horizon 16\n", - "adding: mem time63, current time 78, horizon 15\n", - "adding: mem time64, current time 78, horizon 14\n", - "adding: mem time65, current time 78, horizon 13\n", - "adding: mem time66, current time 78, horizon 12\n", - "adding: mem time67, current time 78, horizon 11\n", - "adding: mem time68, current time 78, horizon 10\n", - "adding: mem time69, current time 78, horizon 9\n", - "adding: mem time70, current time 78, horizon 8\n", - "adding: mem time71, current time 78, horizon 7\n", - "adding: mem time72, current time 78, horizon 6\n", - "adding: mem time73, current time 78, horizon 5\n", - "adding: mem time74, current time 78, horizon 4\n", - "adding: mem time75, current time 78, horizon 3\n", - "adding: mem time76, current time 78, horizon 2\n", - "adding: mem time77, current time 78, horizon 1\n", - "adding: mem time0, current time 79, horizon 79\n", - "adding: mem time1, current time 79, horizon 78\n", - "adding: mem time2, current time 79, horizon 77\n", - "adding: mem time3, current time 79, horizon 76\n", - "adding: mem time4, current time 79, horizon 75\n", - "adding: mem time5, current time 79, horizon 74\n", - "adding: mem time6, current time 79, horizon 73\n", - "adding: mem time7, current time 79, horizon 72\n", - "adding: mem time8, current time 79, horizon 71\n", - "adding: mem time9, current time 79, horizon 70\n", - "adding: mem time10, current time 79, horizon 69\n", - "adding: mem time11, current time 79, horizon 68\n", - "adding: mem time12, current time 79, horizon 67\n", - "adding: mem time13, current time 79, horizon 66\n", - "adding: mem time14, current time 79, horizon 65\n", - "adding: mem time15, current time 79, horizon 64\n", - "adding: mem time16, current time 79, horizon 63\n", - "adding: mem time17, current time 79, horizon 62\n", - "adding: mem time18, current time 79, horizon 61\n", - "adding: mem time19, current time 79, horizon 60\n", - "adding: mem time20, current time 79, horizon 59\n", - "adding: mem time21, current time 79, horizon 58\n", - "adding: mem time22, current time 79, horizon 57\n", - "adding: mem time23, current time 79, horizon 56\n", - "adding: mem time24, current time 79, horizon 55\n", - "adding: mem time25, current time 79, horizon 54\n", - "adding: mem time26, current time 79, horizon 53\n", - "adding: mem time27, current time 79, horizon 52\n", - "adding: mem time28, current time 79, horizon 51\n", - "adding: mem time29, current time 79, horizon 50\n", - "adding: mem time30, current time 79, horizon 49\n", - "adding: mem time31, current time 79, horizon 48\n", - "adding: mem time32, current time 79, horizon 47\n", - "adding: mem time33, current time 79, horizon 46\n", - "adding: mem time34, current time 79, horizon 45\n", - "adding: mem time35, current time 79, horizon 44\n", - "adding: mem time36, current time 79, horizon 43\n", - "adding: mem time37, current time 79, horizon 42\n", - "adding: mem time38, current time 79, horizon 41\n", - "adding: mem time39, current time 79, horizon 40\n", - "adding: mem time40, current time 79, horizon 39\n", - "adding: mem time41, current time 79, horizon 38\n", - "adding: mem time42, current time 79, horizon 37\n", - "adding: mem time43, current time 79, horizon 36\n", - "adding: mem time44, current time 79, horizon 35\n", - "adding: mem time45, current time 79, horizon 34\n", - "adding: mem time46, current time 79, horizon 33\n", - "adding: mem time47, current time 79, horizon 32\n", - "adding: mem time48, current time 79, horizon 31\n", - "adding: mem time49, current time 79, horizon 30\n", - "adding: mem time50, current time 79, horizon 29\n", - "adding: mem time51, current time 79, horizon 28\n", - "adding: mem time52, current time 79, horizon 27\n", - "adding: mem time53, current time 79, horizon 26\n", - "adding: mem time54, current time 79, horizon 25\n", - "adding: mem time55, current time 79, horizon 24\n", - "adding: mem time56, current time 79, horizon 23\n", - "adding: mem time57, current time 79, horizon 22\n", - "adding: mem time58, current time 79, horizon 21\n", - "adding: mem time59, current time 79, horizon 20\n", - "adding: mem time60, current time 79, horizon 19\n", - "adding: mem time61, current time 79, horizon 18\n", - "adding: mem time62, current time 79, horizon 17\n", - "adding: mem time63, current time 79, horizon 16\n", - "adding: mem time64, current time 79, horizon 15\n", - "adding: mem time65, current time 79, horizon 14\n", - "adding: mem time66, current time 79, horizon 13\n", - "adding: mem time67, current time 79, horizon 12\n", - "adding: mem time68, current time 79, horizon 11\n", - "adding: mem time69, current time 79, horizon 10\n", - "adding: mem time70, current time 79, horizon 9\n", - "adding: mem time71, current time 79, horizon 8\n", - "adding: mem time72, current time 79, horizon 7\n", - "adding: mem time73, current time 79, horizon 6\n", - "adding: mem time74, current time 79, horizon 5\n", - "adding: mem time75, current time 79, horizon 4\n", - "adding: mem time76, current time 79, horizon 3\n", - "adding: mem time77, current time 79, horizon 2\n", - "adding: mem time78, current time 79, horizon 1\n", - "adding: mem time0, current time 80, horizon 80\n", - "adding: mem time1, current time 80, horizon 79\n", - "adding: mem time2, current time 80, horizon 78\n", - "adding: mem time3, current time 80, horizon 77\n", - "adding: mem time4, current time 80, horizon 76\n", - "adding: mem time5, current time 80, horizon 75\n", - "adding: mem time6, current time 80, horizon 74\n", - "adding: mem time7, current time 80, horizon 73\n", - "adding: mem time8, current time 80, horizon 72\n", - "adding: mem time9, current time 80, horizon 71\n", - "adding: mem time10, current time 80, horizon 70\n", - "adding: mem time11, current time 80, horizon 69\n", - "adding: mem time12, current time 80, horizon 68\n", - "adding: mem time13, current time 80, horizon 67\n", - "adding: mem time14, current time 80, horizon 66\n", - "adding: mem time15, current time 80, horizon 65\n", - "adding: mem time16, current time 80, horizon 64\n", - "adding: mem time17, current time 80, horizon 63\n", - "adding: mem time18, current time 80, horizon 62\n", - "adding: mem time19, current time 80, horizon 61\n", - "adding: mem time20, current time 80, horizon 60\n", - "adding: mem time21, current time 80, horizon 59\n", - "adding: mem time22, current time 80, horizon 58\n", - "adding: mem time23, current time 80, horizon 57\n", - "adding: mem time24, current time 80, horizon 56\n", - "adding: mem time25, current time 80, horizon 55\n", - "adding: mem time26, current time 80, horizon 54\n", - "adding: mem time27, current time 80, horizon 53\n", - "adding: mem time28, current time 80, horizon 52\n", - "adding: mem time29, current time 80, horizon 51\n", - "adding: mem time30, current time 80, horizon 50\n", - "adding: mem time31, current time 80, horizon 49\n", - "adding: mem time32, current time 80, horizon 48\n", - "adding: mem time33, current time 80, horizon 47\n", - "adding: mem time34, current time 80, horizon 46\n", - "adding: mem time35, current time 80, horizon 45\n", - "adding: mem time36, current time 80, horizon 44\n", - "adding: mem time37, current time 80, horizon 43\n", - "adding: mem time38, current time 80, horizon 42\n", - "adding: mem time39, current time 80, horizon 41\n", - "adding: mem time40, current time 80, horizon 40\n", - "adding: mem time41, current time 80, horizon 39\n", - "adding: mem time42, current time 80, horizon 38\n", - "adding: mem time43, current time 80, horizon 37\n", - "adding: mem time44, current time 80, horizon 36\n", - "adding: mem time45, current time 80, horizon 35\n", - "adding: mem time46, current time 80, horizon 34\n", - "adding: mem time47, current time 80, horizon 33\n", - "adding: mem time48, current time 80, horizon 32\n", - "adding: mem time49, current time 80, horizon 31\n", - "adding: mem time50, current time 80, horizon 30\n", - "adding: mem time51, current time 80, horizon 29\n", - "adding: mem time52, current time 80, horizon 28\n", - "adding: mem time53, current time 80, horizon 27\n", - "adding: mem time54, current time 80, horizon 26\n", - "adding: mem time55, current time 80, horizon 25\n", - "adding: mem time56, current time 80, horizon 24\n", - "adding: mem time57, current time 80, horizon 23\n", - "adding: mem time58, current time 80, horizon 22\n", - "adding: mem time59, current time 80, horizon 21\n", - "adding: mem time60, current time 80, horizon 20\n", - "adding: mem time61, current time 80, horizon 19\n", - "adding: mem time62, current time 80, horizon 18\n", - "adding: mem time63, current time 80, horizon 17\n", - "adding: mem time64, current time 80, horizon 16\n", - "adding: mem time65, current time 80, horizon 15\n", - "adding: mem time66, current time 80, horizon 14\n", - "adding: mem time67, current time 80, horizon 13\n", - "adding: mem time68, current time 80, horizon 12\n", - "adding: mem time69, current time 80, horizon 11\n", - "adding: mem time70, current time 80, horizon 10\n", - "adding: mem time71, current time 80, horizon 9\n", - "adding: mem time72, current time 80, horizon 8\n", - "adding: mem time73, current time 80, horizon 7\n", - "adding: mem time74, current time 80, horizon 6\n", - "adding: mem time75, current time 80, horizon 5\n", - "adding: mem time76, current time 80, horizon 4\n", - "adding: mem time77, current time 80, horizon 3\n", - "adding: mem time78, current time 80, horizon 2\n", - "adding: mem time79, current time 80, horizon 1\n", - "adding: mem time0, current time 81, horizon 81\n", - "adding: mem time1, current time 81, horizon 80\n", - "adding: mem time2, current time 81, horizon 79\n", - "adding: mem time3, current time 81, horizon 78\n", - "adding: mem time4, current time 81, horizon 77\n", - "adding: mem time5, current time 81, horizon 76\n", - "adding: mem time6, current time 81, horizon 75\n", - "adding: mem time7, current time 81, horizon 74\n", - "adding: mem time8, current time 81, horizon 73\n", - "adding: mem time9, current time 81, horizon 72\n", - "adding: mem time10, current time 81, horizon 71\n", - "adding: mem time11, current time 81, horizon 70\n", - "adding: mem time12, current time 81, horizon 69\n", - "adding: mem time13, current time 81, horizon 68\n", - "adding: mem time14, current time 81, horizon 67\n", - "adding: mem time15, current time 81, horizon 66\n", - "adding: mem time16, current time 81, horizon 65\n", - "adding: mem time17, current time 81, horizon 64\n", - "adding: mem time18, current time 81, horizon 63\n", - "adding: mem time19, current time 81, horizon 62\n", - "adding: mem time20, current time 81, horizon 61\n", - "adding: mem time21, current time 81, horizon 60\n", - "adding: mem time22, current time 81, horizon 59\n", - "adding: mem time23, current time 81, horizon 58\n", - "adding: mem time24, current time 81, horizon 57\n", - "adding: mem time25, current time 81, horizon 56\n", - "adding: mem time26, current time 81, horizon 55\n", - "adding: mem time27, current time 81, horizon 54\n", - "adding: mem time28, current time 81, horizon 53\n", - "adding: mem time29, current time 81, horizon 52\n", - "adding: mem time30, current time 81, horizon 51\n", - "adding: mem time31, current time 81, horizon 50\n", - "adding: mem time32, current time 81, horizon 49\n", - "adding: mem time33, current time 81, horizon 48\n", - "adding: mem time34, current time 81, horizon 47\n", - "adding: mem time35, current time 81, horizon 46\n", - "adding: mem time36, current time 81, horizon 45\n", - "adding: mem time37, current time 81, horizon 44\n", - "adding: mem time38, current time 81, horizon 43\n", - "adding: mem time39, current time 81, horizon 42\n", - "adding: mem time40, current time 81, horizon 41\n", - "adding: mem time41, current time 81, horizon 40\n", - "adding: mem time42, current time 81, horizon 39\n", - "adding: mem time43, current time 81, horizon 38\n", - "adding: mem time44, current time 81, horizon 37\n", - "adding: mem time45, current time 81, horizon 36\n", - "adding: mem time46, current time 81, horizon 35\n", - "adding: mem time47, current time 81, horizon 34\n", - "adding: mem time48, current time 81, horizon 33\n", - "adding: mem time49, current time 81, horizon 32\n", - "adding: mem time50, current time 81, horizon 31\n", - "adding: mem time51, current time 81, horizon 30\n", - "adding: mem time52, current time 81, horizon 29\n", - "adding: mem time53, current time 81, horizon 28\n", - "adding: mem time54, current time 81, horizon 27\n", - "adding: mem time55, current time 81, horizon 26\n", - "adding: mem time56, current time 81, horizon 25\n", - "adding: mem time57, current time 81, horizon 24\n", - "adding: mem time58, current time 81, horizon 23\n", - "adding: mem time59, current time 81, horizon 22\n", - "adding: mem time60, current time 81, horizon 21\n", - "adding: mem time61, current time 81, horizon 20\n", - "adding: mem time62, current time 81, horizon 19\n", - "adding: mem time63, current time 81, horizon 18\n", - "adding: mem time64, current time 81, horizon 17\n", - "adding: mem time65, current time 81, horizon 16\n", - "adding: mem time66, current time 81, horizon 15\n", - "adding: mem time67, current time 81, horizon 14\n", - "adding: mem time68, current time 81, horizon 13\n", - "adding: mem time69, current time 81, horizon 12\n", - "adding: mem time70, current time 81, horizon 11\n", - "adding: mem time71, current time 81, horizon 10\n", - "adding: mem time72, current time 81, horizon 9\n", - "adding: mem time73, current time 81, horizon 8\n", - "adding: mem time74, current time 81, horizon 7\n", - "adding: mem time75, current time 81, horizon 6\n", - "adding: mem time76, current time 81, horizon 5\n", - "adding: mem time77, current time 81, horizon 4\n", - "adding: mem time78, current time 81, horizon 3\n", - "adding: mem time79, current time 81, horizon 2\n", - "adding: mem time80, current time 81, horizon 1\n", - "adding: mem time0, current time 82, horizon 82\n", - "adding: mem time1, current time 82, horizon 81\n", - "adding: mem time2, current time 82, horizon 80\n", - "adding: mem time3, current time 82, horizon 79\n", - "adding: mem time4, current time 82, horizon 78\n", - "adding: mem time5, current time 82, horizon 77\n", - "adding: mem time6, current time 82, horizon 76\n", - "adding: mem time7, current time 82, horizon 75\n", - "adding: mem time8, current time 82, horizon 74\n", - "adding: mem time9, current time 82, horizon 73\n", - "adding: mem time10, current time 82, horizon 72\n", - "adding: mem time11, current time 82, horizon 71\n", - "adding: mem time12, current time 82, horizon 70\n", - "adding: mem time13, current time 82, horizon 69\n", - "adding: mem time14, current time 82, horizon 68\n", - "adding: mem time15, current time 82, horizon 67\n", - "adding: mem time16, current time 82, horizon 66\n", - "adding: mem time17, current time 82, horizon 65\n", - "adding: mem time18, current time 82, horizon 64\n", - "adding: mem time19, current time 82, horizon 63\n", - "adding: mem time20, current time 82, horizon 62\n", - "adding: mem time21, current time 82, horizon 61\n", - "adding: mem time22, current time 82, horizon 60\n", - "adding: mem time23, current time 82, horizon 59\n", - "adding: mem time24, current time 82, horizon 58\n", - "adding: mem time25, current time 82, horizon 57\n", - "adding: mem time26, current time 82, horizon 56\n", - "adding: mem time27, current time 82, horizon 55\n", - "adding: mem time28, current time 82, horizon 54\n", - "adding: mem time29, current time 82, horizon 53\n", - "adding: mem time30, current time 82, horizon 52\n", - "adding: mem time31, current time 82, horizon 51\n", - "adding: mem time32, current time 82, horizon 50\n", - "adding: mem time33, current time 82, horizon 49\n", - "adding: mem time34, current time 82, horizon 48\n", - "adding: mem time35, current time 82, horizon 47\n", - "adding: mem time36, current time 82, horizon 46\n", - "adding: mem time37, current time 82, horizon 45\n", - "adding: mem time38, current time 82, horizon 44\n", - "adding: mem time39, current time 82, horizon 43\n", - "adding: mem time40, current time 82, horizon 42\n", - "adding: mem time41, current time 82, horizon 41\n", - "adding: mem time42, current time 82, horizon 40\n", - "adding: mem time43, current time 82, horizon 39\n", - "adding: mem time44, current time 82, horizon 38\n", - "adding: mem time45, current time 82, horizon 37\n", - "adding: mem time46, current time 82, horizon 36\n", - "adding: mem time47, current time 82, horizon 35\n", - "adding: mem time48, current time 82, horizon 34\n", - "adding: mem time49, current time 82, horizon 33\n", - "adding: mem time50, current time 82, horizon 32\n", - "adding: mem time51, current time 82, horizon 31\n", - "adding: mem time52, current time 82, horizon 30\n", - "adding: mem time53, current time 82, horizon 29\n", - "adding: mem time54, current time 82, horizon 28\n", - "adding: mem time55, current time 82, horizon 27\n", - "adding: mem time56, current time 82, horizon 26\n", - "adding: mem time57, current time 82, horizon 25\n", - "adding: mem time58, current time 82, horizon 24\n", - "adding: mem time59, current time 82, horizon 23\n", - "adding: mem time60, current time 82, horizon 22\n", - "adding: mem time61, current time 82, horizon 21\n", - "adding: mem time62, current time 82, horizon 20\n", - "adding: mem time63, current time 82, horizon 19\n", - "adding: mem time64, current time 82, horizon 18\n", - "adding: mem time65, current time 82, horizon 17\n", - "adding: mem time66, current time 82, horizon 16\n", - "adding: mem time67, current time 82, horizon 15\n", - "adding: mem time68, current time 82, horizon 14\n", - "adding: mem time69, current time 82, horizon 13\n", - "adding: mem time70, current time 82, horizon 12\n", - "adding: mem time71, current time 82, horizon 11\n", - "adding: mem time72, current time 82, horizon 10\n", - "adding: mem time73, current time 82, horizon 9\n", - "adding: mem time74, current time 82, horizon 8\n", - "adding: mem time75, current time 82, horizon 7\n", - "adding: mem time76, current time 82, horizon 6\n", - "adding: mem time77, current time 82, horizon 5\n", - "adding: mem time78, current time 82, horizon 4\n", - "adding: mem time79, current time 82, horizon 3\n", - "adding: mem time80, current time 82, horizon 2\n", - "adding: mem time81, current time 82, horizon 1\n", - "adding: mem time0, current time 83, horizon 83\n", - "adding: mem time1, current time 83, horizon 82\n", - "adding: mem time2, current time 83, horizon 81\n", - "adding: mem time3, current time 83, horizon 80\n", - "adding: mem time4, current time 83, horizon 79\n", - "adding: mem time5, current time 83, horizon 78\n", - "adding: mem time6, current time 83, horizon 77\n", - "adding: mem time7, current time 83, horizon 76\n", - "adding: mem time8, current time 83, horizon 75\n", - "adding: mem time9, current time 83, horizon 74\n", - "adding: mem time10, current time 83, horizon 73\n", - "adding: mem time11, current time 83, horizon 72\n", - "adding: mem time12, current time 83, horizon 71\n", - "adding: mem time13, current time 83, horizon 70\n", - "adding: mem time14, current time 83, horizon 69\n", - "adding: mem time15, current time 83, horizon 68\n", - "adding: mem time16, current time 83, horizon 67\n", - "adding: mem time17, current time 83, horizon 66\n", - "adding: mem time18, current time 83, horizon 65\n", - "adding: mem time19, current time 83, horizon 64\n", - "adding: mem time20, current time 83, horizon 63\n", - "adding: mem time21, current time 83, horizon 62\n", - "adding: mem time22, current time 83, horizon 61\n", - "adding: mem time23, current time 83, horizon 60\n", - "adding: mem time24, current time 83, horizon 59\n", - "adding: mem time25, current time 83, horizon 58\n", - "adding: mem time26, current time 83, horizon 57\n", - "adding: mem time27, current time 83, horizon 56\n", - "adding: mem time28, current time 83, horizon 55\n", - "adding: mem time29, current time 83, horizon 54\n", - "adding: mem time30, current time 83, horizon 53\n", - "adding: mem time31, current time 83, horizon 52\n", - "adding: mem time32, current time 83, horizon 51\n", - "adding: mem time33, current time 83, horizon 50\n", - "adding: mem time34, current time 83, horizon 49\n", - "adding: mem time35, current time 83, horizon 48\n", - "adding: mem time36, current time 83, horizon 47\n", - "adding: mem time37, current time 83, horizon 46\n", - "adding: mem time38, current time 83, horizon 45\n", - "adding: mem time39, current time 83, horizon 44\n", - "adding: mem time40, current time 83, horizon 43\n", - "adding: mem time41, current time 83, horizon 42\n", - "adding: mem time42, current time 83, horizon 41\n", - "adding: mem time43, current time 83, horizon 40\n", - "adding: mem time44, current time 83, horizon 39\n", - "adding: mem time45, current time 83, horizon 38\n", - "adding: mem time46, current time 83, horizon 37\n", - "adding: mem time47, current time 83, horizon 36\n", - "adding: mem time48, current time 83, horizon 35\n", - "adding: mem time49, current time 83, horizon 34\n", - "adding: mem time50, current time 83, horizon 33\n", - "adding: mem time51, current time 83, horizon 32\n", - "adding: mem time52, current time 83, horizon 31\n", - "adding: mem time53, current time 83, horizon 30\n", - "adding: mem time54, current time 83, horizon 29\n", - "adding: mem time55, current time 83, horizon 28\n", - "adding: mem time56, current time 83, horizon 27\n", - "adding: mem time57, current time 83, horizon 26\n", - "adding: mem time58, current time 83, horizon 25\n", - "adding: mem time59, current time 83, horizon 24\n", - "adding: mem time60, current time 83, horizon 23\n", - "adding: mem time61, current time 83, horizon 22\n", - "adding: mem time62, current time 83, horizon 21\n", - "adding: mem time63, current time 83, horizon 20\n", - "adding: mem time64, current time 83, horizon 19\n", - "adding: mem time65, current time 83, horizon 18\n", - "adding: mem time66, current time 83, horizon 17\n", - "adding: mem time67, current time 83, horizon 16\n", - "adding: mem time68, current time 83, horizon 15\n", - "adding: mem time69, current time 83, horizon 14\n", - "adding: mem time70, current time 83, horizon 13\n", - "adding: mem time71, current time 83, horizon 12\n", - "adding: mem time72, current time 83, horizon 11\n", - "adding: mem time73, current time 83, horizon 10\n", - "adding: mem time74, current time 83, horizon 9\n", - "adding: mem time75, current time 83, horizon 8\n", - "adding: mem time76, current time 83, horizon 7\n", - "adding: mem time77, current time 83, horizon 6\n", - "adding: mem time78, current time 83, horizon 5\n", - "adding: mem time79, current time 83, horizon 4\n", - "adding: mem time80, current time 83, horizon 3\n", - "adding: mem time81, current time 83, horizon 2\n", - "adding: mem time82, current time 83, horizon 1\n", - "adding: mem time0, current time 84, horizon 84\n", - "adding: mem time1, current time 84, horizon 83\n", - "adding: mem time2, current time 84, horizon 82\n", - "adding: mem time3, current time 84, horizon 81\n", - "adding: mem time4, current time 84, horizon 80\n", - "adding: mem time5, current time 84, horizon 79\n", - "adding: mem time6, current time 84, horizon 78\n", - "adding: mem time7, current time 84, horizon 77\n", - "adding: mem time8, current time 84, horizon 76\n", - "adding: mem time9, current time 84, horizon 75\n", - "adding: mem time10, current time 84, horizon 74\n", - "adding: mem time11, current time 84, horizon 73\n", - "adding: mem time12, current time 84, horizon 72\n", - "adding: mem time13, current time 84, horizon 71\n", - "adding: mem time14, current time 84, horizon 70\n", - "adding: mem time15, current time 84, horizon 69\n", - "adding: mem time16, current time 84, horizon 68\n", - "adding: mem time17, current time 84, horizon 67\n", - "adding: mem time18, current time 84, horizon 66\n", - "adding: mem time19, current time 84, horizon 65\n", - "adding: mem time20, current time 84, horizon 64\n", - "adding: mem time21, current time 84, horizon 63\n", - "adding: mem time22, current time 84, horizon 62\n", - "adding: mem time23, current time 84, horizon 61\n", - "adding: mem time24, current time 84, horizon 60\n", - "adding: mem time25, current time 84, horizon 59\n", - "adding: mem time26, current time 84, horizon 58\n", - "adding: mem time27, current time 84, horizon 57\n", - "adding: mem time28, current time 84, horizon 56\n", - "adding: mem time29, current time 84, horizon 55\n", - "adding: mem time30, current time 84, horizon 54\n", - "adding: mem time31, current time 84, horizon 53\n", - "adding: mem time32, current time 84, horizon 52\n", - "adding: mem time33, current time 84, horizon 51\n", - "adding: mem time34, current time 84, horizon 50\n", - "adding: mem time35, current time 84, horizon 49\n", - "adding: mem time36, current time 84, horizon 48\n", - "adding: mem time37, current time 84, horizon 47\n", - "adding: mem time38, current time 84, horizon 46\n", - "adding: mem time39, current time 84, horizon 45\n", - "adding: mem time40, current time 84, horizon 44\n", - "adding: mem time41, current time 84, horizon 43\n", - "adding: mem time42, current time 84, horizon 42\n", - "adding: mem time43, current time 84, horizon 41\n", - "adding: mem time44, current time 84, horizon 40\n", - "adding: mem time45, current time 84, horizon 39\n", - "adding: mem time46, current time 84, horizon 38\n", - "adding: mem time47, current time 84, horizon 37\n", - "adding: mem time48, current time 84, horizon 36\n", - "adding: mem time49, current time 84, horizon 35\n", - "adding: mem time50, current time 84, horizon 34\n", - "adding: mem time51, current time 84, horizon 33\n", - "adding: mem time52, current time 84, horizon 32\n", - "adding: mem time53, current time 84, horizon 31\n", - "adding: mem time54, current time 84, horizon 30\n", - "adding: mem time55, current time 84, horizon 29\n", - "adding: mem time56, current time 84, horizon 28\n", - "adding: mem time57, current time 84, horizon 27\n", - "adding: mem time58, current time 84, horizon 26\n", - "adding: mem time59, current time 84, horizon 25\n", - "adding: mem time60, current time 84, horizon 24\n", - "adding: mem time61, current time 84, horizon 23\n", - "adding: mem time62, current time 84, horizon 22\n", - "adding: mem time63, current time 84, horizon 21\n", - "adding: mem time64, current time 84, horizon 20\n", - "adding: mem time65, current time 84, horizon 19\n", - "adding: mem time66, current time 84, horizon 18\n", - "adding: mem time67, current time 84, horizon 17\n", - "adding: mem time68, current time 84, horizon 16\n", - "adding: mem time69, current time 84, horizon 15\n", - "adding: mem time70, current time 84, horizon 14\n", - "adding: mem time71, current time 84, horizon 13\n", - "adding: mem time72, current time 84, horizon 12\n", - "adding: mem time73, current time 84, horizon 11\n", - "adding: mem time74, current time 84, horizon 10\n", - "adding: mem time75, current time 84, horizon 9\n", - "adding: mem time76, current time 84, horizon 8\n", - "adding: mem time77, current time 84, horizon 7\n", - "adding: mem time78, current time 84, horizon 6\n", - "adding: mem time79, current time 84, horizon 5\n", - "adding: mem time80, current time 84, horizon 4\n", - "adding: mem time81, current time 84, horizon 3\n", - "adding: mem time82, current time 84, horizon 2\n", - "adding: mem time83, current time 84, horizon 1\n", - "adding: mem time0, current time 85, horizon 85\n", - "adding: mem time1, current time 85, horizon 84\n", - "adding: mem time2, current time 85, horizon 83\n", - "adding: mem time3, current time 85, horizon 82\n", - "adding: mem time4, current time 85, horizon 81\n", - "adding: mem time5, current time 85, horizon 80\n", - "adding: mem time6, current time 85, horizon 79\n", - "adding: mem time7, current time 85, horizon 78\n", - "adding: mem time8, current time 85, horizon 77\n", - "adding: mem time9, current time 85, horizon 76\n", - "adding: mem time10, current time 85, horizon 75\n", - "adding: mem time11, current time 85, horizon 74\n", - "adding: mem time12, current time 85, horizon 73\n", - "adding: mem time13, current time 85, horizon 72\n", - "adding: mem time14, current time 85, horizon 71\n", - "adding: mem time15, current time 85, horizon 70\n", - "adding: mem time16, current time 85, horizon 69\n", - "adding: mem time17, current time 85, horizon 68\n", - "adding: mem time18, current time 85, horizon 67\n", - "adding: mem time19, current time 85, horizon 66\n", - "adding: mem time20, current time 85, horizon 65\n", - "adding: mem time21, current time 85, horizon 64\n", - "adding: mem time22, current time 85, horizon 63\n", - "adding: mem time23, current time 85, horizon 62\n", - "adding: mem time24, current time 85, horizon 61\n", - "adding: mem time25, current time 85, horizon 60\n", - "adding: mem time26, current time 85, horizon 59\n", - "adding: mem time27, current time 85, horizon 58\n", - "adding: mem time28, current time 85, horizon 57\n", - "adding: mem time29, current time 85, horizon 56\n", - "adding: mem time30, current time 85, horizon 55\n", - "adding: mem time31, current time 85, horizon 54\n", - "adding: mem time32, current time 85, horizon 53\n", - "adding: mem time33, current time 85, horizon 52\n", - "adding: mem time34, current time 85, horizon 51\n", - "adding: mem time35, current time 85, horizon 50\n", - "adding: mem time36, current time 85, horizon 49\n", - "adding: mem time37, current time 85, horizon 48\n", - "adding: mem time38, current time 85, horizon 47\n", - "adding: mem time39, current time 85, horizon 46\n", - "adding: mem time40, current time 85, horizon 45\n", - "adding: mem time41, current time 85, horizon 44\n", - "adding: mem time42, current time 85, horizon 43\n", - "adding: mem time43, current time 85, horizon 42\n", - "adding: mem time44, current time 85, horizon 41\n", - "adding: mem time45, current time 85, horizon 40\n", - "adding: mem time46, current time 85, horizon 39\n", - "adding: mem time47, current time 85, horizon 38\n", - "adding: mem time48, current time 85, horizon 37\n", - "adding: mem time49, current time 85, horizon 36\n", - "adding: mem time50, current time 85, horizon 35\n", - "adding: mem time51, current time 85, horizon 34\n", - "adding: mem time52, current time 85, horizon 33\n", - "adding: mem time53, current time 85, horizon 32\n", - "adding: mem time54, current time 85, horizon 31\n", - "adding: mem time55, current time 85, horizon 30\n", - "adding: mem time56, current time 85, horizon 29\n", - "adding: mem time57, current time 85, horizon 28\n", - "adding: mem time58, current time 85, horizon 27\n", - "adding: mem time59, current time 85, horizon 26\n", - "adding: mem time60, current time 85, horizon 25\n", - "adding: mem time61, current time 85, horizon 24\n", - "adding: mem time62, current time 85, horizon 23\n", - "adding: mem time63, current time 85, horizon 22\n", - "adding: mem time64, current time 85, horizon 21\n", - "adding: mem time65, current time 85, horizon 20\n", - "adding: mem time66, current time 85, horizon 19\n", - "adding: mem time67, current time 85, horizon 18\n", - "adding: mem time68, current time 85, horizon 17\n", - "adding: mem time69, current time 85, horizon 16\n", - "adding: mem time70, current time 85, horizon 15\n", - "adding: mem time71, current time 85, horizon 14\n", - "adding: mem time72, current time 85, horizon 13\n", - "adding: mem time73, current time 85, horizon 12\n", - "adding: mem time74, current time 85, horizon 11\n", - "adding: mem time75, current time 85, horizon 10\n", - "adding: mem time76, current time 85, horizon 9\n", - "adding: mem time77, current time 85, horizon 8\n", - "adding: mem time78, current time 85, horizon 7\n", - "adding: mem time79, current time 85, horizon 6\n", - "adding: mem time80, current time 85, horizon 5\n", - "adding: mem time81, current time 85, horizon 4\n", - "adding: mem time82, current time 85, horizon 3\n", - "adding: mem time83, current time 85, horizon 2\n", - "adding: mem time84, current time 85, horizon 1\n", - "adding: mem time0, current time 86, horizon 86\n", - "adding: mem time1, current time 86, horizon 85\n", - "adding: mem time2, current time 86, horizon 84\n", - "adding: mem time3, current time 86, horizon 83\n", - "adding: mem time4, current time 86, horizon 82\n", - "adding: mem time5, current time 86, horizon 81\n", - "adding: mem time6, current time 86, horizon 80\n", - "adding: mem time7, current time 86, horizon 79\n", - "adding: mem time8, current time 86, horizon 78\n", - "adding: mem time9, current time 86, horizon 77\n", - "adding: mem time10, current time 86, horizon 76\n", - "adding: mem time11, current time 86, horizon 75\n", - "adding: mem time12, current time 86, horizon 74\n", - "adding: mem time13, current time 86, horizon 73\n", - "adding: mem time14, current time 86, horizon 72\n", - "adding: mem time15, current time 86, horizon 71\n", - "adding: mem time16, current time 86, horizon 70\n", - "adding: mem time17, current time 86, horizon 69\n", - "adding: mem time18, current time 86, horizon 68\n", - "adding: mem time19, current time 86, horizon 67\n", - "adding: mem time20, current time 86, horizon 66\n", - "adding: mem time21, current time 86, horizon 65\n", - "adding: mem time22, current time 86, horizon 64\n", - "adding: mem time23, current time 86, horizon 63\n", - "adding: mem time24, current time 86, horizon 62\n", - "adding: mem time25, current time 86, horizon 61\n", - "adding: mem time26, current time 86, horizon 60\n", - "adding: mem time27, current time 86, horizon 59\n", - "adding: mem time28, current time 86, horizon 58\n", - "adding: mem time29, current time 86, horizon 57\n", - "adding: mem time30, current time 86, horizon 56\n", - "adding: mem time31, current time 86, horizon 55\n", - "adding: mem time32, current time 86, horizon 54\n", - "adding: mem time33, current time 86, horizon 53\n", - "adding: mem time34, current time 86, horizon 52\n", - "adding: mem time35, current time 86, horizon 51\n", - "adding: mem time36, current time 86, horizon 50\n", - "adding: mem time37, current time 86, horizon 49\n", - "adding: mem time38, current time 86, horizon 48\n", - "adding: mem time39, current time 86, horizon 47\n", - "adding: mem time40, current time 86, horizon 46\n", - "adding: mem time41, current time 86, horizon 45\n", - "adding: mem time42, current time 86, horizon 44\n", - "adding: mem time43, current time 86, horizon 43\n", - "adding: mem time44, current time 86, horizon 42\n", - "adding: mem time45, current time 86, horizon 41\n", - "adding: mem time46, current time 86, horizon 40\n", - "adding: mem time47, current time 86, horizon 39\n", - "adding: mem time48, current time 86, horizon 38\n", - "adding: mem time49, current time 86, horizon 37\n", - "adding: mem time50, current time 86, horizon 36\n", - "adding: mem time51, current time 86, horizon 35\n", - "adding: mem time52, current time 86, horizon 34\n", - "adding: mem time53, current time 86, horizon 33\n", - "adding: mem time54, current time 86, horizon 32\n", - "adding: mem time55, current time 86, horizon 31\n", - "adding: mem time56, current time 86, horizon 30\n", - "adding: mem time57, current time 86, horizon 29\n", - "adding: mem time58, current time 86, horizon 28\n", - "adding: mem time59, current time 86, horizon 27\n", - "adding: mem time60, current time 86, horizon 26\n", - "adding: mem time61, current time 86, horizon 25\n", - "adding: mem time62, current time 86, horizon 24\n", - "adding: mem time63, current time 86, horizon 23\n", - "adding: mem time64, current time 86, horizon 22\n", - "adding: mem time65, current time 86, horizon 21\n", - "adding: mem time66, current time 86, horizon 20\n", - "adding: mem time67, current time 86, horizon 19\n", - "adding: mem time68, current time 86, horizon 18\n", - "adding: mem time69, current time 86, horizon 17\n", - "adding: mem time70, current time 86, horizon 16\n", - "adding: mem time71, current time 86, horizon 15\n", - "adding: mem time72, current time 86, horizon 14\n", - "adding: mem time73, current time 86, horizon 13\n", - "adding: mem time74, current time 86, horizon 12\n", - "adding: mem time75, current time 86, horizon 11\n", - "adding: mem time76, current time 86, horizon 10\n", - "adding: mem time77, current time 86, horizon 9\n", - "adding: mem time78, current time 86, horizon 8\n", - "adding: mem time79, current time 86, horizon 7\n", - "adding: mem time80, current time 86, horizon 6\n", - "adding: mem time81, current time 86, horizon 5\n", - "adding: mem time82, current time 86, horizon 4\n", - "adding: mem time83, current time 86, horizon 3\n", - "adding: mem time84, current time 86, horizon 2\n", - "adding: mem time85, current time 86, horizon 1\n", - "adding: mem time0, current time 87, horizon 87\n", - "adding: mem time1, current time 87, horizon 86\n", - "adding: mem time2, current time 87, horizon 85\n", - "adding: mem time3, current time 87, horizon 84\n", - "adding: mem time4, current time 87, horizon 83\n", - "adding: mem time5, current time 87, horizon 82\n", - "adding: mem time6, current time 87, horizon 81\n", - "adding: mem time7, current time 87, horizon 80\n", - "adding: mem time8, current time 87, horizon 79\n", - "adding: mem time9, current time 87, horizon 78\n", - "adding: mem time10, current time 87, horizon 77\n", - "adding: mem time11, current time 87, horizon 76\n", - "adding: mem time12, current time 87, horizon 75\n", - "adding: mem time13, current time 87, horizon 74\n", - "adding: mem time14, current time 87, horizon 73\n", - "adding: mem time15, current time 87, horizon 72\n", - "adding: mem time16, current time 87, horizon 71\n", - "adding: mem time17, current time 87, horizon 70\n", - "adding: mem time18, current time 87, horizon 69\n", - "adding: mem time19, current time 87, horizon 68\n", - "adding: mem time20, current time 87, horizon 67\n", - "adding: mem time21, current time 87, horizon 66\n", - "adding: mem time22, current time 87, horizon 65\n", - "adding: mem time23, current time 87, horizon 64\n", - "adding: mem time24, current time 87, horizon 63\n", - "adding: mem time25, current time 87, horizon 62\n", - "adding: mem time26, current time 87, horizon 61\n", - "adding: mem time27, current time 87, horizon 60\n", - "adding: mem time28, current time 87, horizon 59\n", - "adding: mem time29, current time 87, horizon 58\n", - "adding: mem time30, current time 87, horizon 57\n", - "adding: mem time31, current time 87, horizon 56\n", - "adding: mem time32, current time 87, horizon 55\n", - "adding: mem time33, current time 87, horizon 54\n", - "adding: mem time34, current time 87, horizon 53\n", - "adding: mem time35, current time 87, horizon 52\n", - "adding: mem time36, current time 87, horizon 51\n", - "adding: mem time37, current time 87, horizon 50\n", - "adding: mem time38, current time 87, horizon 49\n", - "adding: mem time39, current time 87, horizon 48\n", - "adding: mem time40, current time 87, horizon 47\n", - "adding: mem time41, current time 87, horizon 46\n", - "adding: mem time42, current time 87, horizon 45\n", - "adding: mem time43, current time 87, horizon 44\n", - "adding: mem time44, current time 87, horizon 43\n", - "adding: mem time45, current time 87, horizon 42\n", - "adding: mem time46, current time 87, horizon 41\n", - "adding: mem time47, current time 87, horizon 40\n", - "adding: mem time48, current time 87, horizon 39\n", - "adding: mem time49, current time 87, horizon 38\n", - "adding: mem time50, current time 87, horizon 37\n", - "adding: mem time51, current time 87, horizon 36\n", - "adding: mem time52, current time 87, horizon 35\n", - "adding: mem time53, current time 87, horizon 34\n", - "adding: mem time54, current time 87, horizon 33\n", - "adding: mem time55, current time 87, horizon 32\n", - "adding: mem time56, current time 87, horizon 31\n", - "adding: mem time57, current time 87, horizon 30\n", - "adding: mem time58, current time 87, horizon 29\n", - "adding: mem time59, current time 87, horizon 28\n", - "adding: mem time60, current time 87, horizon 27\n", - "adding: mem time61, current time 87, horizon 26\n", - "adding: mem time62, current time 87, horizon 25\n", - "adding: mem time63, current time 87, horizon 24\n", - "adding: mem time64, current time 87, horizon 23\n", - "adding: mem time65, current time 87, horizon 22\n", - "adding: mem time66, current time 87, horizon 21\n", - "adding: mem time67, current time 87, horizon 20\n", - "adding: mem time68, current time 87, horizon 19\n", - "adding: mem time69, current time 87, horizon 18\n", - "adding: mem time70, current time 87, horizon 17\n", - "adding: mem time71, current time 87, horizon 16\n", - "adding: mem time72, current time 87, horizon 15\n", - "adding: mem time73, current time 87, horizon 14\n", - "adding: mem time74, current time 87, horizon 13\n", - "adding: mem time75, current time 87, horizon 12\n", - "adding: mem time76, current time 87, horizon 11\n", - "adding: mem time77, current time 87, horizon 10\n", - "adding: mem time78, current time 87, horizon 9\n", - "adding: mem time79, current time 87, horizon 8\n", - "adding: mem time80, current time 87, horizon 7\n", - "adding: mem time81, current time 87, horizon 6\n", - "adding: mem time82, current time 87, horizon 5\n", - "adding: mem time83, current time 87, horizon 4\n", - "adding: mem time84, current time 87, horizon 3\n", - "adding: mem time85, current time 87, horizon 2\n", - "adding: mem time86, current time 87, horizon 1\n", - "adding: mem time0, current time 88, horizon 88\n", - "adding: mem time1, current time 88, horizon 87\n", - "adding: mem time2, current time 88, horizon 86\n", - "adding: mem time3, current time 88, horizon 85\n", - "adding: mem time4, current time 88, horizon 84\n", - "adding: mem time5, current time 88, horizon 83\n", - "adding: mem time6, current time 88, horizon 82\n", - "adding: mem time7, current time 88, horizon 81\n", - "adding: mem time8, current time 88, horizon 80\n", - "adding: mem time9, current time 88, horizon 79\n", - "adding: mem time10, current time 88, horizon 78\n", - "adding: mem time11, current time 88, horizon 77\n", - "adding: mem time12, current time 88, horizon 76\n", - "adding: mem time13, current time 88, horizon 75\n", - "adding: mem time14, current time 88, horizon 74\n", - "adding: mem time15, current time 88, horizon 73\n", - "adding: mem time16, current time 88, horizon 72\n", - "adding: mem time17, current time 88, horizon 71\n", - "adding: mem time18, current time 88, horizon 70\n", - "adding: mem time19, current time 88, horizon 69\n", - "adding: mem time20, current time 88, horizon 68\n", - "adding: mem time21, current time 88, horizon 67\n", - "adding: mem time22, current time 88, horizon 66\n", - "adding: mem time23, current time 88, horizon 65\n", - "adding: mem time24, current time 88, horizon 64\n", - "adding: mem time25, current time 88, horizon 63\n", - "adding: mem time26, current time 88, horizon 62\n", - "adding: mem time27, current time 88, horizon 61\n", - "adding: mem time28, current time 88, horizon 60\n", - "adding: mem time29, current time 88, horizon 59\n", - "adding: mem time30, current time 88, horizon 58\n", - "adding: mem time31, current time 88, horizon 57\n", - "adding: mem time32, current time 88, horizon 56\n", - "adding: mem time33, current time 88, horizon 55\n", - "adding: mem time34, current time 88, horizon 54\n", - "adding: mem time35, current time 88, horizon 53\n", - "adding: mem time36, current time 88, horizon 52\n", - "adding: mem time37, current time 88, horizon 51\n", - "adding: mem time38, current time 88, horizon 50\n", - "adding: mem time39, current time 88, horizon 49\n", - "adding: mem time40, current time 88, horizon 48\n", - "adding: mem time41, current time 88, horizon 47\n", - "adding: mem time42, current time 88, horizon 46\n", - "adding: mem time43, current time 88, horizon 45\n", - "adding: mem time44, current time 88, horizon 44\n", - "adding: mem time45, current time 88, horizon 43\n", - "adding: mem time46, current time 88, horizon 42\n", - "adding: mem time47, current time 88, horizon 41\n", - "adding: mem time48, current time 88, horizon 40\n", - "adding: mem time49, current time 88, horizon 39\n", - "adding: mem time50, current time 88, horizon 38\n", - "adding: mem time51, current time 88, horizon 37\n", - "adding: mem time52, current time 88, horizon 36\n", - "adding: mem time53, current time 88, horizon 35\n", - "adding: mem time54, current time 88, horizon 34\n", - "adding: mem time55, current time 88, horizon 33\n", - "adding: mem time56, current time 88, horizon 32\n", - "adding: mem time57, current time 88, horizon 31\n", - "adding: mem time58, current time 88, horizon 30\n", - "adding: mem time59, current time 88, horizon 29\n", - "adding: mem time60, current time 88, horizon 28\n", - "adding: mem time61, current time 88, horizon 27\n", - "adding: mem time62, current time 88, horizon 26\n", - "adding: mem time63, current time 88, horizon 25\n", - "adding: mem time64, current time 88, horizon 24\n", - "adding: mem time65, current time 88, horizon 23\n", - "adding: mem time66, current time 88, horizon 22\n", - "adding: mem time67, current time 88, horizon 21\n", - "adding: mem time68, current time 88, horizon 20\n", - "adding: mem time69, current time 88, horizon 19\n", - "adding: mem time70, current time 88, horizon 18\n", - "adding: mem time71, current time 88, horizon 17\n", - "adding: mem time72, current time 88, horizon 16\n", - "adding: mem time73, current time 88, horizon 15\n", - "adding: mem time74, current time 88, horizon 14\n", - "adding: mem time75, current time 88, horizon 13\n", - "adding: mem time76, current time 88, horizon 12\n", - "adding: mem time77, current time 88, horizon 11\n", - "adding: mem time78, current time 88, horizon 10\n", - "adding: mem time79, current time 88, horizon 9\n", - "adding: mem time80, current time 88, horizon 8\n", - "adding: mem time81, current time 88, horizon 7\n", - "adding: mem time82, current time 88, horizon 6\n", - "adding: mem time83, current time 88, horizon 5\n", - "adding: mem time84, current time 88, horizon 4\n", - "adding: mem time85, current time 88, horizon 3\n", - "adding: mem time86, current time 88, horizon 2\n", - "adding: mem time87, current time 88, horizon 1\n", - "adding: mem time0, current time 89, horizon 89\n", - "adding: mem time1, current time 89, horizon 88\n", - "adding: mem time2, current time 89, horizon 87\n", - "adding: mem time3, current time 89, horizon 86\n", - "adding: mem time4, current time 89, horizon 85\n", - "adding: mem time5, current time 89, horizon 84\n", - "adding: mem time6, current time 89, horizon 83\n", - "adding: mem time7, current time 89, horizon 82\n", - "adding: mem time8, current time 89, horizon 81\n", - "adding: mem time9, current time 89, horizon 80\n", - "adding: mem time10, current time 89, horizon 79\n", - "adding: mem time11, current time 89, horizon 78\n", - "adding: mem time12, current time 89, horizon 77\n", - "adding: mem time13, current time 89, horizon 76\n", - "adding: mem time14, current time 89, horizon 75\n", - "adding: mem time15, current time 89, horizon 74\n", - "adding: mem time16, current time 89, horizon 73\n", - "adding: mem time17, current time 89, horizon 72\n", - "adding: mem time18, current time 89, horizon 71\n", - "adding: mem time19, current time 89, horizon 70\n", - "adding: mem time20, current time 89, horizon 69\n", - "adding: mem time21, current time 89, horizon 68\n", - "adding: mem time22, current time 89, horizon 67\n", - "adding: mem time23, current time 89, horizon 66\n", - "adding: mem time24, current time 89, horizon 65\n", - "adding: mem time25, current time 89, horizon 64\n", - "adding: mem time26, current time 89, horizon 63\n", - "adding: mem time27, current time 89, horizon 62\n", - "adding: mem time28, current time 89, horizon 61\n", - "adding: mem time29, current time 89, horizon 60\n", - "adding: mem time30, current time 89, horizon 59\n", - "adding: mem time31, current time 89, horizon 58\n", - "adding: mem time32, current time 89, horizon 57\n", - "adding: mem time33, current time 89, horizon 56\n", - "adding: mem time34, current time 89, horizon 55\n", - "adding: mem time35, current time 89, horizon 54\n", - "adding: mem time36, current time 89, horizon 53\n", - "adding: mem time37, current time 89, horizon 52\n", - "adding: mem time38, current time 89, horizon 51\n", - "adding: mem time39, current time 89, horizon 50\n", - "adding: mem time40, current time 89, horizon 49\n", - "adding: mem time41, current time 89, horizon 48\n", - "adding: mem time42, current time 89, horizon 47\n", - "adding: mem time43, current time 89, horizon 46\n", - "adding: mem time44, current time 89, horizon 45\n", - "adding: mem time45, current time 89, horizon 44\n", - "adding: mem time46, current time 89, horizon 43\n", - "adding: mem time47, current time 89, horizon 42\n", - "adding: mem time48, current time 89, horizon 41\n", - "adding: mem time49, current time 89, horizon 40\n", - "adding: mem time50, current time 89, horizon 39\n", - "adding: mem time51, current time 89, horizon 38\n", - "adding: mem time52, current time 89, horizon 37\n", - "adding: mem time53, current time 89, horizon 36\n", - "adding: mem time54, current time 89, horizon 35\n", - "adding: mem time55, current time 89, horizon 34\n", - "adding: mem time56, current time 89, horizon 33\n", - "adding: mem time57, current time 89, horizon 32\n", - "adding: mem time58, current time 89, horizon 31\n", - "adding: mem time59, current time 89, horizon 30\n", - "adding: mem time60, current time 89, horizon 29\n", - "adding: mem time61, current time 89, horizon 28\n", - "adding: mem time62, current time 89, horizon 27\n", - "adding: mem time63, current time 89, horizon 26\n", - "adding: mem time64, current time 89, horizon 25\n", - "adding: mem time65, current time 89, horizon 24\n", - "adding: mem time66, current time 89, horizon 23\n", - "adding: mem time67, current time 89, horizon 22\n", - "adding: mem time68, current time 89, horizon 21\n", - "adding: mem time69, current time 89, horizon 20\n", - "adding: mem time70, current time 89, horizon 19\n", - "adding: mem time71, current time 89, horizon 18\n", - "adding: mem time72, current time 89, horizon 17\n", - "adding: mem time73, current time 89, horizon 16\n", - "adding: mem time74, current time 89, horizon 15\n", - "adding: mem time75, current time 89, horizon 14\n", - "adding: mem time76, current time 89, horizon 13\n", - "adding: mem time77, current time 89, horizon 12\n", - "adding: mem time78, current time 89, horizon 11\n", - "adding: mem time79, current time 89, horizon 10\n", - "adding: mem time80, current time 89, horizon 9\n", - "adding: mem time81, current time 89, horizon 8\n", - "adding: mem time82, current time 89, horizon 7\n", - "adding: mem time83, current time 89, horizon 6\n", - "adding: mem time84, current time 89, horizon 5\n", - "adding: mem time85, current time 89, horizon 4\n", - "adding: mem time86, current time 89, horizon 3\n", - "adding: mem time87, current time 89, horizon 2\n", - "adding: mem time88, current time 89, horizon 1\n", - "adding: mem time0, current time 90, horizon 90\n", - "adding: mem time1, current time 90, horizon 89\n", - "adding: mem time2, current time 90, horizon 88\n", - "adding: mem time3, current time 90, horizon 87\n", - "adding: mem time4, current time 90, horizon 86\n", - "adding: mem time5, current time 90, horizon 85\n", - "adding: mem time6, current time 90, horizon 84\n", - "adding: mem time7, current time 90, horizon 83\n", - "adding: mem time8, current time 90, horizon 82\n", - "adding: mem time9, current time 90, horizon 81\n", - "adding: mem time10, current time 90, horizon 80\n", - "adding: mem time11, current time 90, horizon 79\n", - "adding: mem time12, current time 90, horizon 78\n", - "adding: mem time13, current time 90, horizon 77\n", - "adding: mem time14, current time 90, horizon 76\n", - "adding: mem time15, current time 90, horizon 75\n", - "adding: mem time16, current time 90, horizon 74\n", - "adding: mem time17, current time 90, horizon 73\n", - "adding: mem time18, current time 90, horizon 72\n", - "adding: mem time19, current time 90, horizon 71\n", - "adding: mem time20, current time 90, horizon 70\n", - "adding: mem time21, current time 90, horizon 69\n", - "adding: mem time22, current time 90, horizon 68\n", - "adding: mem time23, current time 90, horizon 67\n", - "adding: mem time24, current time 90, horizon 66\n", - "adding: mem time25, current time 90, horizon 65\n", - "adding: mem time26, current time 90, horizon 64\n", - "adding: mem time27, current time 90, horizon 63\n", - "adding: mem time28, current time 90, horizon 62\n", - "adding: mem time29, current time 90, horizon 61\n", - "adding: mem time30, current time 90, horizon 60\n", - "adding: mem time31, current time 90, horizon 59\n", - "adding: mem time32, current time 90, horizon 58\n", - "adding: mem time33, current time 90, horizon 57\n", - "adding: mem time34, current time 90, horizon 56\n", - "adding: mem time35, current time 90, horizon 55\n", - "adding: mem time36, current time 90, horizon 54\n", - "adding: mem time37, current time 90, horizon 53\n", - "adding: mem time38, current time 90, horizon 52\n", - "adding: mem time39, current time 90, horizon 51\n", - "adding: mem time40, current time 90, horizon 50\n", - "adding: mem time41, current time 90, horizon 49\n", - "adding: mem time42, current time 90, horizon 48\n", - "adding: mem time43, current time 90, horizon 47\n", - "adding: mem time44, current time 90, horizon 46\n", - "adding: mem time45, current time 90, horizon 45\n", - "adding: mem time46, current time 90, horizon 44\n", - "adding: mem time47, current time 90, horizon 43\n", - "adding: mem time48, current time 90, horizon 42\n", - "adding: mem time49, current time 90, horizon 41\n", - "adding: mem time50, current time 90, horizon 40\n", - "adding: mem time51, current time 90, horizon 39\n", - "adding: mem time52, current time 90, horizon 38\n", - "adding: mem time53, current time 90, horizon 37\n", - "adding: mem time54, current time 90, horizon 36\n", - "adding: mem time55, current time 90, horizon 35\n", - "adding: mem time56, current time 90, horizon 34\n", - "adding: mem time57, current time 90, horizon 33\n", - "adding: mem time58, current time 90, horizon 32\n", - "adding: mem time59, current time 90, horizon 31\n", - "adding: mem time60, current time 90, horizon 30\n", - "adding: mem time61, current time 90, horizon 29\n", - "adding: mem time62, current time 90, horizon 28\n", - "adding: mem time63, current time 90, horizon 27\n", - "adding: mem time64, current time 90, horizon 26\n", - "adding: mem time65, current time 90, horizon 25\n", - "adding: mem time66, current time 90, horizon 24\n", - "adding: mem time67, current time 90, horizon 23\n", - "adding: mem time68, current time 90, horizon 22\n", - "adding: mem time69, current time 90, horizon 21\n", - "adding: mem time70, current time 90, horizon 20\n", - "adding: mem time71, current time 90, horizon 19\n", - "adding: mem time72, current time 90, horizon 18\n", - "adding: mem time73, current time 90, horizon 17\n", - "adding: mem time74, current time 90, horizon 16\n", - "adding: mem time75, current time 90, horizon 15\n", - "adding: mem time76, current time 90, horizon 14\n", - "adding: mem time77, current time 90, horizon 13\n", - "adding: mem time78, current time 90, horizon 12\n", - "adding: mem time79, current time 90, horizon 11\n", - "adding: mem time80, current time 90, horizon 10\n", - "adding: mem time81, current time 90, horizon 9\n", - "adding: mem time82, current time 90, horizon 8\n", - "adding: mem time83, current time 90, horizon 7\n", - "adding: mem time84, current time 90, horizon 6\n", - "adding: mem time85, current time 90, horizon 5\n", - "adding: mem time86, current time 90, horizon 4\n", - "adding: mem time87, current time 90, horizon 3\n", - "adding: mem time88, current time 90, horizon 2\n", - "adding: mem time89, current time 90, horizon 1\n", - "adding: mem time0, current time 91, horizon 91\n", - "adding: mem time1, current time 91, horizon 90\n", - "adding: mem time2, current time 91, horizon 89\n", - "adding: mem time3, current time 91, horizon 88\n", - "adding: mem time4, current time 91, horizon 87\n", - "adding: mem time5, current time 91, horizon 86\n", - "adding: mem time6, current time 91, horizon 85\n", - "adding: mem time7, current time 91, horizon 84\n", - "adding: mem time8, current time 91, horizon 83\n", - "adding: mem time9, current time 91, horizon 82\n", - "adding: mem time10, current time 91, horizon 81\n", - "adding: mem time11, current time 91, horizon 80\n", - "adding: mem time12, current time 91, horizon 79\n", - "adding: mem time13, current time 91, horizon 78\n", - "adding: mem time14, current time 91, horizon 77\n", - "adding: mem time15, current time 91, horizon 76\n", - "adding: mem time16, current time 91, horizon 75\n", - "adding: mem time17, current time 91, horizon 74\n", - "adding: mem time18, current time 91, horizon 73\n", - "adding: mem time19, current time 91, horizon 72\n", - "adding: mem time20, current time 91, horizon 71\n", - "adding: mem time21, current time 91, horizon 70\n", - "adding: mem time22, current time 91, horizon 69\n", - "adding: mem time23, current time 91, horizon 68\n", - "adding: mem time24, current time 91, horizon 67\n", - "adding: mem time25, current time 91, horizon 66\n", - "adding: mem time26, current time 91, horizon 65\n", - "adding: mem time27, current time 91, horizon 64\n", - "adding: mem time28, current time 91, horizon 63\n", - "adding: mem time29, current time 91, horizon 62\n", - "adding: mem time30, current time 91, horizon 61\n", - "adding: mem time31, current time 91, horizon 60\n", - "adding: mem time32, current time 91, horizon 59\n", - "adding: mem time33, current time 91, horizon 58\n", - "adding: mem time34, current time 91, horizon 57\n", - "adding: mem time35, current time 91, horizon 56\n", - "adding: mem time36, current time 91, horizon 55\n", - "adding: mem time37, current time 91, horizon 54\n", - "adding: mem time38, current time 91, horizon 53\n", - "adding: mem time39, current time 91, horizon 52\n", - "adding: mem time40, current time 91, horizon 51\n", - "adding: mem time41, current time 91, horizon 50\n", - "adding: mem time42, current time 91, horizon 49\n", - "adding: mem time43, current time 91, horizon 48\n", - "adding: mem time44, current time 91, horizon 47\n", - "adding: mem time45, current time 91, horizon 46\n", - "adding: mem time46, current time 91, horizon 45\n", - "adding: mem time47, current time 91, horizon 44\n", - "adding: mem time48, current time 91, horizon 43\n", - "adding: mem time49, current time 91, horizon 42\n", - "adding: mem time50, current time 91, horizon 41\n", - "adding: mem time51, current time 91, horizon 40\n", - "adding: mem time52, current time 91, horizon 39\n", - "adding: mem time53, current time 91, horizon 38\n", - "adding: mem time54, current time 91, horizon 37\n", - "adding: mem time55, current time 91, horizon 36\n", - "adding: mem time56, current time 91, horizon 35\n", - "adding: mem time57, current time 91, horizon 34\n", - "adding: mem time58, current time 91, horizon 33\n", - "adding: mem time59, current time 91, horizon 32\n", - "adding: mem time60, current time 91, horizon 31\n", - "adding: mem time61, current time 91, horizon 30\n", - "adding: mem time62, current time 91, horizon 29\n", - "adding: mem time63, current time 91, horizon 28\n", - "adding: mem time64, current time 91, horizon 27\n", - "adding: mem time65, current time 91, horizon 26\n", - "adding: mem time66, current time 91, horizon 25\n", - "adding: mem time67, current time 91, horizon 24\n", - "adding: mem time68, current time 91, horizon 23\n", - "adding: mem time69, current time 91, horizon 22\n", - "adding: mem time70, current time 91, horizon 21\n", - "adding: mem time71, current time 91, horizon 20\n", - "adding: mem time72, current time 91, horizon 19\n", - "adding: mem time73, current time 91, horizon 18\n", - "adding: mem time74, current time 91, horizon 17\n", - "adding: mem time75, current time 91, horizon 16\n", - "adding: mem time76, current time 91, horizon 15\n", - "adding: mem time77, current time 91, horizon 14\n", - "adding: mem time78, current time 91, horizon 13\n", - "adding: mem time79, current time 91, horizon 12\n", - "adding: mem time80, current time 91, horizon 11\n", - "adding: mem time81, current time 91, horizon 10\n", - "adding: mem time82, current time 91, horizon 9\n", - "adding: mem time83, current time 91, horizon 8\n", - "adding: mem time84, current time 91, horizon 7\n", - "adding: mem time85, current time 91, horizon 6\n", - "adding: mem time86, current time 91, horizon 5\n", - "adding: mem time87, current time 91, horizon 4\n", - "adding: mem time88, current time 91, horizon 3\n", - "adding: mem time89, current time 91, horizon 2\n", - "adding: mem time90, current time 91, horizon 1\n", - "adding: mem time0, current time 92, horizon 92\n", - "adding: mem time1, current time 92, horizon 91\n", - "adding: mem time2, current time 92, horizon 90\n", - "adding: mem time3, current time 92, horizon 89\n", - "adding: mem time4, current time 92, horizon 88\n", - "adding: mem time5, current time 92, horizon 87\n", - "adding: mem time6, current time 92, horizon 86\n", - "adding: mem time7, current time 92, horizon 85\n", - "adding: mem time8, current time 92, horizon 84\n", - "adding: mem time9, current time 92, horizon 83\n", - "adding: mem time10, current time 92, horizon 82\n", - "adding: mem time11, current time 92, horizon 81\n", - "adding: mem time12, current time 92, horizon 80\n", - "adding: mem time13, current time 92, horizon 79\n", - "adding: mem time14, current time 92, horizon 78\n", - "adding: mem time15, current time 92, horizon 77\n", - "adding: mem time16, current time 92, horizon 76\n", - "adding: mem time17, current time 92, horizon 75\n", - "adding: mem time18, current time 92, horizon 74\n", - "adding: mem time19, current time 92, horizon 73\n", - "adding: mem time20, current time 92, horizon 72\n", - "adding: mem time21, current time 92, horizon 71\n", - "adding: mem time22, current time 92, horizon 70\n", - "adding: mem time23, current time 92, horizon 69\n", - "adding: mem time24, current time 92, horizon 68\n", - "adding: mem time25, current time 92, horizon 67\n", - "adding: mem time26, current time 92, horizon 66\n", - "adding: mem time27, current time 92, horizon 65\n", - "adding: mem time28, current time 92, horizon 64\n", - "adding: mem time29, current time 92, horizon 63\n", - "adding: mem time30, current time 92, horizon 62\n", - "adding: mem time31, current time 92, horizon 61\n", - "adding: mem time32, current time 92, horizon 60\n", - "adding: mem time33, current time 92, horizon 59\n", - "adding: mem time34, current time 92, horizon 58\n", - "adding: mem time35, current time 92, horizon 57\n", - "adding: mem time36, current time 92, horizon 56\n", - "adding: mem time37, current time 92, horizon 55\n", - "adding: mem time38, current time 92, horizon 54\n", - "adding: mem time39, current time 92, horizon 53\n", - "adding: mem time40, current time 92, horizon 52\n", - "adding: mem time41, current time 92, horizon 51\n", - "adding: mem time42, current time 92, horizon 50\n", - "adding: mem time43, current time 92, horizon 49\n", - "adding: mem time44, current time 92, horizon 48\n", - "adding: mem time45, current time 92, horizon 47\n", - "adding: mem time46, current time 92, horizon 46\n", - "adding: mem time47, current time 92, horizon 45\n", - "adding: mem time48, current time 92, horizon 44\n", - "adding: mem time49, current time 92, horizon 43\n", - "adding: mem time50, current time 92, horizon 42\n", - "adding: mem time51, current time 92, horizon 41\n", - "adding: mem time52, current time 92, horizon 40\n", - "adding: mem time53, current time 92, horizon 39\n", - "adding: mem time54, current time 92, horizon 38\n", - "adding: mem time55, current time 92, horizon 37\n", - "adding: mem time56, current time 92, horizon 36\n", - "adding: mem time57, current time 92, horizon 35\n", - "adding: mem time58, current time 92, horizon 34\n", - "adding: mem time59, current time 92, horizon 33\n", - "adding: mem time60, current time 92, horizon 32\n", - "adding: mem time61, current time 92, horizon 31\n", - "adding: mem time62, current time 92, horizon 30\n", - "adding: mem time63, current time 92, horizon 29\n", - "adding: mem time64, current time 92, horizon 28\n", - "adding: mem time65, current time 92, horizon 27\n", - "adding: mem time66, current time 92, horizon 26\n", - "adding: mem time67, current time 92, horizon 25\n", - "adding: mem time68, current time 92, horizon 24\n", - "adding: mem time69, current time 92, horizon 23\n", - "adding: mem time70, current time 92, horizon 22\n", - "adding: mem time71, current time 92, horizon 21\n", - "adding: mem time72, current time 92, horizon 20\n", - "adding: mem time73, current time 92, horizon 19\n", - "adding: mem time74, current time 92, horizon 18\n", - "adding: mem time75, current time 92, horizon 17\n", - "adding: mem time76, current time 92, horizon 16\n", - "adding: mem time77, current time 92, horizon 15\n", - "adding: mem time78, current time 92, horizon 14\n", - "adding: mem time79, current time 92, horizon 13\n", - "adding: mem time80, current time 92, horizon 12\n", - "adding: mem time81, current time 92, horizon 11\n", - "adding: mem time82, current time 92, horizon 10\n", - "adding: mem time83, current time 92, horizon 9\n", - "adding: mem time84, current time 92, horizon 8\n", - "adding: mem time85, current time 92, horizon 7\n", - "adding: mem time86, current time 92, horizon 6\n", - "adding: mem time87, current time 92, horizon 5\n", - "adding: mem time88, current time 92, horizon 4\n", - "adding: mem time89, current time 92, horizon 3\n", - "adding: mem time90, current time 92, horizon 2\n", - "adding: mem time91, current time 92, horizon 1\n", - "adding: mem time0, current time 93, horizon 93\n", - "adding: mem time1, current time 93, horizon 92\n", - "adding: mem time2, current time 93, horizon 91\n", - "adding: mem time3, current time 93, horizon 90\n", - "adding: mem time4, current time 93, horizon 89\n", - "adding: mem time5, current time 93, horizon 88\n", - "adding: mem time6, current time 93, horizon 87\n", - "adding: mem time7, current time 93, horizon 86\n", - "adding: mem time8, current time 93, horizon 85\n", - "adding: mem time9, current time 93, horizon 84\n", - "adding: mem time10, current time 93, horizon 83\n", - "adding: mem time11, current time 93, horizon 82\n", - "adding: mem time12, current time 93, horizon 81\n", - "adding: mem time13, current time 93, horizon 80\n", - "adding: mem time14, current time 93, horizon 79\n", - "adding: mem time15, current time 93, horizon 78\n", - "adding: mem time16, current time 93, horizon 77\n", - "adding: mem time17, current time 93, horizon 76\n", - "adding: mem time18, current time 93, horizon 75\n", - "adding: mem time19, current time 93, horizon 74\n", - "adding: mem time20, current time 93, horizon 73\n", - "adding: mem time21, current time 93, horizon 72\n", - "adding: mem time22, current time 93, horizon 71\n", - "adding: mem time23, current time 93, horizon 70\n", - "adding: mem time24, current time 93, horizon 69\n", - "adding: mem time25, current time 93, horizon 68\n", - "adding: mem time26, current time 93, horizon 67\n", - "adding: mem time27, current time 93, horizon 66\n", - "adding: mem time28, current time 93, horizon 65\n", - "adding: mem time29, current time 93, horizon 64\n", - "adding: mem time30, current time 93, horizon 63\n", - "adding: mem time31, current time 93, horizon 62\n", - "adding: mem time32, current time 93, horizon 61\n", - "adding: mem time33, current time 93, horizon 60\n", - "adding: mem time34, current time 93, horizon 59\n", - "adding: mem time35, current time 93, horizon 58\n", - "adding: mem time36, current time 93, horizon 57\n", - "adding: mem time37, current time 93, horizon 56\n", - "adding: mem time38, current time 93, horizon 55\n", - "adding: mem time39, current time 93, horizon 54\n", - "adding: mem time40, current time 93, horizon 53\n", - "adding: mem time41, current time 93, horizon 52\n", - "adding: mem time42, current time 93, horizon 51\n", - "adding: mem time43, current time 93, horizon 50\n", - "adding: mem time44, current time 93, horizon 49\n", - "adding: mem time45, current time 93, horizon 48\n", - "adding: mem time46, current time 93, horizon 47\n", - "adding: mem time47, current time 93, horizon 46\n", - "adding: mem time48, current time 93, horizon 45\n", - "adding: mem time49, current time 93, horizon 44\n", - "adding: mem time50, current time 93, horizon 43\n", - "adding: mem time51, current time 93, horizon 42\n", - "adding: mem time52, current time 93, horizon 41\n", - "adding: mem time53, current time 93, horizon 40\n", - "adding: mem time54, current time 93, horizon 39\n", - "adding: mem time55, current time 93, horizon 38\n", - "adding: mem time56, current time 93, horizon 37\n", - "adding: mem time57, current time 93, horizon 36\n", - "adding: mem time58, current time 93, horizon 35\n", - "adding: mem time59, current time 93, horizon 34\n", - "adding: mem time60, current time 93, horizon 33\n", - "adding: mem time61, current time 93, horizon 32\n", - "adding: mem time62, current time 93, horizon 31\n", - "adding: mem time63, current time 93, horizon 30\n", - "adding: mem time64, current time 93, horizon 29\n", - "adding: mem time65, current time 93, horizon 28\n", - "adding: mem time66, current time 93, horizon 27\n", - "adding: mem time67, current time 93, horizon 26\n", - "adding: mem time68, current time 93, horizon 25\n", - "adding: mem time69, current time 93, horizon 24\n", - "adding: mem time70, current time 93, horizon 23\n", - "adding: mem time71, current time 93, horizon 22\n", - "adding: mem time72, current time 93, horizon 21\n", - "adding: mem time73, current time 93, horizon 20\n", - "adding: mem time74, current time 93, horizon 19\n", - "adding: mem time75, current time 93, horizon 18\n", - "adding: mem time76, current time 93, horizon 17\n", - "adding: mem time77, current time 93, horizon 16\n", - "adding: mem time78, current time 93, horizon 15\n", - "adding: mem time79, current time 93, horizon 14\n", - "adding: mem time80, current time 93, horizon 13\n", - "adding: mem time81, current time 93, horizon 12\n", - "adding: mem time82, current time 93, horizon 11\n", - "adding: mem time83, current time 93, horizon 10\n", - "adding: mem time84, current time 93, horizon 9\n", - "adding: mem time85, current time 93, horizon 8\n", - "adding: mem time86, current time 93, horizon 7\n", - "adding: mem time87, current time 93, horizon 6\n", - "adding: mem time88, current time 93, horizon 5\n", - "adding: mem time89, current time 93, horizon 4\n", - "adding: mem time90, current time 93, horizon 3\n", - "adding: mem time91, current time 93, horizon 2\n", - "adding: mem time92, current time 93, horizon 1\n", - "adding: mem time0, current time 94, horizon 94\n", - "adding: mem time1, current time 94, horizon 93\n", - "adding: mem time2, current time 94, horizon 92\n", - "adding: mem time3, current time 94, horizon 91\n", - "adding: mem time4, current time 94, horizon 90\n", - "adding: mem time5, current time 94, horizon 89\n", - "adding: mem time6, current time 94, horizon 88\n", - "adding: mem time7, current time 94, horizon 87\n", - "adding: mem time8, current time 94, horizon 86\n", - "adding: mem time9, current time 94, horizon 85\n", - "adding: mem time10, current time 94, horizon 84\n", - "adding: mem time11, current time 94, horizon 83\n", - "adding: mem time12, current time 94, horizon 82\n", - "adding: mem time13, current time 94, horizon 81\n", - "adding: mem time14, current time 94, horizon 80\n", - "adding: mem time15, current time 94, horizon 79\n", - "adding: mem time16, current time 94, horizon 78\n", - "adding: mem time17, current time 94, horizon 77\n", - "adding: mem time18, current time 94, horizon 76\n", - "adding: mem time19, current time 94, horizon 75\n", - "adding: mem time20, current time 94, horizon 74\n", - "adding: mem time21, current time 94, horizon 73\n", - "adding: mem time22, current time 94, horizon 72\n", - "adding: mem time23, current time 94, horizon 71\n", - "adding: mem time24, current time 94, horizon 70\n", - "adding: mem time25, current time 94, horizon 69\n", - "adding: mem time26, current time 94, horizon 68\n", - "adding: mem time27, current time 94, horizon 67\n", - "adding: mem time28, current time 94, horizon 66\n", - "adding: mem time29, current time 94, horizon 65\n", - "adding: mem time30, current time 94, horizon 64\n", - "adding: mem time31, current time 94, horizon 63\n", - "adding: mem time32, current time 94, horizon 62\n", - "adding: mem time33, current time 94, horizon 61\n", - "adding: mem time34, current time 94, horizon 60\n", - "adding: mem time35, current time 94, horizon 59\n", - "adding: mem time36, current time 94, horizon 58\n", - "adding: mem time37, current time 94, horizon 57\n", - "adding: mem time38, current time 94, horizon 56\n", - "adding: mem time39, current time 94, horizon 55\n", - "adding: mem time40, current time 94, horizon 54\n", - "adding: mem time41, current time 94, horizon 53\n", - "adding: mem time42, current time 94, horizon 52\n", - "adding: mem time43, current time 94, horizon 51\n", - "adding: mem time44, current time 94, horizon 50\n", - "adding: mem time45, current time 94, horizon 49\n", - "adding: mem time46, current time 94, horizon 48\n", - "adding: mem time47, current time 94, horizon 47\n", - "adding: mem time48, current time 94, horizon 46\n", - "adding: mem time49, current time 94, horizon 45\n", - "adding: mem time50, current time 94, horizon 44\n", - "adding: mem time51, current time 94, horizon 43\n", - "adding: mem time52, current time 94, horizon 42\n", - "adding: mem time53, current time 94, horizon 41\n", - "adding: mem time54, current time 94, horizon 40\n", - "adding: mem time55, current time 94, horizon 39\n", - "adding: mem time56, current time 94, horizon 38\n", - "adding: mem time57, current time 94, horizon 37\n", - "adding: mem time58, current time 94, horizon 36\n", - "adding: mem time59, current time 94, horizon 35\n", - "adding: mem time60, current time 94, horizon 34\n", - "adding: mem time61, current time 94, horizon 33\n", - "adding: mem time62, current time 94, horizon 32\n", - "adding: mem time63, current time 94, horizon 31\n", - "adding: mem time64, current time 94, horizon 30\n", - "adding: mem time65, current time 94, horizon 29\n", - "adding: mem time66, current time 94, horizon 28\n", - "adding: mem time67, current time 94, horizon 27\n", - "adding: mem time68, current time 94, horizon 26\n", - "adding: mem time69, current time 94, horizon 25\n", - "adding: mem time70, current time 94, horizon 24\n", - "adding: mem time71, current time 94, horizon 23\n", - "adding: mem time72, current time 94, horizon 22\n", - "adding: mem time73, current time 94, horizon 21\n", - "adding: mem time74, current time 94, horizon 20\n", - "adding: mem time75, current time 94, horizon 19\n", - "adding: mem time76, current time 94, horizon 18\n", - "adding: mem time77, current time 94, horizon 17\n", - "adding: mem time78, current time 94, horizon 16\n", - "adding: mem time79, current time 94, horizon 15\n", - "adding: mem time80, current time 94, horizon 14\n", - "adding: mem time81, current time 94, horizon 13\n", - "adding: mem time82, current time 94, horizon 12\n", - "adding: mem time83, current time 94, horizon 11\n", - "adding: mem time84, current time 94, horizon 10\n", - "adding: mem time85, current time 94, horizon 9\n", - "adding: mem time86, current time 94, horizon 8\n", - "adding: mem time87, current time 94, horizon 7\n", - "adding: mem time88, current time 94, horizon 6\n", - "adding: mem time89, current time 94, horizon 5\n", - "adding: mem time90, current time 94, horizon 4\n", - "adding: mem time91, current time 94, horizon 3\n", - "adding: mem time92, current time 94, horizon 2\n", - "adding: mem time93, current time 94, horizon 1\n", - "adding: mem time0, current time 95, horizon 95\n", - "adding: mem time1, current time 95, horizon 94\n", - "adding: mem time2, current time 95, horizon 93\n", - "adding: mem time3, current time 95, horizon 92\n", - "adding: mem time4, current time 95, horizon 91\n", - "adding: mem time5, current time 95, horizon 90\n", - "adding: mem time6, current time 95, horizon 89\n", - "adding: mem time7, current time 95, horizon 88\n", - "adding: mem time8, current time 95, horizon 87\n", - "adding: mem time9, current time 95, horizon 86\n", - "adding: mem time10, current time 95, horizon 85\n", - "adding: mem time11, current time 95, horizon 84\n", - "adding: mem time12, current time 95, horizon 83\n", - "adding: mem time13, current time 95, horizon 82\n", - "adding: mem time14, current time 95, horizon 81\n", - "adding: mem time15, current time 95, horizon 80\n", - "adding: mem time16, current time 95, horizon 79\n", - "adding: mem time17, current time 95, horizon 78\n", - "adding: mem time18, current time 95, horizon 77\n", - "adding: mem time19, current time 95, horizon 76\n", - "adding: mem time20, current time 95, horizon 75\n", - "adding: mem time21, current time 95, horizon 74\n", - "adding: mem time22, current time 95, horizon 73\n", - "adding: mem time23, current time 95, horizon 72\n", - "adding: mem time24, current time 95, horizon 71\n", - "adding: mem time25, current time 95, horizon 70\n", - "adding: mem time26, current time 95, horizon 69\n", - "adding: mem time27, current time 95, horizon 68\n", - "adding: mem time28, current time 95, horizon 67\n", - "adding: mem time29, current time 95, horizon 66\n", - "adding: mem time30, current time 95, horizon 65\n", - "adding: mem time31, current time 95, horizon 64\n", - "adding: mem time32, current time 95, horizon 63\n", - "adding: mem time33, current time 95, horizon 62\n", - "adding: mem time34, current time 95, horizon 61\n", - "adding: mem time35, current time 95, horizon 60\n", - "adding: mem time36, current time 95, horizon 59\n", - "adding: mem time37, current time 95, horizon 58\n", - "adding: mem time38, current time 95, horizon 57\n", - "adding: mem time39, current time 95, horizon 56\n", - "adding: mem time40, current time 95, horizon 55\n", - "adding: mem time41, current time 95, horizon 54\n", - "adding: mem time42, current time 95, horizon 53\n", - "adding: mem time43, current time 95, horizon 52\n", - "adding: mem time44, current time 95, horizon 51\n", - "adding: mem time45, current time 95, horizon 50\n", - "adding: mem time46, current time 95, horizon 49\n", - "adding: mem time47, current time 95, horizon 48\n", - "adding: mem time48, current time 95, horizon 47\n", - "adding: mem time49, current time 95, horizon 46\n", - "adding: mem time50, current time 95, horizon 45\n", - "adding: mem time51, current time 95, horizon 44\n", - "adding: mem time52, current time 95, horizon 43\n", - "adding: mem time53, current time 95, horizon 42\n", - "adding: mem time54, current time 95, horizon 41\n", - "adding: mem time55, current time 95, horizon 40\n", - "adding: mem time56, current time 95, horizon 39\n", - "adding: mem time57, current time 95, horizon 38\n", - "adding: mem time58, current time 95, horizon 37\n", - "adding: mem time59, current time 95, horizon 36\n", - "adding: mem time60, current time 95, horizon 35\n", - "adding: mem time61, current time 95, horizon 34\n", - "adding: mem time62, current time 95, horizon 33\n", - "adding: mem time63, current time 95, horizon 32\n", - "adding: mem time64, current time 95, horizon 31\n", - "adding: mem time65, current time 95, horizon 30\n", - "adding: mem time66, current time 95, horizon 29\n", - "adding: mem time67, current time 95, horizon 28\n", - "adding: mem time68, current time 95, horizon 27\n", - "adding: mem time69, current time 95, horizon 26\n", - "adding: mem time70, current time 95, horizon 25\n", - "adding: mem time71, current time 95, horizon 24\n", - "adding: mem time72, current time 95, horizon 23\n", - "adding: mem time73, current time 95, horizon 22\n", - "adding: mem time74, current time 95, horizon 21\n", - "adding: mem time75, current time 95, horizon 20\n", - "adding: mem time76, current time 95, horizon 19\n", - "adding: mem time77, current time 95, horizon 18\n", - "adding: mem time78, current time 95, horizon 17\n", - "adding: mem time79, current time 95, horizon 16\n", - "adding: mem time80, current time 95, horizon 15\n", - "adding: mem time81, current time 95, horizon 14\n", - "adding: mem time82, current time 95, horizon 13\n", - "adding: mem time83, current time 95, horizon 12\n", - "adding: mem time84, current time 95, horizon 11\n", - "adding: mem time85, current time 95, horizon 10\n", - "adding: mem time86, current time 95, horizon 9\n", - "adding: mem time87, current time 95, horizon 8\n", - "adding: mem time88, current time 95, horizon 7\n", - "adding: mem time89, current time 95, horizon 6\n", - "adding: mem time90, current time 95, horizon 5\n", - "adding: mem time91, current time 95, horizon 4\n", - "adding: mem time92, current time 95, horizon 3\n", - "adding: mem time93, current time 95, horizon 2\n", - "adding: mem time94, current time 95, horizon 1\n", - "adding: mem time0, current time 96, horizon 96\n", - "adding: mem time1, current time 96, horizon 95\n", - "adding: mem time2, current time 96, horizon 94\n", - "adding: mem time3, current time 96, horizon 93\n", - "adding: mem time4, current time 96, horizon 92\n", - "adding: mem time5, current time 96, horizon 91\n", - "adding: mem time6, current time 96, horizon 90\n", - "adding: mem time7, current time 96, horizon 89\n", - "adding: mem time8, current time 96, horizon 88\n", - "adding: mem time9, current time 96, horizon 87\n", - "adding: mem time10, current time 96, horizon 86\n", - "adding: mem time11, current time 96, horizon 85\n", - "adding: mem time12, current time 96, horizon 84\n", - "adding: mem time13, current time 96, horizon 83\n", - "adding: mem time14, current time 96, horizon 82\n", - "adding: mem time15, current time 96, horizon 81\n", - "adding: mem time16, current time 96, horizon 80\n", - "adding: mem time17, current time 96, horizon 79\n", - "adding: mem time18, current time 96, horizon 78\n", - "adding: mem time19, current time 96, horizon 77\n", - "adding: mem time20, current time 96, horizon 76\n", - "adding: mem time21, current time 96, horizon 75\n", - "adding: mem time22, current time 96, horizon 74\n", - "adding: mem time23, current time 96, horizon 73\n", - "adding: mem time24, current time 96, horizon 72\n", - "adding: mem time25, current time 96, horizon 71\n", - "adding: mem time26, current time 96, horizon 70\n", - "adding: mem time27, current time 96, horizon 69\n", - "adding: mem time28, current time 96, horizon 68\n", - "adding: mem time29, current time 96, horizon 67\n", - "adding: mem time30, current time 96, horizon 66\n", - "adding: mem time31, current time 96, horizon 65\n", - "adding: mem time32, current time 96, horizon 64\n", - "adding: mem time33, current time 96, horizon 63\n", - "adding: mem time34, current time 96, horizon 62\n", - "adding: mem time35, current time 96, horizon 61\n", - "adding: mem time36, current time 96, horizon 60\n", - "adding: mem time37, current time 96, horizon 59\n", - "adding: mem time38, current time 96, horizon 58\n", - "adding: mem time39, current time 96, horizon 57\n", - "adding: mem time40, current time 96, horizon 56\n", - "adding: mem time41, current time 96, horizon 55\n", - "adding: mem time42, current time 96, horizon 54\n", - "adding: mem time43, current time 96, horizon 53\n", - "adding: mem time44, current time 96, horizon 52\n", - "adding: mem time45, current time 96, horizon 51\n", - "adding: mem time46, current time 96, horizon 50\n", - "adding: mem time47, current time 96, horizon 49\n", - "adding: mem time48, current time 96, horizon 48\n", - "adding: mem time49, current time 96, horizon 47\n", - "adding: mem time50, current time 96, horizon 46\n", - "adding: mem time51, current time 96, horizon 45\n", - "adding: mem time52, current time 96, horizon 44\n", - "adding: mem time53, current time 96, horizon 43\n", - "adding: mem time54, current time 96, horizon 42\n", - "adding: mem time55, current time 96, horizon 41\n", - "adding: mem time56, current time 96, horizon 40\n", - "adding: mem time57, current time 96, horizon 39\n", - "adding: mem time58, current time 96, horizon 38\n", - "adding: mem time59, current time 96, horizon 37\n", - "adding: mem time60, current time 96, horizon 36\n", - "adding: mem time61, current time 96, horizon 35\n", - "adding: mem time62, current time 96, horizon 34\n", - "adding: mem time63, current time 96, horizon 33\n", - "adding: mem time64, current time 96, horizon 32\n", - "adding: mem time65, current time 96, horizon 31\n", - "adding: mem time66, current time 96, horizon 30\n", - "adding: mem time67, current time 96, horizon 29\n", - "adding: mem time68, current time 96, horizon 28\n", - "adding: mem time69, current time 96, horizon 27\n", - "adding: mem time70, current time 96, horizon 26\n", - "adding: mem time71, current time 96, horizon 25\n", - "adding: mem time72, current time 96, horizon 24\n", - "adding: mem time73, current time 96, horizon 23\n", - "adding: mem time74, current time 96, horizon 22\n", - "adding: mem time75, current time 96, horizon 21\n", - "adding: mem time76, current time 96, horizon 20\n", - "adding: mem time77, current time 96, horizon 19\n", - "adding: mem time78, current time 96, horizon 18\n", - "adding: mem time79, current time 96, horizon 17\n", - "adding: mem time80, current time 96, horizon 16\n", - "adding: mem time81, current time 96, horizon 15\n", - "adding: mem time82, current time 96, horizon 14\n", - "adding: mem time83, current time 96, horizon 13\n", - "adding: mem time84, current time 96, horizon 12\n", - "adding: mem time85, current time 96, horizon 11\n", - "adding: mem time86, current time 96, horizon 10\n", - "adding: mem time87, current time 96, horizon 9\n", - "adding: mem time88, current time 96, horizon 8\n", - "adding: mem time89, current time 96, horizon 7\n", - "adding: mem time90, current time 96, horizon 6\n", - "adding: mem time91, current time 96, horizon 5\n", - "adding: mem time92, current time 96, horizon 4\n", - "adding: mem time93, current time 96, horizon 3\n", - "adding: mem time94, current time 96, horizon 2\n", - "adding: mem time95, current time 96, horizon 1\n", - "adding: mem time0, current time 97, horizon 97\n", - "adding: mem time1, current time 97, horizon 96\n", - "adding: mem time2, current time 97, horizon 95\n", - "adding: mem time3, current time 97, horizon 94\n", - "adding: mem time4, current time 97, horizon 93\n", - "adding: mem time5, current time 97, horizon 92\n", - "adding: mem time6, current time 97, horizon 91\n", - "adding: mem time7, current time 97, horizon 90\n", - "adding: mem time8, current time 97, horizon 89\n", - "adding: mem time9, current time 97, horizon 88\n", - "adding: mem time10, current time 97, horizon 87\n", - "adding: mem time11, current time 97, horizon 86\n", - "adding: mem time12, current time 97, horizon 85\n", - "adding: mem time13, current time 97, horizon 84\n", - "adding: mem time14, current time 97, horizon 83\n", - "adding: mem time15, current time 97, horizon 82\n", - "adding: mem time16, current time 97, horizon 81\n", - "adding: mem time17, current time 97, horizon 80\n", - "adding: mem time18, current time 97, horizon 79\n", - "adding: mem time19, current time 97, horizon 78\n", - "adding: mem time20, current time 97, horizon 77\n", - "adding: mem time21, current time 97, horizon 76\n", - "adding: mem time22, current time 97, horizon 75\n", - "adding: mem time23, current time 97, horizon 74\n", - "adding: mem time24, current time 97, horizon 73\n", - "adding: mem time25, current time 97, horizon 72\n", - "adding: mem time26, current time 97, horizon 71\n", - "adding: mem time27, current time 97, horizon 70\n", - "adding: mem time28, current time 97, horizon 69\n", - "adding: mem time29, current time 97, horizon 68\n", - "adding: mem time30, current time 97, horizon 67\n", - "adding: mem time31, current time 97, horizon 66\n", - "adding: mem time32, current time 97, horizon 65\n", - "adding: mem time33, current time 97, horizon 64\n", - "adding: mem time34, current time 97, horizon 63\n", - "adding: mem time35, current time 97, horizon 62\n", - "adding: mem time36, current time 97, horizon 61\n", - "adding: mem time37, current time 97, horizon 60\n", - "adding: mem time38, current time 97, horizon 59\n", - "adding: mem time39, current time 97, horizon 58\n", - "adding: mem time40, current time 97, horizon 57\n", - "adding: mem time41, current time 97, horizon 56\n", - "adding: mem time42, current time 97, horizon 55\n", - "adding: mem time43, current time 97, horizon 54\n", - "adding: mem time44, current time 97, horizon 53\n", - "adding: mem time45, current time 97, horizon 52\n", - "adding: mem time46, current time 97, horizon 51\n", - "adding: mem time47, current time 97, horizon 50\n", - "adding: mem time48, current time 97, horizon 49\n", - "adding: mem time49, current time 97, horizon 48\n", - "adding: mem time50, current time 97, horizon 47\n", - "adding: mem time51, current time 97, horizon 46\n", - "adding: mem time52, current time 97, horizon 45\n", - "adding: mem time53, current time 97, horizon 44\n", - "adding: mem time54, current time 97, horizon 43\n", - "adding: mem time55, current time 97, horizon 42\n", - "adding: mem time56, current time 97, horizon 41\n", - "adding: mem time57, current time 97, horizon 40\n", - "adding: mem time58, current time 97, horizon 39\n", - "adding: mem time59, current time 97, horizon 38\n", - "adding: mem time60, current time 97, horizon 37\n", - "adding: mem time61, current time 97, horizon 36\n", - "adding: mem time62, current time 97, horizon 35\n", - "adding: mem time63, current time 97, horizon 34\n", - "adding: mem time64, current time 97, horizon 33\n", - "adding: mem time65, current time 97, horizon 32\n", - "adding: mem time66, current time 97, horizon 31\n", - "adding: mem time67, current time 97, horizon 30\n", - "adding: mem time68, current time 97, horizon 29\n", - "adding: mem time69, current time 97, horizon 28\n", - "adding: mem time70, current time 97, horizon 27\n", - "adding: mem time71, current time 97, horizon 26\n", - "adding: mem time72, current time 97, horizon 25\n", - "adding: mem time73, current time 97, horizon 24\n", - "adding: mem time74, current time 97, horizon 23\n", - "adding: mem time75, current time 97, horizon 22\n", - "adding: mem time76, current time 97, horizon 21\n", - "adding: mem time77, current time 97, horizon 20\n", - "adding: mem time78, current time 97, horizon 19\n", - "adding: mem time79, current time 97, horizon 18\n", - "adding: mem time80, current time 97, horizon 17\n", - "adding: mem time81, current time 97, horizon 16\n", - "adding: mem time82, current time 97, horizon 15\n", - "adding: mem time83, current time 97, horizon 14\n", - "adding: mem time84, current time 97, horizon 13\n", - "adding: mem time85, current time 97, horizon 12\n", - "adding: mem time86, current time 97, horizon 11\n", - "adding: mem time87, current time 97, horizon 10\n", - "adding: mem time88, current time 97, horizon 9\n", - "adding: mem time89, current time 97, horizon 8\n", - "adding: mem time90, current time 97, horizon 7\n", - "adding: mem time91, current time 97, horizon 6\n", - "adding: mem time92, current time 97, horizon 5\n", - "adding: mem time93, current time 97, horizon 4\n", - "adding: mem time94, current time 97, horizon 3\n", - "adding: mem time95, current time 97, horizon 2\n", - "adding: mem time96, current time 97, horizon 1\n", - "adding: mem time0, current time 98, horizon 98\n", - "adding: mem time1, current time 98, horizon 97\n", - "adding: mem time2, current time 98, horizon 96\n", - "adding: mem time3, current time 98, horizon 95\n", - "adding: mem time4, current time 98, horizon 94\n", - "adding: mem time5, current time 98, horizon 93\n", - "adding: mem time6, current time 98, horizon 92\n", - "adding: mem time7, current time 98, horizon 91\n", - "adding: mem time8, current time 98, horizon 90\n", - "adding: mem time9, current time 98, horizon 89\n", - "adding: mem time10, current time 98, horizon 88\n", - "adding: mem time11, current time 98, horizon 87\n", - "adding: mem time12, current time 98, horizon 86\n", - "adding: mem time13, current time 98, horizon 85\n", - "adding: mem time14, current time 98, horizon 84\n", - "adding: mem time15, current time 98, horizon 83\n", - "adding: mem time16, current time 98, horizon 82\n", - "adding: mem time17, current time 98, horizon 81\n", - "adding: mem time18, current time 98, horizon 80\n", - "adding: mem time19, current time 98, horizon 79\n", - "adding: mem time20, current time 98, horizon 78\n", - "adding: mem time21, current time 98, horizon 77\n", - "adding: mem time22, current time 98, horizon 76\n", - "adding: mem time23, current time 98, horizon 75\n", - "adding: mem time24, current time 98, horizon 74\n", - "adding: mem time25, current time 98, horizon 73\n", - "adding: mem time26, current time 98, horizon 72\n", - "adding: mem time27, current time 98, horizon 71\n", - "adding: mem time28, current time 98, horizon 70\n", - "adding: mem time29, current time 98, horizon 69\n", - "adding: mem time30, current time 98, horizon 68\n", - "adding: mem time31, current time 98, horizon 67\n", - "adding: mem time32, current time 98, horizon 66\n", - "adding: mem time33, current time 98, horizon 65\n", - "adding: mem time34, current time 98, horizon 64\n", - "adding: mem time35, current time 98, horizon 63\n", - "adding: mem time36, current time 98, horizon 62\n", - "adding: mem time37, current time 98, horizon 61\n", - "adding: mem time38, current time 98, horizon 60\n", - "adding: mem time39, current time 98, horizon 59\n", - "adding: mem time40, current time 98, horizon 58\n", - "adding: mem time41, current time 98, horizon 57\n", - "adding: mem time42, current time 98, horizon 56\n", - "adding: mem time43, current time 98, horizon 55\n", - "adding: mem time44, current time 98, horizon 54\n", - "adding: mem time45, current time 98, horizon 53\n", - "adding: mem time46, current time 98, horizon 52\n", - "adding: mem time47, current time 98, horizon 51\n", - "adding: mem time48, current time 98, horizon 50\n", - "adding: mem time49, current time 98, horizon 49\n", - "adding: mem time50, current time 98, horizon 48\n", - "adding: mem time51, current time 98, horizon 47\n", - "adding: mem time52, current time 98, horizon 46\n", - "adding: mem time53, current time 98, horizon 45\n", - "adding: mem time54, current time 98, horizon 44\n", - "adding: mem time55, current time 98, horizon 43\n", - "adding: mem time56, current time 98, horizon 42\n", - "adding: mem time57, current time 98, horizon 41\n", - "adding: mem time58, current time 98, horizon 40\n", - "adding: mem time59, current time 98, horizon 39\n", - "adding: mem time60, current time 98, horizon 38\n", - "adding: mem time61, current time 98, horizon 37\n", - "adding: mem time62, current time 98, horizon 36\n", - "adding: mem time63, current time 98, horizon 35\n", - "adding: mem time64, current time 98, horizon 34\n", - "adding: mem time65, current time 98, horizon 33\n", - "adding: mem time66, current time 98, horizon 32\n", - "adding: mem time67, current time 98, horizon 31\n", - "adding: mem time68, current time 98, horizon 30\n", - "adding: mem time69, current time 98, horizon 29\n", - "adding: mem time70, current time 98, horizon 28\n", - "adding: mem time71, current time 98, horizon 27\n", - "adding: mem time72, current time 98, horizon 26\n", - "adding: mem time73, current time 98, horizon 25\n", - "adding: mem time74, current time 98, horizon 24\n", - "adding: mem time75, current time 98, horizon 23\n", - "adding: mem time76, current time 98, horizon 22\n", - "adding: mem time77, current time 98, horizon 21\n", - "adding: mem time78, current time 98, horizon 20\n", - "adding: mem time79, current time 98, horizon 19\n", - "adding: mem time80, current time 98, horizon 18\n", - "adding: mem time81, current time 98, horizon 17\n", - "adding: mem time82, current time 98, horizon 16\n", - "adding: mem time83, current time 98, horizon 15\n", - "adding: mem time84, current time 98, horizon 14\n", - "adding: mem time85, current time 98, horizon 13\n", - "adding: mem time86, current time 98, horizon 12\n", - "adding: mem time87, current time 98, horizon 11\n", - "adding: mem time88, current time 98, horizon 10\n", - "adding: mem time89, current time 98, horizon 9\n", - "adding: mem time90, current time 98, horizon 8\n", - "adding: mem time91, current time 98, horizon 7\n", - "adding: mem time92, current time 98, horizon 6\n", - "adding: mem time93, current time 98, horizon 5\n", - "adding: mem time94, current time 98, horizon 4\n", - "adding: mem time95, current time 98, horizon 3\n", - "adding: mem time96, current time 98, horizon 2\n", - "adding: mem time97, current time 98, horizon 1\n", - "adding: mem time0, current time 99, horizon 99\n", - "adding: mem time1, current time 99, horizon 98\n", - "adding: mem time2, current time 99, horizon 97\n", - "adding: mem time3, current time 99, horizon 96\n", - "adding: mem time4, current time 99, horizon 95\n", - "adding: mem time5, current time 99, horizon 94\n", - "adding: mem time6, current time 99, horizon 93\n", - "adding: mem time7, current time 99, horizon 92\n", - "adding: mem time8, current time 99, horizon 91\n", - "adding: mem time9, current time 99, horizon 90\n", - "adding: mem time10, current time 99, horizon 89\n", - "adding: mem time11, current time 99, horizon 88\n", - "adding: mem time12, current time 99, horizon 87\n", - "adding: mem time13, current time 99, horizon 86\n", - "adding: mem time14, current time 99, horizon 85\n", - "adding: mem time15, current time 99, horizon 84\n", - "adding: mem time16, current time 99, horizon 83\n", - "adding: mem time17, current time 99, horizon 82\n", - "adding: mem time18, current time 99, horizon 81\n", - "adding: mem time19, current time 99, horizon 80\n", - "adding: mem time20, current time 99, horizon 79\n", - "adding: mem time21, current time 99, horizon 78\n", - "adding: mem time22, current time 99, horizon 77\n", - "adding: mem time23, current time 99, horizon 76\n", - "adding: mem time24, current time 99, horizon 75\n", - "adding: mem time25, current time 99, horizon 74\n", - "adding: mem time26, current time 99, horizon 73\n", - "adding: mem time27, current time 99, horizon 72\n", - "adding: mem time28, current time 99, horizon 71\n", - "adding: mem time29, current time 99, horizon 70\n", - "adding: mem time30, current time 99, horizon 69\n", - "adding: mem time31, current time 99, horizon 68\n", - "adding: mem time32, current time 99, horizon 67\n", - "adding: mem time33, current time 99, horizon 66\n", - "adding: mem time34, current time 99, horizon 65\n", - "adding: mem time35, current time 99, horizon 64\n", - "adding: mem time36, current time 99, horizon 63\n", - "adding: mem time37, current time 99, horizon 62\n", - "adding: mem time38, current time 99, horizon 61\n", - "adding: mem time39, current time 99, horizon 60\n", - "adding: mem time40, current time 99, horizon 59\n", - "adding: mem time41, current time 99, horizon 58\n", - "adding: mem time42, current time 99, horizon 57\n", - "adding: mem time43, current time 99, horizon 56\n", - "adding: mem time44, current time 99, horizon 55\n", - "adding: mem time45, current time 99, horizon 54\n", - "adding: mem time46, current time 99, horizon 53\n", - "adding: mem time47, current time 99, horizon 52\n", - "adding: mem time48, current time 99, horizon 51\n", - "adding: mem time49, current time 99, horizon 50\n", - "adding: mem time50, current time 99, horizon 49\n", - "adding: mem time51, current time 99, horizon 48\n", - "adding: mem time52, current time 99, horizon 47\n", - "adding: mem time53, current time 99, horizon 46\n", - "adding: mem time54, current time 99, horizon 45\n", - "adding: mem time55, current time 99, horizon 44\n", - "adding: mem time56, current time 99, horizon 43\n", - "adding: mem time57, current time 99, horizon 42\n", - "adding: mem time58, current time 99, horizon 41\n", - "adding: mem time59, current time 99, horizon 40\n", - "adding: mem time60, current time 99, horizon 39\n", - "adding: mem time61, current time 99, horizon 38\n", - "adding: mem time62, current time 99, horizon 37\n", - "adding: mem time63, current time 99, horizon 36\n", - "adding: mem time64, current time 99, horizon 35\n", - "adding: mem time65, current time 99, horizon 34\n", - "adding: mem time66, current time 99, horizon 33\n", - "adding: mem time67, current time 99, horizon 32\n", - "adding: mem time68, current time 99, horizon 31\n", - "adding: mem time69, current time 99, horizon 30\n", - "adding: mem time70, current time 99, horizon 29\n", - "adding: mem time71, current time 99, horizon 28\n", - "adding: mem time72, current time 99, horizon 27\n", - "adding: mem time73, current time 99, horizon 26\n", - "adding: mem time74, current time 99, horizon 25\n", - "adding: mem time75, current time 99, horizon 24\n", - "adding: mem time76, current time 99, horizon 23\n", - "adding: mem time77, current time 99, horizon 22\n", - "adding: mem time78, current time 99, horizon 21\n", - "adding: mem time79, current time 99, horizon 20\n", - "adding: mem time80, current time 99, horizon 19\n", - "adding: mem time81, current time 99, horizon 18\n", - "adding: mem time82, current time 99, horizon 17\n", - "adding: mem time83, current time 99, horizon 16\n", - "adding: mem time84, current time 99, horizon 15\n", - "adding: mem time85, current time 99, horizon 14\n", - "adding: mem time86, current time 99, horizon 13\n", - "adding: mem time87, current time 99, horizon 12\n", - "adding: mem time88, current time 99, horizon 11\n", - "adding: mem time89, current time 99, horizon 10\n", - "adding: mem time90, current time 99, horizon 9\n", - "adding: mem time91, current time 99, horizon 8\n", - "adding: mem time92, current time 99, horizon 7\n", - "adding: mem time93, current time 99, horizon 6\n", - "adding: mem time94, current time 99, horizon 5\n", - "adding: mem time95, current time 99, horizon 4\n", - "adding: mem time96, current time 99, horizon 3\n", - "adding: mem time97, current time 99, horizon 2\n", - "adding: mem time98, current time 99, horizon 1\n", - "adding: mem time0, current time 100, horizon 100\n", - "adding: mem time1, current time 100, horizon 99\n", - "adding: mem time2, current time 100, horizon 98\n", - "adding: mem time3, current time 100, horizon 97\n", - "adding: mem time4, current time 100, horizon 96\n", - "adding: mem time5, current time 100, horizon 95\n", - "adding: mem time6, current time 100, horizon 94\n", - "adding: mem time7, current time 100, horizon 93\n", - "adding: mem time8, current time 100, horizon 92\n", - "adding: mem time9, current time 100, horizon 91\n", - "adding: mem time10, current time 100, horizon 90\n", - "adding: mem time11, current time 100, horizon 89\n", - "adding: mem time12, current time 100, horizon 88\n", - "adding: mem time13, current time 100, horizon 87\n", - "adding: mem time14, current time 100, horizon 86\n", - "adding: mem time15, current time 100, horizon 85\n", - "adding: mem time16, current time 100, horizon 84\n", - "adding: mem time17, current time 100, horizon 83\n", - "adding: mem time18, current time 100, horizon 82\n", - "adding: mem time19, current time 100, horizon 81\n", - "adding: mem time20, current time 100, horizon 80\n", - "adding: mem time21, current time 100, horizon 79\n", - "adding: mem time22, current time 100, horizon 78\n", - "adding: mem time23, current time 100, horizon 77\n", - "adding: mem time24, current time 100, horizon 76\n", - "adding: mem time25, current time 100, horizon 75\n", - "adding: mem time26, current time 100, horizon 74\n", - "adding: mem time27, current time 100, horizon 73\n", - "adding: mem time28, current time 100, horizon 72\n", - "adding: mem time29, current time 100, horizon 71\n", - "adding: mem time30, current time 100, horizon 70\n", - "adding: mem time31, current time 100, horizon 69\n", - "adding: mem time32, current time 100, horizon 68\n", - "adding: mem time33, current time 100, horizon 67\n", - "adding: mem time34, current time 100, horizon 66\n", - "adding: mem time35, current time 100, horizon 65\n", - "adding: mem time36, current time 100, horizon 64\n", - "adding: mem time37, current time 100, horizon 63\n", - "adding: mem time38, current time 100, horizon 62\n", - "adding: mem time39, current time 100, horizon 61\n", - "adding: mem time40, current time 100, horizon 60\n", - "adding: mem time41, current time 100, horizon 59\n", - "adding: mem time42, current time 100, horizon 58\n", - "adding: mem time43, current time 100, horizon 57\n", - "adding: mem time44, current time 100, horizon 56\n", - "adding: mem time45, current time 100, horizon 55\n", - "adding: mem time46, current time 100, horizon 54\n", - "adding: mem time47, current time 100, horizon 53\n", - "adding: mem time48, current time 100, horizon 52\n", - "adding: mem time49, current time 100, horizon 51\n", - "adding: mem time50, current time 100, horizon 50\n", - "adding: mem time51, current time 100, horizon 49\n", - "adding: mem time52, current time 100, horizon 48\n", - "adding: mem time53, current time 100, horizon 47\n", - "adding: mem time54, current time 100, horizon 46\n", - "adding: mem time55, current time 100, horizon 45\n", - "adding: mem time56, current time 100, horizon 44\n", - "adding: mem time57, current time 100, horizon 43\n", - "adding: mem time58, current time 100, horizon 42\n", - "adding: mem time59, current time 100, horizon 41\n", - "adding: mem time60, current time 100, horizon 40\n", - "adding: mem time61, current time 100, horizon 39\n", - "adding: mem time62, current time 100, horizon 38\n", - "adding: mem time63, current time 100, horizon 37\n", - "adding: mem time64, current time 100, horizon 36\n", - "adding: mem time65, current time 100, horizon 35\n", - "adding: mem time66, current time 100, horizon 34\n", - "adding: mem time67, current time 100, horizon 33\n", - "adding: mem time68, current time 100, horizon 32\n", - "adding: mem time69, current time 100, horizon 31\n", - "adding: mem time70, current time 100, horizon 30\n", - "adding: mem time71, current time 100, horizon 29\n", - "adding: mem time72, current time 100, horizon 28\n", - "adding: mem time73, current time 100, horizon 27\n", - "adding: mem time74, current time 100, horizon 26\n", - "adding: mem time75, current time 100, horizon 25\n", - "adding: mem time76, current time 100, horizon 24\n", - "adding: mem time77, current time 100, horizon 23\n", - "adding: mem time78, current time 100, horizon 22\n", - "adding: mem time79, current time 100, horizon 21\n", - "adding: mem time80, current time 100, horizon 20\n", - "adding: mem time81, current time 100, horizon 19\n", - "adding: mem time82, current time 100, horizon 18\n", - "adding: mem time83, current time 100, horizon 17\n", - "adding: mem time84, current time 100, horizon 16\n", - "adding: mem time85, current time 100, horizon 15\n", - "adding: mem time86, current time 100, horizon 14\n", - "adding: mem time87, current time 100, horizon 13\n", - "adding: mem time88, current time 100, horizon 12\n", - "adding: mem time89, current time 100, horizon 11\n", - "adding: mem time90, current time 100, horizon 10\n", - "adding: mem time91, current time 100, horizon 9\n", - "adding: mem time92, current time 100, horizon 8\n", - "adding: mem time93, current time 100, horizon 7\n", - "adding: mem time94, current time 100, horizon 6\n", - "adding: mem time95, current time 100, horizon 5\n", - "adding: mem time96, current time 100, horizon 4\n", - "adding: mem time97, current time 100, horizon 3\n", - "adding: mem time98, current time 100, horizon 2\n", - "adding: mem time99, current time 100, horizon 1\n", - "adding: mem time0, current time 101, horizon 101\n", - "adding: mem time1, current time 101, horizon 100\n", - "adding: mem time2, current time 101, horizon 99\n", - "adding: mem time3, current time 101, horizon 98\n", - "adding: mem time4, current time 101, horizon 97\n", - "adding: mem time5, current time 101, horizon 96\n", - "adding: mem time6, current time 101, horizon 95\n", - "adding: mem time7, current time 101, horizon 94\n", - "adding: mem time8, current time 101, horizon 93\n", - "adding: mem time9, current time 101, horizon 92\n", - "adding: mem time10, current time 101, horizon 91\n", - "adding: mem time11, current time 101, horizon 90\n", - "adding: mem time12, current time 101, horizon 89\n", - "adding: mem time13, current time 101, horizon 88\n", - "adding: mem time14, current time 101, horizon 87\n", - "adding: mem time15, current time 101, horizon 86\n", - "adding: mem time16, current time 101, horizon 85\n", - "adding: mem time17, current time 101, horizon 84\n", - "adding: mem time18, current time 101, horizon 83\n", - "adding: mem time19, current time 101, horizon 82\n", - "adding: mem time20, current time 101, horizon 81\n", - "adding: mem time21, current time 101, horizon 80\n", - "adding: mem time22, current time 101, horizon 79\n", - "adding: mem time23, current time 101, horizon 78\n", - "adding: mem time24, current time 101, horizon 77\n", - "adding: mem time25, current time 101, horizon 76\n", - "adding: mem time26, current time 101, horizon 75\n", - "adding: mem time27, current time 101, horizon 74\n", - "adding: mem time28, current time 101, horizon 73\n", - "adding: mem time29, current time 101, horizon 72\n", - "adding: mem time30, current time 101, horizon 71\n", - "adding: mem time31, current time 101, horizon 70\n", - "adding: mem time32, current time 101, horizon 69\n", - "adding: mem time33, current time 101, horizon 68\n", - "adding: mem time34, current time 101, horizon 67\n", - "adding: mem time35, current time 101, horizon 66\n", - "adding: mem time36, current time 101, horizon 65\n", - "adding: mem time37, current time 101, horizon 64\n", - "adding: mem time38, current time 101, horizon 63\n", - "adding: mem time39, current time 101, horizon 62\n", - "adding: mem time40, current time 101, horizon 61\n", - "adding: mem time41, current time 101, horizon 60\n", - "adding: mem time42, current time 101, horizon 59\n", - "adding: mem time43, current time 101, horizon 58\n", - "adding: mem time44, current time 101, horizon 57\n", - "adding: mem time45, current time 101, horizon 56\n", - "adding: mem time46, current time 101, horizon 55\n", - "adding: mem time47, current time 101, horizon 54\n", - "adding: mem time48, current time 101, horizon 53\n", - "adding: mem time49, current time 101, horizon 52\n", - "adding: mem time50, current time 101, horizon 51\n", - "adding: mem time51, current time 101, horizon 50\n", - "adding: mem time52, current time 101, horizon 49\n", - "adding: mem time53, current time 101, horizon 48\n", - "adding: mem time54, current time 101, horizon 47\n", - "adding: mem time55, current time 101, horizon 46\n", - "adding: mem time56, current time 101, horizon 45\n", - "adding: mem time57, current time 101, horizon 44\n", - "adding: mem time58, current time 101, horizon 43\n", - "adding: mem time59, current time 101, horizon 42\n", - "adding: mem time60, current time 101, horizon 41\n", - "adding: mem time61, current time 101, horizon 40\n", - "adding: mem time62, current time 101, horizon 39\n", - "adding: mem time63, current time 101, horizon 38\n", - "adding: mem time64, current time 101, horizon 37\n", - "adding: mem time65, current time 101, horizon 36\n", - "adding: mem time66, current time 101, horizon 35\n", - "adding: mem time67, current time 101, horizon 34\n", - "adding: mem time68, current time 101, horizon 33\n", - "adding: mem time69, current time 101, horizon 32\n", - "adding: mem time70, current time 101, horizon 31\n", - "adding: mem time71, current time 101, horizon 30\n", - "adding: mem time72, current time 101, horizon 29\n", - "adding: mem time73, current time 101, horizon 28\n", - "adding: mem time74, current time 101, horizon 27\n", - "adding: mem time75, current time 101, horizon 26\n", - "adding: mem time76, current time 101, horizon 25\n", - "adding: mem time77, current time 101, horizon 24\n", - "adding: mem time78, current time 101, horizon 23\n", - "adding: mem time79, current time 101, horizon 22\n", - "adding: mem time80, current time 101, horizon 21\n", - "adding: mem time81, current time 101, horizon 20\n", - "adding: mem time82, current time 101, horizon 19\n", - "adding: mem time83, current time 101, horizon 18\n", - "adding: mem time84, current time 101, horizon 17\n", - "adding: mem time85, current time 101, horizon 16\n", - "adding: mem time86, current time 101, horizon 15\n", - "adding: mem time87, current time 101, horizon 14\n", - "adding: mem time88, current time 101, horizon 13\n", - "adding: mem time89, current time 101, horizon 12\n", - "adding: mem time90, current time 101, horizon 11\n", - "adding: mem time91, current time 101, horizon 10\n", - "adding: mem time92, current time 101, horizon 9\n", - "adding: mem time93, current time 101, horizon 8\n", - "adding: mem time94, current time 101, horizon 7\n", - "adding: mem time95, current time 101, horizon 6\n", - "adding: mem time96, current time 101, horizon 5\n", - "adding: mem time97, current time 101, horizon 4\n", - "adding: mem time98, current time 101, horizon 3\n", - "adding: mem time99, current time 101, horizon 2\n", - "adding: mem time100, current time 101, horizon 1\n", - "adding: mem time0, current time 102, horizon 102\n", - "adding: mem time1, current time 102, horizon 101\n", - "adding: mem time2, current time 102, horizon 100\n", - "adding: mem time3, current time 102, horizon 99\n", - "adding: mem time4, current time 102, horizon 98\n", - "adding: mem time5, current time 102, horizon 97\n", - "adding: mem time6, current time 102, horizon 96\n", - "adding: mem time7, current time 102, horizon 95\n", - "adding: mem time8, current time 102, horizon 94\n", - "adding: mem time9, current time 102, horizon 93\n", - "adding: mem time10, current time 102, horizon 92\n", - "adding: mem time11, current time 102, horizon 91\n", - "adding: mem time12, current time 102, horizon 90\n", - "adding: mem time13, current time 102, horizon 89\n", - "adding: mem time14, current time 102, horizon 88\n", - "adding: mem time15, current time 102, horizon 87\n", - "adding: mem time16, current time 102, horizon 86\n", - "adding: mem time17, current time 102, horizon 85\n", - "adding: mem time18, current time 102, horizon 84\n", - "adding: mem time19, current time 102, horizon 83\n", - "adding: mem time20, current time 102, horizon 82\n", - "adding: mem time21, current time 102, horizon 81\n", - "adding: mem time22, current time 102, horizon 80\n", - "adding: mem time23, current time 102, horizon 79\n", - "adding: mem time24, current time 102, horizon 78\n", - "adding: mem time25, current time 102, horizon 77\n", - "adding: mem time26, current time 102, horizon 76\n", - "adding: mem time27, current time 102, horizon 75\n", - "adding: mem time28, current time 102, horizon 74\n", - "adding: mem time29, current time 102, horizon 73\n", - "adding: mem time30, current time 102, horizon 72\n", - "adding: mem time31, current time 102, horizon 71\n", - "adding: mem time32, current time 102, horizon 70\n", - "adding: mem time33, current time 102, horizon 69\n", - "adding: mem time34, current time 102, horizon 68\n", - "adding: mem time35, current time 102, horizon 67\n", - "adding: mem time36, current time 102, horizon 66\n", - "adding: mem time37, current time 102, horizon 65\n", - "adding: mem time38, current time 102, horizon 64\n", - "adding: mem time39, current time 102, horizon 63\n", - "adding: mem time40, current time 102, horizon 62\n", - "adding: mem time41, current time 102, horizon 61\n", - "adding: mem time42, current time 102, horizon 60\n", - "adding: mem time43, current time 102, horizon 59\n", - "adding: mem time44, current time 102, horizon 58\n", - "adding: mem time45, current time 102, horizon 57\n", - "adding: mem time46, current time 102, horizon 56\n", - "adding: mem time47, current time 102, horizon 55\n", - "adding: mem time48, current time 102, horizon 54\n", - "adding: mem time49, current time 102, horizon 53\n", - "adding: mem time50, current time 102, horizon 52\n", - "adding: mem time51, current time 102, horizon 51\n", - "adding: mem time52, current time 102, horizon 50\n", - "adding: mem time53, current time 102, horizon 49\n", - "adding: mem time54, current time 102, horizon 48\n", - "adding: mem time55, current time 102, horizon 47\n", - "adding: mem time56, current time 102, horizon 46\n", - "adding: mem time57, current time 102, horizon 45\n", - "adding: mem time58, current time 102, horizon 44\n", - "adding: mem time59, current time 102, horizon 43\n", - "adding: mem time60, current time 102, horizon 42\n", - "adding: mem time61, current time 102, horizon 41\n", - "adding: mem time62, current time 102, horizon 40\n", - "adding: mem time63, current time 102, horizon 39\n", - "adding: mem time64, current time 102, horizon 38\n", - "adding: mem time65, current time 102, horizon 37\n", - "adding: mem time66, current time 102, horizon 36\n", - "adding: mem time67, current time 102, horizon 35\n", - "adding: mem time68, current time 102, horizon 34\n", - "adding: mem time69, current time 102, horizon 33\n", - "adding: mem time70, current time 102, horizon 32\n", - "adding: mem time71, current time 102, horizon 31\n", - "adding: mem time72, current time 102, horizon 30\n", - "adding: mem time73, current time 102, horizon 29\n", - "adding: mem time74, current time 102, horizon 28\n", - "adding: mem time75, current time 102, horizon 27\n", - "adding: mem time76, current time 102, horizon 26\n", - "adding: mem time77, current time 102, horizon 25\n", - "adding: mem time78, current time 102, horizon 24\n", - "adding: mem time79, current time 102, horizon 23\n", - "adding: mem time80, current time 102, horizon 22\n", - "adding: mem time81, current time 102, horizon 21\n", - "adding: mem time82, current time 102, horizon 20\n", - "adding: mem time83, current time 102, horizon 19\n", - "adding: mem time84, current time 102, horizon 18\n", - "adding: mem time85, current time 102, horizon 17\n", - "adding: mem time86, current time 102, horizon 16\n", - "adding: mem time87, current time 102, horizon 15\n", - "adding: mem time88, current time 102, horizon 14\n", - "adding: mem time89, current time 102, horizon 13\n", - "adding: mem time90, current time 102, horizon 12\n", - "adding: mem time91, current time 102, horizon 11\n", - "adding: mem time92, current time 102, horizon 10\n", - "adding: mem time93, current time 102, horizon 9\n", - "adding: mem time94, current time 102, horizon 8\n", - "adding: mem time95, current time 102, horizon 7\n", - "adding: mem time96, current time 102, horizon 6\n", - "adding: mem time97, current time 102, horizon 5\n", - "adding: mem time98, current time 102, horizon 4\n", - "adding: mem time99, current time 102, horizon 3\n", - "adding: mem time100, current time 102, horizon 2\n", - "adding: mem time101, current time 102, horizon 1\n", - "adding: mem time0, current time 103, horizon 103\n", - "adding: mem time1, current time 103, horizon 102\n", - "adding: mem time2, current time 103, horizon 101\n", - "adding: mem time3, current time 103, horizon 100\n", - "adding: mem time4, current time 103, horizon 99\n", - "adding: mem time5, current time 103, horizon 98\n", - "adding: mem time6, current time 103, horizon 97\n", - "adding: mem time7, current time 103, horizon 96\n", - "adding: mem time8, current time 103, horizon 95\n", - "adding: mem time9, current time 103, horizon 94\n", - "adding: mem time10, current time 103, horizon 93\n", - "adding: mem time11, current time 103, horizon 92\n", - "adding: mem time12, current time 103, horizon 91\n", - "adding: mem time13, current time 103, horizon 90\n", - "adding: mem time14, current time 103, horizon 89\n", - "adding: mem time15, current time 103, horizon 88\n", - "adding: mem time16, current time 103, horizon 87\n", - "adding: mem time17, current time 103, horizon 86\n", - "adding: mem time18, current time 103, horizon 85\n", - "adding: mem time19, current time 103, horizon 84\n", - "adding: mem time20, current time 103, horizon 83\n", - "adding: mem time21, current time 103, horizon 82\n", - "adding: mem time22, current time 103, horizon 81\n", - "adding: mem time23, current time 103, horizon 80\n", - "adding: mem time24, current time 103, horizon 79\n", - "adding: mem time25, current time 103, horizon 78\n", - "adding: mem time26, current time 103, horizon 77\n", - "adding: mem time27, current time 103, horizon 76\n", - "adding: mem time28, current time 103, horizon 75\n", - "adding: mem time29, current time 103, horizon 74\n", - "adding: mem time30, current time 103, horizon 73\n", - "adding: mem time31, current time 103, horizon 72\n", - "adding: mem time32, current time 103, horizon 71\n", - "adding: mem time33, current time 103, horizon 70\n", - "adding: mem time34, current time 103, horizon 69\n", - "adding: mem time35, current time 103, horizon 68\n", - "adding: mem time36, current time 103, horizon 67\n", - "adding: mem time37, current time 103, horizon 66\n", - "adding: mem time38, current time 103, horizon 65\n", - "adding: mem time39, current time 103, horizon 64\n", - "adding: mem time40, current time 103, horizon 63\n", - "adding: mem time41, current time 103, horizon 62\n", - "adding: mem time42, current time 103, horizon 61\n", - "adding: mem time43, current time 103, horizon 60\n", - "adding: mem time44, current time 103, horizon 59\n", - "adding: mem time45, current time 103, horizon 58\n", - "adding: mem time46, current time 103, horizon 57\n", - "adding: mem time47, current time 103, horizon 56\n", - "adding: mem time48, current time 103, horizon 55\n", - "adding: mem time49, current time 103, horizon 54\n", - "adding: mem time50, current time 103, horizon 53\n", - "adding: mem time51, current time 103, horizon 52\n", - "adding: mem time52, current time 103, horizon 51\n", - "adding: mem time53, current time 103, horizon 50\n", - "adding: mem time54, current time 103, horizon 49\n", - "adding: mem time55, current time 103, horizon 48\n", - "adding: mem time56, current time 103, horizon 47\n", - "adding: mem time57, current time 103, horizon 46\n", - "adding: mem time58, current time 103, horizon 45\n", - "adding: mem time59, current time 103, horizon 44\n", - "adding: mem time60, current time 103, horizon 43\n", - "adding: mem time61, current time 103, horizon 42\n", - "adding: mem time62, current time 103, horizon 41\n", - "adding: mem time63, current time 103, horizon 40\n", - "adding: mem time64, current time 103, horizon 39\n", - "adding: mem time65, current time 103, horizon 38\n", - "adding: mem time66, current time 103, horizon 37\n", - "adding: mem time67, current time 103, horizon 36\n", - "adding: mem time68, current time 103, horizon 35\n", - "adding: mem time69, current time 103, horizon 34\n", - "adding: mem time70, current time 103, horizon 33\n", - "adding: mem time71, current time 103, horizon 32\n", - "adding: mem time72, current time 103, horizon 31\n", - "adding: mem time73, current time 103, horizon 30\n", - "adding: mem time74, current time 103, horizon 29\n", - "adding: mem time75, current time 103, horizon 28\n", - "adding: mem time76, current time 103, horizon 27\n", - "adding: mem time77, current time 103, horizon 26\n", - "adding: mem time78, current time 103, horizon 25\n", - "adding: mem time79, current time 103, horizon 24\n", - "adding: mem time80, current time 103, horizon 23\n", - "adding: mem time81, current time 103, horizon 22\n", - "adding: mem time82, current time 103, horizon 21\n", - "adding: mem time83, current time 103, horizon 20\n", - "adding: mem time84, current time 103, horizon 19\n", - "adding: mem time85, current time 103, horizon 18\n", - "adding: mem time86, current time 103, horizon 17\n", - "adding: mem time87, current time 103, horizon 16\n", - "adding: mem time88, current time 103, horizon 15\n", - "adding: mem time89, current time 103, horizon 14\n", - "adding: mem time90, current time 103, horizon 13\n", - "adding: mem time91, current time 103, horizon 12\n", - "adding: mem time92, current time 103, horizon 11\n", - "adding: mem time93, current time 103, horizon 10\n", - "adding: mem time94, current time 103, horizon 9\n", - "adding: mem time95, current time 103, horizon 8\n", - "adding: mem time96, current time 103, horizon 7\n", - "adding: mem time97, current time 103, horizon 6\n", - "adding: mem time98, current time 103, horizon 5\n", - "adding: mem time99, current time 103, horizon 4\n", - "adding: mem time100, current time 103, horizon 3\n", - "adding: mem time101, current time 103, horizon 2\n", - "adding: mem time102, current time 103, horizon 1\n", - "adding: mem time0, current time 104, horizon 104\n", - "adding: mem time1, current time 104, horizon 103\n", - "adding: mem time2, current time 104, horizon 102\n", - "adding: mem time3, current time 104, horizon 101\n", - "adding: mem time4, current time 104, horizon 100\n", - "adding: mem time5, current time 104, horizon 99\n", - "adding: mem time6, current time 104, horizon 98\n", - "adding: mem time7, current time 104, horizon 97\n", - "adding: mem time8, current time 104, horizon 96\n", - "adding: mem time9, current time 104, horizon 95\n", - "adding: mem time10, current time 104, horizon 94\n", - "adding: mem time11, current time 104, horizon 93\n", - "adding: mem time12, current time 104, horizon 92\n", - "adding: mem time13, current time 104, horizon 91\n", - "adding: mem time14, current time 104, horizon 90\n", - "adding: mem time15, current time 104, horizon 89\n", - "adding: mem time16, current time 104, horizon 88\n", - "adding: mem time17, current time 104, horizon 87\n", - "adding: mem time18, current time 104, horizon 86\n", - "adding: mem time19, current time 104, horizon 85\n", - "adding: mem time20, current time 104, horizon 84\n", - "adding: mem time21, current time 104, horizon 83\n", - "adding: mem time22, current time 104, horizon 82\n", - "adding: mem time23, current time 104, horizon 81\n", - "adding: mem time24, current time 104, horizon 80\n", - "adding: mem time25, current time 104, horizon 79\n", - "adding: mem time26, current time 104, horizon 78\n", - "adding: mem time27, current time 104, horizon 77\n", - "adding: mem time28, current time 104, horizon 76\n", - "adding: mem time29, current time 104, horizon 75\n", - "adding: mem time30, current time 104, horizon 74\n", - "adding: mem time31, current time 104, horizon 73\n", - "adding: mem time32, current time 104, horizon 72\n", - "adding: mem time33, current time 104, horizon 71\n", - "adding: mem time34, current time 104, horizon 70\n", - "adding: mem time35, current time 104, horizon 69\n", - "adding: mem time36, current time 104, horizon 68\n", - "adding: mem time37, current time 104, horizon 67\n", - "adding: mem time38, current time 104, horizon 66\n", - "adding: mem time39, current time 104, horizon 65\n", - "adding: mem time40, current time 104, horizon 64\n", - "adding: mem time41, current time 104, horizon 63\n", - "adding: mem time42, current time 104, horizon 62\n", - "adding: mem time43, current time 104, horizon 61\n", - "adding: mem time44, current time 104, horizon 60\n", - "adding: mem time45, current time 104, horizon 59\n", - "adding: mem time46, current time 104, horizon 58\n", - "adding: mem time47, current time 104, horizon 57\n", - "adding: mem time48, current time 104, horizon 56\n", - "adding: mem time49, current time 104, horizon 55\n", - "adding: mem time50, current time 104, horizon 54\n", - "adding: mem time51, current time 104, horizon 53\n", - "adding: mem time52, current time 104, horizon 52\n", - "adding: mem time53, current time 104, horizon 51\n", - "adding: mem time54, current time 104, horizon 50\n", - "adding: mem time55, current time 104, horizon 49\n", - "adding: mem time56, current time 104, horizon 48\n", - "adding: mem time57, current time 104, horizon 47\n", - "adding: mem time58, current time 104, horizon 46\n", - "adding: mem time59, current time 104, horizon 45\n", - "adding: mem time60, current time 104, horizon 44\n", - "adding: mem time61, current time 104, horizon 43\n", - "adding: mem time62, current time 104, horizon 42\n", - "adding: mem time63, current time 104, horizon 41\n", - "adding: mem time64, current time 104, horizon 40\n", - "adding: mem time65, current time 104, horizon 39\n", - "adding: mem time66, current time 104, horizon 38\n", - "adding: mem time67, current time 104, horizon 37\n", - "adding: mem time68, current time 104, horizon 36\n", - "adding: mem time69, current time 104, horizon 35\n", - "adding: mem time70, current time 104, horizon 34\n", - "adding: mem time71, current time 104, horizon 33\n", - "adding: mem time72, current time 104, horizon 32\n", - "adding: mem time73, current time 104, horizon 31\n", - "adding: mem time74, current time 104, horizon 30\n", - "adding: mem time75, current time 104, horizon 29\n", - "adding: mem time76, current time 104, horizon 28\n", - "adding: mem time77, current time 104, horizon 27\n", - "adding: mem time78, current time 104, horizon 26\n", - "adding: mem time79, current time 104, horizon 25\n", - "adding: mem time80, current time 104, horizon 24\n", - "adding: mem time81, current time 104, horizon 23\n", - "adding: mem time82, current time 104, horizon 22\n", - "adding: mem time83, current time 104, horizon 21\n", - "adding: mem time84, current time 104, horizon 20\n", - "adding: mem time85, current time 104, horizon 19\n", - "adding: mem time86, current time 104, horizon 18\n", - "adding: mem time87, current time 104, horizon 17\n", - "adding: mem time88, current time 104, horizon 16\n", - "adding: mem time89, current time 104, horizon 15\n", - "adding: mem time90, current time 104, horizon 14\n", - "adding: mem time91, current time 104, horizon 13\n", - "adding: mem time92, current time 104, horizon 12\n", - "adding: mem time93, current time 104, horizon 11\n", - "adding: mem time94, current time 104, horizon 10\n", - "adding: mem time95, current time 104, horizon 9\n", - "adding: mem time96, current time 104, horizon 8\n", - "adding: mem time97, current time 104, horizon 7\n", - "adding: mem time98, current time 104, horizon 6\n", - "adding: mem time99, current time 104, horizon 5\n", - "adding: mem time100, current time 104, horizon 4\n", - "adding: mem time101, current time 104, horizon 3\n", - "adding: mem time102, current time 104, horizon 2\n", - "adding: mem time103, current time 104, horizon 1\n", - "adding: mem time0, current time 105, horizon 105\n", - "adding: mem time1, current time 105, horizon 104\n", - "adding: mem time2, current time 105, horizon 103\n", - "adding: mem time3, current time 105, horizon 102\n", - "adding: mem time4, current time 105, horizon 101\n", - "adding: mem time5, current time 105, horizon 100\n", - "adding: mem time6, current time 105, horizon 99\n", - "adding: mem time7, current time 105, horizon 98\n", - "adding: mem time8, current time 105, horizon 97\n", - "adding: mem time9, current time 105, horizon 96\n", - "adding: mem time10, current time 105, horizon 95\n", - "adding: mem time11, current time 105, horizon 94\n", - "adding: mem time12, current time 105, horizon 93\n", - "adding: mem time13, current time 105, horizon 92\n", - "adding: mem time14, current time 105, horizon 91\n", - "adding: mem time15, current time 105, horizon 90\n", - "adding: mem time16, current time 105, horizon 89\n", - "adding: mem time17, current time 105, horizon 88\n", - "adding: mem time18, current time 105, horizon 87\n", - "adding: mem time19, current time 105, horizon 86\n", - "adding: mem time20, current time 105, horizon 85\n", - "adding: mem time21, current time 105, horizon 84\n", - "adding: mem time22, current time 105, horizon 83\n", - "adding: mem time23, current time 105, horizon 82\n", - "adding: mem time24, current time 105, horizon 81\n", - "adding: mem time25, current time 105, horizon 80\n", - "adding: mem time26, current time 105, horizon 79\n", - "adding: mem time27, current time 105, horizon 78\n", - "adding: mem time28, current time 105, horizon 77\n", - "adding: mem time29, current time 105, horizon 76\n", - "adding: mem time30, current time 105, horizon 75\n", - "adding: mem time31, current time 105, horizon 74\n", - "adding: mem time32, current time 105, horizon 73\n", - "adding: mem time33, current time 105, horizon 72\n", - "adding: mem time34, current time 105, horizon 71\n", - "adding: mem time35, current time 105, horizon 70\n", - "adding: mem time36, current time 105, horizon 69\n", - "adding: mem time37, current time 105, horizon 68\n", - "adding: mem time38, current time 105, horizon 67\n", - "adding: mem time39, current time 105, horizon 66\n", - "adding: mem time40, current time 105, horizon 65\n", - "adding: mem time41, current time 105, horizon 64\n", - "adding: mem time42, current time 105, horizon 63\n", - "adding: mem time43, current time 105, horizon 62\n", - "adding: mem time44, current time 105, horizon 61\n", - "adding: mem time45, current time 105, horizon 60\n", - "adding: mem time46, current time 105, horizon 59\n", - "adding: mem time47, current time 105, horizon 58\n", - "adding: mem time48, current time 105, horizon 57\n", - "adding: mem time49, current time 105, horizon 56\n", - "adding: mem time50, current time 105, horizon 55\n", - "adding: mem time51, current time 105, horizon 54\n", - "adding: mem time52, current time 105, horizon 53\n", - "adding: mem time53, current time 105, horizon 52\n", - "adding: mem time54, current time 105, horizon 51\n", - "adding: mem time55, current time 105, horizon 50\n", - "adding: mem time56, current time 105, horizon 49\n", - "adding: mem time57, current time 105, horizon 48\n", - "adding: mem time58, current time 105, horizon 47\n", - "adding: mem time59, current time 105, horizon 46\n", - "adding: mem time60, current time 105, horizon 45\n", - "adding: mem time61, current time 105, horizon 44\n", - "adding: mem time62, current time 105, horizon 43\n", - "adding: mem time63, current time 105, horizon 42\n", - "adding: mem time64, current time 105, horizon 41\n", - "adding: mem time65, current time 105, horizon 40\n", - "adding: mem time66, current time 105, horizon 39\n", - "adding: mem time67, current time 105, horizon 38\n", - "adding: mem time68, current time 105, horizon 37\n", - "adding: mem time69, current time 105, horizon 36\n", - "adding: mem time70, current time 105, horizon 35\n", - "adding: mem time71, current time 105, horizon 34\n", - "adding: mem time72, current time 105, horizon 33\n", - "adding: mem time73, current time 105, horizon 32\n", - "adding: mem time74, current time 105, horizon 31\n", - "adding: mem time75, current time 105, horizon 30\n", - "adding: mem time76, current time 105, horizon 29\n", - "adding: mem time77, current time 105, horizon 28\n", - "adding: mem time78, current time 105, horizon 27\n", - "adding: mem time79, current time 105, horizon 26\n", - "adding: mem time80, current time 105, horizon 25\n", - "adding: mem time81, current time 105, horizon 24\n", - "adding: mem time82, current time 105, horizon 23\n", - "adding: mem time83, current time 105, horizon 22\n", - "adding: mem time84, current time 105, horizon 21\n", - "adding: mem time85, current time 105, horizon 20\n", - "adding: mem time86, current time 105, horizon 19\n", - "adding: mem time87, current time 105, horizon 18\n", - "adding: mem time88, current time 105, horizon 17\n", - "adding: mem time89, current time 105, horizon 16\n", - "adding: mem time90, current time 105, horizon 15\n", - "adding: mem time91, current time 105, horizon 14\n", - "adding: mem time92, current time 105, horizon 13\n", - "adding: mem time93, current time 105, horizon 12\n", - "adding: mem time94, current time 105, horizon 11\n", - "adding: mem time95, current time 105, horizon 10\n", - "adding: mem time96, current time 105, horizon 9\n", - "adding: mem time97, current time 105, horizon 8\n", - "adding: mem time98, current time 105, horizon 7\n", - "adding: mem time99, current time 105, horizon 6\n", - "adding: mem time100, current time 105, horizon 5\n", - "adding: mem time101, current time 105, horizon 4\n", - "adding: mem time102, current time 105, horizon 3\n", - "adding: mem time103, current time 105, horizon 2\n", - "adding: mem time104, current time 105, horizon 1\n", - "adding: mem time0, current time 106, horizon 106\n", - "adding: mem time1, current time 106, horizon 105\n", - "adding: mem time2, current time 106, horizon 104\n", - "adding: mem time3, current time 106, horizon 103\n", - "adding: mem time4, current time 106, horizon 102\n", - "adding: mem time5, current time 106, horizon 101\n", - "adding: mem time6, current time 106, horizon 100\n", - "adding: mem time7, current time 106, horizon 99\n", - "adding: mem time8, current time 106, horizon 98\n", - "adding: mem time9, current time 106, horizon 97\n", - "adding: mem time10, current time 106, horizon 96\n", - "adding: mem time11, current time 106, horizon 95\n", - "adding: mem time12, current time 106, horizon 94\n", - "adding: mem time13, current time 106, horizon 93\n", - "adding: mem time14, current time 106, horizon 92\n", - "adding: mem time15, current time 106, horizon 91\n", - "adding: mem time16, current time 106, horizon 90\n", - "adding: mem time17, current time 106, horizon 89\n", - "adding: mem time18, current time 106, horizon 88\n", - "adding: mem time19, current time 106, horizon 87\n", - "adding: mem time20, current time 106, horizon 86\n", - "adding: mem time21, current time 106, horizon 85\n", - "adding: mem time22, current time 106, horizon 84\n", - "adding: mem time23, current time 106, horizon 83\n", - "adding: mem time24, current time 106, horizon 82\n", - "adding: mem time25, current time 106, horizon 81\n", - "adding: mem time26, current time 106, horizon 80\n", - "adding: mem time27, current time 106, horizon 79\n", - "adding: mem time28, current time 106, horizon 78\n", - "adding: mem time29, current time 106, horizon 77\n", - "adding: mem time30, current time 106, horizon 76\n", - "adding: mem time31, current time 106, horizon 75\n", - "adding: mem time32, current time 106, horizon 74\n", - "adding: mem time33, current time 106, horizon 73\n", - "adding: mem time34, current time 106, horizon 72\n", - "adding: mem time35, current time 106, horizon 71\n", - "adding: mem time36, current time 106, horizon 70\n", - "adding: mem time37, current time 106, horizon 69\n", - "adding: mem time38, current time 106, horizon 68\n", - "adding: mem time39, current time 106, horizon 67\n", - "adding: mem time40, current time 106, horizon 66\n", - "adding: mem time41, current time 106, horizon 65\n", - "adding: mem time42, current time 106, horizon 64\n", - "adding: mem time43, current time 106, horizon 63\n", - "adding: mem time44, current time 106, horizon 62\n", - "adding: mem time45, current time 106, horizon 61\n", - "adding: mem time46, current time 106, horizon 60\n", - "adding: mem time47, current time 106, horizon 59\n", - "adding: mem time48, current time 106, horizon 58\n", - "adding: mem time49, current time 106, horizon 57\n", - "adding: mem time50, current time 106, horizon 56\n", - "adding: mem time51, current time 106, horizon 55\n", - "adding: mem time52, current time 106, horizon 54\n", - "adding: mem time53, current time 106, horizon 53\n", - "adding: mem time54, current time 106, horizon 52\n", - "adding: mem time55, current time 106, horizon 51\n", - "adding: mem time56, current time 106, horizon 50\n", - "adding: mem time57, current time 106, horizon 49\n", - "adding: mem time58, current time 106, horizon 48\n", - "adding: mem time59, current time 106, horizon 47\n", - "adding: mem time60, current time 106, horizon 46\n", - "adding: mem time61, current time 106, horizon 45\n", - "adding: mem time62, current time 106, horizon 44\n", - "adding: mem time63, current time 106, horizon 43\n", - "adding: mem time64, current time 106, horizon 42\n", - "adding: mem time65, current time 106, horizon 41\n", - "adding: mem time66, current time 106, horizon 40\n", - "adding: mem time67, current time 106, horizon 39\n", - "adding: mem time68, current time 106, horizon 38\n", - "adding: mem time69, current time 106, horizon 37\n", - "adding: mem time70, current time 106, horizon 36\n", - "adding: mem time71, current time 106, horizon 35\n", - "adding: mem time72, current time 106, horizon 34\n", - "adding: mem time73, current time 106, horizon 33\n", - "adding: mem time74, current time 106, horizon 32\n", - "adding: mem time75, current time 106, horizon 31\n", - "adding: mem time76, current time 106, horizon 30\n", - "adding: mem time77, current time 106, horizon 29\n", - "adding: mem time78, current time 106, horizon 28\n", - "adding: mem time79, current time 106, horizon 27\n", - "adding: mem time80, current time 106, horizon 26\n", - "adding: mem time81, current time 106, horizon 25\n", - "adding: mem time82, current time 106, horizon 24\n", - "adding: mem time83, current time 106, horizon 23\n", - "adding: mem time84, current time 106, horizon 22\n", - "adding: mem time85, current time 106, horizon 21\n", - "adding: mem time86, current time 106, horizon 20\n", - "adding: mem time87, current time 106, horizon 19\n", - "adding: mem time88, current time 106, horizon 18\n", - "adding: mem time89, current time 106, horizon 17\n", - "adding: mem time90, current time 106, horizon 16\n", - "adding: mem time91, current time 106, horizon 15\n", - "adding: mem time92, current time 106, horizon 14\n", - "adding: mem time93, current time 106, horizon 13\n", - "adding: mem time94, current time 106, horizon 12\n", - "adding: mem time95, current time 106, horizon 11\n", - "adding: mem time96, current time 106, horizon 10\n", - "adding: mem time97, current time 106, horizon 9\n", - "adding: mem time98, current time 106, horizon 8\n", - "adding: mem time99, current time 106, horizon 7\n", - "adding: mem time100, current time 106, horizon 6\n", - "adding: mem time101, current time 106, horizon 5\n", - "adding: mem time102, current time 106, horizon 4\n", - "adding: mem time103, current time 106, horizon 3\n", - "adding: mem time104, current time 106, horizon 2\n", - "adding: mem time105, current time 106, horizon 1\n", - "adding: mem time0, current time 107, horizon 107\n", - "adding: mem time1, current time 107, horizon 106\n", - "adding: mem time2, current time 107, horizon 105\n", - "adding: mem time3, current time 107, horizon 104\n", - "adding: mem time4, current time 107, horizon 103\n", - "adding: mem time5, current time 107, horizon 102\n", - "adding: mem time6, current time 107, horizon 101\n", - "adding: mem time7, current time 107, horizon 100\n", - "adding: mem time8, current time 107, horizon 99\n", - "adding: mem time9, current time 107, horizon 98\n", - "adding: mem time10, current time 107, horizon 97\n", - "adding: mem time11, current time 107, horizon 96\n", - "adding: mem time12, current time 107, horizon 95\n", - "adding: mem time13, current time 107, horizon 94\n", - "adding: mem time14, current time 107, horizon 93\n", - "adding: mem time15, current time 107, horizon 92\n", - "adding: mem time16, current time 107, horizon 91\n", - "adding: mem time17, current time 107, horizon 90\n", - "adding: mem time18, current time 107, horizon 89\n", - "adding: mem time19, current time 107, horizon 88\n", - "adding: mem time20, current time 107, horizon 87\n", - "adding: mem time21, current time 107, horizon 86\n", - "adding: mem time22, current time 107, horizon 85\n", - "adding: mem time23, current time 107, horizon 84\n", - "adding: mem time24, current time 107, horizon 83\n", - "adding: mem time25, current time 107, horizon 82\n", - "adding: mem time26, current time 107, horizon 81\n", - "adding: mem time27, current time 107, horizon 80\n", - "adding: mem time28, current time 107, horizon 79\n", - "adding: mem time29, current time 107, horizon 78\n", - "adding: mem time30, current time 107, horizon 77\n", - "adding: mem time31, current time 107, horizon 76\n", - "adding: mem time32, current time 107, horizon 75\n", - "adding: mem time33, current time 107, horizon 74\n", - "adding: mem time34, current time 107, horizon 73\n", - "adding: mem time35, current time 107, horizon 72\n", - "adding: mem time36, current time 107, horizon 71\n", - "adding: mem time37, current time 107, horizon 70\n", - "adding: mem time38, current time 107, horizon 69\n", - "adding: mem time39, current time 107, horizon 68\n", - "adding: mem time40, current time 107, horizon 67\n", - "adding: mem time41, current time 107, horizon 66\n", - "adding: mem time42, current time 107, horizon 65\n", - "adding: mem time43, current time 107, horizon 64\n", - "adding: mem time44, current time 107, horizon 63\n", - "adding: mem time45, current time 107, horizon 62\n", - "adding: mem time46, current time 107, horizon 61\n", - "adding: mem time47, current time 107, horizon 60\n", - "adding: mem time48, current time 107, horizon 59\n", - "adding: mem time49, current time 107, horizon 58\n", - "adding: mem time50, current time 107, horizon 57\n", - "adding: mem time51, current time 107, horizon 56\n", - "adding: mem time52, current time 107, horizon 55\n", - "adding: mem time53, current time 107, horizon 54\n", - "adding: mem time54, current time 107, horizon 53\n", - "adding: mem time55, current time 107, horizon 52\n", - "adding: mem time56, current time 107, horizon 51\n", - "adding: mem time57, current time 107, horizon 50\n", - "adding: mem time58, current time 107, horizon 49\n", - "adding: mem time59, current time 107, horizon 48\n", - "adding: mem time60, current time 107, horizon 47\n", - "adding: mem time61, current time 107, horizon 46\n", - "adding: mem time62, current time 107, horizon 45\n", - "adding: mem time63, current time 107, horizon 44\n", - "adding: mem time64, current time 107, horizon 43\n", - "adding: mem time65, current time 107, horizon 42\n", - "adding: mem time66, current time 107, horizon 41\n", - "adding: mem time67, current time 107, horizon 40\n", - "adding: mem time68, current time 107, horizon 39\n", - "adding: mem time69, current time 107, horizon 38\n", - "adding: mem time70, current time 107, horizon 37\n", - "adding: mem time71, current time 107, horizon 36\n", - "adding: mem time72, current time 107, horizon 35\n", - "adding: mem time73, current time 107, horizon 34\n", - "adding: mem time74, current time 107, horizon 33\n", - "adding: mem time75, current time 107, horizon 32\n", - "adding: mem time76, current time 107, horizon 31\n", - "adding: mem time77, current time 107, horizon 30\n", - "adding: mem time78, current time 107, horizon 29\n", - "adding: mem time79, current time 107, horizon 28\n", - "adding: mem time80, current time 107, horizon 27\n", - "adding: mem time81, current time 107, horizon 26\n", - "adding: mem time82, current time 107, horizon 25\n", - "adding: mem time83, current time 107, horizon 24\n", - "adding: mem time84, current time 107, horizon 23\n", - "adding: mem time85, current time 107, horizon 22\n", - "adding: mem time86, current time 107, horizon 21\n", - "adding: mem time87, current time 107, horizon 20\n", - "adding: mem time88, current time 107, horizon 19\n", - "adding: mem time89, current time 107, horizon 18\n", - "adding: mem time90, current time 107, horizon 17\n", - "adding: mem time91, current time 107, horizon 16\n", - "adding: mem time92, current time 107, horizon 15\n", - "adding: mem time93, current time 107, horizon 14\n", - "adding: mem time94, current time 107, horizon 13\n", - "adding: mem time95, current time 107, horizon 12\n", - "adding: mem time96, current time 107, horizon 11\n", - "adding: mem time97, current time 107, horizon 10\n", - "adding: mem time98, current time 107, horizon 9\n", - "adding: mem time99, current time 107, horizon 8\n", - "adding: mem time100, current time 107, horizon 7\n", - "adding: mem time101, current time 107, horizon 6\n", - "adding: mem time102, current time 107, horizon 5\n", - "adding: mem time103, current time 107, horizon 4\n", - "adding: mem time104, current time 107, horizon 3\n", - "adding: mem time105, current time 107, horizon 2\n", - "adding: mem time106, current time 107, horizon 1\n", - "adding: mem time0, current time 108, horizon 108\n", - "adding: mem time1, current time 108, horizon 107\n", - "adding: mem time2, current time 108, horizon 106\n", - "adding: mem time3, current time 108, horizon 105\n", - "adding: mem time4, current time 108, horizon 104\n", - "adding: mem time5, current time 108, horizon 103\n", - "adding: mem time6, current time 108, horizon 102\n", - "adding: mem time7, current time 108, horizon 101\n", - "adding: mem time8, current time 108, horizon 100\n", - "adding: mem time9, current time 108, horizon 99\n", - "adding: mem time10, current time 108, horizon 98\n", - "adding: mem time11, current time 108, horizon 97\n", - "adding: mem time12, current time 108, horizon 96\n", - "adding: mem time13, current time 108, horizon 95\n", - "adding: mem time14, current time 108, horizon 94\n", - "adding: mem time15, current time 108, horizon 93\n", - "adding: mem time16, current time 108, horizon 92\n", - "adding: mem time17, current time 108, horizon 91\n", - "adding: mem time18, current time 108, horizon 90\n", - "adding: mem time19, current time 108, horizon 89\n", - "adding: mem time20, current time 108, horizon 88\n", - "adding: mem time21, current time 108, horizon 87\n", - "adding: mem time22, current time 108, horizon 86\n", - "adding: mem time23, current time 108, horizon 85\n", - "adding: mem time24, current time 108, horizon 84\n", - "adding: mem time25, current time 108, horizon 83\n", - "adding: mem time26, current time 108, horizon 82\n", - "adding: mem time27, current time 108, horizon 81\n", - "adding: mem time28, current time 108, horizon 80\n", - "adding: mem time29, current time 108, horizon 79\n", - "adding: mem time30, current time 108, horizon 78\n", - "adding: mem time31, current time 108, horizon 77\n", - "adding: mem time32, current time 108, horizon 76\n", - "adding: mem time33, current time 108, horizon 75\n", - "adding: mem time34, current time 108, horizon 74\n", - "adding: mem time35, current time 108, horizon 73\n", - "adding: mem time36, current time 108, horizon 72\n", - "adding: mem time37, current time 108, horizon 71\n", - "adding: mem time38, current time 108, horizon 70\n", - "adding: mem time39, current time 108, horizon 69\n", - "adding: mem time40, current time 108, horizon 68\n", - "adding: mem time41, current time 108, horizon 67\n", - "adding: mem time42, current time 108, horizon 66\n", - "adding: mem time43, current time 108, horizon 65\n", - "adding: mem time44, current time 108, horizon 64\n", - "adding: mem time45, current time 108, horizon 63\n", - "adding: mem time46, current time 108, horizon 62\n", - "adding: mem time47, current time 108, horizon 61\n", - "adding: mem time48, current time 108, horizon 60\n", - "adding: mem time49, current time 108, horizon 59\n", - "adding: mem time50, current time 108, horizon 58\n", - "adding: mem time51, current time 108, horizon 57\n", - "adding: mem time52, current time 108, horizon 56\n", - "adding: mem time53, current time 108, horizon 55\n", - "adding: mem time54, current time 108, horizon 54\n", - "adding: mem time55, current time 108, horizon 53\n", - "adding: mem time56, current time 108, horizon 52\n", - "adding: mem time57, current time 108, horizon 51\n", - "adding: mem time58, current time 108, horizon 50\n", - "adding: mem time59, current time 108, horizon 49\n", - "adding: mem time60, current time 108, horizon 48\n", - "adding: mem time61, current time 108, horizon 47\n", - "adding: mem time62, current time 108, horizon 46\n", - "adding: mem time63, current time 108, horizon 45\n", - "adding: mem time64, current time 108, horizon 44\n", - "adding: mem time65, current time 108, horizon 43\n", - "adding: mem time66, current time 108, horizon 42\n", - "adding: mem time67, current time 108, horizon 41\n", - "adding: mem time68, current time 108, horizon 40\n", - "adding: mem time69, current time 108, horizon 39\n", - "adding: mem time70, current time 108, horizon 38\n", - "adding: mem time71, current time 108, horizon 37\n", - "adding: mem time72, current time 108, horizon 36\n", - "adding: mem time73, current time 108, horizon 35\n", - "adding: mem time74, current time 108, horizon 34\n", - "adding: mem time75, current time 108, horizon 33\n", - "adding: mem time76, current time 108, horizon 32\n", - "adding: mem time77, current time 108, horizon 31\n", - "adding: mem time78, current time 108, horizon 30\n", - "adding: mem time79, current time 108, horizon 29\n", - "adding: mem time80, current time 108, horizon 28\n", - "adding: mem time81, current time 108, horizon 27\n", - "adding: mem time82, current time 108, horizon 26\n", - "adding: mem time83, current time 108, horizon 25\n", - "adding: mem time84, current time 108, horizon 24\n", - "adding: mem time85, current time 108, horizon 23\n", - "adding: mem time86, current time 108, horizon 22\n", - "adding: mem time87, current time 108, horizon 21\n", - "adding: mem time88, current time 108, horizon 20\n", - "adding: mem time89, current time 108, horizon 19\n", - "adding: mem time90, current time 108, horizon 18\n", - "adding: mem time91, current time 108, horizon 17\n", - "adding: mem time92, current time 108, horizon 16\n", - "adding: mem time93, current time 108, horizon 15\n", - "adding: mem time94, current time 108, horizon 14\n", - "adding: mem time95, current time 108, horizon 13\n", - "adding: mem time96, current time 108, horizon 12\n", - "adding: mem time97, current time 108, horizon 11\n", - "adding: mem time98, current time 108, horizon 10\n", - "adding: mem time99, current time 108, horizon 9\n", - "adding: mem time100, current time 108, horizon 8\n", - "adding: mem time101, current time 108, horizon 7\n", - "adding: mem time102, current time 108, horizon 6\n", - "adding: mem time103, current time 108, horizon 5\n", - "adding: mem time104, current time 108, horizon 4\n", - "adding: mem time105, current time 108, horizon 3\n", - "adding: mem time106, current time 108, horizon 2\n", - "adding: mem time107, current time 108, horizon 1\n", - "adding: mem time0, current time 109, horizon 109\n", - "adding: mem time1, current time 109, horizon 108\n", - "adding: mem time2, current time 109, horizon 107\n", - "adding: mem time3, current time 109, horizon 106\n", - "adding: mem time4, current time 109, horizon 105\n", - "adding: mem time5, current time 109, horizon 104\n", - "adding: mem time6, current time 109, horizon 103\n", - "adding: mem time7, current time 109, horizon 102\n", - "adding: mem time8, current time 109, horizon 101\n", - "adding: mem time9, current time 109, horizon 100\n", - "adding: mem time10, current time 109, horizon 99\n", - "adding: mem time11, current time 109, horizon 98\n", - "adding: mem time12, current time 109, horizon 97\n", - "adding: mem time13, current time 109, horizon 96\n", - "adding: mem time14, current time 109, horizon 95\n", - "adding: mem time15, current time 109, horizon 94\n", - "adding: mem time16, current time 109, horizon 93\n", - "adding: mem time17, current time 109, horizon 92\n", - "adding: mem time18, current time 109, horizon 91\n", - "adding: mem time19, current time 109, horizon 90\n", - "adding: mem time20, current time 109, horizon 89\n", - "adding: mem time21, current time 109, horizon 88\n", - "adding: mem time22, current time 109, horizon 87\n", - "adding: mem time23, current time 109, horizon 86\n", - "adding: mem time24, current time 109, horizon 85\n", - "adding: mem time25, current time 109, horizon 84\n", - "adding: mem time26, current time 109, horizon 83\n", - "adding: mem time27, current time 109, horizon 82\n", - "adding: mem time28, current time 109, horizon 81\n", - "adding: mem time29, current time 109, horizon 80\n", - "adding: mem time30, current time 109, horizon 79\n", - "adding: mem time31, current time 109, horizon 78\n", - "adding: mem time32, current time 109, horizon 77\n", - "adding: mem time33, current time 109, horizon 76\n", - "adding: mem time34, current time 109, horizon 75\n", - "adding: mem time35, current time 109, horizon 74\n", - "adding: mem time36, current time 109, horizon 73\n", - "adding: mem time37, current time 109, horizon 72\n", - "adding: mem time38, current time 109, horizon 71\n", - "adding: mem time39, current time 109, horizon 70\n", - "adding: mem time40, current time 109, horizon 69\n", - "adding: mem time41, current time 109, horizon 68\n", - "adding: mem time42, current time 109, horizon 67\n", - "adding: mem time43, current time 109, horizon 66\n", - "adding: mem time44, current time 109, horizon 65\n", - "adding: mem time45, current time 109, horizon 64\n", - "adding: mem time46, current time 109, horizon 63\n", - "adding: mem time47, current time 109, horizon 62\n", - "adding: mem time48, current time 109, horizon 61\n", - "adding: mem time49, current time 109, horizon 60\n", - "adding: mem time50, current time 109, horizon 59\n", - "adding: mem time51, current time 109, horizon 58\n", - "adding: mem time52, current time 109, horizon 57\n", - "adding: mem time53, current time 109, horizon 56\n", - "adding: mem time54, current time 109, horizon 55\n", - "adding: mem time55, current time 109, horizon 54\n", - "adding: mem time56, current time 109, horizon 53\n", - "adding: mem time57, current time 109, horizon 52\n", - "adding: mem time58, current time 109, horizon 51\n", - "adding: mem time59, current time 109, horizon 50\n", - "adding: mem time60, current time 109, horizon 49\n", - "adding: mem time61, current time 109, horizon 48\n", - "adding: mem time62, current time 109, horizon 47\n", - "adding: mem time63, current time 109, horizon 46\n", - "adding: mem time64, current time 109, horizon 45\n", - "adding: mem time65, current time 109, horizon 44\n", - "adding: mem time66, current time 109, horizon 43\n", - "adding: mem time67, current time 109, horizon 42\n", - "adding: mem time68, current time 109, horizon 41\n", - "adding: mem time69, current time 109, horizon 40\n", - "adding: mem time70, current time 109, horizon 39\n", - "adding: mem time71, current time 109, horizon 38\n", - "adding: mem time72, current time 109, horizon 37\n", - "adding: mem time73, current time 109, horizon 36\n", - "adding: mem time74, current time 109, horizon 35\n", - "adding: mem time75, current time 109, horizon 34\n", - "adding: mem time76, current time 109, horizon 33\n", - "adding: mem time77, current time 109, horizon 32\n", - "adding: mem time78, current time 109, horizon 31\n", - "adding: mem time79, current time 109, horizon 30\n", - "adding: mem time80, current time 109, horizon 29\n", - "adding: mem time81, current time 109, horizon 28\n", - "adding: mem time82, current time 109, horizon 27\n", - "adding: mem time83, current time 109, horizon 26\n", - "adding: mem time84, current time 109, horizon 25\n", - "adding: mem time85, current time 109, horizon 24\n", - "adding: mem time86, current time 109, horizon 23\n", - "adding: mem time87, current time 109, horizon 22\n", - "adding: mem time88, current time 109, horizon 21\n", - "adding: mem time89, current time 109, horizon 20\n", - "adding: mem time90, current time 109, horizon 19\n", - "adding: mem time91, current time 109, horizon 18\n", - "adding: mem time92, current time 109, horizon 17\n", - "adding: mem time93, current time 109, horizon 16\n", - "adding: mem time94, current time 109, horizon 15\n", - "adding: mem time95, current time 109, horizon 14\n", - "adding: mem time96, current time 109, horizon 13\n", - "adding: mem time97, current time 109, horizon 12\n", - "adding: mem time98, current time 109, horizon 11\n", - "adding: mem time99, current time 109, horizon 10\n", - "adding: mem time100, current time 109, horizon 9\n", - "adding: mem time101, current time 109, horizon 8\n", - "adding: mem time102, current time 109, horizon 7\n", - "adding: mem time103, current time 109, horizon 6\n", - "adding: mem time104, current time 109, horizon 5\n", - "adding: mem time105, current time 109, horizon 4\n", - "adding: mem time106, current time 109, horizon 3\n", - "adding: mem time107, current time 109, horizon 2\n", - "adding: mem time108, current time 109, horizon 1\n", - "adding: mem time0, current time 110, horizon 110\n", - "adding: mem time1, current time 110, horizon 109\n", - "adding: mem time2, current time 110, horizon 108\n", - "adding: mem time3, current time 110, horizon 107\n", - "adding: mem time4, current time 110, horizon 106\n", - "adding: mem time5, current time 110, horizon 105\n", - "adding: mem time6, current time 110, horizon 104\n", - "adding: mem time7, current time 110, horizon 103\n", - "adding: mem time8, current time 110, horizon 102\n", - "adding: mem time9, current time 110, horizon 101\n", - "adding: mem time10, current time 110, horizon 100\n", - "adding: mem time11, current time 110, horizon 99\n", - "adding: mem time12, current time 110, horizon 98\n", - "adding: mem time13, current time 110, horizon 97\n", - "adding: mem time14, current time 110, horizon 96\n", - "adding: mem time15, current time 110, horizon 95\n", - "adding: mem time16, current time 110, horizon 94\n", - "adding: mem time17, current time 110, horizon 93\n", - "adding: mem time18, current time 110, horizon 92\n", - "adding: mem time19, current time 110, horizon 91\n", - "adding: mem time20, current time 110, horizon 90\n", - "adding: mem time21, current time 110, horizon 89\n", - "adding: mem time22, current time 110, horizon 88\n", - "adding: mem time23, current time 110, horizon 87\n", - "adding: mem time24, current time 110, horizon 86\n", - "adding: mem time25, current time 110, horizon 85\n", - "adding: mem time26, current time 110, horizon 84\n", - "adding: mem time27, current time 110, horizon 83\n", - "adding: mem time28, current time 110, horizon 82\n", - "adding: mem time29, current time 110, horizon 81\n", - "adding: mem time30, current time 110, horizon 80\n", - "adding: mem time31, current time 110, horizon 79\n", - "adding: mem time32, current time 110, horizon 78\n", - "adding: mem time33, current time 110, horizon 77\n", - "adding: mem time34, current time 110, horizon 76\n", - "adding: mem time35, current time 110, horizon 75\n", - "adding: mem time36, current time 110, horizon 74\n", - "adding: mem time37, current time 110, horizon 73\n", - "adding: mem time38, current time 110, horizon 72\n", - "adding: mem time39, current time 110, horizon 71\n", - "adding: mem time40, current time 110, horizon 70\n", - "adding: mem time41, current time 110, horizon 69\n", - "adding: mem time42, current time 110, horizon 68\n", - "adding: mem time43, current time 110, horizon 67\n", - "adding: mem time44, current time 110, horizon 66\n", - "adding: mem time45, current time 110, horizon 65\n", - "adding: mem time46, current time 110, horizon 64\n", - "adding: mem time47, current time 110, horizon 63\n", - "adding: mem time48, current time 110, horizon 62\n", - "adding: mem time49, current time 110, horizon 61\n", - "adding: mem time50, current time 110, horizon 60\n", - "adding: mem time51, current time 110, horizon 59\n", - "adding: mem time52, current time 110, horizon 58\n", - "adding: mem time53, current time 110, horizon 57\n", - "adding: mem time54, current time 110, horizon 56\n", - "adding: mem time55, current time 110, horizon 55\n", - "adding: mem time56, current time 110, horizon 54\n", - "adding: mem time57, current time 110, horizon 53\n", - "adding: mem time58, current time 110, horizon 52\n", - "adding: mem time59, current time 110, horizon 51\n", - "adding: mem time60, current time 110, horizon 50\n", - "adding: mem time61, current time 110, horizon 49\n", - "adding: mem time62, current time 110, horizon 48\n", - "adding: mem time63, current time 110, horizon 47\n", - "adding: mem time64, current time 110, horizon 46\n", - "adding: mem time65, current time 110, horizon 45\n", - "adding: mem time66, current time 110, horizon 44\n", - "adding: mem time67, current time 110, horizon 43\n", - "adding: mem time68, current time 110, horizon 42\n", - "adding: mem time69, current time 110, horizon 41\n", - "adding: mem time70, current time 110, horizon 40\n", - "adding: mem time71, current time 110, horizon 39\n", - "adding: mem time72, current time 110, horizon 38\n", - "adding: mem time73, current time 110, horizon 37\n", - "adding: mem time74, current time 110, horizon 36\n", - "adding: mem time75, current time 110, horizon 35\n", - "adding: mem time76, current time 110, horizon 34\n", - "adding: mem time77, current time 110, horizon 33\n", - "adding: mem time78, current time 110, horizon 32\n", - "adding: mem time79, current time 110, horizon 31\n", - "adding: mem time80, current time 110, horizon 30\n", - "adding: mem time81, current time 110, horizon 29\n", - "adding: mem time82, current time 110, horizon 28\n", - "adding: mem time83, current time 110, horizon 27\n", - "adding: mem time84, current time 110, horizon 26\n", - "adding: mem time85, current time 110, horizon 25\n", - "adding: mem time86, current time 110, horizon 24\n", - "adding: mem time87, current time 110, horizon 23\n", - "adding: mem time88, current time 110, horizon 22\n", - "adding: mem time89, current time 110, horizon 21\n", - "adding: mem time90, current time 110, horizon 20\n", - "adding: mem time91, current time 110, horizon 19\n", - "adding: mem time92, current time 110, horizon 18\n", - "adding: mem time93, current time 110, horizon 17\n", - "adding: mem time94, current time 110, horizon 16\n", - "adding: mem time95, current time 110, horizon 15\n", - "adding: mem time96, current time 110, horizon 14\n", - "adding: mem time97, current time 110, horizon 13\n", - "adding: mem time98, current time 110, horizon 12\n", - "adding: mem time99, current time 110, horizon 11\n", - "adding: mem time100, current time 110, horizon 10\n", - "adding: mem time101, current time 110, horizon 9\n", - "adding: mem time102, current time 110, horizon 8\n", - "adding: mem time103, current time 110, horizon 7\n", - "adding: mem time104, current time 110, horizon 6\n", - "adding: mem time105, current time 110, horizon 5\n", - "adding: mem time106, current time 110, horizon 4\n", - "adding: mem time107, current time 110, horizon 3\n", - "adding: mem time108, current time 110, horizon 2\n", - "adding: mem time109, current time 110, horizon 1\n", - "adding: mem time0, current time 111, horizon 111\n", - "adding: mem time1, current time 111, horizon 110\n", - "adding: mem time2, current time 111, horizon 109\n", - "adding: mem time3, current time 111, horizon 108\n", - "adding: mem time4, current time 111, horizon 107\n", - "adding: mem time5, current time 111, horizon 106\n", - "adding: mem time6, current time 111, horizon 105\n", - "adding: mem time7, current time 111, horizon 104\n", - "adding: mem time8, current time 111, horizon 103\n", - "adding: mem time9, current time 111, horizon 102\n", - "adding: mem time10, current time 111, horizon 101\n", - "adding: mem time11, current time 111, horizon 100\n", - "adding: mem time12, current time 111, horizon 99\n", - "adding: mem time13, current time 111, horizon 98\n", - "adding: mem time14, current time 111, horizon 97\n", - "adding: mem time15, current time 111, horizon 96\n", - "adding: mem time16, current time 111, horizon 95\n", - "adding: mem time17, current time 111, horizon 94\n", - "adding: mem time18, current time 111, horizon 93\n", - "adding: mem time19, current time 111, horizon 92\n", - "adding: mem time20, current time 111, horizon 91\n", - "adding: mem time21, current time 111, horizon 90\n", - "adding: mem time22, current time 111, horizon 89\n", - "adding: mem time23, current time 111, horizon 88\n", - "adding: mem time24, current time 111, horizon 87\n", - "adding: mem time25, current time 111, horizon 86\n", - "adding: mem time26, current time 111, horizon 85\n", - "adding: mem time27, current time 111, horizon 84\n", - "adding: mem time28, current time 111, horizon 83\n", - "adding: mem time29, current time 111, horizon 82\n", - "adding: mem time30, current time 111, horizon 81\n", - "adding: mem time31, current time 111, horizon 80\n", - "adding: mem time32, current time 111, horizon 79\n", - "adding: mem time33, current time 111, horizon 78\n", - "adding: mem time34, current time 111, horizon 77\n", - "adding: mem time35, current time 111, horizon 76\n", - "adding: mem time36, current time 111, horizon 75\n", - "adding: mem time37, current time 111, horizon 74\n", - "adding: mem time38, current time 111, horizon 73\n", - "adding: mem time39, current time 111, horizon 72\n", - "adding: mem time40, current time 111, horizon 71\n", - "adding: mem time41, current time 111, horizon 70\n", - "adding: mem time42, current time 111, horizon 69\n", - "adding: mem time43, current time 111, horizon 68\n", - "adding: mem time44, current time 111, horizon 67\n", - "adding: mem time45, current time 111, horizon 66\n", - "adding: mem time46, current time 111, horizon 65\n", - "adding: mem time47, current time 111, horizon 64\n", - "adding: mem time48, current time 111, horizon 63\n", - "adding: mem time49, current time 111, horizon 62\n", - "adding: mem time50, current time 111, horizon 61\n", - "adding: mem time51, current time 111, horizon 60\n", - "adding: mem time52, current time 111, horizon 59\n", - "adding: mem time53, current time 111, horizon 58\n", - "adding: mem time54, current time 111, horizon 57\n", - "adding: mem time55, current time 111, horizon 56\n", - "adding: mem time56, current time 111, horizon 55\n", - "adding: mem time57, current time 111, horizon 54\n", - "adding: mem time58, current time 111, horizon 53\n", - "adding: mem time59, current time 111, horizon 52\n", - "adding: mem time60, current time 111, horizon 51\n", - "adding: mem time61, current time 111, horizon 50\n", - "adding: mem time62, current time 111, horizon 49\n", - "adding: mem time63, current time 111, horizon 48\n", - "adding: mem time64, current time 111, horizon 47\n", - "adding: mem time65, current time 111, horizon 46\n", - "adding: mem time66, current time 111, horizon 45\n", - "adding: mem time67, current time 111, horizon 44\n", - "adding: mem time68, current time 111, horizon 43\n", - "adding: mem time69, current time 111, horizon 42\n", - "adding: mem time70, current time 111, horizon 41\n", - "adding: mem time71, current time 111, horizon 40\n", - "adding: mem time72, current time 111, horizon 39\n", - "adding: mem time73, current time 111, horizon 38\n", - "adding: mem time74, current time 111, horizon 37\n", - "adding: mem time75, current time 111, horizon 36\n", - "adding: mem time76, current time 111, horizon 35\n", - "adding: mem time77, current time 111, horizon 34\n", - "adding: mem time78, current time 111, horizon 33\n", - "adding: mem time79, current time 111, horizon 32\n", - "adding: mem time80, current time 111, horizon 31\n", - "adding: mem time81, current time 111, horizon 30\n", - "adding: mem time82, current time 111, horizon 29\n", - "adding: mem time83, current time 111, horizon 28\n", - "adding: mem time84, current time 111, horizon 27\n", - "adding: mem time85, current time 111, horizon 26\n", - "adding: mem time86, current time 111, horizon 25\n", - "adding: mem time87, current time 111, horizon 24\n", - "adding: mem time88, current time 111, horizon 23\n", - "adding: mem time89, current time 111, horizon 22\n", - "adding: mem time90, current time 111, horizon 21\n", - "adding: mem time91, current time 111, horizon 20\n", - "adding: mem time92, current time 111, horizon 19\n", - "adding: mem time93, current time 111, horizon 18\n", - "adding: mem time94, current time 111, horizon 17\n", - "adding: mem time95, current time 111, horizon 16\n", - "adding: mem time96, current time 111, horizon 15\n", - "adding: mem time97, current time 111, horizon 14\n", - "adding: mem time98, current time 111, horizon 13\n", - "adding: mem time99, current time 111, horizon 12\n", - "adding: mem time100, current time 111, horizon 11\n", - "adding: mem time101, current time 111, horizon 10\n", - "adding: mem time102, current time 111, horizon 9\n", - "adding: mem time103, current time 111, horizon 8\n", - "adding: mem time104, current time 111, horizon 7\n", - "adding: mem time105, current time 111, horizon 6\n", - "adding: mem time106, current time 111, horizon 5\n", - "adding: mem time107, current time 111, horizon 4\n", - "adding: mem time108, current time 111, horizon 3\n", - "adding: mem time109, current time 111, horizon 2\n", - "adding: mem time110, current time 111, horizon 1\n", - "adding: mem time0, current time 112, horizon 112\n", - "adding: mem time1, current time 112, horizon 111\n", - "adding: mem time2, current time 112, horizon 110\n", - "adding: mem time3, current time 112, horizon 109\n", - "adding: mem time4, current time 112, horizon 108\n", - "adding: mem time5, current time 112, horizon 107\n", - "adding: mem time6, current time 112, horizon 106\n", - "adding: mem time7, current time 112, horizon 105\n", - "adding: mem time8, current time 112, horizon 104\n", - "adding: mem time9, current time 112, horizon 103\n", - "adding: mem time10, current time 112, horizon 102\n", - "adding: mem time11, current time 112, horizon 101\n", - "adding: mem time12, current time 112, horizon 100\n", - "adding: mem time13, current time 112, horizon 99\n", - "adding: mem time14, current time 112, horizon 98\n", - "adding: mem time15, current time 112, horizon 97\n", - "adding: mem time16, current time 112, horizon 96\n", - "adding: mem time17, current time 112, horizon 95\n", - "adding: mem time18, current time 112, horizon 94\n", - "adding: mem time19, current time 112, horizon 93\n", - "adding: mem time20, current time 112, horizon 92\n", - "adding: mem time21, current time 112, horizon 91\n", - "adding: mem time22, current time 112, horizon 90\n", - "adding: mem time23, current time 112, horizon 89\n", - "adding: mem time24, current time 112, horizon 88\n", - "adding: mem time25, current time 112, horizon 87\n", - "adding: mem time26, current time 112, horizon 86\n", - "adding: mem time27, current time 112, horizon 85\n", - "adding: mem time28, current time 112, horizon 84\n", - "adding: mem time29, current time 112, horizon 83\n", - "adding: mem time30, current time 112, horizon 82\n", - "adding: mem time31, current time 112, horizon 81\n", - "adding: mem time32, current time 112, horizon 80\n", - "adding: mem time33, current time 112, horizon 79\n", - "adding: mem time34, current time 112, horizon 78\n", - "adding: mem time35, current time 112, horizon 77\n", - "adding: mem time36, current time 112, horizon 76\n", - "adding: mem time37, current time 112, horizon 75\n", - "adding: mem time38, current time 112, horizon 74\n", - "adding: mem time39, current time 112, horizon 73\n", - "adding: mem time40, current time 112, horizon 72\n", - "adding: mem time41, current time 112, horizon 71\n", - "adding: mem time42, current time 112, horizon 70\n", - "adding: mem time43, current time 112, horizon 69\n", - "adding: mem time44, current time 112, horizon 68\n", - "adding: mem time45, current time 112, horizon 67\n", - "adding: mem time46, current time 112, horizon 66\n", - "adding: mem time47, current time 112, horizon 65\n", - "adding: mem time48, current time 112, horizon 64\n", - "adding: mem time49, current time 112, horizon 63\n", - "adding: mem time50, current time 112, horizon 62\n", - "adding: mem time51, current time 112, horizon 61\n", - "adding: mem time52, current time 112, horizon 60\n", - "adding: mem time53, current time 112, horizon 59\n", - "adding: mem time54, current time 112, horizon 58\n", - "adding: mem time55, current time 112, horizon 57\n", - "adding: mem time56, current time 112, horizon 56\n", - "adding: mem time57, current time 112, horizon 55\n", - "adding: mem time58, current time 112, horizon 54\n", - "adding: mem time59, current time 112, horizon 53\n", - "adding: mem time60, current time 112, horizon 52\n", - "adding: mem time61, current time 112, horizon 51\n", - "adding: mem time62, current time 112, horizon 50\n", - "adding: mem time63, current time 112, horizon 49\n", - "adding: mem time64, current time 112, horizon 48\n", - "adding: mem time65, current time 112, horizon 47\n", - "adding: mem time66, current time 112, horizon 46\n", - "adding: mem time67, current time 112, horizon 45\n", - "adding: mem time68, current time 112, horizon 44\n", - "adding: mem time69, current time 112, horizon 43\n", - "adding: mem time70, current time 112, horizon 42\n", - "adding: mem time71, current time 112, horizon 41\n", - "adding: mem time72, current time 112, horizon 40\n", - "adding: mem time73, current time 112, horizon 39\n", - "adding: mem time74, current time 112, horizon 38\n", - "adding: mem time75, current time 112, horizon 37\n", - "adding: mem time76, current time 112, horizon 36\n", - "adding: mem time77, current time 112, horizon 35\n", - "adding: mem time78, current time 112, horizon 34\n", - "adding: mem time79, current time 112, horizon 33\n", - "adding: mem time80, current time 112, horizon 32\n", - "adding: mem time81, current time 112, horizon 31\n", - "adding: mem time82, current time 112, horizon 30\n", - "adding: mem time83, current time 112, horizon 29\n", - "adding: mem time84, current time 112, horizon 28\n", - "adding: mem time85, current time 112, horizon 27\n", - "adding: mem time86, current time 112, horizon 26\n", - "adding: mem time87, current time 112, horizon 25\n", - "adding: mem time88, current time 112, horizon 24\n", - "adding: mem time89, current time 112, horizon 23\n", - "adding: mem time90, current time 112, horizon 22\n", - "adding: mem time91, current time 112, horizon 21\n", - "adding: mem time92, current time 112, horizon 20\n", - "adding: mem time93, current time 112, horizon 19\n", - "adding: mem time94, current time 112, horizon 18\n", - "adding: mem time95, current time 112, horizon 17\n", - "adding: mem time96, current time 112, horizon 16\n", - "adding: mem time97, current time 112, horizon 15\n", - "adding: mem time98, current time 112, horizon 14\n", - "adding: mem time99, current time 112, horizon 13\n", - "adding: mem time100, current time 112, horizon 12\n", - "adding: mem time101, current time 112, horizon 11\n", - "adding: mem time102, current time 112, horizon 10\n", - "adding: mem time103, current time 112, horizon 9\n", - "adding: mem time104, current time 112, horizon 8\n", - "adding: mem time105, current time 112, horizon 7\n", - "adding: mem time106, current time 112, horizon 6\n", - "adding: mem time107, current time 112, horizon 5\n", - "adding: mem time108, current time 112, horizon 4\n", - "adding: mem time109, current time 112, horizon 3\n", - "adding: mem time110, current time 112, horizon 2\n", - "adding: mem time111, current time 112, horizon 1\n", - "adding: mem time0, current time 113, horizon 113\n", - "adding: mem time1, current time 113, horizon 112\n", - "adding: mem time2, current time 113, horizon 111\n", - "adding: mem time3, current time 113, horizon 110\n", - "adding: mem time4, current time 113, horizon 109\n", - "adding: mem time5, current time 113, horizon 108\n", - "adding: mem time6, current time 113, horizon 107\n", - "adding: mem time7, current time 113, horizon 106\n", - "adding: mem time8, current time 113, horizon 105\n", - "adding: mem time9, current time 113, horizon 104\n", - "adding: mem time10, current time 113, horizon 103\n", - "adding: mem time11, current time 113, horizon 102\n", - "adding: mem time12, current time 113, horizon 101\n", - "adding: mem time13, current time 113, horizon 100\n", - "adding: mem time14, current time 113, horizon 99\n", - "adding: mem time15, current time 113, horizon 98\n", - "adding: mem time16, current time 113, horizon 97\n", - "adding: mem time17, current time 113, horizon 96\n", - "adding: mem time18, current time 113, horizon 95\n", - "adding: mem time19, current time 113, horizon 94\n", - "adding: mem time20, current time 113, horizon 93\n", - "adding: mem time21, current time 113, horizon 92\n", - "adding: mem time22, current time 113, horizon 91\n", - "adding: mem time23, current time 113, horizon 90\n", - "adding: mem time24, current time 113, horizon 89\n", - "adding: mem time25, current time 113, horizon 88\n", - "adding: mem time26, current time 113, horizon 87\n", - "adding: mem time27, current time 113, horizon 86\n", - "adding: mem time28, current time 113, horizon 85\n", - "adding: mem time29, current time 113, horizon 84\n", - "adding: mem time30, current time 113, horizon 83\n", - "adding: mem time31, current time 113, horizon 82\n", - "adding: mem time32, current time 113, horizon 81\n", - "adding: mem time33, current time 113, horizon 80\n", - "adding: mem time34, current time 113, horizon 79\n", - "adding: mem time35, current time 113, horizon 78\n", - "adding: mem time36, current time 113, horizon 77\n", - "adding: mem time37, current time 113, horizon 76\n", - "adding: mem time38, current time 113, horizon 75\n", - "adding: mem time39, current time 113, horizon 74\n", - "adding: mem time40, current time 113, horizon 73\n", - "adding: mem time41, current time 113, horizon 72\n", - "adding: mem time42, current time 113, horizon 71\n", - "adding: mem time43, current time 113, horizon 70\n", - "adding: mem time44, current time 113, horizon 69\n", - "adding: mem time45, current time 113, horizon 68\n", - "adding: mem time46, current time 113, horizon 67\n", - "adding: mem time47, current time 113, horizon 66\n", - "adding: mem time48, current time 113, horizon 65\n", - "adding: mem time49, current time 113, horizon 64\n", - "adding: mem time50, current time 113, horizon 63\n", - "adding: mem time51, current time 113, horizon 62\n", - "adding: mem time52, current time 113, horizon 61\n", - "adding: mem time53, current time 113, horizon 60\n", - "adding: mem time54, current time 113, horizon 59\n", - "adding: mem time55, current time 113, horizon 58\n", - "adding: mem time56, current time 113, horizon 57\n", - "adding: mem time57, current time 113, horizon 56\n", - "adding: mem time58, current time 113, horizon 55\n", - "adding: mem time59, current time 113, horizon 54\n", - "adding: mem time60, current time 113, horizon 53\n", - "adding: mem time61, current time 113, horizon 52\n", - "adding: mem time62, current time 113, horizon 51\n", - "adding: mem time63, current time 113, horizon 50\n", - "adding: mem time64, current time 113, horizon 49\n", - "adding: mem time65, current time 113, horizon 48\n", - "adding: mem time66, current time 113, horizon 47\n", - "adding: mem time67, current time 113, horizon 46\n", - "adding: mem time68, current time 113, horizon 45\n", - "adding: mem time69, current time 113, horizon 44\n", - "adding: mem time70, current time 113, horizon 43\n", - "adding: mem time71, current time 113, horizon 42\n", - "adding: mem time72, current time 113, horizon 41\n", - "adding: mem time73, current time 113, horizon 40\n", - "adding: mem time74, current time 113, horizon 39\n", - "adding: mem time75, current time 113, horizon 38\n", - "adding: mem time76, current time 113, horizon 37\n", - "adding: mem time77, current time 113, horizon 36\n", - "adding: mem time78, current time 113, horizon 35\n", - "adding: mem time79, current time 113, horizon 34\n", - "adding: mem time80, current time 113, horizon 33\n", - "adding: mem time81, current time 113, horizon 32\n", - "adding: mem time82, current time 113, horizon 31\n", - "adding: mem time83, current time 113, horizon 30\n", - "adding: mem time84, current time 113, horizon 29\n", - "adding: mem time85, current time 113, horizon 28\n", - "adding: mem time86, current time 113, horizon 27\n", - "adding: mem time87, current time 113, horizon 26\n", - "adding: mem time88, current time 113, horizon 25\n", - "adding: mem time89, current time 113, horizon 24\n", - "adding: mem time90, current time 113, horizon 23\n", - "adding: mem time91, current time 113, horizon 22\n", - "adding: mem time92, current time 113, horizon 21\n", - "adding: mem time93, current time 113, horizon 20\n", - "adding: mem time94, current time 113, horizon 19\n", - "adding: mem time95, current time 113, horizon 18\n", - "adding: mem time96, current time 113, horizon 17\n", - "adding: mem time97, current time 113, horizon 16\n", - "adding: mem time98, current time 113, horizon 15\n", - "adding: mem time99, current time 113, horizon 14\n", - "adding: mem time100, current time 113, horizon 13\n", - "adding: mem time101, current time 113, horizon 12\n", - "adding: mem time102, current time 113, horizon 11\n", - "adding: mem time103, current time 113, horizon 10\n", - "adding: mem time104, current time 113, horizon 9\n", - "adding: mem time105, current time 113, horizon 8\n", - "adding: mem time106, current time 113, horizon 7\n", - "adding: mem time107, current time 113, horizon 6\n", - "adding: mem time108, current time 113, horizon 5\n", - "adding: mem time109, current time 113, horizon 4\n", - "adding: mem time110, current time 113, horizon 3\n", - "adding: mem time111, current time 113, horizon 2\n", - "adding: mem time112, current time 113, horizon 1\n", - "adding: mem time0, current time 114, horizon 114\n", - "adding: mem time1, current time 114, horizon 113\n", - "adding: mem time2, current time 114, horizon 112\n", - "adding: mem time3, current time 114, horizon 111\n", - "adding: mem time4, current time 114, horizon 110\n", - "adding: mem time5, current time 114, horizon 109\n", - "adding: mem time6, current time 114, horizon 108\n", - "adding: mem time7, current time 114, horizon 107\n", - "adding: mem time8, current time 114, horizon 106\n", - "adding: mem time9, current time 114, horizon 105\n", - "adding: mem time10, current time 114, horizon 104\n", - "adding: mem time11, current time 114, horizon 103\n", - "adding: mem time12, current time 114, horizon 102\n", - "adding: mem time13, current time 114, horizon 101\n", - "adding: mem time14, current time 114, horizon 100\n", - "adding: mem time15, current time 114, horizon 99\n", - "adding: mem time16, current time 114, horizon 98\n", - "adding: mem time17, current time 114, horizon 97\n", - "adding: mem time18, current time 114, horizon 96\n", - "adding: mem time19, current time 114, horizon 95\n", - "adding: mem time20, current time 114, horizon 94\n", - "adding: mem time21, current time 114, horizon 93\n", - "adding: mem time22, current time 114, horizon 92\n", - "adding: mem time23, current time 114, horizon 91\n", - "adding: mem time24, current time 114, horizon 90\n", - "adding: mem time25, current time 114, horizon 89\n", - "adding: mem time26, current time 114, horizon 88\n", - "adding: mem time27, current time 114, horizon 87\n", - "adding: mem time28, current time 114, horizon 86\n", - "adding: mem time29, current time 114, horizon 85\n", - "adding: mem time30, current time 114, horizon 84\n", - "adding: mem time31, current time 114, horizon 83\n", - "adding: mem time32, current time 114, horizon 82\n", - "adding: mem time33, current time 114, horizon 81\n", - "adding: mem time34, current time 114, horizon 80\n", - "adding: mem time35, current time 114, horizon 79\n", - "adding: mem time36, current time 114, horizon 78\n", - "adding: mem time37, current time 114, horizon 77\n", - "adding: mem time38, current time 114, horizon 76\n", - "adding: mem time39, current time 114, horizon 75\n", - "adding: mem time40, current time 114, horizon 74\n", - "adding: mem time41, current time 114, horizon 73\n", - "adding: mem time42, current time 114, horizon 72\n", - "adding: mem time43, current time 114, horizon 71\n", - "adding: mem time44, current time 114, horizon 70\n", - "adding: mem time45, current time 114, horizon 69\n", - "adding: mem time46, current time 114, horizon 68\n", - "adding: mem time47, current time 114, horizon 67\n", - "adding: mem time48, current time 114, horizon 66\n", - "adding: mem time49, current time 114, horizon 65\n", - "adding: mem time50, current time 114, horizon 64\n", - "adding: mem time51, current time 114, horizon 63\n", - "adding: mem time52, current time 114, horizon 62\n", - "adding: mem time53, current time 114, horizon 61\n", - "adding: mem time54, current time 114, horizon 60\n", - "adding: mem time55, current time 114, horizon 59\n", - "adding: mem time56, current time 114, horizon 58\n", - "adding: mem time57, current time 114, horizon 57\n", - "adding: mem time58, current time 114, horizon 56\n", - "adding: mem time59, current time 114, horizon 55\n", - "adding: mem time60, current time 114, horizon 54\n", - "adding: mem time61, current time 114, horizon 53\n", - "adding: mem time62, current time 114, horizon 52\n", - "adding: mem time63, current time 114, horizon 51\n", - "adding: mem time64, current time 114, horizon 50\n", - "adding: mem time65, current time 114, horizon 49\n", - "adding: mem time66, current time 114, horizon 48\n", - "adding: mem time67, current time 114, horizon 47\n", - "adding: mem time68, current time 114, horizon 46\n", - "adding: mem time69, current time 114, horizon 45\n", - "adding: mem time70, current time 114, horizon 44\n", - "adding: mem time71, current time 114, horizon 43\n", - "adding: mem time72, current time 114, horizon 42\n", - "adding: mem time73, current time 114, horizon 41\n", - "adding: mem time74, current time 114, horizon 40\n", - "adding: mem time75, current time 114, horizon 39\n", - "adding: mem time76, current time 114, horizon 38\n", - "adding: mem time77, current time 114, horizon 37\n", - "adding: mem time78, current time 114, horizon 36\n", - "adding: mem time79, current time 114, horizon 35\n", - "adding: mem time80, current time 114, horizon 34\n", - "adding: mem time81, current time 114, horizon 33\n", - "adding: mem time82, current time 114, horizon 32\n", - "adding: mem time83, current time 114, horizon 31\n", - "adding: mem time84, current time 114, horizon 30\n", - "adding: mem time85, current time 114, horizon 29\n", - "adding: mem time86, current time 114, horizon 28\n", - "adding: mem time87, current time 114, horizon 27\n", - "adding: mem time88, current time 114, horizon 26\n", - "adding: mem time89, current time 114, horizon 25\n", - "adding: mem time90, current time 114, horizon 24\n", - "adding: mem time91, current time 114, horizon 23\n", - "adding: mem time92, current time 114, horizon 22\n", - "adding: mem time93, current time 114, horizon 21\n", - "adding: mem time94, current time 114, horizon 20\n", - "adding: mem time95, current time 114, horizon 19\n", - "adding: mem time96, current time 114, horizon 18\n", - "adding: mem time97, current time 114, horizon 17\n", - "adding: mem time98, current time 114, horizon 16\n", - "adding: mem time99, current time 114, horizon 15\n", - "adding: mem time100, current time 114, horizon 14\n", - "adding: mem time101, current time 114, horizon 13\n", - "adding: mem time102, current time 114, horizon 12\n", - "adding: mem time103, current time 114, horizon 11\n", - "adding: mem time104, current time 114, horizon 10\n", - "adding: mem time105, current time 114, horizon 9\n", - "adding: mem time106, current time 114, horizon 8\n", - "adding: mem time107, current time 114, horizon 7\n", - "adding: mem time108, current time 114, horizon 6\n", - "adding: mem time109, current time 114, horizon 5\n", - "adding: mem time110, current time 114, horizon 4\n", - "adding: mem time111, current time 114, horizon 3\n", - "adding: mem time112, current time 114, horizon 2\n", - "adding: mem time113, current time 114, horizon 1\n", - "adding: mem time0, current time 115, horizon 115\n", - "adding: mem time1, current time 115, horizon 114\n", - "adding: mem time2, current time 115, horizon 113\n", - "adding: mem time3, current time 115, horizon 112\n", - "adding: mem time4, current time 115, horizon 111\n", - "adding: mem time5, current time 115, horizon 110\n", - "adding: mem time6, current time 115, horizon 109\n", - "adding: mem time7, current time 115, horizon 108\n", - "adding: mem time8, current time 115, horizon 107\n", - "adding: mem time9, current time 115, horizon 106\n", - "adding: mem time10, current time 115, horizon 105\n", - "adding: mem time11, current time 115, horizon 104\n", - "adding: mem time12, current time 115, horizon 103\n", - "adding: mem time13, current time 115, horizon 102\n", - "adding: mem time14, current time 115, horizon 101\n", - "adding: mem time15, current time 115, horizon 100\n", - "adding: mem time16, current time 115, horizon 99\n", - "adding: mem time17, current time 115, horizon 98\n", - "adding: mem time18, current time 115, horizon 97\n", - "adding: mem time19, current time 115, horizon 96\n", - "adding: mem time20, current time 115, horizon 95\n", - "adding: mem time21, current time 115, horizon 94\n", - "adding: mem time22, current time 115, horizon 93\n", - "adding: mem time23, current time 115, horizon 92\n", - "adding: mem time24, current time 115, horizon 91\n", - "adding: mem time25, current time 115, horizon 90\n", - "adding: mem time26, current time 115, horizon 89\n", - "adding: mem time27, current time 115, horizon 88\n", - "adding: mem time28, current time 115, horizon 87\n", - "adding: mem time29, current time 115, horizon 86\n", - "adding: mem time30, current time 115, horizon 85\n", - "adding: mem time31, current time 115, horizon 84\n", - "adding: mem time32, current time 115, horizon 83\n", - "adding: mem time33, current time 115, horizon 82\n", - "adding: mem time34, current time 115, horizon 81\n", - "adding: mem time35, current time 115, horizon 80\n", - "adding: mem time36, current time 115, horizon 79\n", - "adding: mem time37, current time 115, horizon 78\n", - "adding: mem time38, current time 115, horizon 77\n", - "adding: mem time39, current time 115, horizon 76\n", - "adding: mem time40, current time 115, horizon 75\n", - "adding: mem time41, current time 115, horizon 74\n", - "adding: mem time42, current time 115, horizon 73\n", - "adding: mem time43, current time 115, horizon 72\n", - "adding: mem time44, current time 115, horizon 71\n", - "adding: mem time45, current time 115, horizon 70\n", - "adding: mem time46, current time 115, horizon 69\n", - "adding: mem time47, current time 115, horizon 68\n", - "adding: mem time48, current time 115, horizon 67\n", - "adding: mem time49, current time 115, horizon 66\n", - "adding: mem time50, current time 115, horizon 65\n", - "adding: mem time51, current time 115, horizon 64\n", - "adding: mem time52, current time 115, horizon 63\n", - "adding: mem time53, current time 115, horizon 62\n", - "adding: mem time54, current time 115, horizon 61\n", - "adding: mem time55, current time 115, horizon 60\n", - "adding: mem time56, current time 115, horizon 59\n", - "adding: mem time57, current time 115, horizon 58\n", - "adding: mem time58, current time 115, horizon 57\n", - "adding: mem time59, current time 115, horizon 56\n", - "adding: mem time60, current time 115, horizon 55\n", - "adding: mem time61, current time 115, horizon 54\n", - "adding: mem time62, current time 115, horizon 53\n", - "adding: mem time63, current time 115, horizon 52\n", - "adding: mem time64, current time 115, horizon 51\n", - "adding: mem time65, current time 115, horizon 50\n", - "adding: mem time66, current time 115, horizon 49\n", - "adding: mem time67, current time 115, horizon 48\n", - "adding: mem time68, current time 115, horizon 47\n", - "adding: mem time69, current time 115, horizon 46\n", - "adding: mem time70, current time 115, horizon 45\n", - "adding: mem time71, current time 115, horizon 44\n", - "adding: mem time72, current time 115, horizon 43\n", - "adding: mem time73, current time 115, horizon 42\n", - "adding: mem time74, current time 115, horizon 41\n", - "adding: mem time75, current time 115, horizon 40\n", - "adding: mem time76, current time 115, horizon 39\n", - "adding: mem time77, current time 115, horizon 38\n", - "adding: mem time78, current time 115, horizon 37\n", - "adding: mem time79, current time 115, horizon 36\n", - "adding: mem time80, current time 115, horizon 35\n", - "adding: mem time81, current time 115, horizon 34\n", - "adding: mem time82, current time 115, horizon 33\n", - "adding: mem time83, current time 115, horizon 32\n", - "adding: mem time84, current time 115, horizon 31\n", - "adding: mem time85, current time 115, horizon 30\n", - "adding: mem time86, current time 115, horizon 29\n", - "adding: mem time87, current time 115, horizon 28\n", - "adding: mem time88, current time 115, horizon 27\n", - "adding: mem time89, current time 115, horizon 26\n", - "adding: mem time90, current time 115, horizon 25\n", - "adding: mem time91, current time 115, horizon 24\n", - "adding: mem time92, current time 115, horizon 23\n", - "adding: mem time93, current time 115, horizon 22\n", - "adding: mem time94, current time 115, horizon 21\n", - "adding: mem time95, current time 115, horizon 20\n", - "adding: mem time96, current time 115, horizon 19\n", - "adding: mem time97, current time 115, horizon 18\n", - "adding: mem time98, current time 115, horizon 17\n", - "adding: mem time99, current time 115, horizon 16\n", - "adding: mem time100, current time 115, horizon 15\n", - "adding: mem time101, current time 115, horizon 14\n", - "adding: mem time102, current time 115, horizon 13\n", - "adding: mem time103, current time 115, horizon 12\n", - "adding: mem time104, current time 115, horizon 11\n", - "adding: mem time105, current time 115, horizon 10\n", - "adding: mem time106, current time 115, horizon 9\n", - "adding: mem time107, current time 115, horizon 8\n", - "adding: mem time108, current time 115, horizon 7\n", - "adding: mem time109, current time 115, horizon 6\n", - "adding: mem time110, current time 115, horizon 5\n", - "adding: mem time111, current time 115, horizon 4\n", - "adding: mem time112, current time 115, horizon 3\n", - "adding: mem time113, current time 115, horizon 2\n", - "adding: mem time114, current time 115, horizon 1\n", - "adding: mem time0, current time 116, horizon 116\n", - "adding: mem time1, current time 116, horizon 115\n", - "adding: mem time2, current time 116, horizon 114\n", - "adding: mem time3, current time 116, horizon 113\n", - "adding: mem time4, current time 116, horizon 112\n", - "adding: mem time5, current time 116, horizon 111\n", - "adding: mem time6, current time 116, horizon 110\n", - "adding: mem time7, current time 116, horizon 109\n", - "adding: mem time8, current time 116, horizon 108\n", - "adding: mem time9, current time 116, horizon 107\n", - "adding: mem time10, current time 116, horizon 106\n", - "adding: mem time11, current time 116, horizon 105\n", - "adding: mem time12, current time 116, horizon 104\n", - "adding: mem time13, current time 116, horizon 103\n", - "adding: mem time14, current time 116, horizon 102\n", - "adding: mem time15, current time 116, horizon 101\n", - "adding: mem time16, current time 116, horizon 100\n", - "adding: mem time17, current time 116, horizon 99\n", - "adding: mem time18, current time 116, horizon 98\n", - "adding: mem time19, current time 116, horizon 97\n", - "adding: mem time20, current time 116, horizon 96\n", - "adding: mem time21, current time 116, horizon 95\n", - "adding: mem time22, current time 116, horizon 94\n", - "adding: mem time23, current time 116, horizon 93\n", - "adding: mem time24, current time 116, horizon 92\n", - "adding: mem time25, current time 116, horizon 91\n", - "adding: mem time26, current time 116, horizon 90\n", - "adding: mem time27, current time 116, horizon 89\n", - "adding: mem time28, current time 116, horizon 88\n", - "adding: mem time29, current time 116, horizon 87\n", - "adding: mem time30, current time 116, horizon 86\n", - "adding: mem time31, current time 116, horizon 85\n", - "adding: mem time32, current time 116, horizon 84\n", - "adding: mem time33, current time 116, horizon 83\n", - "adding: mem time34, current time 116, horizon 82\n", - "adding: mem time35, current time 116, horizon 81\n", - "adding: mem time36, current time 116, horizon 80\n", - "adding: mem time37, current time 116, horizon 79\n", - "adding: mem time38, current time 116, horizon 78\n", - "adding: mem time39, current time 116, horizon 77\n", - "adding: mem time40, current time 116, horizon 76\n", - "adding: mem time41, current time 116, horizon 75\n", - "adding: mem time42, current time 116, horizon 74\n", - "adding: mem time43, current time 116, horizon 73\n", - "adding: mem time44, current time 116, horizon 72\n", - "adding: mem time45, current time 116, horizon 71\n", - "adding: mem time46, current time 116, horizon 70\n", - "adding: mem time47, current time 116, horizon 69\n", - "adding: mem time48, current time 116, horizon 68\n", - "adding: mem time49, current time 116, horizon 67\n", - "adding: mem time50, current time 116, horizon 66\n", - "adding: mem time51, current time 116, horizon 65\n", - "adding: mem time52, current time 116, horizon 64\n", - "adding: mem time53, current time 116, horizon 63\n", - "adding: mem time54, current time 116, horizon 62\n", - "adding: mem time55, current time 116, horizon 61\n", - "adding: mem time56, current time 116, horizon 60\n", - "adding: mem time57, current time 116, horizon 59\n", - "adding: mem time58, current time 116, horizon 58\n", - "adding: mem time59, current time 116, horizon 57\n", - "adding: mem time60, current time 116, horizon 56\n", - "adding: mem time61, current time 116, horizon 55\n", - "adding: mem time62, current time 116, horizon 54\n", - "adding: mem time63, current time 116, horizon 53\n", - "adding: mem time64, current time 116, horizon 52\n", - "adding: mem time65, current time 116, horizon 51\n", - "adding: mem time66, current time 116, horizon 50\n", - "adding: mem time67, current time 116, horizon 49\n", - "adding: mem time68, current time 116, horizon 48\n", - "adding: mem time69, current time 116, horizon 47\n", - "adding: mem time70, current time 116, horizon 46\n", - "adding: mem time71, current time 116, horizon 45\n", - "adding: mem time72, current time 116, horizon 44\n", - "adding: mem time73, current time 116, horizon 43\n", - "adding: mem time74, current time 116, horizon 42\n", - "adding: mem time75, current time 116, horizon 41\n", - "adding: mem time76, current time 116, horizon 40\n", - "adding: mem time77, current time 116, horizon 39\n", - "adding: mem time78, current time 116, horizon 38\n", - "adding: mem time79, current time 116, horizon 37\n", - "adding: mem time80, current time 116, horizon 36\n", - "adding: mem time81, current time 116, horizon 35\n", - "adding: mem time82, current time 116, horizon 34\n", - "adding: mem time83, current time 116, horizon 33\n", - "adding: mem time84, current time 116, horizon 32\n", - "adding: mem time85, current time 116, horizon 31\n", - "adding: mem time86, current time 116, horizon 30\n", - "adding: mem time87, current time 116, horizon 29\n", - "adding: mem time88, current time 116, horizon 28\n", - "adding: mem time89, current time 116, horizon 27\n", - "adding: mem time90, current time 116, horizon 26\n", - "adding: mem time91, current time 116, horizon 25\n", - "adding: mem time92, current time 116, horizon 24\n", - "adding: mem time93, current time 116, horizon 23\n", - "adding: mem time94, current time 116, horizon 22\n", - "adding: mem time95, current time 116, horizon 21\n", - "adding: mem time96, current time 116, horizon 20\n", - "adding: mem time97, current time 116, horizon 19\n", - "adding: mem time98, current time 116, horizon 18\n", - "adding: mem time99, current time 116, horizon 17\n", - "adding: mem time100, current time 116, horizon 16\n", - "adding: mem time101, current time 116, horizon 15\n", - "adding: mem time102, current time 116, horizon 14\n", - "adding: mem time103, current time 116, horizon 13\n", - "adding: mem time104, current time 116, horizon 12\n", - "adding: mem time105, current time 116, horizon 11\n", - "adding: mem time106, current time 116, horizon 10\n", - "adding: mem time107, current time 116, horizon 9\n", - "adding: mem time108, current time 116, horizon 8\n", - "adding: mem time109, current time 116, horizon 7\n", - "adding: mem time110, current time 116, horizon 6\n", - "adding: mem time111, current time 116, horizon 5\n", - "adding: mem time112, current time 116, horizon 4\n", - "adding: mem time113, current time 116, horizon 3\n", - "adding: mem time114, current time 116, horizon 2\n", - "adding: mem time115, current time 116, horizon 1\n", - "adding: mem time0, current time 117, horizon 117\n", - "adding: mem time1, current time 117, horizon 116\n", - "adding: mem time2, current time 117, horizon 115\n", - "adding: mem time3, current time 117, horizon 114\n", - "adding: mem time4, current time 117, horizon 113\n", - "adding: mem time5, current time 117, horizon 112\n", - "adding: mem time6, current time 117, horizon 111\n", - "adding: mem time7, current time 117, horizon 110\n", - "adding: mem time8, current time 117, horizon 109\n", - "adding: mem time9, current time 117, horizon 108\n", - "adding: mem time10, current time 117, horizon 107\n", - "adding: mem time11, current time 117, horizon 106\n", - "adding: mem time12, current time 117, horizon 105\n", - "adding: mem time13, current time 117, horizon 104\n", - "adding: mem time14, current time 117, horizon 103\n", - "adding: mem time15, current time 117, horizon 102\n", - "adding: mem time16, current time 117, horizon 101\n", - "adding: mem time17, current time 117, horizon 100\n", - "adding: mem time18, current time 117, horizon 99\n", - "adding: mem time19, current time 117, horizon 98\n", - "adding: mem time20, current time 117, horizon 97\n", - "adding: mem time21, current time 117, horizon 96\n", - "adding: mem time22, current time 117, horizon 95\n", - "adding: mem time23, current time 117, horizon 94\n", - "adding: mem time24, current time 117, horizon 93\n", - "adding: mem time25, current time 117, horizon 92\n", - "adding: mem time26, current time 117, horizon 91\n", - "adding: mem time27, current time 117, horizon 90\n", - "adding: mem time28, current time 117, horizon 89\n", - "adding: mem time29, current time 117, horizon 88\n", - "adding: mem time30, current time 117, horizon 87\n", - "adding: mem time31, current time 117, horizon 86\n", - "adding: mem time32, current time 117, horizon 85\n", - "adding: mem time33, current time 117, horizon 84\n", - "adding: mem time34, current time 117, horizon 83\n", - "adding: mem time35, current time 117, horizon 82\n", - "adding: mem time36, current time 117, horizon 81\n", - "adding: mem time37, current time 117, horizon 80\n", - "adding: mem time38, current time 117, horizon 79\n", - "adding: mem time39, current time 117, horizon 78\n", - "adding: mem time40, current time 117, horizon 77\n", - "adding: mem time41, current time 117, horizon 76\n", - "adding: mem time42, current time 117, horizon 75\n", - "adding: mem time43, current time 117, horizon 74\n", - "adding: mem time44, current time 117, horizon 73\n", - "adding: mem time45, current time 117, horizon 72\n", - "adding: mem time46, current time 117, horizon 71\n", - "adding: mem time47, current time 117, horizon 70\n", - "adding: mem time48, current time 117, horizon 69\n", - "adding: mem time49, current time 117, horizon 68\n", - "adding: mem time50, current time 117, horizon 67\n", - "adding: mem time51, current time 117, horizon 66\n", - "adding: mem time52, current time 117, horizon 65\n", - "adding: mem time53, current time 117, horizon 64\n", - "adding: mem time54, current time 117, horizon 63\n", - "adding: mem time55, current time 117, horizon 62\n", - "adding: mem time56, current time 117, horizon 61\n", - "adding: mem time57, current time 117, horizon 60\n", - "adding: mem time58, current time 117, horizon 59\n", - "adding: mem time59, current time 117, horizon 58\n", - "adding: mem time60, current time 117, horizon 57\n", - "adding: mem time61, current time 117, horizon 56\n", - "adding: mem time62, current time 117, horizon 55\n", - "adding: mem time63, current time 117, horizon 54\n", - "adding: mem time64, current time 117, horizon 53\n", - "adding: mem time65, current time 117, horizon 52\n", - "adding: mem time66, current time 117, horizon 51\n", - "adding: mem time67, current time 117, horizon 50\n", - "adding: mem time68, current time 117, horizon 49\n", - "adding: mem time69, current time 117, horizon 48\n", - "adding: mem time70, current time 117, horizon 47\n", - "adding: mem time71, current time 117, horizon 46\n", - "adding: mem time72, current time 117, horizon 45\n", - "adding: mem time73, current time 117, horizon 44\n", - "adding: mem time74, current time 117, horizon 43\n", - "adding: mem time75, current time 117, horizon 42\n", - "adding: mem time76, current time 117, horizon 41\n", - "adding: mem time77, current time 117, horizon 40\n", - "adding: mem time78, current time 117, horizon 39\n", - "adding: mem time79, current time 117, horizon 38\n", - "adding: mem time80, current time 117, horizon 37\n", - "adding: mem time81, current time 117, horizon 36\n", - "adding: mem time82, current time 117, horizon 35\n", - "adding: mem time83, current time 117, horizon 34\n", - "adding: mem time84, current time 117, horizon 33\n", - "adding: mem time85, current time 117, horizon 32\n", - "adding: mem time86, current time 117, horizon 31\n", - "adding: mem time87, current time 117, horizon 30\n", - "adding: mem time88, current time 117, horizon 29\n", - "adding: mem time89, current time 117, horizon 28\n", - "adding: mem time90, current time 117, horizon 27\n", - "adding: mem time91, current time 117, horizon 26\n", - "adding: mem time92, current time 117, horizon 25\n", - "adding: mem time93, current time 117, horizon 24\n", - "adding: mem time94, current time 117, horizon 23\n", - "adding: mem time95, current time 117, horizon 22\n", - "adding: mem time96, current time 117, horizon 21\n", - "adding: mem time97, current time 117, horizon 20\n", - "adding: mem time98, current time 117, horizon 19\n", - "adding: mem time99, current time 117, horizon 18\n", - "adding: mem time100, current time 117, horizon 17\n", - "adding: mem time101, current time 117, horizon 16\n", - "adding: mem time102, current time 117, horizon 15\n", - "adding: mem time103, current time 117, horizon 14\n", - "adding: mem time104, current time 117, horizon 13\n", - "adding: mem time105, current time 117, horizon 12\n", - "adding: mem time106, current time 117, horizon 11\n", - "adding: mem time107, current time 117, horizon 10\n", - "adding: mem time108, current time 117, horizon 9\n", - "adding: mem time109, current time 117, horizon 8\n", - "adding: mem time110, current time 117, horizon 7\n", - "adding: mem time111, current time 117, horizon 6\n", - "adding: mem time112, current time 117, horizon 5\n", - "adding: mem time113, current time 117, horizon 4\n", - "adding: mem time114, current time 117, horizon 3\n", - "adding: mem time115, current time 117, horizon 2\n", - "adding: mem time116, current time 117, horizon 1\n", - "adding: mem time0, current time 118, horizon 118\n", - "adding: mem time1, current time 118, horizon 117\n", - "adding: mem time2, current time 118, horizon 116\n", - "adding: mem time3, current time 118, horizon 115\n", - "adding: mem time4, current time 118, horizon 114\n", - "adding: mem time5, current time 118, horizon 113\n", - "adding: mem time6, current time 118, horizon 112\n", - "adding: mem time7, current time 118, horizon 111\n", - "adding: mem time8, current time 118, horizon 110\n", - "adding: mem time9, current time 118, horizon 109\n", - "adding: mem time10, current time 118, horizon 108\n", - "adding: mem time11, current time 118, horizon 107\n", - "adding: mem time12, current time 118, horizon 106\n", - "adding: mem time13, current time 118, horizon 105\n", - "adding: mem time14, current time 118, horizon 104\n", - "adding: mem time15, current time 118, horizon 103\n", - "adding: mem time16, current time 118, horizon 102\n", - "adding: mem time17, current time 118, horizon 101\n", - "adding: mem time18, current time 118, horizon 100\n", - "adding: mem time19, current time 118, horizon 99\n", - "adding: mem time20, current time 118, horizon 98\n", - "adding: mem time21, current time 118, horizon 97\n", - "adding: mem time22, current time 118, horizon 96\n", - "adding: mem time23, current time 118, horizon 95\n", - "adding: mem time24, current time 118, horizon 94\n", - "adding: mem time25, current time 118, horizon 93\n", - "adding: mem time26, current time 118, horizon 92\n", - "adding: mem time27, current time 118, horizon 91\n", - "adding: mem time28, current time 118, horizon 90\n", - "adding: mem time29, current time 118, horizon 89\n", - "adding: mem time30, current time 118, horizon 88\n", - "adding: mem time31, current time 118, horizon 87\n", - "adding: mem time32, current time 118, horizon 86\n", - "adding: mem time33, current time 118, horizon 85\n", - "adding: mem time34, current time 118, horizon 84\n", - "adding: mem time35, current time 118, horizon 83\n", - "adding: mem time36, current time 118, horizon 82\n", - "adding: mem time37, current time 118, horizon 81\n", - "adding: mem time38, current time 118, horizon 80\n", - "adding: mem time39, current time 118, horizon 79\n", - "adding: mem time40, current time 118, horizon 78\n", - "adding: mem time41, current time 118, horizon 77\n", - "adding: mem time42, current time 118, horizon 76\n", - "adding: mem time43, current time 118, horizon 75\n", - "adding: mem time44, current time 118, horizon 74\n", - "adding: mem time45, current time 118, horizon 73\n", - "adding: mem time46, current time 118, horizon 72\n", - "adding: mem time47, current time 118, horizon 71\n", - "adding: mem time48, current time 118, horizon 70\n", - "adding: mem time49, current time 118, horizon 69\n", - "adding: mem time50, current time 118, horizon 68\n", - "adding: mem time51, current time 118, horizon 67\n", - "adding: mem time52, current time 118, horizon 66\n", - "adding: mem time53, current time 118, horizon 65\n", - "adding: mem time54, current time 118, horizon 64\n", - "adding: mem time55, current time 118, horizon 63\n", - "adding: mem time56, current time 118, horizon 62\n", - "adding: mem time57, current time 118, horizon 61\n", - "adding: mem time58, current time 118, horizon 60\n", - "adding: mem time59, current time 118, horizon 59\n", - "adding: mem time60, current time 118, horizon 58\n", - "adding: mem time61, current time 118, horizon 57\n", - "adding: mem time62, current time 118, horizon 56\n", - "adding: mem time63, current time 118, horizon 55\n", - "adding: mem time64, current time 118, horizon 54\n", - "adding: mem time65, current time 118, horizon 53\n", - "adding: mem time66, current time 118, horizon 52\n", - "adding: mem time67, current time 118, horizon 51\n", - "adding: mem time68, current time 118, horizon 50\n", - "adding: mem time69, current time 118, horizon 49\n", - "adding: mem time70, current time 118, horizon 48\n", - "adding: mem time71, current time 118, horizon 47\n", - "adding: mem time72, current time 118, horizon 46\n", - "adding: mem time73, current time 118, horizon 45\n", - "adding: mem time74, current time 118, horizon 44\n", - "adding: mem time75, current time 118, horizon 43\n", - "adding: mem time76, current time 118, horizon 42\n", - "adding: mem time77, current time 118, horizon 41\n", - "adding: mem time78, current time 118, horizon 40\n", - "adding: mem time79, current time 118, horizon 39\n", - "adding: mem time80, current time 118, horizon 38\n", - "adding: mem time81, current time 118, horizon 37\n", - "adding: mem time82, current time 118, horizon 36\n", - "adding: mem time83, current time 118, horizon 35\n", - "adding: mem time84, current time 118, horizon 34\n", - "adding: mem time85, current time 118, horizon 33\n", - "adding: mem time86, current time 118, horizon 32\n", - "adding: mem time87, current time 118, horizon 31\n", - "adding: mem time88, current time 118, horizon 30\n", - "adding: mem time89, current time 118, horizon 29\n", - "adding: mem time90, current time 118, horizon 28\n", - "adding: mem time91, current time 118, horizon 27\n", - "adding: mem time92, current time 118, horizon 26\n", - "adding: mem time93, current time 118, horizon 25\n", - "adding: mem time94, current time 118, horizon 24\n", - "adding: mem time95, current time 118, horizon 23\n", - "adding: mem time96, current time 118, horizon 22\n", - "adding: mem time97, current time 118, horizon 21\n", - "adding: mem time98, current time 118, horizon 20\n", - "adding: mem time99, current time 118, horizon 19\n", - "adding: mem time100, current time 118, horizon 18\n", - "adding: mem time101, current time 118, horizon 17\n", - "adding: mem time102, current time 118, horizon 16\n", - "adding: mem time103, current time 118, horizon 15\n", - "adding: mem time104, current time 118, horizon 14\n", - "adding: mem time105, current time 118, horizon 13\n", - "adding: mem time106, current time 118, horizon 12\n", - "adding: mem time107, current time 118, horizon 11\n", - "adding: mem time108, current time 118, horizon 10\n", - "adding: mem time109, current time 118, horizon 9\n", - "adding: mem time110, current time 118, horizon 8\n", - "adding: mem time111, current time 118, horizon 7\n", - "adding: mem time112, current time 118, horizon 6\n", - "adding: mem time113, current time 118, horizon 5\n", - "adding: mem time114, current time 118, horizon 4\n", - "adding: mem time115, current time 118, horizon 3\n", - "adding: mem time116, current time 118, horizon 2\n", - "adding: mem time117, current time 118, horizon 1\n", - "adding: mem time0, current time 119, horizon 119\n", - "adding: mem time1, current time 119, horizon 118\n", - "adding: mem time2, current time 119, horizon 117\n", - "adding: mem time3, current time 119, horizon 116\n", - "adding: mem time4, current time 119, horizon 115\n", - "adding: mem time5, current time 119, horizon 114\n", - "adding: mem time6, current time 119, horizon 113\n", - "adding: mem time7, current time 119, horizon 112\n", - "adding: mem time8, current time 119, horizon 111\n", - "adding: mem time9, current time 119, horizon 110\n", - "adding: mem time10, current time 119, horizon 109\n", - "adding: mem time11, current time 119, horizon 108\n", - "adding: mem time12, current time 119, horizon 107\n", - "adding: mem time13, current time 119, horizon 106\n", - "adding: mem time14, current time 119, horizon 105\n", - "adding: mem time15, current time 119, horizon 104\n", - "adding: mem time16, current time 119, horizon 103\n", - "adding: mem time17, current time 119, horizon 102\n", - "adding: mem time18, current time 119, horizon 101\n", - "adding: mem time19, current time 119, horizon 100\n", - "adding: mem time20, current time 119, horizon 99\n", - "adding: mem time21, current time 119, horizon 98\n", - "adding: mem time22, current time 119, horizon 97\n", - "adding: mem time23, current time 119, horizon 96\n", - "adding: mem time24, current time 119, horizon 95\n", - "adding: mem time25, current time 119, horizon 94\n", - "adding: mem time26, current time 119, horizon 93\n", - "adding: mem time27, current time 119, horizon 92\n", - "adding: mem time28, current time 119, horizon 91\n", - "adding: mem time29, current time 119, horizon 90\n", - "adding: mem time30, current time 119, horizon 89\n", - "adding: mem time31, current time 119, horizon 88\n", - "adding: mem time32, current time 119, horizon 87\n", - "adding: mem time33, current time 119, horizon 86\n", - "adding: mem time34, current time 119, horizon 85\n", - "adding: mem time35, current time 119, horizon 84\n", - "adding: mem time36, current time 119, horizon 83\n", - "adding: mem time37, current time 119, horizon 82\n", - "adding: mem time38, current time 119, horizon 81\n", - "adding: mem time39, current time 119, horizon 80\n", - "adding: mem time40, current time 119, horizon 79\n", - "adding: mem time41, current time 119, horizon 78\n", - "adding: mem time42, current time 119, horizon 77\n", - "adding: mem time43, current time 119, horizon 76\n", - "adding: mem time44, current time 119, horizon 75\n", - "adding: mem time45, current time 119, horizon 74\n", - "adding: mem time46, current time 119, horizon 73\n", - "adding: mem time47, current time 119, horizon 72\n", - "adding: mem time48, current time 119, horizon 71\n", - "adding: mem time49, current time 119, horizon 70\n", - "adding: mem time50, current time 119, horizon 69\n", - "adding: mem time51, current time 119, horizon 68\n", - "adding: mem time52, current time 119, horizon 67\n", - "adding: mem time53, current time 119, horizon 66\n", - "adding: mem time54, current time 119, horizon 65\n", - "adding: mem time55, current time 119, horizon 64\n", - "adding: mem time56, current time 119, horizon 63\n", - "adding: mem time57, current time 119, horizon 62\n", - "adding: mem time58, current time 119, horizon 61\n", - "adding: mem time59, current time 119, horizon 60\n", - "adding: mem time60, current time 119, horizon 59\n", - "adding: mem time61, current time 119, horizon 58\n", - "adding: mem time62, current time 119, horizon 57\n", - "adding: mem time63, current time 119, horizon 56\n", - "adding: mem time64, current time 119, horizon 55\n", - "adding: mem time65, current time 119, horizon 54\n", - "adding: mem time66, current time 119, horizon 53\n", - "adding: mem time67, current time 119, horizon 52\n", - "adding: mem time68, current time 119, horizon 51\n", - "adding: mem time69, current time 119, horizon 50\n", - "adding: mem time70, current time 119, horizon 49\n", - "adding: mem time71, current time 119, horizon 48\n", - "adding: mem time72, current time 119, horizon 47\n", - "adding: mem time73, current time 119, horizon 46\n", - "adding: mem time74, current time 119, horizon 45\n", - "adding: mem time75, current time 119, horizon 44\n", - "adding: mem time76, current time 119, horizon 43\n", - "adding: mem time77, current time 119, horizon 42\n", - "adding: mem time78, current time 119, horizon 41\n", - "adding: mem time79, current time 119, horizon 40\n", - "adding: mem time80, current time 119, horizon 39\n", - "adding: mem time81, current time 119, horizon 38\n", - "adding: mem time82, current time 119, horizon 37\n", - "adding: mem time83, current time 119, horizon 36\n", - "adding: mem time84, current time 119, horizon 35\n", - "adding: mem time85, current time 119, horizon 34\n", - "adding: mem time86, current time 119, horizon 33\n", - "adding: mem time87, current time 119, horizon 32\n", - "adding: mem time88, current time 119, horizon 31\n", - "adding: mem time89, current time 119, horizon 30\n", - "adding: mem time90, current time 119, horizon 29\n", - "adding: mem time91, current time 119, horizon 28\n", - "adding: mem time92, current time 119, horizon 27\n", - "adding: mem time93, current time 119, horizon 26\n", - "adding: mem time94, current time 119, horizon 25\n", - "adding: mem time95, current time 119, horizon 24\n", - "adding: mem time96, current time 119, horizon 23\n", - "adding: mem time97, current time 119, horizon 22\n", - "adding: mem time98, current time 119, horizon 21\n", - "adding: mem time99, current time 119, horizon 20\n", - "adding: mem time100, current time 119, horizon 19\n", - "adding: mem time101, current time 119, horizon 18\n", - "adding: mem time102, current time 119, horizon 17\n", - "adding: mem time103, current time 119, horizon 16\n", - "adding: mem time104, current time 119, horizon 15\n", - "adding: mem time105, current time 119, horizon 14\n", - "adding: mem time106, current time 119, horizon 13\n", - "adding: mem time107, current time 119, horizon 12\n", - "adding: mem time108, current time 119, horizon 11\n", - "adding: mem time109, current time 119, horizon 10\n", - "adding: mem time110, current time 119, horizon 9\n", - "adding: mem time111, current time 119, horizon 8\n", - "adding: mem time112, current time 119, horizon 7\n", - "adding: mem time113, current time 119, horizon 6\n", - "adding: mem time114, current time 119, horizon 5\n", - "adding: mem time115, current time 119, horizon 4\n", - "adding: mem time116, current time 119, horizon 3\n", - "adding: mem time117, current time 119, horizon 2\n", - "adding: mem time118, current time 119, horizon 1\n", - "adding: mem time0, current time 120, horizon 120\n", - "adding: mem time1, current time 120, horizon 119\n", - "adding: mem time2, current time 120, horizon 118\n", - "adding: mem time3, current time 120, horizon 117\n", - "adding: mem time4, current time 120, horizon 116\n", - "adding: mem time5, current time 120, horizon 115\n", - "adding: mem time6, current time 120, horizon 114\n", - "adding: mem time7, current time 120, horizon 113\n", - "adding: mem time8, current time 120, horizon 112\n", - "adding: mem time9, current time 120, horizon 111\n", - "adding: mem time10, current time 120, horizon 110\n", - "adding: mem time11, current time 120, horizon 109\n", - "adding: mem time12, current time 120, horizon 108\n", - "adding: mem time13, current time 120, horizon 107\n", - "adding: mem time14, current time 120, horizon 106\n", - "adding: mem time15, current time 120, horizon 105\n", - "adding: mem time16, current time 120, horizon 104\n", - "adding: mem time17, current time 120, horizon 103\n", - "adding: mem time18, current time 120, horizon 102\n", - "adding: mem time19, current time 120, horizon 101\n", - "adding: mem time20, current time 120, horizon 100\n", - "adding: mem time21, current time 120, horizon 99\n", - "adding: mem time22, current time 120, horizon 98\n", - "adding: mem time23, current time 120, horizon 97\n", - "adding: mem time24, current time 120, horizon 96\n", - "adding: mem time25, current time 120, horizon 95\n", - "adding: mem time26, current time 120, horizon 94\n", - "adding: mem time27, current time 120, horizon 93\n", - "adding: mem time28, current time 120, horizon 92\n", - "adding: mem time29, current time 120, horizon 91\n", - "adding: mem time30, current time 120, horizon 90\n", - "adding: mem time31, current time 120, horizon 89\n", - "adding: mem time32, current time 120, horizon 88\n", - "adding: mem time33, current time 120, horizon 87\n", - "adding: mem time34, current time 120, horizon 86\n", - "adding: mem time35, current time 120, horizon 85\n", - "adding: mem time36, current time 120, horizon 84\n", - "adding: mem time37, current time 120, horizon 83\n", - "adding: mem time38, current time 120, horizon 82\n", - "adding: mem time39, current time 120, horizon 81\n", - "adding: mem time40, current time 120, horizon 80\n", - "adding: mem time41, current time 120, horizon 79\n", - "adding: mem time42, current time 120, horizon 78\n", - "adding: mem time43, current time 120, horizon 77\n", - "adding: mem time44, current time 120, horizon 76\n", - "adding: mem time45, current time 120, horizon 75\n", - "adding: mem time46, current time 120, horizon 74\n", - "adding: mem time47, current time 120, horizon 73\n", - "adding: mem time48, current time 120, horizon 72\n", - "adding: mem time49, current time 120, horizon 71\n", - "adding: mem time50, current time 120, horizon 70\n", - "adding: mem time51, current time 120, horizon 69\n", - "adding: mem time52, current time 120, horizon 68\n", - "adding: mem time53, current time 120, horizon 67\n", - "adding: mem time54, current time 120, horizon 66\n", - "adding: mem time55, current time 120, horizon 65\n", - "adding: mem time56, current time 120, horizon 64\n", - "adding: mem time57, current time 120, horizon 63\n", - "adding: mem time58, current time 120, horizon 62\n", - "adding: mem time59, current time 120, horizon 61\n", - "adding: mem time60, current time 120, horizon 60\n", - "adding: mem time61, current time 120, horizon 59\n", - "adding: mem time62, current time 120, horizon 58\n", - "adding: mem time63, current time 120, horizon 57\n", - "adding: mem time64, current time 120, horizon 56\n", - "adding: mem time65, current time 120, horizon 55\n", - "adding: mem time66, current time 120, horizon 54\n", - "adding: mem time67, current time 120, horizon 53\n", - "adding: mem time68, current time 120, horizon 52\n", - "adding: mem time69, current time 120, horizon 51\n", - "adding: mem time70, current time 120, horizon 50\n", - "adding: mem time71, current time 120, horizon 49\n", - "adding: mem time72, current time 120, horizon 48\n", - "adding: mem time73, current time 120, horizon 47\n", - "adding: mem time74, current time 120, horizon 46\n", - "adding: mem time75, current time 120, horizon 45\n", - "adding: mem time76, current time 120, horizon 44\n", - "adding: mem time77, current time 120, horizon 43\n", - "adding: mem time78, current time 120, horizon 42\n", - "adding: mem time79, current time 120, horizon 41\n", - "adding: mem time80, current time 120, horizon 40\n", - "adding: mem time81, current time 120, horizon 39\n", - "adding: mem time82, current time 120, horizon 38\n", - "adding: mem time83, current time 120, horizon 37\n", - "adding: mem time84, current time 120, horizon 36\n", - "adding: mem time85, current time 120, horizon 35\n", - "adding: mem time86, current time 120, horizon 34\n", - "adding: mem time87, current time 120, horizon 33\n", - "adding: mem time88, current time 120, horizon 32\n", - "adding: mem time89, current time 120, horizon 31\n", - "adding: mem time90, current time 120, horizon 30\n", - "adding: mem time91, current time 120, horizon 29\n", - "adding: mem time92, current time 120, horizon 28\n", - "adding: mem time93, current time 120, horizon 27\n", - "adding: mem time94, current time 120, horizon 26\n", - "adding: mem time95, current time 120, horizon 25\n", - "adding: mem time96, current time 120, horizon 24\n", - "adding: mem time97, current time 120, horizon 23\n", - "adding: mem time98, current time 120, horizon 22\n", - "adding: mem time99, current time 120, horizon 21\n", - "adding: mem time100, current time 120, horizon 20\n", - "adding: mem time101, current time 120, horizon 19\n", - "adding: mem time102, current time 120, horizon 18\n", - "adding: mem time103, current time 120, horizon 17\n", - "adding: mem time104, current time 120, horizon 16\n", - "adding: mem time105, current time 120, horizon 15\n", - "adding: mem time106, current time 120, horizon 14\n", - "adding: mem time107, current time 120, horizon 13\n", - "adding: mem time108, current time 120, horizon 12\n", - "adding: mem time109, current time 120, horizon 11\n", - "adding: mem time110, current time 120, horizon 10\n", - "adding: mem time111, current time 120, horizon 9\n", - "adding: mem time112, current time 120, horizon 8\n", - "adding: mem time113, current time 120, horizon 7\n", - "adding: mem time114, current time 120, horizon 6\n", - "adding: mem time115, current time 120, horizon 5\n", - "adding: mem time116, current time 120, horizon 4\n", - "adding: mem time117, current time 120, horizon 3\n", - "adding: mem time118, current time 120, horizon 2\n", - "adding: mem time119, current time 120, horizon 1\n", - "adding: mem time0, current time 121, horizon 121\n", - "adding: mem time1, current time 121, horizon 120\n", - "adding: mem time2, current time 121, horizon 119\n", - "adding: mem time3, current time 121, horizon 118\n", - "adding: mem time4, current time 121, horizon 117\n", - "adding: mem time5, current time 121, horizon 116\n", - "adding: mem time6, current time 121, horizon 115\n", - "adding: mem time7, current time 121, horizon 114\n", - "adding: mem time8, current time 121, horizon 113\n", - "adding: mem time9, current time 121, horizon 112\n", - "adding: mem time10, current time 121, horizon 111\n", - "adding: mem time11, current time 121, horizon 110\n", - "adding: mem time12, current time 121, horizon 109\n", - "adding: mem time13, current time 121, horizon 108\n", - "adding: mem time14, current time 121, horizon 107\n", - "adding: mem time15, current time 121, horizon 106\n", - "adding: mem time16, current time 121, horizon 105\n", - "adding: mem time17, current time 121, horizon 104\n", - "adding: mem time18, current time 121, horizon 103\n", - "adding: mem time19, current time 121, horizon 102\n", - "adding: mem time20, current time 121, horizon 101\n", - "adding: mem time21, current time 121, horizon 100\n", - "adding: mem time22, current time 121, horizon 99\n", - "adding: mem time23, current time 121, horizon 98\n", - "adding: mem time24, current time 121, horizon 97\n", - "adding: mem time25, current time 121, horizon 96\n", - "adding: mem time26, current time 121, horizon 95\n", - "adding: mem time27, current time 121, horizon 94\n", - "adding: mem time28, current time 121, horizon 93\n", - "adding: mem time29, current time 121, horizon 92\n", - "adding: mem time30, current time 121, horizon 91\n", - "adding: mem time31, current time 121, horizon 90\n", - "adding: mem time32, current time 121, horizon 89\n", - "adding: mem time33, current time 121, horizon 88\n", - "adding: mem time34, current time 121, horizon 87\n", - "adding: mem time35, current time 121, horizon 86\n", - "adding: mem time36, current time 121, horizon 85\n", - "adding: mem time37, current time 121, horizon 84\n", - "adding: mem time38, current time 121, horizon 83\n", - "adding: mem time39, current time 121, horizon 82\n", - "adding: mem time40, current time 121, horizon 81\n", - "adding: mem time41, current time 121, horizon 80\n", - "adding: mem time42, current time 121, horizon 79\n", - "adding: mem time43, current time 121, horizon 78\n", - "adding: mem time44, current time 121, horizon 77\n", - "adding: mem time45, current time 121, horizon 76\n", - "adding: mem time46, current time 121, horizon 75\n", - "adding: mem time47, current time 121, horizon 74\n", - "adding: mem time48, current time 121, horizon 73\n", - "adding: mem time49, current time 121, horizon 72\n", - "adding: mem time50, current time 121, horizon 71\n", - "adding: mem time51, current time 121, horizon 70\n", - "adding: mem time52, current time 121, horizon 69\n", - "adding: mem time53, current time 121, horizon 68\n", - "adding: mem time54, current time 121, horizon 67\n", - "adding: mem time55, current time 121, horizon 66\n", - "adding: mem time56, current time 121, horizon 65\n", - "adding: mem time57, current time 121, horizon 64\n", - "adding: mem time58, current time 121, horizon 63\n", - "adding: mem time59, current time 121, horizon 62\n", - "adding: mem time60, current time 121, horizon 61\n", - "adding: mem time61, current time 121, horizon 60\n", - "adding: mem time62, current time 121, horizon 59\n", - "adding: mem time63, current time 121, horizon 58\n", - "adding: mem time64, current time 121, horizon 57\n", - "adding: mem time65, current time 121, horizon 56\n", - "adding: mem time66, current time 121, horizon 55\n", - "adding: mem time67, current time 121, horizon 54\n", - "adding: mem time68, current time 121, horizon 53\n", - "adding: mem time69, current time 121, horizon 52\n", - "adding: mem time70, current time 121, horizon 51\n", - "adding: mem time71, current time 121, horizon 50\n", - "adding: mem time72, current time 121, horizon 49\n", - "adding: mem time73, current time 121, horizon 48\n", - "adding: mem time74, current time 121, horizon 47\n", - "adding: mem time75, current time 121, horizon 46\n", - "adding: mem time76, current time 121, horizon 45\n", - "adding: mem time77, current time 121, horizon 44\n", - "adding: mem time78, current time 121, horizon 43\n", - "adding: mem time79, current time 121, horizon 42\n", - "adding: mem time80, current time 121, horizon 41\n", - "adding: mem time81, current time 121, horizon 40\n", - "adding: mem time82, current time 121, horizon 39\n", - "adding: mem time83, current time 121, horizon 38\n", - "adding: mem time84, current time 121, horizon 37\n", - "adding: mem time85, current time 121, horizon 36\n", - "adding: mem time86, current time 121, horizon 35\n", - "adding: mem time87, current time 121, horizon 34\n", - "adding: mem time88, current time 121, horizon 33\n", - "adding: mem time89, current time 121, horizon 32\n", - "adding: mem time90, current time 121, horizon 31\n", - "adding: mem time91, current time 121, horizon 30\n", - "adding: mem time92, current time 121, horizon 29\n", - "adding: mem time93, current time 121, horizon 28\n", - "adding: mem time94, current time 121, horizon 27\n", - "adding: mem time95, current time 121, horizon 26\n", - "adding: mem time96, current time 121, horizon 25\n", - "adding: mem time97, current time 121, horizon 24\n", - "adding: mem time98, current time 121, horizon 23\n", - "adding: mem time99, current time 121, horizon 22\n", - "adding: mem time100, current time 121, horizon 21\n", - "adding: mem time101, current time 121, horizon 20\n", - "adding: mem time102, current time 121, horizon 19\n", - "adding: mem time103, current time 121, horizon 18\n", - "adding: mem time104, current time 121, horizon 17\n", - "adding: mem time105, current time 121, horizon 16\n", - "adding: mem time106, current time 121, horizon 15\n", - "adding: mem time107, current time 121, horizon 14\n", - "adding: mem time108, current time 121, horizon 13\n", - "adding: mem time109, current time 121, horizon 12\n", - "adding: mem time110, current time 121, horizon 11\n", - "adding: mem time111, current time 121, horizon 10\n", - "adding: mem time112, current time 121, horizon 9\n", - "adding: mem time113, current time 121, horizon 8\n", - "adding: mem time114, current time 121, horizon 7\n", - "adding: mem time115, current time 121, horizon 6\n", - "adding: mem time116, current time 121, horizon 5\n", - "adding: mem time117, current time 121, horizon 4\n", - "adding: mem time118, current time 121, horizon 3\n", - "adding: mem time119, current time 121, horizon 2\n", - "adding: mem time120, current time 121, horizon 1\n", - "adding: mem time0, current time 122, horizon 122\n", - "adding: mem time1, current time 122, horizon 121\n", - "adding: mem time2, current time 122, horizon 120\n", - "adding: mem time3, current time 122, horizon 119\n", - "adding: mem time4, current time 122, horizon 118\n", - "adding: mem time5, current time 122, horizon 117\n", - "adding: mem time6, current time 122, horizon 116\n", - "adding: mem time7, current time 122, horizon 115\n", - "adding: mem time8, current time 122, horizon 114\n", - "adding: mem time9, current time 122, horizon 113\n", - "adding: mem time10, current time 122, horizon 112\n", - "adding: mem time11, current time 122, horizon 111\n", - "adding: mem time12, current time 122, horizon 110\n", - "adding: mem time13, current time 122, horizon 109\n", - "adding: mem time14, current time 122, horizon 108\n", - "adding: mem time15, current time 122, horizon 107\n", - "adding: mem time16, current time 122, horizon 106\n", - "adding: mem time17, current time 122, horizon 105\n", - "adding: mem time18, current time 122, horizon 104\n", - "adding: mem time19, current time 122, horizon 103\n", - "adding: mem time20, current time 122, horizon 102\n", - "adding: mem time21, current time 122, horizon 101\n", - "adding: mem time22, current time 122, horizon 100\n", - "adding: mem time23, current time 122, horizon 99\n", - "adding: mem time24, current time 122, horizon 98\n", - "adding: mem time25, current time 122, horizon 97\n", - "adding: mem time26, current time 122, horizon 96\n", - "adding: mem time27, current time 122, horizon 95\n", - "adding: mem time28, current time 122, horizon 94\n", - "adding: mem time29, current time 122, horizon 93\n", - "adding: mem time30, current time 122, horizon 92\n", - "adding: mem time31, current time 122, horizon 91\n", - "adding: mem time32, current time 122, horizon 90\n", - "adding: mem time33, current time 122, horizon 89\n", - "adding: mem time34, current time 122, horizon 88\n", - "adding: mem time35, current time 122, horizon 87\n", - "adding: mem time36, current time 122, horizon 86\n", - "adding: mem time37, current time 122, horizon 85\n", - "adding: mem time38, current time 122, horizon 84\n", - "adding: mem time39, current time 122, horizon 83\n", - "adding: mem time40, current time 122, horizon 82\n", - "adding: mem time41, current time 122, horizon 81\n", - "adding: mem time42, current time 122, horizon 80\n", - "adding: mem time43, current time 122, horizon 79\n", - "adding: mem time44, current time 122, horizon 78\n", - "adding: mem time45, current time 122, horizon 77\n", - "adding: mem time46, current time 122, horizon 76\n", - "adding: mem time47, current time 122, horizon 75\n", - "adding: mem time48, current time 122, horizon 74\n", - "adding: mem time49, current time 122, horizon 73\n", - "adding: mem time50, current time 122, horizon 72\n", - "adding: mem time51, current time 122, horizon 71\n", - "adding: mem time52, current time 122, horizon 70\n", - "adding: mem time53, current time 122, horizon 69\n", - "adding: mem time54, current time 122, horizon 68\n", - "adding: mem time55, current time 122, horizon 67\n", - "adding: mem time56, current time 122, horizon 66\n", - "adding: mem time57, current time 122, horizon 65\n", - "adding: mem time58, current time 122, horizon 64\n", - "adding: mem time59, current time 122, horizon 63\n", - "adding: mem time60, current time 122, horizon 62\n", - "adding: mem time61, current time 122, horizon 61\n", - "adding: mem time62, current time 122, horizon 60\n", - "adding: mem time63, current time 122, horizon 59\n", - "adding: mem time64, current time 122, horizon 58\n", - "adding: mem time65, current time 122, horizon 57\n", - "adding: mem time66, current time 122, horizon 56\n", - "adding: mem time67, current time 122, horizon 55\n", - "adding: mem time68, current time 122, horizon 54\n", - "adding: mem time69, current time 122, horizon 53\n", - "adding: mem time70, current time 122, horizon 52\n", - "adding: mem time71, current time 122, horizon 51\n", - "adding: mem time72, current time 122, horizon 50\n", - "adding: mem time73, current time 122, horizon 49\n", - "adding: mem time74, current time 122, horizon 48\n", - "adding: mem time75, current time 122, horizon 47\n", - "adding: mem time76, current time 122, horizon 46\n", - "adding: mem time77, current time 122, horizon 45\n", - "adding: mem time78, current time 122, horizon 44\n", - "adding: mem time79, current time 122, horizon 43\n", - "adding: mem time80, current time 122, horizon 42\n", - "adding: mem time81, current time 122, horizon 41\n", - "adding: mem time82, current time 122, horizon 40\n", - "adding: mem time83, current time 122, horizon 39\n", - "adding: mem time84, current time 122, horizon 38\n", - "adding: mem time85, current time 122, horizon 37\n", - "adding: mem time86, current time 122, horizon 36\n", - "adding: mem time87, current time 122, horizon 35\n", - "adding: mem time88, current time 122, horizon 34\n", - "adding: mem time89, current time 122, horizon 33\n", - "adding: mem time90, current time 122, horizon 32\n", - "adding: mem time91, current time 122, horizon 31\n", - "adding: mem time92, current time 122, horizon 30\n", - "adding: mem time93, current time 122, horizon 29\n", - "adding: mem time94, current time 122, horizon 28\n", - "adding: mem time95, current time 122, horizon 27\n", - "adding: mem time96, current time 122, horizon 26\n", - "adding: mem time97, current time 122, horizon 25\n", - "adding: mem time98, current time 122, horizon 24\n", - "adding: mem time99, current time 122, horizon 23\n", - "adding: mem time100, current time 122, horizon 22\n", - "adding: mem time101, current time 122, horizon 21\n", - "adding: mem time102, current time 122, horizon 20\n", - "adding: mem time103, current time 122, horizon 19\n", - "adding: mem time104, current time 122, horizon 18\n", - "adding: mem time105, current time 122, horizon 17\n", - "adding: mem time106, current time 122, horizon 16\n", - "adding: mem time107, current time 122, horizon 15\n", - "adding: mem time108, current time 122, horizon 14\n", - "adding: mem time109, current time 122, horizon 13\n", - "adding: mem time110, current time 122, horizon 12\n", - "adding: mem time111, current time 122, horizon 11\n", - "adding: mem time112, current time 122, horizon 10\n", - "adding: mem time113, current time 122, horizon 9\n", - "adding: mem time114, current time 122, horizon 8\n", - "adding: mem time115, current time 122, horizon 7\n", - "adding: mem time116, current time 122, horizon 6\n", - "adding: mem time117, current time 122, horizon 5\n", - "adding: mem time118, current time 122, horizon 4\n", - "adding: mem time119, current time 122, horizon 3\n", - "adding: mem time120, current time 122, horizon 2\n", - "adding: mem time121, current time 122, horizon 1\n", - "adding: mem time0, current time 123, horizon 123\n", - "adding: mem time1, current time 123, horizon 122\n", - "adding: mem time2, current time 123, horizon 121\n", - "adding: mem time3, current time 123, horizon 120\n", - "adding: mem time4, current time 123, horizon 119\n", - "adding: mem time5, current time 123, horizon 118\n", - "adding: mem time6, current time 123, horizon 117\n", - "adding: mem time7, current time 123, horizon 116\n", - "adding: mem time8, current time 123, horizon 115\n", - "adding: mem time9, current time 123, horizon 114\n", - "adding: mem time10, current time 123, horizon 113\n", - "adding: mem time11, current time 123, horizon 112\n", - "adding: mem time12, current time 123, horizon 111\n", - "adding: mem time13, current time 123, horizon 110\n", - "adding: mem time14, current time 123, horizon 109\n", - "adding: mem time15, current time 123, horizon 108\n", - "adding: mem time16, current time 123, horizon 107\n", - "adding: mem time17, current time 123, horizon 106\n", - "adding: mem time18, current time 123, horizon 105\n", - "adding: mem time19, current time 123, horizon 104\n", - "adding: mem time20, current time 123, horizon 103\n", - "adding: mem time21, current time 123, horizon 102\n", - "adding: mem time22, current time 123, horizon 101\n", - "adding: mem time23, current time 123, horizon 100\n", - "adding: mem time24, current time 123, horizon 99\n", - "adding: mem time25, current time 123, horizon 98\n", - "adding: mem time26, current time 123, horizon 97\n", - "adding: mem time27, current time 123, horizon 96\n", - "adding: mem time28, current time 123, horizon 95\n", - "adding: mem time29, current time 123, horizon 94\n", - "adding: mem time30, current time 123, horizon 93\n", - "adding: mem time31, current time 123, horizon 92\n", - "adding: mem time32, current time 123, horizon 91\n", - "adding: mem time33, current time 123, horizon 90\n", - "adding: mem time34, current time 123, horizon 89\n", - "adding: mem time35, current time 123, horizon 88\n", - "adding: mem time36, current time 123, horizon 87\n", - "adding: mem time37, current time 123, horizon 86\n", - "adding: mem time38, current time 123, horizon 85\n", - "adding: mem time39, current time 123, horizon 84\n", - "adding: mem time40, current time 123, horizon 83\n", - "adding: mem time41, current time 123, horizon 82\n", - "adding: mem time42, current time 123, horizon 81\n", - "adding: mem time43, current time 123, horizon 80\n", - "adding: mem time44, current time 123, horizon 79\n", - "adding: mem time45, current time 123, horizon 78\n", - "adding: mem time46, current time 123, horizon 77\n", - "adding: mem time47, current time 123, horizon 76\n", - "adding: mem time48, current time 123, horizon 75\n", - "adding: mem time49, current time 123, horizon 74\n", - "adding: mem time50, current time 123, horizon 73\n", - "adding: mem time51, current time 123, horizon 72\n", - "adding: mem time52, current time 123, horizon 71\n", - "adding: mem time53, current time 123, horizon 70\n", - "adding: mem time54, current time 123, horizon 69\n", - "adding: mem time55, current time 123, horizon 68\n", - "adding: mem time56, current time 123, horizon 67\n", - "adding: mem time57, current time 123, horizon 66\n", - "adding: mem time58, current time 123, horizon 65\n", - "adding: mem time59, current time 123, horizon 64\n", - "adding: mem time60, current time 123, horizon 63\n", - "adding: mem time61, current time 123, horizon 62\n", - "adding: mem time62, current time 123, horizon 61\n", - "adding: mem time63, current time 123, horizon 60\n", - "adding: mem time64, current time 123, horizon 59\n", - "adding: mem time65, current time 123, horizon 58\n", - "adding: mem time66, current time 123, horizon 57\n", - "adding: mem time67, current time 123, horizon 56\n", - "adding: mem time68, current time 123, horizon 55\n", - "adding: mem time69, current time 123, horizon 54\n", - "adding: mem time70, current time 123, horizon 53\n", - "adding: mem time71, current time 123, horizon 52\n", - "adding: mem time72, current time 123, horizon 51\n", - "adding: mem time73, current time 123, horizon 50\n", - "adding: mem time74, current time 123, horizon 49\n", - "adding: mem time75, current time 123, horizon 48\n", - "adding: mem time76, current time 123, horizon 47\n", - "adding: mem time77, current time 123, horizon 46\n", - "adding: mem time78, current time 123, horizon 45\n", - "adding: mem time79, current time 123, horizon 44\n", - "adding: mem time80, current time 123, horizon 43\n", - "adding: mem time81, current time 123, horizon 42\n", - "adding: mem time82, current time 123, horizon 41\n", - "adding: mem time83, current time 123, horizon 40\n", - "adding: mem time84, current time 123, horizon 39\n", - "adding: mem time85, current time 123, horizon 38\n", - "adding: mem time86, current time 123, horizon 37\n", - "adding: mem time87, current time 123, horizon 36\n", - "adding: mem time88, current time 123, horizon 35\n", - "adding: mem time89, current time 123, horizon 34\n", - "adding: mem time90, current time 123, horizon 33\n", - "adding: mem time91, current time 123, horizon 32\n", - "adding: mem time92, current time 123, horizon 31\n", - "adding: mem time93, current time 123, horizon 30\n", - "adding: mem time94, current time 123, horizon 29\n", - "adding: mem time95, current time 123, horizon 28\n", - "adding: mem time96, current time 123, horizon 27\n", - "adding: mem time97, current time 123, horizon 26\n", - "adding: mem time98, current time 123, horizon 25\n", - "adding: mem time99, current time 123, horizon 24\n", - "adding: mem time100, current time 123, horizon 23\n", - "adding: mem time101, current time 123, horizon 22\n", - "adding: mem time102, current time 123, horizon 21\n", - "adding: mem time103, current time 123, horizon 20\n", - "adding: mem time104, current time 123, horizon 19\n", - "adding: mem time105, current time 123, horizon 18\n", - "adding: mem time106, current time 123, horizon 17\n", - "adding: mem time107, current time 123, horizon 16\n", - "adding: mem time108, current time 123, horizon 15\n", - "adding: mem time109, current time 123, horizon 14\n", - "adding: mem time110, current time 123, horizon 13\n", - "adding: mem time111, current time 123, horizon 12\n", - "adding: mem time112, current time 123, horizon 11\n", - "adding: mem time113, current time 123, horizon 10\n", - "adding: mem time114, current time 123, horizon 9\n", - "adding: mem time115, current time 123, horizon 8\n", - "adding: mem time116, current time 123, horizon 7\n", - "adding: mem time117, current time 123, horizon 6\n", - "adding: mem time118, current time 123, horizon 5\n", - "adding: mem time119, current time 123, horizon 4\n", - "adding: mem time120, current time 123, horizon 3\n", - "adding: mem time121, current time 123, horizon 2\n", - "adding: mem time122, current time 123, horizon 1\n", - "adding: mem time0, current time 124, horizon 124\n", - "adding: mem time1, current time 124, horizon 123\n", - "adding: mem time2, current time 124, horizon 122\n", - "adding: mem time3, current time 124, horizon 121\n", - "adding: mem time4, current time 124, horizon 120\n", - "adding: mem time5, current time 124, horizon 119\n", - "adding: mem time6, current time 124, horizon 118\n", - "adding: mem time7, current time 124, horizon 117\n", - "adding: mem time8, current time 124, horizon 116\n", - "adding: mem time9, current time 124, horizon 115\n", - "adding: mem time10, current time 124, horizon 114\n", - "adding: mem time11, current time 124, horizon 113\n", - "adding: mem time12, current time 124, horizon 112\n", - "adding: mem time13, current time 124, horizon 111\n", - "adding: mem time14, current time 124, horizon 110\n", - "adding: mem time15, current time 124, horizon 109\n", - "adding: mem time16, current time 124, horizon 108\n", - "adding: mem time17, current time 124, horizon 107\n", - "adding: mem time18, current time 124, horizon 106\n", - "adding: mem time19, current time 124, horizon 105\n", - "adding: mem time20, current time 124, horizon 104\n", - "adding: mem time21, current time 124, horizon 103\n", - "adding: mem time22, current time 124, horizon 102\n", - "adding: mem time23, current time 124, horizon 101\n", - "adding: mem time24, current time 124, horizon 100\n", - "adding: mem time25, current time 124, horizon 99\n", - "adding: mem time26, current time 124, horizon 98\n", - "adding: mem time27, current time 124, horizon 97\n", - "adding: mem time28, current time 124, horizon 96\n", - "adding: mem time29, current time 124, horizon 95\n", - "adding: mem time30, current time 124, horizon 94\n", - "adding: mem time31, current time 124, horizon 93\n", - "adding: mem time32, current time 124, horizon 92\n", - "adding: mem time33, current time 124, horizon 91\n", - "adding: mem time34, current time 124, horizon 90\n", - "adding: mem time35, current time 124, horizon 89\n", - "adding: mem time36, current time 124, horizon 88\n", - "adding: mem time37, current time 124, horizon 87\n", - "adding: mem time38, current time 124, horizon 86\n", - "adding: mem time39, current time 124, horizon 85\n", - "adding: mem time40, current time 124, horizon 84\n", - "adding: mem time41, current time 124, horizon 83\n", - "adding: mem time42, current time 124, horizon 82\n", - "adding: mem time43, current time 124, horizon 81\n", - "adding: mem time44, current time 124, horizon 80\n", - "adding: mem time45, current time 124, horizon 79\n", - "adding: mem time46, current time 124, horizon 78\n", - "adding: mem time47, current time 124, horizon 77\n", - "adding: mem time48, current time 124, horizon 76\n", - "adding: mem time49, current time 124, horizon 75\n", - "adding: mem time50, current time 124, horizon 74\n", - "adding: mem time51, current time 124, horizon 73\n", - "adding: mem time52, current time 124, horizon 72\n", - "adding: mem time53, current time 124, horizon 71\n", - "adding: mem time54, current time 124, horizon 70\n", - "adding: mem time55, current time 124, horizon 69\n", - "adding: mem time56, current time 124, horizon 68\n", - "adding: mem time57, current time 124, horizon 67\n", - "adding: mem time58, current time 124, horizon 66\n", - "adding: mem time59, current time 124, horizon 65\n", - "adding: mem time60, current time 124, horizon 64\n", - "adding: mem time61, current time 124, horizon 63\n", - "adding: mem time62, current time 124, horizon 62\n", - "adding: mem time63, current time 124, horizon 61\n", - "adding: mem time64, current time 124, horizon 60\n", - "adding: mem time65, current time 124, horizon 59\n", - "adding: mem time66, current time 124, horizon 58\n", - "adding: mem time67, current time 124, horizon 57\n", - "adding: mem time68, current time 124, horizon 56\n", - "adding: mem time69, current time 124, horizon 55\n", - "adding: mem time70, current time 124, horizon 54\n", - "adding: mem time71, current time 124, horizon 53\n", - "adding: mem time72, current time 124, horizon 52\n", - "adding: mem time73, current time 124, horizon 51\n", - "adding: mem time74, current time 124, horizon 50\n", - "adding: mem time75, current time 124, horizon 49\n", - "adding: mem time76, current time 124, horizon 48\n", - "adding: mem time77, current time 124, horizon 47\n", - "adding: mem time78, current time 124, horizon 46\n", - "adding: mem time79, current time 124, horizon 45\n", - "adding: mem time80, current time 124, horizon 44\n", - "adding: mem time81, current time 124, horizon 43\n", - "adding: mem time82, current time 124, horizon 42\n", - "adding: mem time83, current time 124, horizon 41\n", - "adding: mem time84, current time 124, horizon 40\n", - "adding: mem time85, current time 124, horizon 39\n", - "adding: mem time86, current time 124, horizon 38\n", - "adding: mem time87, current time 124, horizon 37\n", - "adding: mem time88, current time 124, horizon 36\n", - "adding: mem time89, current time 124, horizon 35\n", - "adding: mem time90, current time 124, horizon 34\n", - "adding: mem time91, current time 124, horizon 33\n", - "adding: mem time92, current time 124, horizon 32\n", - "adding: mem time93, current time 124, horizon 31\n", - "adding: mem time94, current time 124, horizon 30\n", - "adding: mem time95, current time 124, horizon 29\n", - "adding: mem time96, current time 124, horizon 28\n", - "adding: mem time97, current time 124, horizon 27\n", - "adding: mem time98, current time 124, horizon 26\n", - "adding: mem time99, current time 124, horizon 25\n", - "adding: mem time100, current time 124, horizon 24\n", - "adding: mem time101, current time 124, horizon 23\n", - "adding: mem time102, current time 124, horizon 22\n", - "adding: mem time103, current time 124, horizon 21\n", - "adding: mem time104, current time 124, horizon 20\n", - "adding: mem time105, current time 124, horizon 19\n", - "adding: mem time106, current time 124, horizon 18\n", - "adding: mem time107, current time 124, horizon 17\n", - "adding: mem time108, current time 124, horizon 16\n", - "adding: mem time109, current time 124, horizon 15\n", - "adding: mem time110, current time 124, horizon 14\n", - "adding: mem time111, current time 124, horizon 13\n", - "adding: mem time112, current time 124, horizon 12\n", - "adding: mem time113, current time 124, horizon 11\n", - "adding: mem time114, current time 124, horizon 10\n", - "adding: mem time115, current time 124, horizon 9\n", - "adding: mem time116, current time 124, horizon 8\n", - "adding: mem time117, current time 124, horizon 7\n", - "adding: mem time118, current time 124, horizon 6\n", - "adding: mem time119, current time 124, horizon 5\n", - "adding: mem time120, current time 124, horizon 4\n", - "adding: mem time121, current time 124, horizon 3\n", - "adding: mem time122, current time 124, horizon 2\n", - "adding: mem time123, current time 124, horizon 1\n", - "adding: mem time0, current time 125, horizon 125\n", - "adding: mem time1, current time 125, horizon 124\n", - "adding: mem time2, current time 125, horizon 123\n", - "adding: mem time3, current time 125, horizon 122\n", - "adding: mem time4, current time 125, horizon 121\n", - "adding: mem time5, current time 125, horizon 120\n", - "adding: mem time6, current time 125, horizon 119\n", - "adding: mem time7, current time 125, horizon 118\n", - "adding: mem time8, current time 125, horizon 117\n", - "adding: mem time9, current time 125, horizon 116\n", - "adding: mem time10, current time 125, horizon 115\n", - "adding: mem time11, current time 125, horizon 114\n", - "adding: mem time12, current time 125, horizon 113\n", - "adding: mem time13, current time 125, horizon 112\n", - "adding: mem time14, current time 125, horizon 111\n", - "adding: mem time15, current time 125, horizon 110\n", - "adding: mem time16, current time 125, horizon 109\n", - "adding: mem time17, current time 125, horizon 108\n", - "adding: mem time18, current time 125, horizon 107\n", - "adding: mem time19, current time 125, horizon 106\n", - "adding: mem time20, current time 125, horizon 105\n", - "adding: mem time21, current time 125, horizon 104\n", - "adding: mem time22, current time 125, horizon 103\n", - "adding: mem time23, current time 125, horizon 102\n", - "adding: mem time24, current time 125, horizon 101\n", - "adding: mem time25, current time 125, horizon 100\n", - "adding: mem time26, current time 125, horizon 99\n", - "adding: mem time27, current time 125, horizon 98\n", - "adding: mem time28, current time 125, horizon 97\n", - "adding: mem time29, current time 125, horizon 96\n", - "adding: mem time30, current time 125, horizon 95\n", - "adding: mem time31, current time 125, horizon 94\n", - "adding: mem time32, current time 125, horizon 93\n", - "adding: mem time33, current time 125, horizon 92\n", - "adding: mem time34, current time 125, horizon 91\n", - "adding: mem time35, current time 125, horizon 90\n", - "adding: mem time36, current time 125, horizon 89\n", - "adding: mem time37, current time 125, horizon 88\n", - "adding: mem time38, current time 125, horizon 87\n", - "adding: mem time39, current time 125, horizon 86\n", - "adding: mem time40, current time 125, horizon 85\n", - "adding: mem time41, current time 125, horizon 84\n", - "adding: mem time42, current time 125, horizon 83\n", - "adding: mem time43, current time 125, horizon 82\n", - "adding: mem time44, current time 125, horizon 81\n", - "adding: mem time45, current time 125, horizon 80\n", - "adding: mem time46, current time 125, horizon 79\n", - "adding: mem time47, current time 125, horizon 78\n", - "adding: mem time48, current time 125, horizon 77\n", - "adding: mem time49, current time 125, horizon 76\n", - "adding: mem time50, current time 125, horizon 75\n", - "adding: mem time51, current time 125, horizon 74\n", - "adding: mem time52, current time 125, horizon 73\n", - "adding: mem time53, current time 125, horizon 72\n", - "adding: mem time54, current time 125, horizon 71\n", - "adding: mem time55, current time 125, horizon 70\n", - "adding: mem time56, current time 125, horizon 69\n", - "adding: mem time57, current time 125, horizon 68\n", - "adding: mem time58, current time 125, horizon 67\n", - "adding: mem time59, current time 125, horizon 66\n", - "adding: mem time60, current time 125, horizon 65\n", - "adding: mem time61, current time 125, horizon 64\n", - "adding: mem time62, current time 125, horizon 63\n", - "adding: mem time63, current time 125, horizon 62\n", - "adding: mem time64, current time 125, horizon 61\n", - "adding: mem time65, current time 125, horizon 60\n", - "adding: mem time66, current time 125, horizon 59\n", - "adding: mem time67, current time 125, horizon 58\n", - "adding: mem time68, current time 125, horizon 57\n", - "adding: mem time69, current time 125, horizon 56\n", - "adding: mem time70, current time 125, horizon 55\n", - "adding: mem time71, current time 125, horizon 54\n", - "adding: mem time72, current time 125, horizon 53\n", - "adding: mem time73, current time 125, horizon 52\n", - "adding: mem time74, current time 125, horizon 51\n", - "adding: mem time75, current time 125, horizon 50\n", - "adding: mem time76, current time 125, horizon 49\n", - "adding: mem time77, current time 125, horizon 48\n", - "adding: mem time78, current time 125, horizon 47\n", - "adding: mem time79, current time 125, horizon 46\n", - "adding: mem time80, current time 125, horizon 45\n", - "adding: mem time81, current time 125, horizon 44\n", - "adding: mem time82, current time 125, horizon 43\n", - "adding: mem time83, current time 125, horizon 42\n", - "adding: mem time84, current time 125, horizon 41\n", - "adding: mem time85, current time 125, horizon 40\n", - "adding: mem time86, current time 125, horizon 39\n", - "adding: mem time87, current time 125, horizon 38\n", - "adding: mem time88, current time 125, horizon 37\n", - "adding: mem time89, current time 125, horizon 36\n", - "adding: mem time90, current time 125, horizon 35\n", - "adding: mem time91, current time 125, horizon 34\n", - "adding: mem time92, current time 125, horizon 33\n", - "adding: mem time93, current time 125, horizon 32\n", - "adding: mem time94, current time 125, horizon 31\n", - "adding: mem time95, current time 125, horizon 30\n", - "adding: mem time96, current time 125, horizon 29\n", - "adding: mem time97, current time 125, horizon 28\n", - "adding: mem time98, current time 125, horizon 27\n", - "adding: mem time99, current time 125, horizon 26\n", - "adding: mem time100, current time 125, horizon 25\n", - "adding: mem time101, current time 125, horizon 24\n", - "adding: mem time102, current time 125, horizon 23\n", - "adding: mem time103, current time 125, horizon 22\n", - "adding: mem time104, current time 125, horizon 21\n", - "adding: mem time105, current time 125, horizon 20\n", - "adding: mem time106, current time 125, horizon 19\n", - "adding: mem time107, current time 125, horizon 18\n", - "adding: mem time108, current time 125, horizon 17\n", - "adding: mem time109, current time 125, horizon 16\n", - "adding: mem time110, current time 125, horizon 15\n", - "adding: mem time111, current time 125, horizon 14\n", - "adding: mem time112, current time 125, horizon 13\n", - "adding: mem time113, current time 125, horizon 12\n", - "adding: mem time114, current time 125, horizon 11\n", - "adding: mem time115, current time 125, horizon 10\n", - "adding: mem time116, current time 125, horizon 9\n", - "adding: mem time117, current time 125, horizon 8\n", - "adding: mem time118, current time 125, horizon 7\n", - "adding: mem time119, current time 125, horizon 6\n", - "adding: mem time120, current time 125, horizon 5\n", - "adding: mem time121, current time 125, horizon 4\n", - "adding: mem time122, current time 125, horizon 3\n", - "adding: mem time123, current time 125, horizon 2\n", - "adding: mem time124, current time 125, horizon 1\n", - "adding: mem time0, current time 126, horizon 126\n", - "adding: mem time1, current time 126, horizon 125\n", - "adding: mem time2, current time 126, horizon 124\n", - "adding: mem time3, current time 126, horizon 123\n", - "adding: mem time4, current time 126, horizon 122\n", - "adding: mem time5, current time 126, horizon 121\n", - "adding: mem time6, current time 126, horizon 120\n", - "adding: mem time7, current time 126, horizon 119\n", - "adding: mem time8, current time 126, horizon 118\n", - "adding: mem time9, current time 126, horizon 117\n", - "adding: mem time10, current time 126, horizon 116\n", - "adding: mem time11, current time 126, horizon 115\n", - "adding: mem time12, current time 126, horizon 114\n", - "adding: mem time13, current time 126, horizon 113\n", - "adding: mem time14, current time 126, horizon 112\n", - "adding: mem time15, current time 126, horizon 111\n", - "adding: mem time16, current time 126, horizon 110\n", - "adding: mem time17, current time 126, horizon 109\n", - "adding: mem time18, current time 126, horizon 108\n", - "adding: mem time19, current time 126, horizon 107\n", - "adding: mem time20, current time 126, horizon 106\n", - "adding: mem time21, current time 126, horizon 105\n", - "adding: mem time22, current time 126, horizon 104\n", - "adding: mem time23, current time 126, horizon 103\n", - "adding: mem time24, current time 126, horizon 102\n", - "adding: mem time25, current time 126, horizon 101\n", - "adding: mem time26, current time 126, horizon 100\n", - "adding: mem time27, current time 126, horizon 99\n", - "adding: mem time28, current time 126, horizon 98\n", - "adding: mem time29, current time 126, horizon 97\n", - "adding: mem time30, current time 126, horizon 96\n", - "adding: mem time31, current time 126, horizon 95\n", - "adding: mem time32, current time 126, horizon 94\n", - "adding: mem time33, current time 126, horizon 93\n", - "adding: mem time34, current time 126, horizon 92\n", - "adding: mem time35, current time 126, horizon 91\n", - "adding: mem time36, current time 126, horizon 90\n", - "adding: mem time37, current time 126, horizon 89\n", - "adding: mem time38, current time 126, horizon 88\n", - "adding: mem time39, current time 126, horizon 87\n", - "adding: mem time40, current time 126, horizon 86\n", - "adding: mem time41, current time 126, horizon 85\n", - "adding: mem time42, current time 126, horizon 84\n", - "adding: mem time43, current time 126, horizon 83\n", - "adding: mem time44, current time 126, horizon 82\n", - "adding: mem time45, current time 126, horizon 81\n", - "adding: mem time46, current time 126, horizon 80\n", - "adding: mem time47, current time 126, horizon 79\n", - "adding: mem time48, current time 126, horizon 78\n", - "adding: mem time49, current time 126, horizon 77\n", - "adding: mem time50, current time 126, horizon 76\n", - "adding: mem time51, current time 126, horizon 75\n", - "adding: mem time52, current time 126, horizon 74\n", - "adding: mem time53, current time 126, horizon 73\n", - "adding: mem time54, current time 126, horizon 72\n", - "adding: mem time55, current time 126, horizon 71\n", - "adding: mem time56, current time 126, horizon 70\n", - "adding: mem time57, current time 126, horizon 69\n", - "adding: mem time58, current time 126, horizon 68\n", - "adding: mem time59, current time 126, horizon 67\n", - "adding: mem time60, current time 126, horizon 66\n", - "adding: mem time61, current time 126, horizon 65\n", - "adding: mem time62, current time 126, horizon 64\n", - "adding: mem time63, current time 126, horizon 63\n", - "adding: mem time64, current time 126, horizon 62\n", - "adding: mem time65, current time 126, horizon 61\n", - "adding: mem time66, current time 126, horizon 60\n", - "adding: mem time67, current time 126, horizon 59\n", - "adding: mem time68, current time 126, horizon 58\n", - "adding: mem time69, current time 126, horizon 57\n", - "adding: mem time70, current time 126, horizon 56\n", - "adding: mem time71, current time 126, horizon 55\n", - "adding: mem time72, current time 126, horizon 54\n", - "adding: mem time73, current time 126, horizon 53\n", - "adding: mem time74, current time 126, horizon 52\n", - "adding: mem time75, current time 126, horizon 51\n", - "adding: mem time76, current time 126, horizon 50\n", - "adding: mem time77, current time 126, horizon 49\n", - "adding: mem time78, current time 126, horizon 48\n", - "adding: mem time79, current time 126, horizon 47\n", - "adding: mem time80, current time 126, horizon 46\n", - "adding: mem time81, current time 126, horizon 45\n", - "adding: mem time82, current time 126, horizon 44\n", - "adding: mem time83, current time 126, horizon 43\n", - "adding: mem time84, current time 126, horizon 42\n", - "adding: mem time85, current time 126, horizon 41\n", - "adding: mem time86, current time 126, horizon 40\n", - "adding: mem time87, current time 126, horizon 39\n", - "adding: mem time88, current time 126, horizon 38\n", - "adding: mem time89, current time 126, horizon 37\n", - "adding: mem time90, current time 126, horizon 36\n", - "adding: mem time91, current time 126, horizon 35\n", - "adding: mem time92, current time 126, horizon 34\n", - "adding: mem time93, current time 126, horizon 33\n", - "adding: mem time94, current time 126, horizon 32\n", - "adding: mem time95, current time 126, horizon 31\n", - "adding: mem time96, current time 126, horizon 30\n", - "adding: mem time97, current time 126, horizon 29\n", - "adding: mem time98, current time 126, horizon 28\n", - "adding: mem time99, current time 126, horizon 27\n", - "adding: mem time100, current time 126, horizon 26\n", - "adding: mem time101, current time 126, horizon 25\n", - "adding: mem time102, current time 126, horizon 24\n", - "adding: mem time103, current time 126, horizon 23\n", - "adding: mem time104, current time 126, horizon 22\n", - "adding: mem time105, current time 126, horizon 21\n", - "adding: mem time106, current time 126, horizon 20\n", - "adding: mem time107, current time 126, horizon 19\n", - "adding: mem time108, current time 126, horizon 18\n", - "adding: mem time109, current time 126, horizon 17\n", - "adding: mem time110, current time 126, horizon 16\n", - "adding: mem time111, current time 126, horizon 15\n", - "adding: mem time112, current time 126, horizon 14\n", - "adding: mem time113, current time 126, horizon 13\n", - "adding: mem time114, current time 126, horizon 12\n", - "adding: mem time115, current time 126, horizon 11\n", - "adding: mem time116, current time 126, horizon 10\n", - "adding: mem time117, current time 126, horizon 9\n", - "adding: mem time118, current time 126, horizon 8\n", - "adding: mem time119, current time 126, horizon 7\n", - "adding: mem time120, current time 126, horizon 6\n", - "adding: mem time121, current time 126, horizon 5\n", - "adding: mem time122, current time 126, horizon 4\n", - "adding: mem time123, current time 126, horizon 3\n", - "adding: mem time124, current time 126, horizon 2\n", - "adding: mem time125, current time 126, horizon 1\n", - "adding: mem time0, current time 127, horizon 127\n", - "adding: mem time1, current time 127, horizon 126\n", - "adding: mem time2, current time 127, horizon 125\n", - "adding: mem time3, current time 127, horizon 124\n", - "adding: mem time4, current time 127, horizon 123\n", - "adding: mem time5, current time 127, horizon 122\n", - "adding: mem time6, current time 127, horizon 121\n", - "adding: mem time7, current time 127, horizon 120\n", - "adding: mem time8, current time 127, horizon 119\n", - "adding: mem time9, current time 127, horizon 118\n", - "adding: mem time10, current time 127, horizon 117\n", - "adding: mem time11, current time 127, horizon 116\n", - "adding: mem time12, current time 127, horizon 115\n", - "adding: mem time13, current time 127, horizon 114\n", - "adding: mem time14, current time 127, horizon 113\n", - "adding: mem time15, current time 127, horizon 112\n", - "adding: mem time16, current time 127, horizon 111\n", - "adding: mem time17, current time 127, horizon 110\n", - "adding: mem time18, current time 127, horizon 109\n", - "adding: mem time19, current time 127, horizon 108\n", - "adding: mem time20, current time 127, horizon 107\n", - "adding: mem time21, current time 127, horizon 106\n", - "adding: mem time22, current time 127, horizon 105\n", - "adding: mem time23, current time 127, horizon 104\n", - "adding: mem time24, current time 127, horizon 103\n", - "adding: mem time25, current time 127, horizon 102\n", - "adding: mem time26, current time 127, horizon 101\n", - "adding: mem time27, current time 127, horizon 100\n", - "adding: mem time28, current time 127, horizon 99\n", - "adding: mem time29, current time 127, horizon 98\n", - "adding: mem time30, current time 127, horizon 97\n", - "adding: mem time31, current time 127, horizon 96\n", - "adding: mem time32, current time 127, horizon 95\n", - "adding: mem time33, current time 127, horizon 94\n", - "adding: mem time34, current time 127, horizon 93\n", - "adding: mem time35, current time 127, horizon 92\n", - "adding: mem time36, current time 127, horizon 91\n", - "adding: mem time37, current time 127, horizon 90\n", - "adding: mem time38, current time 127, horizon 89\n", - "adding: mem time39, current time 127, horizon 88\n", - "adding: mem time40, current time 127, horizon 87\n", - "adding: mem time41, current time 127, horizon 86\n", - "adding: mem time42, current time 127, horizon 85\n", - "adding: mem time43, current time 127, horizon 84\n", - "adding: mem time44, current time 127, horizon 83\n", - "adding: mem time45, current time 127, horizon 82\n", - "adding: mem time46, current time 127, horizon 81\n", - "adding: mem time47, current time 127, horizon 80\n", - "adding: mem time48, current time 127, horizon 79\n", - "adding: mem time49, current time 127, horizon 78\n", - "adding: mem time50, current time 127, horizon 77\n", - "adding: mem time51, current time 127, horizon 76\n", - "adding: mem time52, current time 127, horizon 75\n", - "adding: mem time53, current time 127, horizon 74\n", - "adding: mem time54, current time 127, horizon 73\n", - "adding: mem time55, current time 127, horizon 72\n", - "adding: mem time56, current time 127, horizon 71\n", - "adding: mem time57, current time 127, horizon 70\n", - "adding: mem time58, current time 127, horizon 69\n", - "adding: mem time59, current time 127, horizon 68\n", - "adding: mem time60, current time 127, horizon 67\n", - "adding: mem time61, current time 127, horizon 66\n", - "adding: mem time62, current time 127, horizon 65\n", - "adding: mem time63, current time 127, horizon 64\n", - "adding: mem time64, current time 127, horizon 63\n", - "adding: mem time65, current time 127, horizon 62\n", - "adding: mem time66, current time 127, horizon 61\n", - "adding: mem time67, current time 127, horizon 60\n", - "adding: mem time68, current time 127, horizon 59\n", - "adding: mem time69, current time 127, horizon 58\n", - "adding: mem time70, current time 127, horizon 57\n", - "adding: mem time71, current time 127, horizon 56\n", - "adding: mem time72, current time 127, horizon 55\n", - "adding: mem time73, current time 127, horizon 54\n", - "adding: mem time74, current time 127, horizon 53\n", - "adding: mem time75, current time 127, horizon 52\n", - "adding: mem time76, current time 127, horizon 51\n", - "adding: mem time77, current time 127, horizon 50\n", - "adding: mem time78, current time 127, horizon 49\n", - "adding: mem time79, current time 127, horizon 48\n", - "adding: mem time80, current time 127, horizon 47\n", - "adding: mem time81, current time 127, horizon 46\n", - "adding: mem time82, current time 127, horizon 45\n", - "adding: mem time83, current time 127, horizon 44\n", - "adding: mem time84, current time 127, horizon 43\n", - "adding: mem time85, current time 127, horizon 42\n", - "adding: mem time86, current time 127, horizon 41\n", - "adding: mem time87, current time 127, horizon 40\n", - "adding: mem time88, current time 127, horizon 39\n", - "adding: mem time89, current time 127, horizon 38\n", - "adding: mem time90, current time 127, horizon 37\n", - "adding: mem time91, current time 127, horizon 36\n", - "adding: mem time92, current time 127, horizon 35\n", - "adding: mem time93, current time 127, horizon 34\n", - "adding: mem time94, current time 127, horizon 33\n", - "adding: mem time95, current time 127, horizon 32\n", - "adding: mem time96, current time 127, horizon 31\n", - "adding: mem time97, current time 127, horizon 30\n", - "adding: mem time98, current time 127, horizon 29\n", - "adding: mem time99, current time 127, horizon 28\n", - "adding: mem time100, current time 127, horizon 27\n", - "adding: mem time101, current time 127, horizon 26\n", - "adding: mem time102, current time 127, horizon 25\n", - "adding: mem time103, current time 127, horizon 24\n", - "adding: mem time104, current time 127, horizon 23\n", - "adding: mem time105, current time 127, horizon 22\n", - "adding: mem time106, current time 127, horizon 21\n", - "adding: mem time107, current time 127, horizon 20\n", - "adding: mem time108, current time 127, horizon 19\n", - "adding: mem time109, current time 127, horizon 18\n", - "adding: mem time110, current time 127, horizon 17\n", - "adding: mem time111, current time 127, horizon 16\n", - "adding: mem time112, current time 127, horizon 15\n", - "adding: mem time113, current time 127, horizon 14\n", - "adding: mem time114, current time 127, horizon 13\n", - "adding: mem time115, current time 127, horizon 12\n", - "adding: mem time116, current time 127, horizon 11\n", - "adding: mem time117, current time 127, horizon 10\n", - "adding: mem time118, current time 127, horizon 9\n", - "adding: mem time119, current time 127, horizon 8\n", - "adding: mem time120, current time 127, horizon 7\n", - "adding: mem time121, current time 127, horizon 6\n", - "adding: mem time122, current time 127, horizon 5\n", - "adding: mem time123, current time 127, horizon 4\n", - "adding: mem time124, current time 127, horizon 3\n", - "adding: mem time125, current time 127, horizon 2\n", - "adding: mem time126, current time 127, horizon 1\n", - "adding: mem time0, current time 128, horizon 128\n", - "adding: mem time1, current time 128, horizon 127\n", - "adding: mem time2, current time 128, horizon 126\n", - "adding: mem time3, current time 128, horizon 125\n", - "adding: mem time4, current time 128, horizon 124\n", - "adding: mem time5, current time 128, horizon 123\n", - "adding: mem time6, current time 128, horizon 122\n", - "adding: mem time7, current time 128, horizon 121\n", - "adding: mem time8, current time 128, horizon 120\n", - "adding: mem time9, current time 128, horizon 119\n", - "adding: mem time10, current time 128, horizon 118\n", - "adding: mem time11, current time 128, horizon 117\n", - "adding: mem time12, current time 128, horizon 116\n", - "adding: mem time13, current time 128, horizon 115\n", - "adding: mem time14, current time 128, horizon 114\n", - "adding: mem time15, current time 128, horizon 113\n", - "adding: mem time16, current time 128, horizon 112\n", - "adding: mem time17, current time 128, horizon 111\n", - "adding: mem time18, current time 128, horizon 110\n", - "adding: mem time19, current time 128, horizon 109\n", - "adding: mem time20, current time 128, horizon 108\n", - "adding: mem time21, current time 128, horizon 107\n", - "adding: mem time22, current time 128, horizon 106\n", - "adding: mem time23, current time 128, horizon 105\n", - "adding: mem time24, current time 128, horizon 104\n", - "adding: mem time25, current time 128, horizon 103\n", - "adding: mem time26, current time 128, horizon 102\n", - "adding: mem time27, current time 128, horizon 101\n", - "adding: mem time28, current time 128, horizon 100\n", - "adding: mem time29, current time 128, horizon 99\n", - "adding: mem time30, current time 128, horizon 98\n", - "adding: mem time31, current time 128, horizon 97\n", - "adding: mem time32, current time 128, horizon 96\n", - "adding: mem time33, current time 128, horizon 95\n", - "adding: mem time34, current time 128, horizon 94\n", - "adding: mem time35, current time 128, horizon 93\n", - "adding: mem time36, current time 128, horizon 92\n", - "adding: mem time37, current time 128, horizon 91\n", - "adding: mem time38, current time 128, horizon 90\n", - "adding: mem time39, current time 128, horizon 89\n", - "adding: mem time40, current time 128, horizon 88\n", - "adding: mem time41, current time 128, horizon 87\n", - "adding: mem time42, current time 128, horizon 86\n", - "adding: mem time43, current time 128, horizon 85\n", - "adding: mem time44, current time 128, horizon 84\n", - "adding: mem time45, current time 128, horizon 83\n", - "adding: mem time46, current time 128, horizon 82\n", - "adding: mem time47, current time 128, horizon 81\n", - "adding: mem time48, current time 128, horizon 80\n", - "adding: mem time49, current time 128, horizon 79\n", - "adding: mem time50, current time 128, horizon 78\n", - "adding: mem time51, current time 128, horizon 77\n", - "adding: mem time52, current time 128, horizon 76\n", - "adding: mem time53, current time 128, horizon 75\n", - "adding: mem time54, current time 128, horizon 74\n", - "adding: mem time55, current time 128, horizon 73\n", - "adding: mem time56, current time 128, horizon 72\n", - "adding: mem time57, current time 128, horizon 71\n", - "adding: mem time58, current time 128, horizon 70\n", - "adding: mem time59, current time 128, horizon 69\n", - "adding: mem time60, current time 128, horizon 68\n", - "adding: mem time61, current time 128, horizon 67\n", - "adding: mem time62, current time 128, horizon 66\n", - "adding: mem time63, current time 128, horizon 65\n", - "adding: mem time64, current time 128, horizon 64\n", - "adding: mem time65, current time 128, horizon 63\n", - "adding: mem time66, current time 128, horizon 62\n", - "adding: mem time67, current time 128, horizon 61\n", - "adding: mem time68, current time 128, horizon 60\n", - "adding: mem time69, current time 128, horizon 59\n", - "adding: mem time70, current time 128, horizon 58\n", - "adding: mem time71, current time 128, horizon 57\n", - "adding: mem time72, current time 128, horizon 56\n", - "adding: mem time73, current time 128, horizon 55\n", - "adding: mem time74, current time 128, horizon 54\n", - "adding: mem time75, current time 128, horizon 53\n", - "adding: mem time76, current time 128, horizon 52\n", - "adding: mem time77, current time 128, horizon 51\n", - "adding: mem time78, current time 128, horizon 50\n", - "adding: mem time79, current time 128, horizon 49\n", - "adding: mem time80, current time 128, horizon 48\n", - "adding: mem time81, current time 128, horizon 47\n", - "adding: mem time82, current time 128, horizon 46\n", - "adding: mem time83, current time 128, horizon 45\n", - "adding: mem time84, current time 128, horizon 44\n", - "adding: mem time85, current time 128, horizon 43\n", - "adding: mem time86, current time 128, horizon 42\n", - "adding: mem time87, current time 128, horizon 41\n", - "adding: mem time88, current time 128, horizon 40\n", - "adding: mem time89, current time 128, horizon 39\n", - "adding: mem time90, current time 128, horizon 38\n", - "adding: mem time91, current time 128, horizon 37\n", - "adding: mem time92, current time 128, horizon 36\n", - "adding: mem time93, current time 128, horizon 35\n", - "adding: mem time94, current time 128, horizon 34\n", - "adding: mem time95, current time 128, horizon 33\n", - "adding: mem time96, current time 128, horizon 32\n", - "adding: mem time97, current time 128, horizon 31\n", - "adding: mem time98, current time 128, horizon 30\n", - "adding: mem time99, current time 128, horizon 29\n", - "adding: mem time100, current time 128, horizon 28\n", - "adding: mem time101, current time 128, horizon 27\n", - "adding: mem time102, current time 128, horizon 26\n", - "adding: mem time103, current time 128, horizon 25\n", - "adding: mem time104, current time 128, horizon 24\n", - "adding: mem time105, current time 128, horizon 23\n", - "adding: mem time106, current time 128, horizon 22\n", - "adding: mem time107, current time 128, horizon 21\n", - "adding: mem time108, current time 128, horizon 20\n", - "adding: mem time109, current time 128, horizon 19\n", - "adding: mem time110, current time 128, horizon 18\n", - "adding: mem time111, current time 128, horizon 17\n", - "adding: mem time112, current time 128, horizon 16\n", - "adding: mem time113, current time 128, horizon 15\n", - "adding: mem time114, current time 128, horizon 14\n", - "adding: mem time115, current time 128, horizon 13\n", - "adding: mem time116, current time 128, horizon 12\n", - "adding: mem time117, current time 128, horizon 11\n", - "adding: mem time118, current time 128, horizon 10\n", - "adding: mem time119, current time 128, horizon 9\n", - "adding: mem time120, current time 128, horizon 8\n", - "adding: mem time121, current time 128, horizon 7\n", - "adding: mem time122, current time 128, horizon 6\n", - "adding: mem time123, current time 128, horizon 5\n", - "adding: mem time124, current time 128, horizon 4\n", - "adding: mem time125, current time 128, horizon 3\n", - "adding: mem time126, current time 128, horizon 2\n", - "adding: mem time127, current time 128, horizon 1\n", - "adding: mem time0, current time 129, horizon 129\n", - "adding: mem time1, current time 129, horizon 128\n", - "adding: mem time2, current time 129, horizon 127\n", - "adding: mem time3, current time 129, horizon 126\n", - "adding: mem time4, current time 129, horizon 125\n", - "adding: mem time5, current time 129, horizon 124\n", - "adding: mem time6, current time 129, horizon 123\n", - "adding: mem time7, current time 129, horizon 122\n", - "adding: mem time8, current time 129, horizon 121\n", - "adding: mem time9, current time 129, horizon 120\n", - "adding: mem time10, current time 129, horizon 119\n", - "adding: mem time11, current time 129, horizon 118\n", - "adding: mem time12, current time 129, horizon 117\n", - "adding: mem time13, current time 129, horizon 116\n", - "adding: mem time14, current time 129, horizon 115\n", - "adding: mem time15, current time 129, horizon 114\n", - "adding: mem time16, current time 129, horizon 113\n", - "adding: mem time17, current time 129, horizon 112\n", - "adding: mem time18, current time 129, horizon 111\n", - "adding: mem time19, current time 129, horizon 110\n", - "adding: mem time20, current time 129, horizon 109\n", - "adding: mem time21, current time 129, horizon 108\n", - "adding: mem time22, current time 129, horizon 107\n", - "adding: mem time23, current time 129, horizon 106\n", - "adding: mem time24, current time 129, horizon 105\n", - "adding: mem time25, current time 129, horizon 104\n", - "adding: mem time26, current time 129, horizon 103\n", - "adding: mem time27, current time 129, horizon 102\n", - "adding: mem time28, current time 129, horizon 101\n", - "adding: mem time29, current time 129, horizon 100\n", - "adding: mem time30, current time 129, horizon 99\n", - "adding: mem time31, current time 129, horizon 98\n", - "adding: mem time32, current time 129, horizon 97\n", - "adding: mem time33, current time 129, horizon 96\n", - "adding: mem time34, current time 129, horizon 95\n", - "adding: mem time35, current time 129, horizon 94\n", - "adding: mem time36, current time 129, horizon 93\n", - "adding: mem time37, current time 129, horizon 92\n", - "adding: mem time38, current time 129, horizon 91\n", - "adding: mem time39, current time 129, horizon 90\n", - "adding: mem time40, current time 129, horizon 89\n", - "adding: mem time41, current time 129, horizon 88\n", - "adding: mem time42, current time 129, horizon 87\n", - "adding: mem time43, current time 129, horizon 86\n", - "adding: mem time44, current time 129, horizon 85\n", - "adding: mem time45, current time 129, horizon 84\n", - "adding: mem time46, current time 129, horizon 83\n", - "adding: mem time47, current time 129, horizon 82\n", - "adding: mem time48, current time 129, horizon 81\n", - "adding: mem time49, current time 129, horizon 80\n", - "adding: mem time50, current time 129, horizon 79\n", - "adding: mem time51, current time 129, horizon 78\n", - "adding: mem time52, current time 129, horizon 77\n", - "adding: mem time53, current time 129, horizon 76\n", - "adding: mem time54, current time 129, horizon 75\n", - "adding: mem time55, current time 129, horizon 74\n", - "adding: mem time56, current time 129, horizon 73\n", - "adding: mem time57, current time 129, horizon 72\n", - "adding: mem time58, current time 129, horizon 71\n", - "adding: mem time59, current time 129, horizon 70\n", - "adding: mem time60, current time 129, horizon 69\n", - "adding: mem time61, current time 129, horizon 68\n", - "adding: mem time62, current time 129, horizon 67\n", - "adding: mem time63, current time 129, horizon 66\n", - "adding: mem time64, current time 129, horizon 65\n", - "adding: mem time65, current time 129, horizon 64\n", - "adding: mem time66, current time 129, horizon 63\n", - "adding: mem time67, current time 129, horizon 62\n", - "adding: mem time68, current time 129, horizon 61\n", - "adding: mem time69, current time 129, horizon 60\n", - "adding: mem time70, current time 129, horizon 59\n", - "adding: mem time71, current time 129, horizon 58\n", - "adding: mem time72, current time 129, horizon 57\n", - "adding: mem time73, current time 129, horizon 56\n", - "adding: mem time74, current time 129, horizon 55\n", - "adding: mem time75, current time 129, horizon 54\n", - "adding: mem time76, current time 129, horizon 53\n", - "adding: mem time77, current time 129, horizon 52\n", - "adding: mem time78, current time 129, horizon 51\n", - "adding: mem time79, current time 129, horizon 50\n", - "adding: mem time80, current time 129, horizon 49\n", - "adding: mem time81, current time 129, horizon 48\n", - "adding: mem time82, current time 129, horizon 47\n", - "adding: mem time83, current time 129, horizon 46\n", - "adding: mem time84, current time 129, horizon 45\n", - "adding: mem time85, current time 129, horizon 44\n", - "adding: mem time86, current time 129, horizon 43\n", - "adding: mem time87, current time 129, horizon 42\n", - "adding: mem time88, current time 129, horizon 41\n", - "adding: mem time89, current time 129, horizon 40\n", - "adding: mem time90, current time 129, horizon 39\n", - "adding: mem time91, current time 129, horizon 38\n", - "adding: mem time92, current time 129, horizon 37\n", - "adding: mem time93, current time 129, horizon 36\n", - "adding: mem time94, current time 129, horizon 35\n", - "adding: mem time95, current time 129, horizon 34\n", - "adding: mem time96, current time 129, horizon 33\n", - "adding: mem time97, current time 129, horizon 32\n", - "adding: mem time98, current time 129, horizon 31\n", - "adding: mem time99, current time 129, horizon 30\n", - "adding: mem time100, current time 129, horizon 29\n", - "adding: mem time101, current time 129, horizon 28\n", - "adding: mem time102, current time 129, horizon 27\n", - "adding: mem time103, current time 129, horizon 26\n", - "adding: mem time104, current time 129, horizon 25\n", - "adding: mem time105, current time 129, horizon 24\n", - "adding: mem time106, current time 129, horizon 23\n", - "adding: mem time107, current time 129, horizon 22\n", - "adding: mem time108, current time 129, horizon 21\n", - "adding: mem time109, current time 129, horizon 20\n", - "adding: mem time110, current time 129, horizon 19\n", - "adding: mem time111, current time 129, horizon 18\n", - "adding: mem time112, current time 129, horizon 17\n", - "adding: mem time113, current time 129, horizon 16\n", - "adding: mem time114, current time 129, horizon 15\n", - "adding: mem time115, current time 129, horizon 14\n", - "adding: mem time116, current time 129, horizon 13\n", - "adding: mem time117, current time 129, horizon 12\n", - "adding: mem time118, current time 129, horizon 11\n", - "adding: mem time119, current time 129, horizon 10\n", - "adding: mem time120, current time 129, horizon 9\n", - "adding: mem time121, current time 129, horizon 8\n", - "adding: mem time122, current time 129, horizon 7\n", - "adding: mem time123, current time 129, horizon 6\n", - "adding: mem time124, current time 129, horizon 5\n", - "adding: mem time125, current time 129, horizon 4\n", - "adding: mem time126, current time 129, horizon 3\n", - "adding: mem time127, current time 129, horizon 2\n", - "adding: mem time128, current time 129, horizon 1\n", - "adding: mem time0, current time 130, horizon 130\n", - "adding: mem time1, current time 130, horizon 129\n", - "adding: mem time2, current time 130, horizon 128\n", - "adding: mem time3, current time 130, horizon 127\n", - "adding: mem time4, current time 130, horizon 126\n", - "adding: mem time5, current time 130, horizon 125\n", - "adding: mem time6, current time 130, horizon 124\n", - "adding: mem time7, current time 130, horizon 123\n", - "adding: mem time8, current time 130, horizon 122\n", - "adding: mem time9, current time 130, horizon 121\n", - "adding: mem time10, current time 130, horizon 120\n", - "adding: mem time11, current time 130, horizon 119\n", - "adding: mem time12, current time 130, horizon 118\n", - "adding: mem time13, current time 130, horizon 117\n", - "adding: mem time14, current time 130, horizon 116\n", - "adding: mem time15, current time 130, horizon 115\n", - "adding: mem time16, current time 130, horizon 114\n", - "adding: mem time17, current time 130, horizon 113\n", - "adding: mem time18, current time 130, horizon 112\n", - "adding: mem time19, current time 130, horizon 111\n", - "adding: mem time20, current time 130, horizon 110\n", - "adding: mem time21, current time 130, horizon 109\n", - "adding: mem time22, current time 130, horizon 108\n", - "adding: mem time23, current time 130, horizon 107\n", - "adding: mem time24, current time 130, horizon 106\n", - "adding: mem time25, current time 130, horizon 105\n", - "adding: mem time26, current time 130, horizon 104\n", - "adding: mem time27, current time 130, horizon 103\n", - "adding: mem time28, current time 130, horizon 102\n", - "adding: mem time29, current time 130, horizon 101\n", - "adding: mem time30, current time 130, horizon 100\n", - "adding: mem time31, current time 130, horizon 99\n", - "adding: mem time32, current time 130, horizon 98\n", - "adding: mem time33, current time 130, horizon 97\n", - "adding: mem time34, current time 130, horizon 96\n", - "adding: mem time35, current time 130, horizon 95\n", - "adding: mem time36, current time 130, horizon 94\n", - "adding: mem time37, current time 130, horizon 93\n", - "adding: mem time38, current time 130, horizon 92\n", - "adding: mem time39, current time 130, horizon 91\n", - "adding: mem time40, current time 130, horizon 90\n", - "adding: mem time41, current time 130, horizon 89\n", - "adding: mem time42, current time 130, horizon 88\n", - "adding: mem time43, current time 130, horizon 87\n", - "adding: mem time44, current time 130, horizon 86\n", - "adding: mem time45, current time 130, horizon 85\n", - "adding: mem time46, current time 130, horizon 84\n", - "adding: mem time47, current time 130, horizon 83\n", - "adding: mem time48, current time 130, horizon 82\n", - "adding: mem time49, current time 130, horizon 81\n", - "adding: mem time50, current time 130, horizon 80\n", - "adding: mem time51, current time 130, horizon 79\n", - "adding: mem time52, current time 130, horizon 78\n", - "adding: mem time53, current time 130, horizon 77\n", - "adding: mem time54, current time 130, horizon 76\n", - "adding: mem time55, current time 130, horizon 75\n", - "adding: mem time56, current time 130, horizon 74\n", - "adding: mem time57, current time 130, horizon 73\n", - "adding: mem time58, current time 130, horizon 72\n", - "adding: mem time59, current time 130, horizon 71\n", - "adding: mem time60, current time 130, horizon 70\n", - "adding: mem time61, current time 130, horizon 69\n", - "adding: mem time62, current time 130, horizon 68\n", - "adding: mem time63, current time 130, horizon 67\n", - "adding: mem time64, current time 130, horizon 66\n", - "adding: mem time65, current time 130, horizon 65\n", - "adding: mem time66, current time 130, horizon 64\n", - "adding: mem time67, current time 130, horizon 63\n", - "adding: mem time68, current time 130, horizon 62\n", - "adding: mem time69, current time 130, horizon 61\n", - "adding: mem time70, current time 130, horizon 60\n", - "adding: mem time71, current time 130, horizon 59\n", - "adding: mem time72, current time 130, horizon 58\n", - "adding: mem time73, current time 130, horizon 57\n", - "adding: mem time74, current time 130, horizon 56\n", - "adding: mem time75, current time 130, horizon 55\n", - "adding: mem time76, current time 130, horizon 54\n", - "adding: mem time77, current time 130, horizon 53\n", - "adding: mem time78, current time 130, horizon 52\n", - "adding: mem time79, current time 130, horizon 51\n", - "adding: mem time80, current time 130, horizon 50\n", - "adding: mem time81, current time 130, horizon 49\n", - "adding: mem time82, current time 130, horizon 48\n", - "adding: mem time83, current time 130, horizon 47\n", - "adding: mem time84, current time 130, horizon 46\n", - "adding: mem time85, current time 130, horizon 45\n", - "adding: mem time86, current time 130, horizon 44\n", - "adding: mem time87, current time 130, horizon 43\n", - "adding: mem time88, current time 130, horizon 42\n", - "adding: mem time89, current time 130, horizon 41\n", - "adding: mem time90, current time 130, horizon 40\n", - "adding: mem time91, current time 130, horizon 39\n", - "adding: mem time92, current time 130, horizon 38\n", - "adding: mem time93, current time 130, horizon 37\n", - "adding: mem time94, current time 130, horizon 36\n", - "adding: mem time95, current time 130, horizon 35\n", - "adding: mem time96, current time 130, horizon 34\n", - "adding: mem time97, current time 130, horizon 33\n", - "adding: mem time98, current time 130, horizon 32\n", - "adding: mem time99, current time 130, horizon 31\n", - "adding: mem time100, current time 130, horizon 30\n", - "adding: mem time101, current time 130, horizon 29\n", - "adding: mem time102, current time 130, horizon 28\n", - "adding: mem time103, current time 130, horizon 27\n", - "adding: mem time104, current time 130, horizon 26\n", - "adding: mem time105, current time 130, horizon 25\n", - "adding: mem time106, current time 130, horizon 24\n", - "adding: mem time107, current time 130, horizon 23\n", - "adding: mem time108, current time 130, horizon 22\n", - "adding: mem time109, current time 130, horizon 21\n", - "adding: mem time110, current time 130, horizon 20\n", - "adding: mem time111, current time 130, horizon 19\n", - "adding: mem time112, current time 130, horizon 18\n", - "adding: mem time113, current time 130, horizon 17\n", - "adding: mem time114, current time 130, horizon 16\n", - "adding: mem time115, current time 130, horizon 15\n", - "adding: mem time116, current time 130, horizon 14\n", - "adding: mem time117, current time 130, horizon 13\n", - "adding: mem time118, current time 130, horizon 12\n", - "adding: mem time119, current time 130, horizon 11\n", - "adding: mem time120, current time 130, horizon 10\n", - "adding: mem time121, current time 130, horizon 9\n", - "adding: mem time122, current time 130, horizon 8\n", - "adding: mem time123, current time 130, horizon 7\n", - "adding: mem time124, current time 130, horizon 6\n", - "adding: mem time125, current time 130, horizon 5\n", - "adding: mem time126, current time 130, horizon 4\n", - "adding: mem time127, current time 130, horizon 3\n", - "adding: mem time128, current time 130, horizon 2\n", - "adding: mem time129, current time 130, horizon 1\n", - "adding: mem time0, current time 131, horizon 131\n", - "adding: mem time1, current time 131, horizon 130\n", - "adding: mem time2, current time 131, horizon 129\n", - "adding: mem time3, current time 131, horizon 128\n", - "adding: mem time4, current time 131, horizon 127\n", - "adding: mem time5, current time 131, horizon 126\n", - "adding: mem time6, current time 131, horizon 125\n", - "adding: mem time7, current time 131, horizon 124\n", - "adding: mem time8, current time 131, horizon 123\n", - "adding: mem time9, current time 131, horizon 122\n", - "adding: mem time10, current time 131, horizon 121\n", - "adding: mem time11, current time 131, horizon 120\n", - "adding: mem time12, current time 131, horizon 119\n", - "adding: mem time13, current time 131, horizon 118\n", - "adding: mem time14, current time 131, horizon 117\n", - "adding: mem time15, current time 131, horizon 116\n", - "adding: mem time16, current time 131, horizon 115\n", - "adding: mem time17, current time 131, horizon 114\n", - "adding: mem time18, current time 131, horizon 113\n", - "adding: mem time19, current time 131, horizon 112\n", - "adding: mem time20, current time 131, horizon 111\n", - "adding: mem time21, current time 131, horizon 110\n", - "adding: mem time22, current time 131, horizon 109\n", - "adding: mem time23, current time 131, horizon 108\n", - "adding: mem time24, current time 131, horizon 107\n", - "adding: mem time25, current time 131, horizon 106\n", - "adding: mem time26, current time 131, horizon 105\n", - "adding: mem time27, current time 131, horizon 104\n", - "adding: mem time28, current time 131, horizon 103\n", - "adding: mem time29, current time 131, horizon 102\n", - "adding: mem time30, current time 131, horizon 101\n", - "adding: mem time31, current time 131, horizon 100\n", - "adding: mem time32, current time 131, horizon 99\n", - "adding: mem time33, current time 131, horizon 98\n", - "adding: mem time34, current time 131, horizon 97\n", - "adding: mem time35, current time 131, horizon 96\n", - "adding: mem time36, current time 131, horizon 95\n", - "adding: mem time37, current time 131, horizon 94\n", - "adding: mem time38, current time 131, horizon 93\n", - "adding: mem time39, current time 131, horizon 92\n", - "adding: mem time40, current time 131, horizon 91\n", - "adding: mem time41, current time 131, horizon 90\n", - "adding: mem time42, current time 131, horizon 89\n", - "adding: mem time43, current time 131, horizon 88\n", - "adding: mem time44, current time 131, horizon 87\n", - "adding: mem time45, current time 131, horizon 86\n", - "adding: mem time46, current time 131, horizon 85\n", - "adding: mem time47, current time 131, horizon 84\n", - "adding: mem time48, current time 131, horizon 83\n", - "adding: mem time49, current time 131, horizon 82\n", - "adding: mem time50, current time 131, horizon 81\n", - "adding: mem time51, current time 131, horizon 80\n", - "adding: mem time52, current time 131, horizon 79\n", - "adding: mem time53, current time 131, horizon 78\n", - "adding: mem time54, current time 131, horizon 77\n", - "adding: mem time55, current time 131, horizon 76\n", - "adding: mem time56, current time 131, horizon 75\n", - "adding: mem time57, current time 131, horizon 74\n", - "adding: mem time58, current time 131, horizon 73\n", - "adding: mem time59, current time 131, horizon 72\n", - "adding: mem time60, current time 131, horizon 71\n", - "adding: mem time61, current time 131, horizon 70\n", - "adding: mem time62, current time 131, horizon 69\n", - "adding: mem time63, current time 131, horizon 68\n", - "adding: mem time64, current time 131, horizon 67\n", - "adding: mem time65, current time 131, horizon 66\n", - "adding: mem time66, current time 131, horizon 65\n", - "adding: mem time67, current time 131, horizon 64\n", - "adding: mem time68, current time 131, horizon 63\n", - "adding: mem time69, current time 131, horizon 62\n", - "adding: mem time70, current time 131, horizon 61\n", - "adding: mem time71, current time 131, horizon 60\n", - "adding: mem time72, current time 131, horizon 59\n", - "adding: mem time73, current time 131, horizon 58\n", - "adding: mem time74, current time 131, horizon 57\n", - "adding: mem time75, current time 131, horizon 56\n", - "adding: mem time76, current time 131, horizon 55\n", - "adding: mem time77, current time 131, horizon 54\n", - "adding: mem time78, current time 131, horizon 53\n", - "adding: mem time79, current time 131, horizon 52\n", - "adding: mem time80, current time 131, horizon 51\n", - "adding: mem time81, current time 131, horizon 50\n", - "adding: mem time82, current time 131, horizon 49\n", - "adding: mem time83, current time 131, horizon 48\n", - "adding: mem time84, current time 131, horizon 47\n", - "adding: mem time85, current time 131, horizon 46\n", - "adding: mem time86, current time 131, horizon 45\n", - "adding: mem time87, current time 131, horizon 44\n", - "adding: mem time88, current time 131, horizon 43\n", - "adding: mem time89, current time 131, horizon 42\n", - "adding: mem time90, current time 131, horizon 41\n", - "adding: mem time91, current time 131, horizon 40\n", - "adding: mem time92, current time 131, horizon 39\n", - "adding: mem time93, current time 131, horizon 38\n", - "adding: mem time94, current time 131, horizon 37\n", - "adding: mem time95, current time 131, horizon 36\n", - "adding: mem time96, current time 131, horizon 35\n", - "adding: mem time97, current time 131, horizon 34\n", - "adding: mem time98, current time 131, horizon 33\n", - "adding: mem time99, current time 131, horizon 32\n", - "adding: mem time100, current time 131, horizon 31\n", - "adding: mem time101, current time 131, horizon 30\n", - "adding: mem time102, current time 131, horizon 29\n", - "adding: mem time103, current time 131, horizon 28\n", - "adding: mem time104, current time 131, horizon 27\n", - "adding: mem time105, current time 131, horizon 26\n", - "adding: mem time106, current time 131, horizon 25\n", - "adding: mem time107, current time 131, horizon 24\n", - "adding: mem time108, current time 131, horizon 23\n", - "adding: mem time109, current time 131, horizon 22\n", - "adding: mem time110, current time 131, horizon 21\n", - "adding: mem time111, current time 131, horizon 20\n", - "adding: mem time112, current time 131, horizon 19\n", - "adding: mem time113, current time 131, horizon 18\n", - "adding: mem time114, current time 131, horizon 17\n", - "adding: mem time115, current time 131, horizon 16\n", - "adding: mem time116, current time 131, horizon 15\n", - "adding: mem time117, current time 131, horizon 14\n", - "adding: mem time118, current time 131, horizon 13\n", - "adding: mem time119, current time 131, horizon 12\n", - "adding: mem time120, current time 131, horizon 11\n", - "adding: mem time121, current time 131, horizon 10\n", - "adding: mem time122, current time 131, horizon 9\n", - "adding: mem time123, current time 131, horizon 8\n", - "adding: mem time124, current time 131, horizon 7\n", - "adding: mem time125, current time 131, horizon 6\n", - "adding: mem time126, current time 131, horizon 5\n", - "adding: mem time127, current time 131, horizon 4\n", - "adding: mem time128, current time 131, horizon 3\n", - "adding: mem time129, current time 131, horizon 2\n", - "adding: mem time130, current time 131, horizon 1\n", - "adding: mem time0, current time 132, horizon 132\n", - "adding: mem time1, current time 132, horizon 131\n", - "adding: mem time2, current time 132, horizon 130\n", - "adding: mem time3, current time 132, horizon 129\n", - "adding: mem time4, current time 132, horizon 128\n", - "adding: mem time5, current time 132, horizon 127\n", - "adding: mem time6, current time 132, horizon 126\n", - "adding: mem time7, current time 132, horizon 125\n", - "adding: mem time8, current time 132, horizon 124\n", - "adding: mem time9, current time 132, horizon 123\n", - "adding: mem time10, current time 132, horizon 122\n", - "adding: mem time11, current time 132, horizon 121\n", - "adding: mem time12, current time 132, horizon 120\n", - "adding: mem time13, current time 132, horizon 119\n", - "adding: mem time14, current time 132, horizon 118\n", - "adding: mem time15, current time 132, horizon 117\n", - "adding: mem time16, current time 132, horizon 116\n", - "adding: mem time17, current time 132, horizon 115\n", - "adding: mem time18, current time 132, horizon 114\n", - "adding: mem time19, current time 132, horizon 113\n", - "adding: mem time20, current time 132, horizon 112\n", - "adding: mem time21, current time 132, horizon 111\n", - "adding: mem time22, current time 132, horizon 110\n", - "adding: mem time23, current time 132, horizon 109\n", - "adding: mem time24, current time 132, horizon 108\n", - "adding: mem time25, current time 132, horizon 107\n", - "adding: mem time26, current time 132, horizon 106\n", - "adding: mem time27, current time 132, horizon 105\n", - "adding: mem time28, current time 132, horizon 104\n", - "adding: mem time29, current time 132, horizon 103\n", - "adding: mem time30, current time 132, horizon 102\n", - "adding: mem time31, current time 132, horizon 101\n", - "adding: mem time32, current time 132, horizon 100\n", - "adding: mem time33, current time 132, horizon 99\n", - "adding: mem time34, current time 132, horizon 98\n", - "adding: mem time35, current time 132, horizon 97\n", - "adding: mem time36, current time 132, horizon 96\n", - "adding: mem time37, current time 132, horizon 95\n", - "adding: mem time38, current time 132, horizon 94\n", - "adding: mem time39, current time 132, horizon 93\n", - "adding: mem time40, current time 132, horizon 92\n", - "adding: mem time41, current time 132, horizon 91\n", - "adding: mem time42, current time 132, horizon 90\n", - "adding: mem time43, current time 132, horizon 89\n", - "adding: mem time44, current time 132, horizon 88\n", - "adding: mem time45, current time 132, horizon 87\n", - "adding: mem time46, current time 132, horizon 86\n", - "adding: mem time47, current time 132, horizon 85\n", - "adding: mem time48, current time 132, horizon 84\n", - "adding: mem time49, current time 132, horizon 83\n", - "adding: mem time50, current time 132, horizon 82\n", - "adding: mem time51, current time 132, horizon 81\n", - "adding: mem time52, current time 132, horizon 80\n", - "adding: mem time53, current time 132, horizon 79\n", - "adding: mem time54, current time 132, horizon 78\n", - "adding: mem time55, current time 132, horizon 77\n", - "adding: mem time56, current time 132, horizon 76\n", - "adding: mem time57, current time 132, horizon 75\n", - "adding: mem time58, current time 132, horizon 74\n", - "adding: mem time59, current time 132, horizon 73\n", - "adding: mem time60, current time 132, horizon 72\n", - "adding: mem time61, current time 132, horizon 71\n", - "adding: mem time62, current time 132, horizon 70\n", - "adding: mem time63, current time 132, horizon 69\n", - "adding: mem time64, current time 132, horizon 68\n", - "adding: mem time65, current time 132, horizon 67\n", - "adding: mem time66, current time 132, horizon 66\n", - "adding: mem time67, current time 132, horizon 65\n", - "adding: mem time68, current time 132, horizon 64\n", - "adding: mem time69, current time 132, horizon 63\n", - "adding: mem time70, current time 132, horizon 62\n", - "adding: mem time71, current time 132, horizon 61\n", - "adding: mem time72, current time 132, horizon 60\n", - "adding: mem time73, current time 132, horizon 59\n", - "adding: mem time74, current time 132, horizon 58\n", - "adding: mem time75, current time 132, horizon 57\n", - "adding: mem time76, current time 132, horizon 56\n", - "adding: mem time77, current time 132, horizon 55\n", - "adding: mem time78, current time 132, horizon 54\n", - "adding: mem time79, current time 132, horizon 53\n", - "adding: mem time80, current time 132, horizon 52\n", - "adding: mem time81, current time 132, horizon 51\n", - "adding: mem time82, current time 132, horizon 50\n", - "adding: mem time83, current time 132, horizon 49\n", - "adding: mem time84, current time 132, horizon 48\n", - "adding: mem time85, current time 132, horizon 47\n", - "adding: mem time86, current time 132, horizon 46\n", - "adding: mem time87, current time 132, horizon 45\n", - "adding: mem time88, current time 132, horizon 44\n", - "adding: mem time89, current time 132, horizon 43\n", - "adding: mem time90, current time 132, horizon 42\n", - "adding: mem time91, current time 132, horizon 41\n", - "adding: mem time92, current time 132, horizon 40\n", - "adding: mem time93, current time 132, horizon 39\n", - "adding: mem time94, current time 132, horizon 38\n", - "adding: mem time95, current time 132, horizon 37\n", - "adding: mem time96, current time 132, horizon 36\n", - "adding: mem time97, current time 132, horizon 35\n", - "adding: mem time98, current time 132, horizon 34\n", - "adding: mem time99, current time 132, horizon 33\n", - "adding: mem time100, current time 132, horizon 32\n", - "adding: mem time101, current time 132, horizon 31\n", - "adding: mem time102, current time 132, horizon 30\n", - "adding: mem time103, current time 132, horizon 29\n", - "adding: mem time104, current time 132, horizon 28\n", - "adding: mem time105, current time 132, horizon 27\n", - "adding: mem time106, current time 132, horizon 26\n", - "adding: mem time107, current time 132, horizon 25\n", - "adding: mem time108, current time 132, horizon 24\n", - "adding: mem time109, current time 132, horizon 23\n", - "adding: mem time110, current time 132, horizon 22\n", - "adding: mem time111, current time 132, horizon 21\n", - "adding: mem time112, current time 132, horizon 20\n", - "adding: mem time113, current time 132, horizon 19\n", - "adding: mem time114, current time 132, horizon 18\n", - "adding: mem time115, current time 132, horizon 17\n", - "adding: mem time116, current time 132, horizon 16\n", - "adding: mem time117, current time 132, horizon 15\n", - "adding: mem time118, current time 132, horizon 14\n", - "adding: mem time119, current time 132, horizon 13\n", - "adding: mem time120, current time 132, horizon 12\n", - "adding: mem time121, current time 132, horizon 11\n", - "adding: mem time122, current time 132, horizon 10\n", - "adding: mem time123, current time 132, horizon 9\n", - "adding: mem time124, current time 132, horizon 8\n", - "adding: mem time125, current time 132, horizon 7\n", - "adding: mem time126, current time 132, horizon 6\n", - "adding: mem time127, current time 132, horizon 5\n", - "adding: mem time128, current time 132, horizon 4\n", - "adding: mem time129, current time 132, horizon 3\n", - "adding: mem time130, current time 132, horizon 2\n", - "adding: mem time131, current time 132, horizon 1\n", - "adding: mem time0, current time 133, horizon 133\n", - "adding: mem time1, current time 133, horizon 132\n", - "adding: mem time2, current time 133, horizon 131\n", - "adding: mem time3, current time 133, horizon 130\n", - "adding: mem time4, current time 133, horizon 129\n", - "adding: mem time5, current time 133, horizon 128\n", - "adding: mem time6, current time 133, horizon 127\n", - "adding: mem time7, current time 133, horizon 126\n", - "adding: mem time8, current time 133, horizon 125\n", - "adding: mem time9, current time 133, horizon 124\n", - "adding: mem time10, current time 133, horizon 123\n", - "adding: mem time11, current time 133, horizon 122\n", - "adding: mem time12, current time 133, horizon 121\n", - "adding: mem time13, current time 133, horizon 120\n", - "adding: mem time14, current time 133, horizon 119\n", - "adding: mem time15, current time 133, horizon 118\n", - "adding: mem time16, current time 133, horizon 117\n", - "adding: mem time17, current time 133, horizon 116\n", - "adding: mem time18, current time 133, horizon 115\n", - "adding: mem time19, current time 133, horizon 114\n", - "adding: mem time20, current time 133, horizon 113\n", - "adding: mem time21, current time 133, horizon 112\n", - "adding: mem time22, current time 133, horizon 111\n", - "adding: mem time23, current time 133, horizon 110\n", - "adding: mem time24, current time 133, horizon 109\n", - "adding: mem time25, current time 133, horizon 108\n", - "adding: mem time26, current time 133, horizon 107\n", - "adding: mem time27, current time 133, horizon 106\n", - "adding: mem time28, current time 133, horizon 105\n", - "adding: mem time29, current time 133, horizon 104\n", - "adding: mem time30, current time 133, horizon 103\n", - "adding: mem time31, current time 133, horizon 102\n", - "adding: mem time32, current time 133, horizon 101\n", - "adding: mem time33, current time 133, horizon 100\n", - "adding: mem time34, current time 133, horizon 99\n", - "adding: mem time35, current time 133, horizon 98\n", - "adding: mem time36, current time 133, horizon 97\n", - "adding: mem time37, current time 133, horizon 96\n", - "adding: mem time38, current time 133, horizon 95\n", - "adding: mem time39, current time 133, horizon 94\n", - "adding: mem time40, current time 133, horizon 93\n", - "adding: mem time41, current time 133, horizon 92\n", - "adding: mem time42, current time 133, horizon 91\n", - "adding: mem time43, current time 133, horizon 90\n", - "adding: mem time44, current time 133, horizon 89\n", - "adding: mem time45, current time 133, horizon 88\n", - "adding: mem time46, current time 133, horizon 87\n", - "adding: mem time47, current time 133, horizon 86\n", - "adding: mem time48, current time 133, horizon 85\n", - "adding: mem time49, current time 133, horizon 84\n", - "adding: mem time50, current time 133, horizon 83\n", - "adding: mem time51, current time 133, horizon 82\n", - "adding: mem time52, current time 133, horizon 81\n", - "adding: mem time53, current time 133, horizon 80\n", - "adding: mem time54, current time 133, horizon 79\n", - "adding: mem time55, current time 133, horizon 78\n", - "adding: mem time56, current time 133, horizon 77\n", - "adding: mem time57, current time 133, horizon 76\n", - "adding: mem time58, current time 133, horizon 75\n", - "adding: mem time59, current time 133, horizon 74\n", - "adding: mem time60, current time 133, horizon 73\n", - "adding: mem time61, current time 133, horizon 72\n", - "adding: mem time62, current time 133, horizon 71\n", - "adding: mem time63, current time 133, horizon 70\n", - "adding: mem time64, current time 133, horizon 69\n", - "adding: mem time65, current time 133, horizon 68\n", - "adding: mem time66, current time 133, horizon 67\n", - "adding: mem time67, current time 133, horizon 66\n", - "adding: mem time68, current time 133, horizon 65\n", - "adding: mem time69, current time 133, horizon 64\n", - "adding: mem time70, current time 133, horizon 63\n", - "adding: mem time71, current time 133, horizon 62\n", - "adding: mem time72, current time 133, horizon 61\n", - "adding: mem time73, current time 133, horizon 60\n", - "adding: mem time74, current time 133, horizon 59\n", - "adding: mem time75, current time 133, horizon 58\n", - "adding: mem time76, current time 133, horizon 57\n", - "adding: mem time77, current time 133, horizon 56\n", - "adding: mem time78, current time 133, horizon 55\n", - "adding: mem time79, current time 133, horizon 54\n", - "adding: mem time80, current time 133, horizon 53\n", - "adding: mem time81, current time 133, horizon 52\n", - "adding: mem time82, current time 133, horizon 51\n", - "adding: mem time83, current time 133, horizon 50\n", - "adding: mem time84, current time 133, horizon 49\n", - "adding: mem time85, current time 133, horizon 48\n", - "adding: mem time86, current time 133, horizon 47\n", - "adding: mem time87, current time 133, horizon 46\n", - "adding: mem time88, current time 133, horizon 45\n", - "adding: mem time89, current time 133, horizon 44\n", - "adding: mem time90, current time 133, horizon 43\n", - "adding: mem time91, current time 133, horizon 42\n", - "adding: mem time92, current time 133, horizon 41\n", - "adding: mem time93, current time 133, horizon 40\n", - "adding: mem time94, current time 133, horizon 39\n", - "adding: mem time95, current time 133, horizon 38\n", - "adding: mem time96, current time 133, horizon 37\n", - "adding: mem time97, current time 133, horizon 36\n", - "adding: mem time98, current time 133, horizon 35\n", - "adding: mem time99, current time 133, horizon 34\n", - "adding: mem time100, current time 133, horizon 33\n", - "adding: mem time101, current time 133, horizon 32\n", - "adding: mem time102, current time 133, horizon 31\n", - "adding: mem time103, current time 133, horizon 30\n", - "adding: mem time104, current time 133, horizon 29\n", - "adding: mem time105, current time 133, horizon 28\n", - "adding: mem time106, current time 133, horizon 27\n", - "adding: mem time107, current time 133, horizon 26\n", - "adding: mem time108, current time 133, horizon 25\n", - "adding: mem time109, current time 133, horizon 24\n", - "adding: mem time110, current time 133, horizon 23\n", - "adding: mem time111, current time 133, horizon 22\n", - "adding: mem time112, current time 133, horizon 21\n", - "adding: mem time113, current time 133, horizon 20\n", - "adding: mem time114, current time 133, horizon 19\n", - "adding: mem time115, current time 133, horizon 18\n", - "adding: mem time116, current time 133, horizon 17\n", - "adding: mem time117, current time 133, horizon 16\n", - "adding: mem time118, current time 133, horizon 15\n", - "adding: mem time119, current time 133, horizon 14\n", - "adding: mem time120, current time 133, horizon 13\n", - "adding: mem time121, current time 133, horizon 12\n", - "adding: mem time122, current time 133, horizon 11\n", - "adding: mem time123, current time 133, horizon 10\n", - "adding: mem time124, current time 133, horizon 9\n", - "adding: mem time125, current time 133, horizon 8\n", - "adding: mem time126, current time 133, horizon 7\n", - "adding: mem time127, current time 133, horizon 6\n", - "adding: mem time128, current time 133, horizon 5\n", - "adding: mem time129, current time 133, horizon 4\n", - "adding: mem time130, current time 133, horizon 3\n", - "adding: mem time131, current time 133, horizon 2\n", - "adding: mem time132, current time 133, horizon 1\n", - "adding: mem time0, current time 134, horizon 134\n", - "adding: mem time1, current time 134, horizon 133\n", - "adding: mem time2, current time 134, horizon 132\n", - "adding: mem time3, current time 134, horizon 131\n", - "adding: mem time4, current time 134, horizon 130\n", - "adding: mem time5, current time 134, horizon 129\n", - "adding: mem time6, current time 134, horizon 128\n", - "adding: mem time7, current time 134, horizon 127\n", - "adding: mem time8, current time 134, horizon 126\n", - "adding: mem time9, current time 134, horizon 125\n", - "adding: mem time10, current time 134, horizon 124\n", - "adding: mem time11, current time 134, horizon 123\n", - "adding: mem time12, current time 134, horizon 122\n", - "adding: mem time13, current time 134, horizon 121\n", - "adding: mem time14, current time 134, horizon 120\n", - "adding: mem time15, current time 134, horizon 119\n", - "adding: mem time16, current time 134, horizon 118\n", - "adding: mem time17, current time 134, horizon 117\n", - "adding: mem time18, current time 134, horizon 116\n", - "adding: mem time19, current time 134, horizon 115\n", - "adding: mem time20, current time 134, horizon 114\n", - "adding: mem time21, current time 134, horizon 113\n", - "adding: mem time22, current time 134, horizon 112\n", - "adding: mem time23, current time 134, horizon 111\n", - "adding: mem time24, current time 134, horizon 110\n", - "adding: mem time25, current time 134, horizon 109\n", - "adding: mem time26, current time 134, horizon 108\n", - "adding: mem time27, current time 134, horizon 107\n", - "adding: mem time28, current time 134, horizon 106\n", - "adding: mem time29, current time 134, horizon 105\n", - "adding: mem time30, current time 134, horizon 104\n", - "adding: mem time31, current time 134, horizon 103\n", - "adding: mem time32, current time 134, horizon 102\n", - "adding: mem time33, current time 134, horizon 101\n", - "adding: mem time34, current time 134, horizon 100\n", - "adding: mem time35, current time 134, horizon 99\n", - "adding: mem time36, current time 134, horizon 98\n", - "adding: mem time37, current time 134, horizon 97\n", - "adding: mem time38, current time 134, horizon 96\n", - "adding: mem time39, current time 134, horizon 95\n", - "adding: mem time40, current time 134, horizon 94\n", - "adding: mem time41, current time 134, horizon 93\n", - "adding: mem time42, current time 134, horizon 92\n", - "adding: mem time43, current time 134, horizon 91\n", - "adding: mem time44, current time 134, horizon 90\n", - "adding: mem time45, current time 134, horizon 89\n", - "adding: mem time46, current time 134, horizon 88\n", - "adding: mem time47, current time 134, horizon 87\n", - "adding: mem time48, current time 134, horizon 86\n", - "adding: mem time49, current time 134, horizon 85\n", - "adding: mem time50, current time 134, horizon 84\n", - "adding: mem time51, current time 134, horizon 83\n", - "adding: mem time52, current time 134, horizon 82\n", - "adding: mem time53, current time 134, horizon 81\n", - "adding: mem time54, current time 134, horizon 80\n", - "adding: mem time55, current time 134, horizon 79\n", - "adding: mem time56, current time 134, horizon 78\n", - "adding: mem time57, current time 134, horizon 77\n", - "adding: mem time58, current time 134, horizon 76\n", - "adding: mem time59, current time 134, horizon 75\n", - "adding: mem time60, current time 134, horizon 74\n", - "adding: mem time61, current time 134, horizon 73\n", - "adding: mem time62, current time 134, horizon 72\n", - "adding: mem time63, current time 134, horizon 71\n", - "adding: mem time64, current time 134, horizon 70\n", - "adding: mem time65, current time 134, horizon 69\n", - "adding: mem time66, current time 134, horizon 68\n", - "adding: mem time67, current time 134, horizon 67\n", - "adding: mem time68, current time 134, horizon 66\n", - "adding: mem time69, current time 134, horizon 65\n", - "adding: mem time70, current time 134, horizon 64\n", - "adding: mem time71, current time 134, horizon 63\n", - "adding: mem time72, current time 134, horizon 62\n", - "adding: mem time73, current time 134, horizon 61\n", - "adding: mem time74, current time 134, horizon 60\n", - "adding: mem time75, current time 134, horizon 59\n", - "adding: mem time76, current time 134, horizon 58\n", - "adding: mem time77, current time 134, horizon 57\n", - "adding: mem time78, current time 134, horizon 56\n", - "adding: mem time79, current time 134, horizon 55\n", - "adding: mem time80, current time 134, horizon 54\n", - "adding: mem time81, current time 134, horizon 53\n", - "adding: mem time82, current time 134, horizon 52\n", - "adding: mem time83, current time 134, horizon 51\n", - "adding: mem time84, current time 134, horizon 50\n", - "adding: mem time85, current time 134, horizon 49\n", - "adding: mem time86, current time 134, horizon 48\n", - "adding: mem time87, current time 134, horizon 47\n", - "adding: mem time88, current time 134, horizon 46\n", - "adding: mem time89, current time 134, horizon 45\n", - "adding: mem time90, current time 134, horizon 44\n", - "adding: mem time91, current time 134, horizon 43\n", - "adding: mem time92, current time 134, horizon 42\n", - "adding: mem time93, current time 134, horizon 41\n", - "adding: mem time94, current time 134, horizon 40\n", - "adding: mem time95, current time 134, horizon 39\n", - "adding: mem time96, current time 134, horizon 38\n", - "adding: mem time97, current time 134, horizon 37\n", - "adding: mem time98, current time 134, horizon 36\n", - "adding: mem time99, current time 134, horizon 35\n", - "adding: mem time100, current time 134, horizon 34\n", - "adding: mem time101, current time 134, horizon 33\n", - "adding: mem time102, current time 134, horizon 32\n", - "adding: mem time103, current time 134, horizon 31\n", - "adding: mem time104, current time 134, horizon 30\n", - "adding: mem time105, current time 134, horizon 29\n", - "adding: mem time106, current time 134, horizon 28\n", - "adding: mem time107, current time 134, horizon 27\n", - "adding: mem time108, current time 134, horizon 26\n", - "adding: mem time109, current time 134, horizon 25\n", - "adding: mem time110, current time 134, horizon 24\n", - "adding: mem time111, current time 134, horizon 23\n", - "adding: mem time112, current time 134, horizon 22\n", - "adding: mem time113, current time 134, horizon 21\n", - "adding: mem time114, current time 134, horizon 20\n", - "adding: mem time115, current time 134, horizon 19\n", - "adding: mem time116, current time 134, horizon 18\n", - "adding: mem time117, current time 134, horizon 17\n", - "adding: mem time118, current time 134, horizon 16\n", - "adding: mem time119, current time 134, horizon 15\n", - "adding: mem time120, current time 134, horizon 14\n", - "adding: mem time121, current time 134, horizon 13\n", - "adding: mem time122, current time 134, horizon 12\n", - "adding: mem time123, current time 134, horizon 11\n", - "adding: mem time124, current time 134, horizon 10\n", - "adding: mem time125, current time 134, horizon 9\n", - "adding: mem time126, current time 134, horizon 8\n", - "adding: mem time127, current time 134, horizon 7\n", - "adding: mem time128, current time 134, horizon 6\n", - "adding: mem time129, current time 134, horizon 5\n", - "adding: mem time130, current time 134, horizon 4\n", - "adding: mem time131, current time 134, horizon 3\n", - "adding: mem time132, current time 134, horizon 2\n", - "adding: mem time133, current time 134, horizon 1\n", - "adding: mem time0, current time 135, horizon 135\n", - "adding: mem time1, current time 135, horizon 134\n", - "adding: mem time2, current time 135, horizon 133\n", - "adding: mem time3, current time 135, horizon 132\n", - "adding: mem time4, current time 135, horizon 131\n", - "adding: mem time5, current time 135, horizon 130\n", - "adding: mem time6, current time 135, horizon 129\n", - "adding: mem time7, current time 135, horizon 128\n", - "adding: mem time8, current time 135, horizon 127\n", - "adding: mem time9, current time 135, horizon 126\n", - "adding: mem time10, current time 135, horizon 125\n", - "adding: mem time11, current time 135, horizon 124\n", - "adding: mem time12, current time 135, horizon 123\n", - "adding: mem time13, current time 135, horizon 122\n", - "adding: mem time14, current time 135, horizon 121\n", - "adding: mem time15, current time 135, horizon 120\n", - "adding: mem time16, current time 135, horizon 119\n", - "adding: mem time17, current time 135, horizon 118\n", - "adding: mem time18, current time 135, horizon 117\n", - "adding: mem time19, current time 135, horizon 116\n", - "adding: mem time20, current time 135, horizon 115\n", - "adding: mem time21, current time 135, horizon 114\n", - "adding: mem time22, current time 135, horizon 113\n", - "adding: mem time23, current time 135, horizon 112\n", - "adding: mem time24, current time 135, horizon 111\n", - "adding: mem time25, current time 135, horizon 110\n", - "adding: mem time26, current time 135, horizon 109\n", - "adding: mem time27, current time 135, horizon 108\n", - "adding: mem time28, current time 135, horizon 107\n", - "adding: mem time29, current time 135, horizon 106\n", - "adding: mem time30, current time 135, horizon 105\n", - "adding: mem time31, current time 135, horizon 104\n", - "adding: mem time32, current time 135, horizon 103\n", - "adding: mem time33, current time 135, horizon 102\n", - "adding: mem time34, current time 135, horizon 101\n", - "adding: mem time35, current time 135, horizon 100\n", - "adding: mem time36, current time 135, horizon 99\n", - "adding: mem time37, current time 135, horizon 98\n", - "adding: mem time38, current time 135, horizon 97\n", - "adding: mem time39, current time 135, horizon 96\n", - "adding: mem time40, current time 135, horizon 95\n", - "adding: mem time41, current time 135, horizon 94\n", - "adding: mem time42, current time 135, horizon 93\n", - "adding: mem time43, current time 135, horizon 92\n", - "adding: mem time44, current time 135, horizon 91\n", - "adding: mem time45, current time 135, horizon 90\n", - "adding: mem time46, current time 135, horizon 89\n", - "adding: mem time47, current time 135, horizon 88\n", - "adding: mem time48, current time 135, horizon 87\n", - "adding: mem time49, current time 135, horizon 86\n", - "adding: mem time50, current time 135, horizon 85\n", - "adding: mem time51, current time 135, horizon 84\n", - "adding: mem time52, current time 135, horizon 83\n", - "adding: mem time53, current time 135, horizon 82\n", - "adding: mem time54, current time 135, horizon 81\n", - "adding: mem time55, current time 135, horizon 80\n", - "adding: mem time56, current time 135, horizon 79\n", - "adding: mem time57, current time 135, horizon 78\n", - "adding: mem time58, current time 135, horizon 77\n", - "adding: mem time59, current time 135, horizon 76\n", - "adding: mem time60, current time 135, horizon 75\n", - "adding: mem time61, current time 135, horizon 74\n", - "adding: mem time62, current time 135, horizon 73\n", - "adding: mem time63, current time 135, horizon 72\n", - "adding: mem time64, current time 135, horizon 71\n", - "adding: mem time65, current time 135, horizon 70\n", - "adding: mem time66, current time 135, horizon 69\n", - "adding: mem time67, current time 135, horizon 68\n", - "adding: mem time68, current time 135, horizon 67\n", - "adding: mem time69, current time 135, horizon 66\n", - "adding: mem time70, current time 135, horizon 65\n", - "adding: mem time71, current time 135, horizon 64\n", - "adding: mem time72, current time 135, horizon 63\n", - "adding: mem time73, current time 135, horizon 62\n", - "adding: mem time74, current time 135, horizon 61\n", - "adding: mem time75, current time 135, horizon 60\n", - "adding: mem time76, current time 135, horizon 59\n", - "adding: mem time77, current time 135, horizon 58\n", - "adding: mem time78, current time 135, horizon 57\n", - "adding: mem time79, current time 135, horizon 56\n", - "adding: mem time80, current time 135, horizon 55\n", - "adding: mem time81, current time 135, horizon 54\n", - "adding: mem time82, current time 135, horizon 53\n", - "adding: mem time83, current time 135, horizon 52\n", - "adding: mem time84, current time 135, horizon 51\n", - "adding: mem time85, current time 135, horizon 50\n", - "adding: mem time86, current time 135, horizon 49\n", - "adding: mem time87, current time 135, horizon 48\n", - "adding: mem time88, current time 135, horizon 47\n", - "adding: mem time89, current time 135, horizon 46\n", - "adding: mem time90, current time 135, horizon 45\n", - "adding: mem time91, current time 135, horizon 44\n", - "adding: mem time92, current time 135, horizon 43\n", - "adding: mem time93, current time 135, horizon 42\n", - "adding: mem time94, current time 135, horizon 41\n", - "adding: mem time95, current time 135, horizon 40\n", - "adding: mem time96, current time 135, horizon 39\n", - "adding: mem time97, current time 135, horizon 38\n", - "adding: mem time98, current time 135, horizon 37\n", - "adding: mem time99, current time 135, horizon 36\n", - "adding: mem time100, current time 135, horizon 35\n", - "adding: mem time101, current time 135, horizon 34\n", - "adding: mem time102, current time 135, horizon 33\n", - "adding: mem time103, current time 135, horizon 32\n", - "adding: mem time104, current time 135, horizon 31\n", - "adding: mem time105, current time 135, horizon 30\n", - "adding: mem time106, current time 135, horizon 29\n", - "adding: mem time107, current time 135, horizon 28\n", - "adding: mem time108, current time 135, horizon 27\n", - "adding: mem time109, current time 135, horizon 26\n", - "adding: mem time110, current time 135, horizon 25\n", - "adding: mem time111, current time 135, horizon 24\n", - "adding: mem time112, current time 135, horizon 23\n", - "adding: mem time113, current time 135, horizon 22\n", - "adding: mem time114, current time 135, horizon 21\n", - "adding: mem time115, current time 135, horizon 20\n", - "adding: mem time116, current time 135, horizon 19\n", - "adding: mem time117, current time 135, horizon 18\n", - "adding: mem time118, current time 135, horizon 17\n", - "adding: mem time119, current time 135, horizon 16\n", - "adding: mem time120, current time 135, horizon 15\n", - "adding: mem time121, current time 135, horizon 14\n", - "adding: mem time122, current time 135, horizon 13\n", - "adding: mem time123, current time 135, horizon 12\n", - "adding: mem time124, current time 135, horizon 11\n", - "adding: mem time125, current time 135, horizon 10\n", - "adding: mem time126, current time 135, horizon 9\n", - "adding: mem time127, current time 135, horizon 8\n", - "adding: mem time128, current time 135, horizon 7\n", - "adding: mem time129, current time 135, horizon 6\n", - "adding: mem time130, current time 135, horizon 5\n", - "adding: mem time131, current time 135, horizon 4\n", - "adding: mem time132, current time 135, horizon 3\n", - "adding: mem time133, current time 135, horizon 2\n", - "adding: mem time134, current time 135, horizon 1\n", - "adding: mem time0, current time 136, horizon 136\n", - "adding: mem time1, current time 136, horizon 135\n", - "adding: mem time2, current time 136, horizon 134\n", - "adding: mem time3, current time 136, horizon 133\n", - "adding: mem time4, current time 136, horizon 132\n", - "adding: mem time5, current time 136, horizon 131\n", - "adding: mem time6, current time 136, horizon 130\n", - "adding: mem time7, current time 136, horizon 129\n", - "adding: mem time8, current time 136, horizon 128\n", - "adding: mem time9, current time 136, horizon 127\n", - "adding: mem time10, current time 136, horizon 126\n", - "adding: mem time11, current time 136, horizon 125\n", - "adding: mem time12, current time 136, horizon 124\n", - "adding: mem time13, current time 136, horizon 123\n", - "adding: mem time14, current time 136, horizon 122\n", - "adding: mem time15, current time 136, horizon 121\n", - "adding: mem time16, current time 136, horizon 120\n", - "adding: mem time17, current time 136, horizon 119\n", - "adding: mem time18, current time 136, horizon 118\n", - "adding: mem time19, current time 136, horizon 117\n", - "adding: mem time20, current time 136, horizon 116\n", - "adding: mem time21, current time 136, horizon 115\n", - "adding: mem time22, current time 136, horizon 114\n", - "adding: mem time23, current time 136, horizon 113\n", - "adding: mem time24, current time 136, horizon 112\n", - "adding: mem time25, current time 136, horizon 111\n", - "adding: mem time26, current time 136, horizon 110\n", - "adding: mem time27, current time 136, horizon 109\n", - "adding: mem time28, current time 136, horizon 108\n", - "adding: mem time29, current time 136, horizon 107\n", - "adding: mem time30, current time 136, horizon 106\n", - "adding: mem time31, current time 136, horizon 105\n", - "adding: mem time32, current time 136, horizon 104\n", - "adding: mem time33, current time 136, horizon 103\n", - "adding: mem time34, current time 136, horizon 102\n", - "adding: mem time35, current time 136, horizon 101\n", - "adding: mem time36, current time 136, horizon 100\n", - "adding: mem time37, current time 136, horizon 99\n", - "adding: mem time38, current time 136, horizon 98\n", - "adding: mem time39, current time 136, horizon 97\n", - "adding: mem time40, current time 136, horizon 96\n", - "adding: mem time41, current time 136, horizon 95\n", - "adding: mem time42, current time 136, horizon 94\n", - "adding: mem time43, current time 136, horizon 93\n", - "adding: mem time44, current time 136, horizon 92\n", - "adding: mem time45, current time 136, horizon 91\n", - "adding: mem time46, current time 136, horizon 90\n", - "adding: mem time47, current time 136, horizon 89\n", - "adding: mem time48, current time 136, horizon 88\n", - "adding: mem time49, current time 136, horizon 87\n", - "adding: mem time50, current time 136, horizon 86\n", - "adding: mem time51, current time 136, horizon 85\n", - "adding: mem time52, current time 136, horizon 84\n", - "adding: mem time53, current time 136, horizon 83\n", - "adding: mem time54, current time 136, horizon 82\n", - "adding: mem time55, current time 136, horizon 81\n", - "adding: mem time56, current time 136, horizon 80\n", - "adding: mem time57, current time 136, horizon 79\n", - "adding: mem time58, current time 136, horizon 78\n", - "adding: mem time59, current time 136, horizon 77\n", - "adding: mem time60, current time 136, horizon 76\n", - "adding: mem time61, current time 136, horizon 75\n", - "adding: mem time62, current time 136, horizon 74\n", - "adding: mem time63, current time 136, horizon 73\n", - "adding: mem time64, current time 136, horizon 72\n", - "adding: mem time65, current time 136, horizon 71\n", - "adding: mem time66, current time 136, horizon 70\n", - "adding: mem time67, current time 136, horizon 69\n", - "adding: mem time68, current time 136, horizon 68\n", - "adding: mem time69, current time 136, horizon 67\n", - "adding: mem time70, current time 136, horizon 66\n", - "adding: mem time71, current time 136, horizon 65\n", - "adding: mem time72, current time 136, horizon 64\n", - "adding: mem time73, current time 136, horizon 63\n", - "adding: mem time74, current time 136, horizon 62\n", - "adding: mem time75, current time 136, horizon 61\n", - "adding: mem time76, current time 136, horizon 60\n", - "adding: mem time77, current time 136, horizon 59\n", - "adding: mem time78, current time 136, horizon 58\n", - "adding: mem time79, current time 136, horizon 57\n", - "adding: mem time80, current time 136, horizon 56\n", - "adding: mem time81, current time 136, horizon 55\n", - "adding: mem time82, current time 136, horizon 54\n", - "adding: mem time83, current time 136, horizon 53\n", - "adding: mem time84, current time 136, horizon 52\n", - "adding: mem time85, current time 136, horizon 51\n", - "adding: mem time86, current time 136, horizon 50\n", - "adding: mem time87, current time 136, horizon 49\n", - "adding: mem time88, current time 136, horizon 48\n", - "adding: mem time89, current time 136, horizon 47\n", - "adding: mem time90, current time 136, horizon 46\n", - "adding: mem time91, current time 136, horizon 45\n", - "adding: mem time92, current time 136, horizon 44\n", - "adding: mem time93, current time 136, horizon 43\n", - "adding: mem time94, current time 136, horizon 42\n", - "adding: mem time95, current time 136, horizon 41\n", - "adding: mem time96, current time 136, horizon 40\n", - "adding: mem time97, current time 136, horizon 39\n", - "adding: mem time98, current time 136, horizon 38\n", - "adding: mem time99, current time 136, horizon 37\n", - "adding: mem time100, current time 136, horizon 36\n", - "adding: mem time101, current time 136, horizon 35\n", - "adding: mem time102, current time 136, horizon 34\n", - "adding: mem time103, current time 136, horizon 33\n", - "adding: mem time104, current time 136, horizon 32\n", - "adding: mem time105, current time 136, horizon 31\n", - "adding: mem time106, current time 136, horizon 30\n", - "adding: mem time107, current time 136, horizon 29\n", - "adding: mem time108, current time 136, horizon 28\n", - "adding: mem time109, current time 136, horizon 27\n", - "adding: mem time110, current time 136, horizon 26\n", - "adding: mem time111, current time 136, horizon 25\n", - "adding: mem time112, current time 136, horizon 24\n", - "adding: mem time113, current time 136, horizon 23\n", - "adding: mem time114, current time 136, horizon 22\n", - "adding: mem time115, current time 136, horizon 21\n", - "adding: mem time116, current time 136, horizon 20\n", - "adding: mem time117, current time 136, horizon 19\n", - "adding: mem time118, current time 136, horizon 18\n", - "adding: mem time119, current time 136, horizon 17\n", - "adding: mem time120, current time 136, horizon 16\n", - "adding: mem time121, current time 136, horizon 15\n", - "adding: mem time122, current time 136, horizon 14\n", - "adding: mem time123, current time 136, horizon 13\n", - "adding: mem time124, current time 136, horizon 12\n", - "adding: mem time125, current time 136, horizon 11\n", - "adding: mem time126, current time 136, horizon 10\n", - "adding: mem time127, current time 136, horizon 9\n", - "adding: mem time128, current time 136, horizon 8\n", - "adding: mem time129, current time 136, horizon 7\n", - "adding: mem time130, current time 136, horizon 6\n", - "adding: mem time131, current time 136, horizon 5\n", - "adding: mem time132, current time 136, horizon 4\n", - "adding: mem time133, current time 136, horizon 3\n", - "adding: mem time134, current time 136, horizon 2\n", - "adding: mem time135, current time 136, horizon 1\n", - "adding: mem time0, current time 137, horizon 137\n", - "adding: mem time1, current time 137, horizon 136\n", - "adding: mem time2, current time 137, horizon 135\n", - "adding: mem time3, current time 137, horizon 134\n", - "adding: mem time4, current time 137, horizon 133\n", - "adding: mem time5, current time 137, horizon 132\n", - "adding: mem time6, current time 137, horizon 131\n", - "adding: mem time7, current time 137, horizon 130\n", - "adding: mem time8, current time 137, horizon 129\n", - "adding: mem time9, current time 137, horizon 128\n", - "adding: mem time10, current time 137, horizon 127\n", - "adding: mem time11, current time 137, horizon 126\n", - "adding: mem time12, current time 137, horizon 125\n", - "adding: mem time13, current time 137, horizon 124\n", - "adding: mem time14, current time 137, horizon 123\n", - "adding: mem time15, current time 137, horizon 122\n", - "adding: mem time16, current time 137, horizon 121\n", - "adding: mem time17, current time 137, horizon 120\n", - "adding: mem time18, current time 137, horizon 119\n", - "adding: mem time19, current time 137, horizon 118\n", - "adding: mem time20, current time 137, horizon 117\n", - "adding: mem time21, current time 137, horizon 116\n", - "adding: mem time22, current time 137, horizon 115\n", - "adding: mem time23, current time 137, horizon 114\n", - "adding: mem time24, current time 137, horizon 113\n", - "adding: mem time25, current time 137, horizon 112\n", - "adding: mem time26, current time 137, horizon 111\n", - "adding: mem time27, current time 137, horizon 110\n", - "adding: mem time28, current time 137, horizon 109\n", - "adding: mem time29, current time 137, horizon 108\n", - "adding: mem time30, current time 137, horizon 107\n", - "adding: mem time31, current time 137, horizon 106\n", - "adding: mem time32, current time 137, horizon 105\n", - "adding: mem time33, current time 137, horizon 104\n", - "adding: mem time34, current time 137, horizon 103\n", - "adding: mem time35, current time 137, horizon 102\n", - "adding: mem time36, current time 137, horizon 101\n", - "adding: mem time37, current time 137, horizon 100\n", - "adding: mem time38, current time 137, horizon 99\n", - "adding: mem time39, current time 137, horizon 98\n", - "adding: mem time40, current time 137, horizon 97\n", - "adding: mem time41, current time 137, horizon 96\n", - "adding: mem time42, current time 137, horizon 95\n", - "adding: mem time43, current time 137, horizon 94\n", - "adding: mem time44, current time 137, horizon 93\n", - "adding: mem time45, current time 137, horizon 92\n", - "adding: mem time46, current time 137, horizon 91\n", - "adding: mem time47, current time 137, horizon 90\n", - "adding: mem time48, current time 137, horizon 89\n", - "adding: mem time49, current time 137, horizon 88\n", - "adding: mem time50, current time 137, horizon 87\n", - "adding: mem time51, current time 137, horizon 86\n", - "adding: mem time52, current time 137, horizon 85\n", - "adding: mem time53, current time 137, horizon 84\n", - "adding: mem time54, current time 137, horizon 83\n", - "adding: mem time55, current time 137, horizon 82\n", - "adding: mem time56, current time 137, horizon 81\n", - "adding: mem time57, current time 137, horizon 80\n", - "adding: mem time58, current time 137, horizon 79\n", - "adding: mem time59, current time 137, horizon 78\n", - "adding: mem time60, current time 137, horizon 77\n", - "adding: mem time61, current time 137, horizon 76\n", - "adding: mem time62, current time 137, horizon 75\n", - "adding: mem time63, current time 137, horizon 74\n", - "adding: mem time64, current time 137, horizon 73\n", - "adding: mem time65, current time 137, horizon 72\n", - "adding: mem time66, current time 137, horizon 71\n", - "adding: mem time67, current time 137, horizon 70\n", - "adding: mem time68, current time 137, horizon 69\n", - "adding: mem time69, current time 137, horizon 68\n", - "adding: mem time70, current time 137, horizon 67\n", - "adding: mem time71, current time 137, horizon 66\n", - "adding: mem time72, current time 137, horizon 65\n", - "adding: mem time73, current time 137, horizon 64\n", - "adding: mem time74, current time 137, horizon 63\n", - "adding: mem time75, current time 137, horizon 62\n", - "adding: mem time76, current time 137, horizon 61\n", - "adding: mem time77, current time 137, horizon 60\n", - "adding: mem time78, current time 137, horizon 59\n", - "adding: mem time79, current time 137, horizon 58\n", - "adding: mem time80, current time 137, horizon 57\n", - "adding: mem time81, current time 137, horizon 56\n", - "adding: mem time82, current time 137, horizon 55\n", - "adding: mem time83, current time 137, horizon 54\n", - "adding: mem time84, current time 137, horizon 53\n", - "adding: mem time85, current time 137, horizon 52\n", - "adding: mem time86, current time 137, horizon 51\n", - "adding: mem time87, current time 137, horizon 50\n", - "adding: mem time88, current time 137, horizon 49\n", - "adding: mem time89, current time 137, horizon 48\n", - "adding: mem time90, current time 137, horizon 47\n", - "adding: mem time91, current time 137, horizon 46\n", - "adding: mem time92, current time 137, horizon 45\n", - "adding: mem time93, current time 137, horizon 44\n", - "adding: mem time94, current time 137, horizon 43\n", - "adding: mem time95, current time 137, horizon 42\n", - "adding: mem time96, current time 137, horizon 41\n", - "adding: mem time97, current time 137, horizon 40\n", - "adding: mem time98, current time 137, horizon 39\n", - "adding: mem time99, current time 137, horizon 38\n", - "adding: mem time100, current time 137, horizon 37\n", - "adding: mem time101, current time 137, horizon 36\n", - "adding: mem time102, current time 137, horizon 35\n", - "adding: mem time103, current time 137, horizon 34\n", - "adding: mem time104, current time 137, horizon 33\n", - "adding: mem time105, current time 137, horizon 32\n", - "adding: mem time106, current time 137, horizon 31\n", - "adding: mem time107, current time 137, horizon 30\n", - "adding: mem time108, current time 137, horizon 29\n", - "adding: mem time109, current time 137, horizon 28\n", - "adding: mem time110, current time 137, horizon 27\n", - "adding: mem time111, current time 137, horizon 26\n", - "adding: mem time112, current time 137, horizon 25\n", - "adding: mem time113, current time 137, horizon 24\n", - "adding: mem time114, current time 137, horizon 23\n", - "adding: mem time115, current time 137, horizon 22\n", - "adding: mem time116, current time 137, horizon 21\n", - "adding: mem time117, current time 137, horizon 20\n", - "adding: mem time118, current time 137, horizon 19\n", - "adding: mem time119, current time 137, horizon 18\n", - "adding: mem time120, current time 137, horizon 17\n", - "adding: mem time121, current time 137, horizon 16\n", - "adding: mem time122, current time 137, horizon 15\n", - "adding: mem time123, current time 137, horizon 14\n", - "adding: mem time124, current time 137, horizon 13\n", - "adding: mem time125, current time 137, horizon 12\n", - "adding: mem time126, current time 137, horizon 11\n", - "adding: mem time127, current time 137, horizon 10\n", - "adding: mem time128, current time 137, horizon 9\n", - "adding: mem time129, current time 137, horizon 8\n", - "adding: mem time130, current time 137, horizon 7\n", - "adding: mem time131, current time 137, horizon 6\n", - "adding: mem time132, current time 137, horizon 5\n", - "adding: mem time133, current time 137, horizon 4\n", - "adding: mem time134, current time 137, horizon 3\n", - "adding: mem time135, current time 137, horizon 2\n", - "adding: mem time136, current time 137, horizon 1\n", - "adding: mem time0, current time 138, horizon 138\n", - "adding: mem time1, current time 138, horizon 137\n", - "adding: mem time2, current time 138, horizon 136\n", - "adding: mem time3, current time 138, horizon 135\n", - "adding: mem time4, current time 138, horizon 134\n", - "adding: mem time5, current time 138, horizon 133\n", - "adding: mem time6, current time 138, horizon 132\n", - "adding: mem time7, current time 138, horizon 131\n", - "adding: mem time8, current time 138, horizon 130\n", - "adding: mem time9, current time 138, horizon 129\n", - "adding: mem time10, current time 138, horizon 128\n", - "adding: mem time11, current time 138, horizon 127\n", - "adding: mem time12, current time 138, horizon 126\n", - "adding: mem time13, current time 138, horizon 125\n", - "adding: mem time14, current time 138, horizon 124\n", - "adding: mem time15, current time 138, horizon 123\n", - "adding: mem time16, current time 138, horizon 122\n", - "adding: mem time17, current time 138, horizon 121\n", - "adding: mem time18, current time 138, horizon 120\n", - "adding: mem time19, current time 138, horizon 119\n", - "adding: mem time20, current time 138, horizon 118\n", - "adding: mem time21, current time 138, horizon 117\n", - "adding: mem time22, current time 138, horizon 116\n", - "adding: mem time23, current time 138, horizon 115\n", - "adding: mem time24, current time 138, horizon 114\n", - "adding: mem time25, current time 138, horizon 113\n", - "adding: mem time26, current time 138, horizon 112\n", - "adding: mem time27, current time 138, horizon 111\n", - "adding: mem time28, current time 138, horizon 110\n", - "adding: mem time29, current time 138, horizon 109\n", - "adding: mem time30, current time 138, horizon 108\n", - "adding: mem time31, current time 138, horizon 107\n", - "adding: mem time32, current time 138, horizon 106\n", - "adding: mem time33, current time 138, horizon 105\n", - "adding: mem time34, current time 138, horizon 104\n", - "adding: mem time35, current time 138, horizon 103\n", - "adding: mem time36, current time 138, horizon 102\n", - "adding: mem time37, current time 138, horizon 101\n", - "adding: mem time38, current time 138, horizon 100\n", - "adding: mem time39, current time 138, horizon 99\n", - "adding: mem time40, current time 138, horizon 98\n", - "adding: mem time41, current time 138, horizon 97\n", - "adding: mem time42, current time 138, horizon 96\n", - "adding: mem time43, current time 138, horizon 95\n", - "adding: mem time44, current time 138, horizon 94\n", - "adding: mem time45, current time 138, horizon 93\n", - "adding: mem time46, current time 138, horizon 92\n", - "adding: mem time47, current time 138, horizon 91\n", - "adding: mem time48, current time 138, horizon 90\n", - "adding: mem time49, current time 138, horizon 89\n", - "adding: mem time50, current time 138, horizon 88\n", - "adding: mem time51, current time 138, horizon 87\n", - "adding: mem time52, current time 138, horizon 86\n", - "adding: mem time53, current time 138, horizon 85\n", - "adding: mem time54, current time 138, horizon 84\n", - "adding: mem time55, current time 138, horizon 83\n", - "adding: mem time56, current time 138, horizon 82\n", - "adding: mem time57, current time 138, horizon 81\n", - "adding: mem time58, current time 138, horizon 80\n", - "adding: mem time59, current time 138, horizon 79\n", - "adding: mem time60, current time 138, horizon 78\n", - "adding: mem time61, current time 138, horizon 77\n", - "adding: mem time62, current time 138, horizon 76\n", - "adding: mem time63, current time 138, horizon 75\n", - "adding: mem time64, current time 138, horizon 74\n", - "adding: mem time65, current time 138, horizon 73\n", - "adding: mem time66, current time 138, horizon 72\n", - "adding: mem time67, current time 138, horizon 71\n", - "adding: mem time68, current time 138, horizon 70\n", - "adding: mem time69, current time 138, horizon 69\n", - "adding: mem time70, current time 138, horizon 68\n", - "adding: mem time71, current time 138, horizon 67\n", - "adding: mem time72, current time 138, horizon 66\n", - "adding: mem time73, current time 138, horizon 65\n", - "adding: mem time74, current time 138, horizon 64\n", - "adding: mem time75, current time 138, horizon 63\n", - "adding: mem time76, current time 138, horizon 62\n", - "adding: mem time77, current time 138, horizon 61\n", - "adding: mem time78, current time 138, horizon 60\n", - "adding: mem time79, current time 138, horizon 59\n", - "adding: mem time80, current time 138, horizon 58\n", - "adding: mem time81, current time 138, horizon 57\n", - "adding: mem time82, current time 138, horizon 56\n", - "adding: mem time83, current time 138, horizon 55\n", - "adding: mem time84, current time 138, horizon 54\n", - "adding: mem time85, current time 138, horizon 53\n", - "adding: mem time86, current time 138, horizon 52\n", - "adding: mem time87, current time 138, horizon 51\n", - "adding: mem time88, current time 138, horizon 50\n", - "adding: mem time89, current time 138, horizon 49\n", - "adding: mem time90, current time 138, horizon 48\n", - "adding: mem time91, current time 138, horizon 47\n", - "adding: mem time92, current time 138, horizon 46\n", - "adding: mem time93, current time 138, horizon 45\n", - "adding: mem time94, current time 138, horizon 44\n", - "adding: mem time95, current time 138, horizon 43\n", - "adding: mem time96, current time 138, horizon 42\n", - "adding: mem time97, current time 138, horizon 41\n", - "adding: mem time98, current time 138, horizon 40\n", - "adding: mem time99, current time 138, horizon 39\n", - "adding: mem time100, current time 138, horizon 38\n", - "adding: mem time101, current time 138, horizon 37\n", - "adding: mem time102, current time 138, horizon 36\n", - "adding: mem time103, current time 138, horizon 35\n", - "adding: mem time104, current time 138, horizon 34\n", - "adding: mem time105, current time 138, horizon 33\n", - "adding: mem time106, current time 138, horizon 32\n", - "adding: mem time107, current time 138, horizon 31\n", - "adding: mem time108, current time 138, horizon 30\n", - "adding: mem time109, current time 138, horizon 29\n", - "adding: mem time110, current time 138, horizon 28\n", - "adding: mem time111, current time 138, horizon 27\n", - "adding: mem time112, current time 138, horizon 26\n", - "adding: mem time113, current time 138, horizon 25\n", - "adding: mem time114, current time 138, horizon 24\n", - "adding: mem time115, current time 138, horizon 23\n", - "adding: mem time116, current time 138, horizon 22\n", - "adding: mem time117, current time 138, horizon 21\n", - "adding: mem time118, current time 138, horizon 20\n", - "adding: mem time119, current time 138, horizon 19\n", - "adding: mem time120, current time 138, horizon 18\n", - "adding: mem time121, current time 138, horizon 17\n", - "adding: mem time122, current time 138, horizon 16\n", - "adding: mem time123, current time 138, horizon 15\n", - "adding: mem time124, current time 138, horizon 14\n", - "adding: mem time125, current time 138, horizon 13\n", - "adding: mem time126, current time 138, horizon 12\n", - "adding: mem time127, current time 138, horizon 11\n", - "adding: mem time128, current time 138, horizon 10\n", - "adding: mem time129, current time 138, horizon 9\n", - "adding: mem time130, current time 138, horizon 8\n", - "adding: mem time131, current time 138, horizon 7\n", - "adding: mem time132, current time 138, horizon 6\n", - "adding: mem time133, current time 138, horizon 5\n", - "adding: mem time134, current time 138, horizon 4\n", - "adding: mem time135, current time 138, horizon 3\n", - "adding: mem time136, current time 138, horizon 2\n", - "adding: mem time137, current time 138, horizon 1\n", - "adding: mem time0, current time 139, horizon 139\n", - "adding: mem time1, current time 139, horizon 138\n", - "adding: mem time2, current time 139, horizon 137\n", - "adding: mem time3, current time 139, horizon 136\n", - "adding: mem time4, current time 139, horizon 135\n", - "adding: mem time5, current time 139, horizon 134\n", - "adding: mem time6, current time 139, horizon 133\n", - "adding: mem time7, current time 139, horizon 132\n", - "adding: mem time8, current time 139, horizon 131\n", - "adding: mem time9, current time 139, horizon 130\n", - "adding: mem time10, current time 139, horizon 129\n", - "adding: mem time11, current time 139, horizon 128\n", - "adding: mem time12, current time 139, horizon 127\n", - "adding: mem time13, current time 139, horizon 126\n", - "adding: mem time14, current time 139, horizon 125\n", - "adding: mem time15, current time 139, horizon 124\n", - "adding: mem time16, current time 139, horizon 123\n", - "adding: mem time17, current time 139, horizon 122\n", - "adding: mem time18, current time 139, horizon 121\n", - "adding: mem time19, current time 139, horizon 120\n", - "adding: mem time20, current time 139, horizon 119\n", - "adding: mem time21, current time 139, horizon 118\n", - "adding: mem time22, current time 139, horizon 117\n", - "adding: mem time23, current time 139, horizon 116\n", - "adding: mem time24, current time 139, horizon 115\n", - "adding: mem time25, current time 139, horizon 114\n", - "adding: mem time26, current time 139, horizon 113\n", - "adding: mem time27, current time 139, horizon 112\n", - "adding: mem time28, current time 139, horizon 111\n", - "adding: mem time29, current time 139, horizon 110\n", - "adding: mem time30, current time 139, horizon 109\n", - "adding: mem time31, current time 139, horizon 108\n", - "adding: mem time32, current time 139, horizon 107\n", - "adding: mem time33, current time 139, horizon 106\n", - "adding: mem time34, current time 139, horizon 105\n", - "adding: mem time35, current time 139, horizon 104\n", - "adding: mem time36, current time 139, horizon 103\n", - "adding: mem time37, current time 139, horizon 102\n", - "adding: mem time38, current time 139, horizon 101\n", - "adding: mem time39, current time 139, horizon 100\n", - "adding: mem time40, current time 139, horizon 99\n", - "adding: mem time41, current time 139, horizon 98\n", - "adding: mem time42, current time 139, horizon 97\n", - "adding: mem time43, current time 139, horizon 96\n", - "adding: mem time44, current time 139, horizon 95\n", - "adding: mem time45, current time 139, horizon 94\n", - "adding: mem time46, current time 139, horizon 93\n", - "adding: mem time47, current time 139, horizon 92\n", - "adding: mem time48, current time 139, horizon 91\n", - "adding: mem time49, current time 139, horizon 90\n", - "adding: mem time50, current time 139, horizon 89\n", - "adding: mem time51, current time 139, horizon 88\n", - "adding: mem time52, current time 139, horizon 87\n", - "adding: mem time53, current time 139, horizon 86\n", - "adding: mem time54, current time 139, horizon 85\n", - "adding: mem time55, current time 139, horizon 84\n", - "adding: mem time56, current time 139, horizon 83\n", - "adding: mem time57, current time 139, horizon 82\n", - "adding: mem time58, current time 139, horizon 81\n", - "adding: mem time59, current time 139, horizon 80\n", - "adding: mem time60, current time 139, horizon 79\n", - "adding: mem time61, current time 139, horizon 78\n", - "adding: mem time62, current time 139, horizon 77\n", - "adding: mem time63, current time 139, horizon 76\n", - "adding: mem time64, current time 139, horizon 75\n", - "adding: mem time65, current time 139, horizon 74\n", - "adding: mem time66, current time 139, horizon 73\n", - "adding: mem time67, current time 139, horizon 72\n", - "adding: mem time68, current time 139, horizon 71\n", - "adding: mem time69, current time 139, horizon 70\n", - "adding: mem time70, current time 139, horizon 69\n", - "adding: mem time71, current time 139, horizon 68\n", - "adding: mem time72, current time 139, horizon 67\n", - "adding: mem time73, current time 139, horizon 66\n", - "adding: mem time74, current time 139, horizon 65\n", - "adding: mem time75, current time 139, horizon 64\n", - "adding: mem time76, current time 139, horizon 63\n", - "adding: mem time77, current time 139, horizon 62\n", - "adding: mem time78, current time 139, horizon 61\n", - "adding: mem time79, current time 139, horizon 60\n", - "adding: mem time80, current time 139, horizon 59\n", - "adding: mem time81, current time 139, horizon 58\n", - "adding: mem time82, current time 139, horizon 57\n", - "adding: mem time83, current time 139, horizon 56\n", - "adding: mem time84, current time 139, horizon 55\n", - "adding: mem time85, current time 139, horizon 54\n", - "adding: mem time86, current time 139, horizon 53\n", - "adding: mem time87, current time 139, horizon 52\n", - "adding: mem time88, current time 139, horizon 51\n", - "adding: mem time89, current time 139, horizon 50\n", - "adding: mem time90, current time 139, horizon 49\n", - "adding: mem time91, current time 139, horizon 48\n", - "adding: mem time92, current time 139, horizon 47\n", - "adding: mem time93, current time 139, horizon 46\n", - "adding: mem time94, current time 139, horizon 45\n", - "adding: mem time95, current time 139, horizon 44\n", - "adding: mem time96, current time 139, horizon 43\n", - "adding: mem time97, current time 139, horizon 42\n", - "adding: mem time98, current time 139, horizon 41\n", - "adding: mem time99, current time 139, horizon 40\n", - "adding: mem time100, current time 139, horizon 39\n", - "adding: mem time101, current time 139, horizon 38\n", - "adding: mem time102, current time 139, horizon 37\n", - "adding: mem time103, current time 139, horizon 36\n", - "adding: mem time104, current time 139, horizon 35\n", - "adding: mem time105, current time 139, horizon 34\n", - "adding: mem time106, current time 139, horizon 33\n", - "adding: mem time107, current time 139, horizon 32\n", - "adding: mem time108, current time 139, horizon 31\n", - "adding: mem time109, current time 139, horizon 30\n", - "adding: mem time110, current time 139, horizon 29\n", - "adding: mem time111, current time 139, horizon 28\n", - "adding: mem time112, current time 139, horizon 27\n", - "adding: mem time113, current time 139, horizon 26\n", - "adding: mem time114, current time 139, horizon 25\n", - "adding: mem time115, current time 139, horizon 24\n", - "adding: mem time116, current time 139, horizon 23\n", - "adding: mem time117, current time 139, horizon 22\n", - "adding: mem time118, current time 139, horizon 21\n", - "adding: mem time119, current time 139, horizon 20\n", - "adding: mem time120, current time 139, horizon 19\n", - "adding: mem time121, current time 139, horizon 18\n", - "adding: mem time122, current time 139, horizon 17\n", - "adding: mem time123, current time 139, horizon 16\n", - "adding: mem time124, current time 139, horizon 15\n", - "adding: mem time125, current time 139, horizon 14\n", - "adding: mem time126, current time 139, horizon 13\n", - "adding: mem time127, current time 139, horizon 12\n", - "adding: mem time128, current time 139, horizon 11\n", - "adding: mem time129, current time 139, horizon 10\n", - "adding: mem time130, current time 139, horizon 9\n", - "adding: mem time131, current time 139, horizon 8\n", - "adding: mem time132, current time 139, horizon 7\n", - "adding: mem time133, current time 139, horizon 6\n", - "adding: mem time134, current time 139, horizon 5\n", - "adding: mem time135, current time 139, horizon 4\n", - "adding: mem time136, current time 139, horizon 3\n", - "adding: mem time137, current time 139, horizon 2\n", - "adding: mem time138, current time 139, horizon 1\n", - "adding: mem time0, current time 140, horizon 140\n", - "adding: mem time1, current time 140, horizon 139\n", - "adding: mem time2, current time 140, horizon 138\n", - "adding: mem time3, current time 140, horizon 137\n", - "adding: mem time4, current time 140, horizon 136\n", - "adding: mem time5, current time 140, horizon 135\n", - "adding: mem time6, current time 140, horizon 134\n", - "adding: mem time7, current time 140, horizon 133\n", - "adding: mem time8, current time 140, horizon 132\n", - "adding: mem time9, current time 140, horizon 131\n", - "adding: mem time10, current time 140, horizon 130\n", - "adding: mem time11, current time 140, horizon 129\n", - "adding: mem time12, current time 140, horizon 128\n", - "adding: mem time13, current time 140, horizon 127\n", - "adding: mem time14, current time 140, horizon 126\n", - "adding: mem time15, current time 140, horizon 125\n", - "adding: mem time16, current time 140, horizon 124\n", - "adding: mem time17, current time 140, horizon 123\n", - "adding: mem time18, current time 140, horizon 122\n", - "adding: mem time19, current time 140, horizon 121\n", - "adding: mem time20, current time 140, horizon 120\n", - "adding: mem time21, current time 140, horizon 119\n", - "adding: mem time22, current time 140, horizon 118\n", - "adding: mem time23, current time 140, horizon 117\n", - "adding: mem time24, current time 140, horizon 116\n", - "adding: mem time25, current time 140, horizon 115\n", - "adding: mem time26, current time 140, horizon 114\n", - "adding: mem time27, current time 140, horizon 113\n", - "adding: mem time28, current time 140, horizon 112\n", - "adding: mem time29, current time 140, horizon 111\n", - "adding: mem time30, current time 140, horizon 110\n", - "adding: mem time31, current time 140, horizon 109\n", - "adding: mem time32, current time 140, horizon 108\n", - "adding: mem time33, current time 140, horizon 107\n", - "adding: mem time34, current time 140, horizon 106\n", - "adding: mem time35, current time 140, horizon 105\n", - "adding: mem time36, current time 140, horizon 104\n", - "adding: mem time37, current time 140, horizon 103\n", - "adding: mem time38, current time 140, horizon 102\n", - "adding: mem time39, current time 140, horizon 101\n", - "adding: mem time40, current time 140, horizon 100\n", - "adding: mem time41, current time 140, horizon 99\n", - "adding: mem time42, current time 140, horizon 98\n", - "adding: mem time43, current time 140, horizon 97\n", - "adding: mem time44, current time 140, horizon 96\n", - "adding: mem time45, current time 140, horizon 95\n", - "adding: mem time46, current time 140, horizon 94\n", - "adding: mem time47, current time 140, horizon 93\n", - "adding: mem time48, current time 140, horizon 92\n", - "adding: mem time49, current time 140, horizon 91\n", - "adding: mem time50, current time 140, horizon 90\n", - "adding: mem time51, current time 140, horizon 89\n", - "adding: mem time52, current time 140, horizon 88\n", - "adding: mem time53, current time 140, horizon 87\n", - "adding: mem time54, current time 140, horizon 86\n", - "adding: mem time55, current time 140, horizon 85\n", - "adding: mem time56, current time 140, horizon 84\n", - "adding: mem time57, current time 140, horizon 83\n", - "adding: mem time58, current time 140, horizon 82\n", - "adding: mem time59, current time 140, horizon 81\n", - "adding: mem time60, current time 140, horizon 80\n", - "adding: mem time61, current time 140, horizon 79\n", - "adding: mem time62, current time 140, horizon 78\n", - "adding: mem time63, current time 140, horizon 77\n", - "adding: mem time64, current time 140, horizon 76\n", - "adding: mem time65, current time 140, horizon 75\n", - "adding: mem time66, current time 140, horizon 74\n", - "adding: mem time67, current time 140, horizon 73\n", - "adding: mem time68, current time 140, horizon 72\n", - "adding: mem time69, current time 140, horizon 71\n", - "adding: mem time70, current time 140, horizon 70\n", - "adding: mem time71, current time 140, horizon 69\n", - "adding: mem time72, current time 140, horizon 68\n", - "adding: mem time73, current time 140, horizon 67\n", - "adding: mem time74, current time 140, horizon 66\n", - "adding: mem time75, current time 140, horizon 65\n", - "adding: mem time76, current time 140, horizon 64\n", - "adding: mem time77, current time 140, horizon 63\n", - "adding: mem time78, current time 140, horizon 62\n", - "adding: mem time79, current time 140, horizon 61\n", - "adding: mem time80, current time 140, horizon 60\n", - "adding: mem time81, current time 140, horizon 59\n", - "adding: mem time82, current time 140, horizon 58\n", - "adding: mem time83, current time 140, horizon 57\n", - "adding: mem time84, current time 140, horizon 56\n", - "adding: mem time85, current time 140, horizon 55\n", - "adding: mem time86, current time 140, horizon 54\n", - "adding: mem time87, current time 140, horizon 53\n", - "adding: mem time88, current time 140, horizon 52\n", - "adding: mem time89, current time 140, horizon 51\n", - "adding: mem time90, current time 140, horizon 50\n", - "adding: mem time91, current time 140, horizon 49\n", - "adding: mem time92, current time 140, horizon 48\n", - "adding: mem time93, current time 140, horizon 47\n", - "adding: mem time94, current time 140, horizon 46\n", - "adding: mem time95, current time 140, horizon 45\n", - "adding: mem time96, current time 140, horizon 44\n", - "adding: mem time97, current time 140, horizon 43\n", - "adding: mem time98, current time 140, horizon 42\n", - "adding: mem time99, current time 140, horizon 41\n", - "adding: mem time100, current time 140, horizon 40\n", - "adding: mem time101, current time 140, horizon 39\n", - "adding: mem time102, current time 140, horizon 38\n", - "adding: mem time103, current time 140, horizon 37\n", - "adding: mem time104, current time 140, horizon 36\n", - "adding: mem time105, current time 140, horizon 35\n", - "adding: mem time106, current time 140, horizon 34\n", - "adding: mem time107, current time 140, horizon 33\n", - "adding: mem time108, current time 140, horizon 32\n", - "adding: mem time109, current time 140, horizon 31\n", - "adding: mem time110, current time 140, horizon 30\n", - "adding: mem time111, current time 140, horizon 29\n", - "adding: mem time112, current time 140, horizon 28\n", - "adding: mem time113, current time 140, horizon 27\n", - "adding: mem time114, current time 140, horizon 26\n", - "adding: mem time115, current time 140, horizon 25\n", - "adding: mem time116, current time 140, horizon 24\n", - "adding: mem time117, current time 140, horizon 23\n", - "adding: mem time118, current time 140, horizon 22\n", - "adding: mem time119, current time 140, horizon 21\n", - "adding: mem time120, current time 140, horizon 20\n", - "adding: mem time121, current time 140, horizon 19\n", - "adding: mem time122, current time 140, horizon 18\n", - "adding: mem time123, current time 140, horizon 17\n", - "adding: mem time124, current time 140, horizon 16\n", - "adding: mem time125, current time 140, horizon 15\n", - "adding: mem time126, current time 140, horizon 14\n", - "adding: mem time127, current time 140, horizon 13\n", - "adding: mem time128, current time 140, horizon 12\n", - "adding: mem time129, current time 140, horizon 11\n", - "adding: mem time130, current time 140, horizon 10\n", - "adding: mem time131, current time 140, horizon 9\n", - "adding: mem time132, current time 140, horizon 8\n", - "adding: mem time133, current time 140, horizon 7\n", - "adding: mem time134, current time 140, horizon 6\n", - "adding: mem time135, current time 140, horizon 5\n", - "adding: mem time136, current time 140, horizon 4\n", - "adding: mem time137, current time 140, horizon 3\n", - "adding: mem time138, current time 140, horizon 2\n", - "adding: mem time139, current time 140, horizon 1\n", - "adding: mem time0, current time 141, horizon 141\n", - "adding: mem time1, current time 141, horizon 140\n", - "adding: mem time2, current time 141, horizon 139\n", - "adding: mem time3, current time 141, horizon 138\n", - "adding: mem time4, current time 141, horizon 137\n", - "adding: mem time5, current time 141, horizon 136\n", - "adding: mem time6, current time 141, horizon 135\n", - "adding: mem time7, current time 141, horizon 134\n", - "adding: mem time8, current time 141, horizon 133\n", - "adding: mem time9, current time 141, horizon 132\n", - "adding: mem time10, current time 141, horizon 131\n", - "adding: mem time11, current time 141, horizon 130\n", - "adding: mem time12, current time 141, horizon 129\n", - "adding: mem time13, current time 141, horizon 128\n", - "adding: mem time14, current time 141, horizon 127\n", - "adding: mem time15, current time 141, horizon 126\n", - "adding: mem time16, current time 141, horizon 125\n", - "adding: mem time17, current time 141, horizon 124\n", - "adding: mem time18, current time 141, horizon 123\n", - "adding: mem time19, current time 141, horizon 122\n", - "adding: mem time20, current time 141, horizon 121\n", - "adding: mem time21, current time 141, horizon 120\n", - "adding: mem time22, current time 141, horizon 119\n", - "adding: mem time23, current time 141, horizon 118\n", - "adding: mem time24, current time 141, horizon 117\n", - "adding: mem time25, current time 141, horizon 116\n", - "adding: mem time26, current time 141, horizon 115\n", - "adding: mem time27, current time 141, horizon 114\n", - "adding: mem time28, current time 141, horizon 113\n", - "adding: mem time29, current time 141, horizon 112\n", - "adding: mem time30, current time 141, horizon 111\n", - "adding: mem time31, current time 141, horizon 110\n", - "adding: mem time32, current time 141, horizon 109\n", - "adding: mem time33, current time 141, horizon 108\n", - "adding: mem time34, current time 141, horizon 107\n", - "adding: mem time35, current time 141, horizon 106\n", - "adding: mem time36, current time 141, horizon 105\n", - "adding: mem time37, current time 141, horizon 104\n", - "adding: mem time38, current time 141, horizon 103\n", - "adding: mem time39, current time 141, horizon 102\n", - "adding: mem time40, current time 141, horizon 101\n", - "adding: mem time41, current time 141, horizon 100\n", - "adding: mem time42, current time 141, horizon 99\n", - "adding: mem time43, current time 141, horizon 98\n", - "adding: mem time44, current time 141, horizon 97\n", - "adding: mem time45, current time 141, horizon 96\n", - "adding: mem time46, current time 141, horizon 95\n", - "adding: mem time47, current time 141, horizon 94\n", - "adding: mem time48, current time 141, horizon 93\n", - "adding: mem time49, current time 141, horizon 92\n", - "adding: mem time50, current time 141, horizon 91\n", - "adding: mem time51, current time 141, horizon 90\n", - "adding: mem time52, current time 141, horizon 89\n", - "adding: mem time53, current time 141, horizon 88\n", - "adding: mem time54, current time 141, horizon 87\n", - "adding: mem time55, current time 141, horizon 86\n", - "adding: mem time56, current time 141, horizon 85\n", - "adding: mem time57, current time 141, horizon 84\n", - "adding: mem time58, current time 141, horizon 83\n", - "adding: mem time59, current time 141, horizon 82\n", - "adding: mem time60, current time 141, horizon 81\n", - "adding: mem time61, current time 141, horizon 80\n", - "adding: mem time62, current time 141, horizon 79\n", - "adding: mem time63, current time 141, horizon 78\n", - "adding: mem time64, current time 141, horizon 77\n", - "adding: mem time65, current time 141, horizon 76\n", - "adding: mem time66, current time 141, horizon 75\n", - "adding: mem time67, current time 141, horizon 74\n", - "adding: mem time68, current time 141, horizon 73\n", - "adding: mem time69, current time 141, horizon 72\n", - "adding: mem time70, current time 141, horizon 71\n", - "adding: mem time71, current time 141, horizon 70\n", - "adding: mem time72, current time 141, horizon 69\n", - "adding: mem time73, current time 141, horizon 68\n", - "adding: mem time74, current time 141, horizon 67\n", - "adding: mem time75, current time 141, horizon 66\n", - "adding: mem time76, current time 141, horizon 65\n", - "adding: mem time77, current time 141, horizon 64\n", - "adding: mem time78, current time 141, horizon 63\n", - "adding: mem time79, current time 141, horizon 62\n", - "adding: mem time80, current time 141, horizon 61\n", - "adding: mem time81, current time 141, horizon 60\n", - "adding: mem time82, current time 141, horizon 59\n", - "adding: mem time83, current time 141, horizon 58\n", - "adding: mem time84, current time 141, horizon 57\n", - "adding: mem time85, current time 141, horizon 56\n", - "adding: mem time86, current time 141, horizon 55\n", - "adding: mem time87, current time 141, horizon 54\n", - "adding: mem time88, current time 141, horizon 53\n", - "adding: mem time89, current time 141, horizon 52\n", - "adding: mem time90, current time 141, horizon 51\n", - "adding: mem time91, current time 141, horizon 50\n", - "adding: mem time92, current time 141, horizon 49\n", - "adding: mem time93, current time 141, horizon 48\n", - "adding: mem time94, current time 141, horizon 47\n", - "adding: mem time95, current time 141, horizon 46\n", - "adding: mem time96, current time 141, horizon 45\n", - "adding: mem time97, current time 141, horizon 44\n", - "adding: mem time98, current time 141, horizon 43\n", - "adding: mem time99, current time 141, horizon 42\n", - "adding: mem time100, current time 141, horizon 41\n", - "adding: mem time101, current time 141, horizon 40\n", - "adding: mem time102, current time 141, horizon 39\n", - "adding: mem time103, current time 141, horizon 38\n", - "adding: mem time104, current time 141, horizon 37\n", - "adding: mem time105, current time 141, horizon 36\n", - "adding: mem time106, current time 141, horizon 35\n", - "adding: mem time107, current time 141, horizon 34\n", - "adding: mem time108, current time 141, horizon 33\n", - "adding: mem time109, current time 141, horizon 32\n", - "adding: mem time110, current time 141, horizon 31\n", - "adding: mem time111, current time 141, horizon 30\n", - "adding: mem time112, current time 141, horizon 29\n", - "adding: mem time113, current time 141, horizon 28\n", - "adding: mem time114, current time 141, horizon 27\n", - "adding: mem time115, current time 141, horizon 26\n", - "adding: mem time116, current time 141, horizon 25\n", - "adding: mem time117, current time 141, horizon 24\n", - "adding: mem time118, current time 141, horizon 23\n", - "adding: mem time119, current time 141, horizon 22\n", - "adding: mem time120, current time 141, horizon 21\n", - "adding: mem time121, current time 141, horizon 20\n", - "adding: mem time122, current time 141, horizon 19\n", - "adding: mem time123, current time 141, horizon 18\n", - "adding: mem time124, current time 141, horizon 17\n", - "adding: mem time125, current time 141, horizon 16\n", - "adding: mem time126, current time 141, horizon 15\n", - "adding: mem time127, current time 141, horizon 14\n", - "adding: mem time128, current time 141, horizon 13\n", - "adding: mem time129, current time 141, horizon 12\n", - "adding: mem time130, current time 141, horizon 11\n", - "adding: mem time131, current time 141, horizon 10\n", - "adding: mem time132, current time 141, horizon 9\n", - "adding: mem time133, current time 141, horizon 8\n", - "adding: mem time134, current time 141, horizon 7\n", - "adding: mem time135, current time 141, horizon 6\n", - "adding: mem time136, current time 141, horizon 5\n", - "adding: mem time137, current time 141, horizon 4\n", - "adding: mem time138, current time 141, horizon 3\n", - "adding: mem time139, current time 141, horizon 2\n", - "adding: mem time140, current time 141, horizon 1\n", - "adding: mem time0, current time 142, horizon 142\n", - "adding: mem time1, current time 142, horizon 141\n", - "adding: mem time2, current time 142, horizon 140\n", - "adding: mem time3, current time 142, horizon 139\n", - "adding: mem time4, current time 142, horizon 138\n", - "adding: mem time5, current time 142, horizon 137\n", - "adding: mem time6, current time 142, horizon 136\n", - "adding: mem time7, current time 142, horizon 135\n", - "adding: mem time8, current time 142, horizon 134\n", - "adding: mem time9, current time 142, horizon 133\n", - "adding: mem time10, current time 142, horizon 132\n", - "adding: mem time11, current time 142, horizon 131\n", - "adding: mem time12, current time 142, horizon 130\n", - "adding: mem time13, current time 142, horizon 129\n", - "adding: mem time14, current time 142, horizon 128\n", - "adding: mem time15, current time 142, horizon 127\n", - "adding: mem time16, current time 142, horizon 126\n", - "adding: mem time17, current time 142, horizon 125\n", - "adding: mem time18, current time 142, horizon 124\n", - "adding: mem time19, current time 142, horizon 123\n", - "adding: mem time20, current time 142, horizon 122\n", - "adding: mem time21, current time 142, horizon 121\n", - "adding: mem time22, current time 142, horizon 120\n", - "adding: mem time23, current time 142, horizon 119\n", - "adding: mem time24, current time 142, horizon 118\n", - "adding: mem time25, current time 142, horizon 117\n", - "adding: mem time26, current time 142, horizon 116\n", - "adding: mem time27, current time 142, horizon 115\n", - "adding: mem time28, current time 142, horizon 114\n", - "adding: mem time29, current time 142, horizon 113\n", - "adding: mem time30, current time 142, horizon 112\n", - "adding: mem time31, current time 142, horizon 111\n", - "adding: mem time32, current time 142, horizon 110\n", - "adding: mem time33, current time 142, horizon 109\n", - "adding: mem time34, current time 142, horizon 108\n", - "adding: mem time35, current time 142, horizon 107\n", - "adding: mem time36, current time 142, horizon 106\n", - "adding: mem time37, current time 142, horizon 105\n", - "adding: mem time38, current time 142, horizon 104\n", - "adding: mem time39, current time 142, horizon 103\n", - "adding: mem time40, current time 142, horizon 102\n", - "adding: mem time41, current time 142, horizon 101\n", - "adding: mem time42, current time 142, horizon 100\n", - "adding: mem time43, current time 142, horizon 99\n", - "adding: mem time44, current time 142, horizon 98\n", - "adding: mem time45, current time 142, horizon 97\n", - "adding: mem time46, current time 142, horizon 96\n", - "adding: mem time47, current time 142, horizon 95\n", - "adding: mem time48, current time 142, horizon 94\n", - "adding: mem time49, current time 142, horizon 93\n", - "adding: mem time50, current time 142, horizon 92\n", - "adding: mem time51, current time 142, horizon 91\n", - "adding: mem time52, current time 142, horizon 90\n", - "adding: mem time53, current time 142, horizon 89\n", - "adding: mem time54, current time 142, horizon 88\n", - "adding: mem time55, current time 142, horizon 87\n", - "adding: mem time56, current time 142, horizon 86\n", - "adding: mem time57, current time 142, horizon 85\n", - "adding: mem time58, current time 142, horizon 84\n", - "adding: mem time59, current time 142, horizon 83\n", - "adding: mem time60, current time 142, horizon 82\n", - "adding: mem time61, current time 142, horizon 81\n", - "adding: mem time62, current time 142, horizon 80\n", - "adding: mem time63, current time 142, horizon 79\n", - "adding: mem time64, current time 142, horizon 78\n", - "adding: mem time65, current time 142, horizon 77\n", - "adding: mem time66, current time 142, horizon 76\n", - "adding: mem time67, current time 142, horizon 75\n", - "adding: mem time68, current time 142, horizon 74\n", - "adding: mem time69, current time 142, horizon 73\n", - "adding: mem time70, current time 142, horizon 72\n", - "adding: mem time71, current time 142, horizon 71\n", - "adding: mem time72, current time 142, horizon 70\n", - "adding: mem time73, current time 142, horizon 69\n", - "adding: mem time74, current time 142, horizon 68\n", - "adding: mem time75, current time 142, horizon 67\n", - "adding: mem time76, current time 142, horizon 66\n", - "adding: mem time77, current time 142, horizon 65\n", - "adding: mem time78, current time 142, horizon 64\n", - "adding: mem time79, current time 142, horizon 63\n", - "adding: mem time80, current time 142, horizon 62\n", - "adding: mem time81, current time 142, horizon 61\n", - "adding: mem time82, current time 142, horizon 60\n", - "adding: mem time83, current time 142, horizon 59\n", - "adding: mem time84, current time 142, horizon 58\n", - "adding: mem time85, current time 142, horizon 57\n", - "adding: mem time86, current time 142, horizon 56\n", - "adding: mem time87, current time 142, horizon 55\n", - "adding: mem time88, current time 142, horizon 54\n", - "adding: mem time89, current time 142, horizon 53\n", - "adding: mem time90, current time 142, horizon 52\n", - "adding: mem time91, current time 142, horizon 51\n", - "adding: mem time92, current time 142, horizon 50\n", - "adding: mem time93, current time 142, horizon 49\n", - "adding: mem time94, current time 142, horizon 48\n", - "adding: mem time95, current time 142, horizon 47\n", - "adding: mem time96, current time 142, horizon 46\n", - "adding: mem time97, current time 142, horizon 45\n", - "adding: mem time98, current time 142, horizon 44\n", - "adding: mem time99, current time 142, horizon 43\n", - "adding: mem time100, current time 142, horizon 42\n", - "adding: mem time101, current time 142, horizon 41\n", - "adding: mem time102, current time 142, horizon 40\n", - "adding: mem time103, current time 142, horizon 39\n", - "adding: mem time104, current time 142, horizon 38\n", - "adding: mem time105, current time 142, horizon 37\n", - "adding: mem time106, current time 142, horizon 36\n", - "adding: mem time107, current time 142, horizon 35\n", - "adding: mem time108, current time 142, horizon 34\n", - "adding: mem time109, current time 142, horizon 33\n", - "adding: mem time110, current time 142, horizon 32\n", - "adding: mem time111, current time 142, horizon 31\n", - "adding: mem time112, current time 142, horizon 30\n", - "adding: mem time113, current time 142, horizon 29\n", - "adding: mem time114, current time 142, horizon 28\n", - "adding: mem time115, current time 142, horizon 27\n", - "adding: mem time116, current time 142, horizon 26\n", - "adding: mem time117, current time 142, horizon 25\n", - "adding: mem time118, current time 142, horizon 24\n", - "adding: mem time119, current time 142, horizon 23\n", - "adding: mem time120, current time 142, horizon 22\n", - "adding: mem time121, current time 142, horizon 21\n", - "adding: mem time122, current time 142, horizon 20\n", - "adding: mem time123, current time 142, horizon 19\n", - "adding: mem time124, current time 142, horizon 18\n", - "adding: mem time125, current time 142, horizon 17\n", - "adding: mem time126, current time 142, horizon 16\n", - "adding: mem time127, current time 142, horizon 15\n", - "adding: mem time128, current time 142, horizon 14\n", - "adding: mem time129, current time 142, horizon 13\n", - "adding: mem time130, current time 142, horizon 12\n", - "adding: mem time131, current time 142, horizon 11\n", - "adding: mem time132, current time 142, horizon 10\n", - "adding: mem time133, current time 142, horizon 9\n", - "adding: mem time134, current time 142, horizon 8\n", - "adding: mem time135, current time 142, horizon 7\n", - "adding: mem time136, current time 142, horizon 6\n", - "adding: mem time137, current time 142, horizon 5\n", - "adding: mem time138, current time 142, horizon 4\n", - "adding: mem time139, current time 142, horizon 3\n", - "adding: mem time140, current time 142, horizon 2\n", - "adding: mem time141, current time 142, horizon 1\n", - "adding: mem time0, current time 143, horizon 143\n", - "adding: mem time1, current time 143, horizon 142\n", - "adding: mem time2, current time 143, horizon 141\n", - "adding: mem time3, current time 143, horizon 140\n", - "adding: mem time4, current time 143, horizon 139\n", - "adding: mem time5, current time 143, horizon 138\n", - "adding: mem time6, current time 143, horizon 137\n", - "adding: mem time7, current time 143, horizon 136\n", - "adding: mem time8, current time 143, horizon 135\n", - "adding: mem time9, current time 143, horizon 134\n", - "adding: mem time10, current time 143, horizon 133\n", - "adding: mem time11, current time 143, horizon 132\n", - "adding: mem time12, current time 143, horizon 131\n", - "adding: mem time13, current time 143, horizon 130\n", - "adding: mem time14, current time 143, horizon 129\n", - "adding: mem time15, current time 143, horizon 128\n", - "adding: mem time16, current time 143, horizon 127\n", - "adding: mem time17, current time 143, horizon 126\n", - "adding: mem time18, current time 143, horizon 125\n", - "adding: mem time19, current time 143, horizon 124\n", - "adding: mem time20, current time 143, horizon 123\n", - "adding: mem time21, current time 143, horizon 122\n", - "adding: mem time22, current time 143, horizon 121\n", - "adding: mem time23, current time 143, horizon 120\n", - "adding: mem time24, current time 143, horizon 119\n", - "adding: mem time25, current time 143, horizon 118\n", - "adding: mem time26, current time 143, horizon 117\n", - "adding: mem time27, current time 143, horizon 116\n", - "adding: mem time28, current time 143, horizon 115\n", - "adding: mem time29, current time 143, horizon 114\n", - "adding: mem time30, current time 143, horizon 113\n", - "adding: mem time31, current time 143, horizon 112\n", - "adding: mem time32, current time 143, horizon 111\n", - "adding: mem time33, current time 143, horizon 110\n", - "adding: mem time34, current time 143, horizon 109\n", - "adding: mem time35, current time 143, horizon 108\n", - "adding: mem time36, current time 143, horizon 107\n", - "adding: mem time37, current time 143, horizon 106\n", - "adding: mem time38, current time 143, horizon 105\n", - "adding: mem time39, current time 143, horizon 104\n", - "adding: mem time40, current time 143, horizon 103\n", - "adding: mem time41, current time 143, horizon 102\n", - "adding: mem time42, current time 143, horizon 101\n", - "adding: mem time43, current time 143, horizon 100\n", - "adding: mem time44, current time 143, horizon 99\n", - "adding: mem time45, current time 143, horizon 98\n", - "adding: mem time46, current time 143, horizon 97\n", - "adding: mem time47, current time 143, horizon 96\n", - "adding: mem time48, current time 143, horizon 95\n", - "adding: mem time49, current time 143, horizon 94\n", - "adding: mem time50, current time 143, horizon 93\n", - "adding: mem time51, current time 143, horizon 92\n", - "adding: mem time52, current time 143, horizon 91\n", - "adding: mem time53, current time 143, horizon 90\n", - "adding: mem time54, current time 143, horizon 89\n", - "adding: mem time55, current time 143, horizon 88\n", - "adding: mem time56, current time 143, horizon 87\n", - "adding: mem time57, current time 143, horizon 86\n", - "adding: mem time58, current time 143, horizon 85\n", - "adding: mem time59, current time 143, horizon 84\n", - "adding: mem time60, current time 143, horizon 83\n", - "adding: mem time61, current time 143, horizon 82\n", - "adding: mem time62, current time 143, horizon 81\n", - "adding: mem time63, current time 143, horizon 80\n", - "adding: mem time64, current time 143, horizon 79\n", - "adding: mem time65, current time 143, horizon 78\n", - "adding: mem time66, current time 143, horizon 77\n", - "adding: mem time67, current time 143, horizon 76\n", - "adding: mem time68, current time 143, horizon 75\n", - "adding: mem time69, current time 143, horizon 74\n", - "adding: mem time70, current time 143, horizon 73\n", - "adding: mem time71, current time 143, horizon 72\n", - "adding: mem time72, current time 143, horizon 71\n", - "adding: mem time73, current time 143, horizon 70\n", - "adding: mem time74, current time 143, horizon 69\n", - "adding: mem time75, current time 143, horizon 68\n", - "adding: mem time76, current time 143, horizon 67\n", - "adding: mem time77, current time 143, horizon 66\n", - "adding: mem time78, current time 143, horizon 65\n", - "adding: mem time79, current time 143, horizon 64\n", - "adding: mem time80, current time 143, horizon 63\n", - "adding: mem time81, current time 143, horizon 62\n", - "adding: mem time82, current time 143, horizon 61\n", - "adding: mem time83, current time 143, horizon 60\n", - "adding: mem time84, current time 143, horizon 59\n", - "adding: mem time85, current time 143, horizon 58\n", - "adding: mem time86, current time 143, horizon 57\n", - "adding: mem time87, current time 143, horizon 56\n", - "adding: mem time88, current time 143, horizon 55\n", - "adding: mem time89, current time 143, horizon 54\n", - "adding: mem time90, current time 143, horizon 53\n", - "adding: mem time91, current time 143, horizon 52\n", - "adding: mem time92, current time 143, horizon 51\n", - "adding: mem time93, current time 143, horizon 50\n", - "adding: mem time94, current time 143, horizon 49\n", - "adding: mem time95, current time 143, horizon 48\n", - "adding: mem time96, current time 143, horizon 47\n", - "adding: mem time97, current time 143, horizon 46\n", - "adding: mem time98, current time 143, horizon 45\n", - "adding: mem time99, current time 143, horizon 44\n", - "adding: mem time100, current time 143, horizon 43\n", - "adding: mem time101, current time 143, horizon 42\n", - "adding: mem time102, current time 143, horizon 41\n", - "adding: mem time103, current time 143, horizon 40\n", - "adding: mem time104, current time 143, horizon 39\n", - "adding: mem time105, current time 143, horizon 38\n", - "adding: mem time106, current time 143, horizon 37\n", - "adding: mem time107, current time 143, horizon 36\n", - "adding: mem time108, current time 143, horizon 35\n", - "adding: mem time109, current time 143, horizon 34\n", - "adding: mem time110, current time 143, horizon 33\n", - "adding: mem time111, current time 143, horizon 32\n", - "adding: mem time112, current time 143, horizon 31\n", - "adding: mem time113, current time 143, horizon 30\n", - "adding: mem time114, current time 143, horizon 29\n", - "adding: mem time115, current time 143, horizon 28\n", - "adding: mem time116, current time 143, horizon 27\n", - "adding: mem time117, current time 143, horizon 26\n", - "adding: mem time118, current time 143, horizon 25\n", - "adding: mem time119, current time 143, horizon 24\n", - "adding: mem time120, current time 143, horizon 23\n", - "adding: mem time121, current time 143, horizon 22\n", - "adding: mem time122, current time 143, horizon 21\n", - "adding: mem time123, current time 143, horizon 20\n", - "adding: mem time124, current time 143, horizon 19\n", - "adding: mem time125, current time 143, horizon 18\n", - "adding: mem time126, current time 143, horizon 17\n", - "adding: mem time127, current time 143, horizon 16\n", - "adding: mem time128, current time 143, horizon 15\n", - "adding: mem time129, current time 143, horizon 14\n", - "adding: mem time130, current time 143, horizon 13\n", - "adding: mem time131, current time 143, horizon 12\n", - "adding: mem time132, current time 143, horizon 11\n", - "adding: mem time133, current time 143, horizon 10\n", - "adding: mem time134, current time 143, horizon 9\n", - "adding: mem time135, current time 143, horizon 8\n", - "adding: mem time136, current time 143, horizon 7\n", - "adding: mem time137, current time 143, horizon 6\n", - "adding: mem time138, current time 143, horizon 5\n", - "adding: mem time139, current time 143, horizon 4\n", - "adding: mem time140, current time 143, horizon 3\n", - "adding: mem time141, current time 143, horizon 2\n", - "adding: mem time142, current time 143, horizon 1\n", - "adding: mem time0, current time 144, horizon 144\n", - "adding: mem time1, current time 144, horizon 143\n", - "adding: mem time2, current time 144, horizon 142\n", - "adding: mem time3, current time 144, horizon 141\n", - "adding: mem time4, current time 144, horizon 140\n", - "adding: mem time5, current time 144, horizon 139\n", - "adding: mem time6, current time 144, horizon 138\n", - "adding: mem time7, current time 144, horizon 137\n", - "adding: mem time8, current time 144, horizon 136\n", - "adding: mem time9, current time 144, horizon 135\n", - "adding: mem time10, current time 144, horizon 134\n", - "adding: mem time11, current time 144, horizon 133\n", - "adding: mem time12, current time 144, horizon 132\n", - "adding: mem time13, current time 144, horizon 131\n", - "adding: mem time14, current time 144, horizon 130\n", - "adding: mem time15, current time 144, horizon 129\n", - "adding: mem time16, current time 144, horizon 128\n", - "adding: mem time17, current time 144, horizon 127\n", - "adding: mem time18, current time 144, horizon 126\n", - "adding: mem time19, current time 144, horizon 125\n", - "adding: mem time20, current time 144, horizon 124\n", - "adding: mem time21, current time 144, horizon 123\n", - "adding: mem time22, current time 144, horizon 122\n", - "adding: mem time23, current time 144, horizon 121\n", - "adding: mem time24, current time 144, horizon 120\n", - "adding: mem time25, current time 144, horizon 119\n", - "adding: mem time26, current time 144, horizon 118\n", - "adding: mem time27, current time 144, horizon 117\n", - "adding: mem time28, current time 144, horizon 116\n", - "adding: mem time29, current time 144, horizon 115\n", - "adding: mem time30, current time 144, horizon 114\n", - "adding: mem time31, current time 144, horizon 113\n", - "adding: mem time32, current time 144, horizon 112\n", - "adding: mem time33, current time 144, horizon 111\n", - "adding: mem time34, current time 144, horizon 110\n", - "adding: mem time35, current time 144, horizon 109\n", - "adding: mem time36, current time 144, horizon 108\n", - "adding: mem time37, current time 144, horizon 107\n", - "adding: mem time38, current time 144, horizon 106\n", - "adding: mem time39, current time 144, horizon 105\n", - "adding: mem time40, current time 144, horizon 104\n", - "adding: mem time41, current time 144, horizon 103\n", - "adding: mem time42, current time 144, horizon 102\n", - "adding: mem time43, current time 144, horizon 101\n", - "adding: mem time44, current time 144, horizon 100\n", - "adding: mem time45, current time 144, horizon 99\n", - "adding: mem time46, current time 144, horizon 98\n", - "adding: mem time47, current time 144, horizon 97\n", - "adding: mem time48, current time 144, horizon 96\n", - "adding: mem time49, current time 144, horizon 95\n", - "adding: mem time50, current time 144, horizon 94\n", - "adding: mem time51, current time 144, horizon 93\n", - "adding: mem time52, current time 144, horizon 92\n", - "adding: mem time53, current time 144, horizon 91\n", - "adding: mem time54, current time 144, horizon 90\n", - "adding: mem time55, current time 144, horizon 89\n", - "adding: mem time56, current time 144, horizon 88\n", - "adding: mem time57, current time 144, horizon 87\n", - "adding: mem time58, current time 144, horizon 86\n", - "adding: mem time59, current time 144, horizon 85\n", - "adding: mem time60, current time 144, horizon 84\n", - "adding: mem time61, current time 144, horizon 83\n", - "adding: mem time62, current time 144, horizon 82\n", - "adding: mem time63, current time 144, horizon 81\n", - "adding: mem time64, current time 144, horizon 80\n", - "adding: mem time65, current time 144, horizon 79\n", - "adding: mem time66, current time 144, horizon 78\n", - "adding: mem time67, current time 144, horizon 77\n", - "adding: mem time68, current time 144, horizon 76\n", - "adding: mem time69, current time 144, horizon 75\n", - "adding: mem time70, current time 144, horizon 74\n", - "adding: mem time71, current time 144, horizon 73\n", - "adding: mem time72, current time 144, horizon 72\n", - "adding: mem time73, current time 144, horizon 71\n", - "adding: mem time74, current time 144, horizon 70\n", - "adding: mem time75, current time 144, horizon 69\n", - "adding: mem time76, current time 144, horizon 68\n", - "adding: mem time77, current time 144, horizon 67\n", - "adding: mem time78, current time 144, horizon 66\n", - "adding: mem time79, current time 144, horizon 65\n", - "adding: mem time80, current time 144, horizon 64\n", - "adding: mem time81, current time 144, horizon 63\n", - "adding: mem time82, current time 144, horizon 62\n", - "adding: mem time83, current time 144, horizon 61\n", - "adding: mem time84, current time 144, horizon 60\n", - "adding: mem time85, current time 144, horizon 59\n", - "adding: mem time86, current time 144, horizon 58\n", - "adding: mem time87, current time 144, horizon 57\n", - "adding: mem time88, current time 144, horizon 56\n", - "adding: mem time89, current time 144, horizon 55\n", - "adding: mem time90, current time 144, horizon 54\n", - "adding: mem time91, current time 144, horizon 53\n", - "adding: mem time92, current time 144, horizon 52\n", - "adding: mem time93, current time 144, horizon 51\n", - "adding: mem time94, current time 144, horizon 50\n", - "adding: mem time95, current time 144, horizon 49\n", - "adding: mem time96, current time 144, horizon 48\n", - "adding: mem time97, current time 144, horizon 47\n", - "adding: mem time98, current time 144, horizon 46\n", - "adding: mem time99, current time 144, horizon 45\n", - "adding: mem time100, current time 144, horizon 44\n", - "adding: mem time101, current time 144, horizon 43\n", - "adding: mem time102, current time 144, horizon 42\n", - "adding: mem time103, current time 144, horizon 41\n", - "adding: mem time104, current time 144, horizon 40\n", - "adding: mem time105, current time 144, horizon 39\n", - "adding: mem time106, current time 144, horizon 38\n", - "adding: mem time107, current time 144, horizon 37\n", - "adding: mem time108, current time 144, horizon 36\n", - "adding: mem time109, current time 144, horizon 35\n", - "adding: mem time110, current time 144, horizon 34\n", - "adding: mem time111, current time 144, horizon 33\n", - "adding: mem time112, current time 144, horizon 32\n", - "adding: mem time113, current time 144, horizon 31\n", - "adding: mem time114, current time 144, horizon 30\n", - "adding: mem time115, current time 144, horizon 29\n", - "adding: mem time116, current time 144, horizon 28\n", - "adding: mem time117, current time 144, horizon 27\n", - "adding: mem time118, current time 144, horizon 26\n", - "adding: mem time119, current time 144, horizon 25\n", - "adding: mem time120, current time 144, horizon 24\n", - "adding: mem time121, current time 144, horizon 23\n", - "adding: mem time122, current time 144, horizon 22\n", - "adding: mem time123, current time 144, horizon 21\n", - "adding: mem time124, current time 144, horizon 20\n", - "adding: mem time125, current time 144, horizon 19\n", - "adding: mem time126, current time 144, horizon 18\n", - "adding: mem time127, current time 144, horizon 17\n", - "adding: mem time128, current time 144, horizon 16\n", - "adding: mem time129, current time 144, horizon 15\n", - "adding: mem time130, current time 144, horizon 14\n", - "adding: mem time131, current time 144, horizon 13\n", - "adding: mem time132, current time 144, horizon 12\n", - "adding: mem time133, current time 144, horizon 11\n", - "adding: mem time134, current time 144, horizon 10\n", - "adding: mem time135, current time 144, horizon 9\n", - "adding: mem time136, current time 144, horizon 8\n", - "adding: mem time137, current time 144, horizon 7\n", - "adding: mem time138, current time 144, horizon 6\n", - "adding: mem time139, current time 144, horizon 5\n", - "adding: mem time140, current time 144, horizon 4\n", - "adding: mem time141, current time 144, horizon 3\n", - "adding: mem time142, current time 144, horizon 2\n", - "adding: mem time143, current time 144, horizon 1\n", - "adding: mem time0, current time 145, horizon 145\n", - "adding: mem time1, current time 145, horizon 144\n", - "adding: mem time2, current time 145, horizon 143\n", - "adding: mem time3, current time 145, horizon 142\n", - "adding: mem time4, current time 145, horizon 141\n", - "adding: mem time5, current time 145, horizon 140\n", - "adding: mem time6, current time 145, horizon 139\n", - "adding: mem time7, current time 145, horizon 138\n", - "adding: mem time8, current time 145, horizon 137\n", - "adding: mem time9, current time 145, horizon 136\n", - "adding: mem time10, current time 145, horizon 135\n", - "adding: mem time11, current time 145, horizon 134\n", - "adding: mem time12, current time 145, horizon 133\n", - "adding: mem time13, current time 145, horizon 132\n", - "adding: mem time14, current time 145, horizon 131\n", - "adding: mem time15, current time 145, horizon 130\n", - "adding: mem time16, current time 145, horizon 129\n", - "adding: mem time17, current time 145, horizon 128\n", - "adding: mem time18, current time 145, horizon 127\n", - "adding: mem time19, current time 145, horizon 126\n", - "adding: mem time20, current time 145, horizon 125\n", - "adding: mem time21, current time 145, horizon 124\n", - "adding: mem time22, current time 145, horizon 123\n", - "adding: mem time23, current time 145, horizon 122\n", - "adding: mem time24, current time 145, horizon 121\n", - "adding: mem time25, current time 145, horizon 120\n", - "adding: mem time26, current time 145, horizon 119\n", - "adding: mem time27, current time 145, horizon 118\n", - "adding: mem time28, current time 145, horizon 117\n", - "adding: mem time29, current time 145, horizon 116\n", - "adding: mem time30, current time 145, horizon 115\n", - "adding: mem time31, current time 145, horizon 114\n", - "adding: mem time32, current time 145, horizon 113\n", - "adding: mem time33, current time 145, horizon 112\n", - "adding: mem time34, current time 145, horizon 111\n", - "adding: mem time35, current time 145, horizon 110\n", - "adding: mem time36, current time 145, horizon 109\n", - "adding: mem time37, current time 145, horizon 108\n", - "adding: mem time38, current time 145, horizon 107\n", - "adding: mem time39, current time 145, horizon 106\n", - "adding: mem time40, current time 145, horizon 105\n", - "adding: mem time41, current time 145, horizon 104\n", - "adding: mem time42, current time 145, horizon 103\n", - "adding: mem time43, current time 145, horizon 102\n", - "adding: mem time44, current time 145, horizon 101\n", - "adding: mem time45, current time 145, horizon 100\n", - "adding: mem time46, current time 145, horizon 99\n", - "adding: mem time47, current time 145, horizon 98\n", - "adding: mem time48, current time 145, horizon 97\n", - "adding: mem time49, current time 145, horizon 96\n", - "adding: mem time50, current time 145, horizon 95\n", - "adding: mem time51, current time 145, horizon 94\n", - "adding: mem time52, current time 145, horizon 93\n", - "adding: mem time53, current time 145, horizon 92\n", - "adding: mem time54, current time 145, horizon 91\n", - "adding: mem time55, current time 145, horizon 90\n", - "adding: mem time56, current time 145, horizon 89\n", - "adding: mem time57, current time 145, horizon 88\n", - "adding: mem time58, current time 145, horizon 87\n", - "adding: mem time59, current time 145, horizon 86\n", - "adding: mem time60, current time 145, horizon 85\n", - "adding: mem time61, current time 145, horizon 84\n", - "adding: mem time62, current time 145, horizon 83\n", - "adding: mem time63, current time 145, horizon 82\n", - "adding: mem time64, current time 145, horizon 81\n", - "adding: mem time65, current time 145, horizon 80\n", - "adding: mem time66, current time 145, horizon 79\n", - "adding: mem time67, current time 145, horizon 78\n", - "adding: mem time68, current time 145, horizon 77\n", - "adding: mem time69, current time 145, horizon 76\n", - "adding: mem time70, current time 145, horizon 75\n", - "adding: mem time71, current time 145, horizon 74\n", - "adding: mem time72, current time 145, horizon 73\n", - "adding: mem time73, current time 145, horizon 72\n", - "adding: mem time74, current time 145, horizon 71\n", - "adding: mem time75, current time 145, horizon 70\n", - "adding: mem time76, current time 145, horizon 69\n", - "adding: mem time77, current time 145, horizon 68\n", - "adding: mem time78, current time 145, horizon 67\n", - "adding: mem time79, current time 145, horizon 66\n", - "adding: mem time80, current time 145, horizon 65\n", - "adding: mem time81, current time 145, horizon 64\n", - "adding: mem time82, current time 145, horizon 63\n", - "adding: mem time83, current time 145, horizon 62\n", - "adding: mem time84, current time 145, horizon 61\n", - "adding: mem time85, current time 145, horizon 60\n", - "adding: mem time86, current time 145, horizon 59\n", - "adding: mem time87, current time 145, horizon 58\n", - "adding: mem time88, current time 145, horizon 57\n", - "adding: mem time89, current time 145, horizon 56\n", - "adding: mem time90, current time 145, horizon 55\n", - "adding: mem time91, current time 145, horizon 54\n", - "adding: mem time92, current time 145, horizon 53\n", - "adding: mem time93, current time 145, horizon 52\n", - "adding: mem time94, current time 145, horizon 51\n", - "adding: mem time95, current time 145, horizon 50\n", - "adding: mem time96, current time 145, horizon 49\n", - "adding: mem time97, current time 145, horizon 48\n", - "adding: mem time98, current time 145, horizon 47\n", - "adding: mem time99, current time 145, horizon 46\n", - "adding: mem time100, current time 145, horizon 45\n", - "adding: mem time101, current time 145, horizon 44\n", - "adding: mem time102, current time 145, horizon 43\n", - "adding: mem time103, current time 145, horizon 42\n", - "adding: mem time104, current time 145, horizon 41\n", - "adding: mem time105, current time 145, horizon 40\n", - "adding: mem time106, current time 145, horizon 39\n", - "adding: mem time107, current time 145, horizon 38\n", - "adding: mem time108, current time 145, horizon 37\n", - "adding: mem time109, current time 145, horizon 36\n", - "adding: mem time110, current time 145, horizon 35\n", - "adding: mem time111, current time 145, horizon 34\n", - "adding: mem time112, current time 145, horizon 33\n", - "adding: mem time113, current time 145, horizon 32\n", - "adding: mem time114, current time 145, horizon 31\n", - "adding: mem time115, current time 145, horizon 30\n", - "adding: mem time116, current time 145, horizon 29\n", - "adding: mem time117, current time 145, horizon 28\n", - "adding: mem time118, current time 145, horizon 27\n", - "adding: mem time119, current time 145, horizon 26\n", - "adding: mem time120, current time 145, horizon 25\n", - "adding: mem time121, current time 145, horizon 24\n", - "adding: mem time122, current time 145, horizon 23\n", - "adding: mem time123, current time 145, horizon 22\n", - "adding: mem time124, current time 145, horizon 21\n", - "adding: mem time125, current time 145, horizon 20\n", - "adding: mem time126, current time 145, horizon 19\n", - "adding: mem time127, current time 145, horizon 18\n", - "adding: mem time128, current time 145, horizon 17\n", - "adding: mem time129, current time 145, horizon 16\n", - "adding: mem time130, current time 145, horizon 15\n", - "adding: mem time131, current time 145, horizon 14\n", - "adding: mem time132, current time 145, horizon 13\n", - "adding: mem time133, current time 145, horizon 12\n", - "adding: mem time134, current time 145, horizon 11\n", - "adding: mem time135, current time 145, horizon 10\n", - "adding: mem time136, current time 145, horizon 9\n", - "adding: mem time137, current time 145, horizon 8\n", - "adding: mem time138, current time 145, horizon 7\n", - "adding: mem time139, current time 145, horizon 6\n", - "adding: mem time140, current time 145, horizon 5\n", - "adding: mem time141, current time 145, horizon 4\n", - "adding: mem time142, current time 145, horizon 3\n", - "adding: mem time143, current time 145, horizon 2\n", - "adding: mem time144, current time 145, horizon 1\n", - "adding: mem time0, current time 146, horizon 146\n", - "adding: mem time1, current time 146, horizon 145\n", - "adding: mem time2, current time 146, horizon 144\n", - "adding: mem time3, current time 146, horizon 143\n", - "adding: mem time4, current time 146, horizon 142\n", - "adding: mem time5, current time 146, horizon 141\n", - "adding: mem time6, current time 146, horizon 140\n", - "adding: mem time7, current time 146, horizon 139\n", - "adding: mem time8, current time 146, horizon 138\n", - "adding: mem time9, current time 146, horizon 137\n", - "adding: mem time10, current time 146, horizon 136\n", - "adding: mem time11, current time 146, horizon 135\n", - "adding: mem time12, current time 146, horizon 134\n", - "adding: mem time13, current time 146, horizon 133\n", - "adding: mem time14, current time 146, horizon 132\n", - "adding: mem time15, current time 146, horizon 131\n", - "adding: mem time16, current time 146, horizon 130\n", - "adding: mem time17, current time 146, horizon 129\n", - "adding: mem time18, current time 146, horizon 128\n", - "adding: mem time19, current time 146, horizon 127\n", - "adding: mem time20, current time 146, horizon 126\n", - "adding: mem time21, current time 146, horizon 125\n", - "adding: mem time22, current time 146, horizon 124\n", - "adding: mem time23, current time 146, horizon 123\n", - "adding: mem time24, current time 146, horizon 122\n", - "adding: mem time25, current time 146, horizon 121\n", - "adding: mem time26, current time 146, horizon 120\n", - "adding: mem time27, current time 146, horizon 119\n", - "adding: mem time28, current time 146, horizon 118\n", - "adding: mem time29, current time 146, horizon 117\n", - "adding: mem time30, current time 146, horizon 116\n", - "adding: mem time31, current time 146, horizon 115\n", - "adding: mem time32, current time 146, horizon 114\n", - "adding: mem time33, current time 146, horizon 113\n", - "adding: mem time34, current time 146, horizon 112\n", - "adding: mem time35, current time 146, horizon 111\n", - "adding: mem time36, current time 146, horizon 110\n", - "adding: mem time37, current time 146, horizon 109\n", - "adding: mem time38, current time 146, horizon 108\n", - "adding: mem time39, current time 146, horizon 107\n", - "adding: mem time40, current time 146, horizon 106\n", - "adding: mem time41, current time 146, horizon 105\n", - "adding: mem time42, current time 146, horizon 104\n", - "adding: mem time43, current time 146, horizon 103\n", - "adding: mem time44, current time 146, horizon 102\n", - "adding: mem time45, current time 146, horizon 101\n", - "adding: mem time46, current time 146, horizon 100\n", - "adding: mem time47, current time 146, horizon 99\n", - "adding: mem time48, current time 146, horizon 98\n", - "adding: mem time49, current time 146, horizon 97\n", - "adding: mem time50, current time 146, horizon 96\n", - "adding: mem time51, current time 146, horizon 95\n", - "adding: mem time52, current time 146, horizon 94\n", - "adding: mem time53, current time 146, horizon 93\n", - "adding: mem time54, current time 146, horizon 92\n", - "adding: mem time55, current time 146, horizon 91\n", - "adding: mem time56, current time 146, horizon 90\n", - "adding: mem time57, current time 146, horizon 89\n", - "adding: mem time58, current time 146, horizon 88\n", - "adding: mem time59, current time 146, horizon 87\n", - "adding: mem time60, current time 146, horizon 86\n", - "adding: mem time61, current time 146, horizon 85\n", - "adding: mem time62, current time 146, horizon 84\n", - "adding: mem time63, current time 146, horizon 83\n", - "adding: mem time64, current time 146, horizon 82\n", - "adding: mem time65, current time 146, horizon 81\n", - "adding: mem time66, current time 146, horizon 80\n", - "adding: mem time67, current time 146, horizon 79\n", - "adding: mem time68, current time 146, horizon 78\n", - "adding: mem time69, current time 146, horizon 77\n", - "adding: mem time70, current time 146, horizon 76\n", - "adding: mem time71, current time 146, horizon 75\n", - "adding: mem time72, current time 146, horizon 74\n", - "adding: mem time73, current time 146, horizon 73\n", - "adding: mem time74, current time 146, horizon 72\n", - "adding: mem time75, current time 146, horizon 71\n", - "adding: mem time76, current time 146, horizon 70\n", - "adding: mem time77, current time 146, horizon 69\n", - "adding: mem time78, current time 146, horizon 68\n", - "adding: mem time79, current time 146, horizon 67\n", - "adding: mem time80, current time 146, horizon 66\n", - "adding: mem time81, current time 146, horizon 65\n", - "adding: mem time82, current time 146, horizon 64\n", - "adding: mem time83, current time 146, horizon 63\n", - "adding: mem time84, current time 146, horizon 62\n", - "adding: mem time85, current time 146, horizon 61\n", - "adding: mem time86, current time 146, horizon 60\n", - "adding: mem time87, current time 146, horizon 59\n", - "adding: mem time88, current time 146, horizon 58\n", - "adding: mem time89, current time 146, horizon 57\n", - "adding: mem time90, current time 146, horizon 56\n", - "adding: mem time91, current time 146, horizon 55\n", - "adding: mem time92, current time 146, horizon 54\n", - "adding: mem time93, current time 146, horizon 53\n", - "adding: mem time94, current time 146, horizon 52\n", - "adding: mem time95, current time 146, horizon 51\n", - "adding: mem time96, current time 146, horizon 50\n", - "adding: mem time97, current time 146, horizon 49\n", - "adding: mem time98, current time 146, horizon 48\n", - "adding: mem time99, current time 146, horizon 47\n", - "adding: mem time100, current time 146, horizon 46\n", - "adding: mem time101, current time 146, horizon 45\n", - "adding: mem time102, current time 146, horizon 44\n", - "adding: mem time103, current time 146, horizon 43\n", - "adding: mem time104, current time 146, horizon 42\n", - "adding: mem time105, current time 146, horizon 41\n", - "adding: mem time106, current time 146, horizon 40\n", - "adding: mem time107, current time 146, horizon 39\n", - "adding: mem time108, current time 146, horizon 38\n", - "adding: mem time109, current time 146, horizon 37\n", - "adding: mem time110, current time 146, horizon 36\n", - "adding: mem time111, current time 146, horizon 35\n", - "adding: mem time112, current time 146, horizon 34\n", - "adding: mem time113, current time 146, horizon 33\n", - "adding: mem time114, current time 146, horizon 32\n", - "adding: mem time115, current time 146, horizon 31\n", - "adding: mem time116, current time 146, horizon 30\n", - "adding: mem time117, current time 146, horizon 29\n", - "adding: mem time118, current time 146, horizon 28\n", - "adding: mem time119, current time 146, horizon 27\n", - "adding: mem time120, current time 146, horizon 26\n", - "adding: mem time121, current time 146, horizon 25\n", - "adding: mem time122, current time 146, horizon 24\n", - "adding: mem time123, current time 146, horizon 23\n", - "adding: mem time124, current time 146, horizon 22\n", - "adding: mem time125, current time 146, horizon 21\n", - "adding: mem time126, current time 146, horizon 20\n", - "adding: mem time127, current time 146, horizon 19\n", - "adding: mem time128, current time 146, horizon 18\n", - "adding: mem time129, current time 146, horizon 17\n", - "adding: mem time130, current time 146, horizon 16\n", - "adding: mem time131, current time 146, horizon 15\n", - "adding: mem time132, current time 146, horizon 14\n", - "adding: mem time133, current time 146, horizon 13\n", - "adding: mem time134, current time 146, horizon 12\n", - "adding: mem time135, current time 146, horizon 11\n", - "adding: mem time136, current time 146, horizon 10\n", - "adding: mem time137, current time 146, horizon 9\n", - "adding: mem time138, current time 146, horizon 8\n", - "adding: mem time139, current time 146, horizon 7\n", - "adding: mem time140, current time 146, horizon 6\n", - "adding: mem time141, current time 146, horizon 5\n", - "adding: mem time142, current time 146, horizon 4\n", - "adding: mem time143, current time 146, horizon 3\n", - "adding: mem time144, current time 146, horizon 2\n", - "adding: mem time145, current time 146, horizon 1\n", - "adding: mem time0, current time 147, horizon 147\n", - "adding: mem time1, current time 147, horizon 146\n", - "adding: mem time2, current time 147, horizon 145\n", - "adding: mem time3, current time 147, horizon 144\n", - "adding: mem time4, current time 147, horizon 143\n", - "adding: mem time5, current time 147, horizon 142\n", - "adding: mem time6, current time 147, horizon 141\n", - "adding: mem time7, current time 147, horizon 140\n", - "adding: mem time8, current time 147, horizon 139\n", - "adding: mem time9, current time 147, horizon 138\n", - "adding: mem time10, current time 147, horizon 137\n", - "adding: mem time11, current time 147, horizon 136\n", - "adding: mem time12, current time 147, horizon 135\n", - "adding: mem time13, current time 147, horizon 134\n", - "adding: mem time14, current time 147, horizon 133\n", - "adding: mem time15, current time 147, horizon 132\n", - "adding: mem time16, current time 147, horizon 131\n", - "adding: mem time17, current time 147, horizon 130\n", - "adding: mem time18, current time 147, horizon 129\n", - "adding: mem time19, current time 147, horizon 128\n", - "adding: mem time20, current time 147, horizon 127\n", - "adding: mem time21, current time 147, horizon 126\n", - "adding: mem time22, current time 147, horizon 125\n", - "adding: mem time23, current time 147, horizon 124\n", - "adding: mem time24, current time 147, horizon 123\n", - "adding: mem time25, current time 147, horizon 122\n", - "adding: mem time26, current time 147, horizon 121\n", - "adding: mem time27, current time 147, horizon 120\n", - "adding: mem time28, current time 147, horizon 119\n", - "adding: mem time29, current time 147, horizon 118\n", - "adding: mem time30, current time 147, horizon 117\n", - "adding: mem time31, current time 147, horizon 116\n", - "adding: mem time32, current time 147, horizon 115\n", - "adding: mem time33, current time 147, horizon 114\n", - "adding: mem time34, current time 147, horizon 113\n", - "adding: mem time35, current time 147, horizon 112\n", - "adding: mem time36, current time 147, horizon 111\n", - "adding: mem time37, current time 147, horizon 110\n", - "adding: mem time38, current time 147, horizon 109\n", - "adding: mem time39, current time 147, horizon 108\n", - "adding: mem time40, current time 147, horizon 107\n", - "adding: mem time41, current time 147, horizon 106\n", - "adding: mem time42, current time 147, horizon 105\n", - "adding: mem time43, current time 147, horizon 104\n", - "adding: mem time44, current time 147, horizon 103\n", - "adding: mem time45, current time 147, horizon 102\n", - "adding: mem time46, current time 147, horizon 101\n", - "adding: mem time47, current time 147, horizon 100\n", - "adding: mem time48, current time 147, horizon 99\n", - "adding: mem time49, current time 147, horizon 98\n", - "adding: mem time50, current time 147, horizon 97\n", - "adding: mem time51, current time 147, horizon 96\n", - "adding: mem time52, current time 147, horizon 95\n", - "adding: mem time53, current time 147, horizon 94\n", - "adding: mem time54, current time 147, horizon 93\n", - "adding: mem time55, current time 147, horizon 92\n", - "adding: mem time56, current time 147, horizon 91\n", - "adding: mem time57, current time 147, horizon 90\n", - "adding: mem time58, current time 147, horizon 89\n", - "adding: mem time59, current time 147, horizon 88\n", - "adding: mem time60, current time 147, horizon 87\n", - "adding: mem time61, current time 147, horizon 86\n", - "adding: mem time62, current time 147, horizon 85\n", - "adding: mem time63, current time 147, horizon 84\n", - "adding: mem time64, current time 147, horizon 83\n", - "adding: mem time65, current time 147, horizon 82\n", - "adding: mem time66, current time 147, horizon 81\n", - "adding: mem time67, current time 147, horizon 80\n", - "adding: mem time68, current time 147, horizon 79\n", - "adding: mem time69, current time 147, horizon 78\n", - "adding: mem time70, current time 147, horizon 77\n", - "adding: mem time71, current time 147, horizon 76\n", - "adding: mem time72, current time 147, horizon 75\n", - "adding: mem time73, current time 147, horizon 74\n", - "adding: mem time74, current time 147, horizon 73\n", - "adding: mem time75, current time 147, horizon 72\n", - "adding: mem time76, current time 147, horizon 71\n", - "adding: mem time77, current time 147, horizon 70\n", - "adding: mem time78, current time 147, horizon 69\n", - "adding: mem time79, current time 147, horizon 68\n", - "adding: mem time80, current time 147, horizon 67\n", - "adding: mem time81, current time 147, horizon 66\n", - "adding: mem time82, current time 147, horizon 65\n", - "adding: mem time83, current time 147, horizon 64\n", - "adding: mem time84, current time 147, horizon 63\n", - "adding: mem time85, current time 147, horizon 62\n", - "adding: mem time86, current time 147, horizon 61\n", - "adding: mem time87, current time 147, horizon 60\n", - "adding: mem time88, current time 147, horizon 59\n", - "adding: mem time89, current time 147, horizon 58\n", - "adding: mem time90, current time 147, horizon 57\n", - "adding: mem time91, current time 147, horizon 56\n", - "adding: mem time92, current time 147, horizon 55\n", - "adding: mem time93, current time 147, horizon 54\n", - "adding: mem time94, current time 147, horizon 53\n", - "adding: mem time95, current time 147, horizon 52\n", - "adding: mem time96, current time 147, horizon 51\n", - "adding: mem time97, current time 147, horizon 50\n", - "adding: mem time98, current time 147, horizon 49\n", - "adding: mem time99, current time 147, horizon 48\n", - "adding: mem time100, current time 147, horizon 47\n", - "adding: mem time101, current time 147, horizon 46\n", - "adding: mem time102, current time 147, horizon 45\n", - "adding: mem time103, current time 147, horizon 44\n", - "adding: mem time104, current time 147, horizon 43\n", - "adding: mem time105, current time 147, horizon 42\n", - "adding: mem time106, current time 147, horizon 41\n", - "adding: mem time107, current time 147, horizon 40\n", - "adding: mem time108, current time 147, horizon 39\n", - "adding: mem time109, current time 147, horizon 38\n", - "adding: mem time110, current time 147, horizon 37\n", - "adding: mem time111, current time 147, horizon 36\n", - "adding: mem time112, current time 147, horizon 35\n", - "adding: mem time113, current time 147, horizon 34\n", - "adding: mem time114, current time 147, horizon 33\n", - "adding: mem time115, current time 147, horizon 32\n", - "adding: mem time116, current time 147, horizon 31\n", - "adding: mem time117, current time 147, horizon 30\n", - "adding: mem time118, current time 147, horizon 29\n", - "adding: mem time119, current time 147, horizon 28\n", - "adding: mem time120, current time 147, horizon 27\n", - "adding: mem time121, current time 147, horizon 26\n", - "adding: mem time122, current time 147, horizon 25\n", - "adding: mem time123, current time 147, horizon 24\n", - "adding: mem time124, current time 147, horizon 23\n", - "adding: mem time125, current time 147, horizon 22\n", - "adding: mem time126, current time 147, horizon 21\n", - "adding: mem time127, current time 147, horizon 20\n", - "adding: mem time128, current time 147, horizon 19\n", - "adding: mem time129, current time 147, horizon 18\n", - "adding: mem time130, current time 147, horizon 17\n", - "adding: mem time131, current time 147, horizon 16\n", - "adding: mem time132, current time 147, horizon 15\n", - "adding: mem time133, current time 147, horizon 14\n", - "adding: mem time134, current time 147, horizon 13\n", - "adding: mem time135, current time 147, horizon 12\n", - "adding: mem time136, current time 147, horizon 11\n", - "adding: mem time137, current time 147, horizon 10\n", - "adding: mem time138, current time 147, horizon 9\n", - "adding: mem time139, current time 147, horizon 8\n", - "adding: mem time140, current time 147, horizon 7\n", - "adding: mem time141, current time 147, horizon 6\n", - "adding: mem time142, current time 147, horizon 5\n", - "adding: mem time143, current time 147, horizon 4\n", - "adding: mem time144, current time 147, horizon 3\n", - "adding: mem time145, current time 147, horizon 2\n", - "adding: mem time146, current time 147, horizon 1\n", - "adding: mem time0, current time 148, horizon 148\n", - "adding: mem time1, current time 148, horizon 147\n", - "adding: mem time2, current time 148, horizon 146\n", - "adding: mem time3, current time 148, horizon 145\n", - "adding: mem time4, current time 148, horizon 144\n", - "adding: mem time5, current time 148, horizon 143\n", - "adding: mem time6, current time 148, horizon 142\n", - "adding: mem time7, current time 148, horizon 141\n", - "adding: mem time8, current time 148, horizon 140\n", - "adding: mem time9, current time 148, horizon 139\n", - "adding: mem time10, current time 148, horizon 138\n", - "adding: mem time11, current time 148, horizon 137\n", - "adding: mem time12, current time 148, horizon 136\n", - "adding: mem time13, current time 148, horizon 135\n", - "adding: mem time14, current time 148, horizon 134\n", - "adding: mem time15, current time 148, horizon 133\n", - "adding: mem time16, current time 148, horizon 132\n", - "adding: mem time17, current time 148, horizon 131\n", - "adding: mem time18, current time 148, horizon 130\n", - "adding: mem time19, current time 148, horizon 129\n", - "adding: mem time20, current time 148, horizon 128\n", - "adding: mem time21, current time 148, horizon 127\n", - "adding: mem time22, current time 148, horizon 126\n", - "adding: mem time23, current time 148, horizon 125\n", - "adding: mem time24, current time 148, horizon 124\n", - "adding: mem time25, current time 148, horizon 123\n", - "adding: mem time26, current time 148, horizon 122\n", - "adding: mem time27, current time 148, horizon 121\n", - "adding: mem time28, current time 148, horizon 120\n", - "adding: mem time29, current time 148, horizon 119\n", - "adding: mem time30, current time 148, horizon 118\n", - "adding: mem time31, current time 148, horizon 117\n", - "adding: mem time32, current time 148, horizon 116\n", - "adding: mem time33, current time 148, horizon 115\n", - "adding: mem time34, current time 148, horizon 114\n", - "adding: mem time35, current time 148, horizon 113\n", - "adding: mem time36, current time 148, horizon 112\n", - "adding: mem time37, current time 148, horizon 111\n", - "adding: mem time38, current time 148, horizon 110\n", - "adding: mem time39, current time 148, horizon 109\n", - "adding: mem time40, current time 148, horizon 108\n", - "adding: mem time41, current time 148, horizon 107\n", - "adding: mem time42, current time 148, horizon 106\n", - "adding: mem time43, current time 148, horizon 105\n", - "adding: mem time44, current time 148, horizon 104\n", - "adding: mem time45, current time 148, horizon 103\n", - "adding: mem time46, current time 148, horizon 102\n", - "adding: mem time47, current time 148, horizon 101\n", - "adding: mem time48, current time 148, horizon 100\n", - "adding: mem time49, current time 148, horizon 99\n", - "adding: mem time50, current time 148, horizon 98\n", - "adding: mem time51, current time 148, horizon 97\n", - "adding: mem time52, current time 148, horizon 96\n", - "adding: mem time53, current time 148, horizon 95\n", - "adding: mem time54, current time 148, horizon 94\n", - "adding: mem time55, current time 148, horizon 93\n", - "adding: mem time56, current time 148, horizon 92\n", - "adding: mem time57, current time 148, horizon 91\n", - "adding: mem time58, current time 148, horizon 90\n", - "adding: mem time59, current time 148, horizon 89\n", - "adding: mem time60, current time 148, horizon 88\n", - "adding: mem time61, current time 148, horizon 87\n", - "adding: mem time62, current time 148, horizon 86\n", - "adding: mem time63, current time 148, horizon 85\n", - "adding: mem time64, current time 148, horizon 84\n", - "adding: mem time65, current time 148, horizon 83\n", - "adding: mem time66, current time 148, horizon 82\n", - "adding: mem time67, current time 148, horizon 81\n", - "adding: mem time68, current time 148, horizon 80\n", - "adding: mem time69, current time 148, horizon 79\n", - "adding: mem time70, current time 148, horizon 78\n", - "adding: mem time71, current time 148, horizon 77\n", - "adding: mem time72, current time 148, horizon 76\n", - "adding: mem time73, current time 148, horizon 75\n", - "adding: mem time74, current time 148, horizon 74\n", - "adding: mem time75, current time 148, horizon 73\n", - "adding: mem time76, current time 148, horizon 72\n", - "adding: mem time77, current time 148, horizon 71\n", - "adding: mem time78, current time 148, horizon 70\n", - "adding: mem time79, current time 148, horizon 69\n", - "adding: mem time80, current time 148, horizon 68\n", - "adding: mem time81, current time 148, horizon 67\n", - "adding: mem time82, current time 148, horizon 66\n", - "adding: mem time83, current time 148, horizon 65\n", - "adding: mem time84, current time 148, horizon 64\n", - "adding: mem time85, current time 148, horizon 63\n", - "adding: mem time86, current time 148, horizon 62\n", - "adding: mem time87, current time 148, horizon 61\n", - "adding: mem time88, current time 148, horizon 60\n", - "adding: mem time89, current time 148, horizon 59\n", - "adding: mem time90, current time 148, horizon 58\n", - "adding: mem time91, current time 148, horizon 57\n", - "adding: mem time92, current time 148, horizon 56\n", - "adding: mem time93, current time 148, horizon 55\n", - "adding: mem time94, current time 148, horizon 54\n", - "adding: mem time95, current time 148, horizon 53\n", - "adding: mem time96, current time 148, horizon 52\n", - "adding: mem time97, current time 148, horizon 51\n", - "adding: mem time98, current time 148, horizon 50\n", - "adding: mem time99, current time 148, horizon 49\n", - "adding: mem time100, current time 148, horizon 48\n", - "adding: mem time101, current time 148, horizon 47\n", - "adding: mem time102, current time 148, horizon 46\n", - "adding: mem time103, current time 148, horizon 45\n", - "adding: mem time104, current time 148, horizon 44\n", - "adding: mem time105, current time 148, horizon 43\n", - "adding: mem time106, current time 148, horizon 42\n", - "adding: mem time107, current time 148, horizon 41\n", - "adding: mem time108, current time 148, horizon 40\n", - "adding: mem time109, current time 148, horizon 39\n", - "adding: mem time110, current time 148, horizon 38\n", - "adding: mem time111, current time 148, horizon 37\n", - "adding: mem time112, current time 148, horizon 36\n", - "adding: mem time113, current time 148, horizon 35\n", - "adding: mem time114, current time 148, horizon 34\n", - "adding: mem time115, current time 148, horizon 33\n", - "adding: mem time116, current time 148, horizon 32\n", - "adding: mem time117, current time 148, horizon 31\n", - "adding: mem time118, current time 148, horizon 30\n", - "adding: mem time119, current time 148, horizon 29\n", - "adding: mem time120, current time 148, horizon 28\n", - "adding: mem time121, current time 148, horizon 27\n", - "adding: mem time122, current time 148, horizon 26\n", - "adding: mem time123, current time 148, horizon 25\n", - "adding: mem time124, current time 148, horizon 24\n", - "adding: mem time125, current time 148, horizon 23\n", - "adding: mem time126, current time 148, horizon 22\n", - "adding: mem time127, current time 148, horizon 21\n", - "adding: mem time128, current time 148, horizon 20\n", - "adding: mem time129, current time 148, horizon 19\n", - "adding: mem time130, current time 148, horizon 18\n", - "adding: mem time131, current time 148, horizon 17\n", - "adding: mem time132, current time 148, horizon 16\n", - "adding: mem time133, current time 148, horizon 15\n", - "adding: mem time134, current time 148, horizon 14\n", - "adding: mem time135, current time 148, horizon 13\n", - "adding: mem time136, current time 148, horizon 12\n", - "adding: mem time137, current time 148, horizon 11\n", - "adding: mem time138, current time 148, horizon 10\n", - "adding: mem time139, current time 148, horizon 9\n", - "adding: mem time140, current time 148, horizon 8\n", - "adding: mem time141, current time 148, horizon 7\n", - "adding: mem time142, current time 148, horizon 6\n", - "adding: mem time143, current time 148, horizon 5\n", - "adding: mem time144, current time 148, horizon 4\n", - "adding: mem time145, current time 148, horizon 3\n", - "adding: mem time146, current time 148, horizon 2\n", - "adding: mem time147, current time 148, horizon 1\n", - "adding: mem time0, current time 149, horizon 149\n", - "adding: mem time1, current time 149, horizon 148\n", - "adding: mem time2, current time 149, horizon 147\n", - "adding: mem time3, current time 149, horizon 146\n", - "adding: mem time4, current time 149, horizon 145\n", - "adding: mem time5, current time 149, horizon 144\n", - "adding: mem time6, current time 149, horizon 143\n", - "adding: mem time7, current time 149, horizon 142\n", - "adding: mem time8, current time 149, horizon 141\n", - "adding: mem time9, current time 149, horizon 140\n", - "adding: mem time10, current time 149, horizon 139\n", - "adding: mem time11, current time 149, horizon 138\n", - "adding: mem time12, current time 149, horizon 137\n", - "adding: mem time13, current time 149, horizon 136\n", - "adding: mem time14, current time 149, horizon 135\n", - "adding: mem time15, current time 149, horizon 134\n", - "adding: mem time16, current time 149, horizon 133\n", - "adding: mem time17, current time 149, horizon 132\n", - "adding: mem time18, current time 149, horizon 131\n", - "adding: mem time19, current time 149, horizon 130\n", - "adding: mem time20, current time 149, horizon 129\n", - "adding: mem time21, current time 149, horizon 128\n", - "adding: mem time22, current time 149, horizon 127\n", - "adding: mem time23, current time 149, horizon 126\n", - "adding: mem time24, current time 149, horizon 125\n", - "adding: mem time25, current time 149, horizon 124\n", - "adding: mem time26, current time 149, horizon 123\n", - "adding: mem time27, current time 149, horizon 122\n", - "adding: mem time28, current time 149, horizon 121\n", - "adding: mem time29, current time 149, horizon 120\n", - "adding: mem time30, current time 149, horizon 119\n", - "adding: mem time31, current time 149, horizon 118\n", - "adding: mem time32, current time 149, horizon 117\n", - "adding: mem time33, current time 149, horizon 116\n", - "adding: mem time34, current time 149, horizon 115\n", - "adding: mem time35, current time 149, horizon 114\n", - "adding: mem time36, current time 149, horizon 113\n", - "adding: mem time37, current time 149, horizon 112\n", - "adding: mem time38, current time 149, horizon 111\n", - "adding: mem time39, current time 149, horizon 110\n", - "adding: mem time40, current time 149, horizon 109\n", - "adding: mem time41, current time 149, horizon 108\n", - "adding: mem time42, current time 149, horizon 107\n", - "adding: mem time43, current time 149, horizon 106\n", - "adding: mem time44, current time 149, horizon 105\n", - "adding: mem time45, current time 149, horizon 104\n", - "adding: mem time46, current time 149, horizon 103\n", - "adding: mem time47, current time 149, horizon 102\n", - "adding: mem time48, current time 149, horizon 101\n", - "adding: mem time49, current time 149, horizon 100\n", - "adding: mem time50, current time 149, horizon 99\n", - "adding: mem time51, current time 149, horizon 98\n", - "adding: mem time52, current time 149, horizon 97\n", - "adding: mem time53, current time 149, horizon 96\n", - "adding: mem time54, current time 149, horizon 95\n", - "adding: mem time55, current time 149, horizon 94\n", - "adding: mem time56, current time 149, horizon 93\n", - "adding: mem time57, current time 149, horizon 92\n", - "adding: mem time58, current time 149, horizon 91\n", - "adding: mem time59, current time 149, horizon 90\n", - "adding: mem time60, current time 149, horizon 89\n", - "adding: mem time61, current time 149, horizon 88\n", - "adding: mem time62, current time 149, horizon 87\n", - "adding: mem time63, current time 149, horizon 86\n", - "adding: mem time64, current time 149, horizon 85\n", - "adding: mem time65, current time 149, horizon 84\n", - "adding: mem time66, current time 149, horizon 83\n", - "adding: mem time67, current time 149, horizon 82\n", - "adding: mem time68, current time 149, horizon 81\n", - "adding: mem time69, current time 149, horizon 80\n", - "adding: mem time70, current time 149, horizon 79\n", - "adding: mem time71, current time 149, horizon 78\n", - "adding: mem time72, current time 149, horizon 77\n", - "adding: mem time73, current time 149, horizon 76\n", - "adding: mem time74, current time 149, horizon 75\n", - "adding: mem time75, current time 149, horizon 74\n", - "adding: mem time76, current time 149, horizon 73\n", - "adding: mem time77, current time 149, horizon 72\n", - "adding: mem time78, current time 149, horizon 71\n", - "adding: mem time79, current time 149, horizon 70\n", - "adding: mem time80, current time 149, horizon 69\n", - "adding: mem time81, current time 149, horizon 68\n", - "adding: mem time82, current time 149, horizon 67\n", - "adding: mem time83, current time 149, horizon 66\n", - "adding: mem time84, current time 149, horizon 65\n", - "adding: mem time85, current time 149, horizon 64\n", - "adding: mem time86, current time 149, horizon 63\n", - "adding: mem time87, current time 149, horizon 62\n", - "adding: mem time88, current time 149, horizon 61\n", - "adding: mem time89, current time 149, horizon 60\n", - "adding: mem time90, current time 149, horizon 59\n", - "adding: mem time91, current time 149, horizon 58\n", - "adding: mem time92, current time 149, horizon 57\n", - "adding: mem time93, current time 149, horizon 56\n", - "adding: mem time94, current time 149, horizon 55\n", - "adding: mem time95, current time 149, horizon 54\n", - "adding: mem time96, current time 149, horizon 53\n", - "adding: mem time97, current time 149, horizon 52\n", - "adding: mem time98, current time 149, horizon 51\n", - "adding: mem time99, current time 149, horizon 50\n", - "adding: mem time100, current time 149, horizon 49\n", - "adding: mem time101, current time 149, horizon 48\n", - "adding: mem time102, current time 149, horizon 47\n", - "adding: mem time103, current time 149, horizon 46\n", - "adding: mem time104, current time 149, horizon 45\n", - "adding: mem time105, current time 149, horizon 44\n", - "adding: mem time106, current time 149, horizon 43\n", - "adding: mem time107, current time 149, horizon 42\n", - "adding: mem time108, current time 149, horizon 41\n", - "adding: mem time109, current time 149, horizon 40\n", - "adding: mem time110, current time 149, horizon 39\n", - "adding: mem time111, current time 149, horizon 38\n", - "adding: mem time112, current time 149, horizon 37\n", - "adding: mem time113, current time 149, horizon 36\n", - "adding: mem time114, current time 149, horizon 35\n", - "adding: mem time115, current time 149, horizon 34\n", - "adding: mem time116, current time 149, horizon 33\n", - "adding: mem time117, current time 149, horizon 32\n", - "adding: mem time118, current time 149, horizon 31\n", - "adding: mem time119, current time 149, horizon 30\n", - "adding: mem time120, current time 149, horizon 29\n", - "adding: mem time121, current time 149, horizon 28\n", - "adding: mem time122, current time 149, horizon 27\n", - "adding: mem time123, current time 149, horizon 26\n", - "adding: mem time124, current time 149, horizon 25\n", - "adding: mem time125, current time 149, horizon 24\n", - "adding: mem time126, current time 149, horizon 23\n", - "adding: mem time127, current time 149, horizon 22\n", - "adding: mem time128, current time 149, horizon 21\n", - "adding: mem time129, current time 149, horizon 20\n", - "adding: mem time130, current time 149, horizon 19\n", - "adding: mem time131, current time 149, horizon 18\n", - "adding: mem time132, current time 149, horizon 17\n", - "adding: mem time133, current time 149, horizon 16\n", - "adding: mem time134, current time 149, horizon 15\n", - "adding: mem time135, current time 149, horizon 14\n", - "adding: mem time136, current time 149, horizon 13\n", - "adding: mem time137, current time 149, horizon 12\n", - "adding: mem time138, current time 149, horizon 11\n", - "adding: mem time139, current time 149, horizon 10\n", - "adding: mem time140, current time 149, horizon 9\n", - "adding: mem time141, current time 149, horizon 8\n", - "adding: mem time142, current time 149, horizon 7\n", - "adding: mem time143, current time 149, horizon 6\n", - "adding: mem time144, current time 149, horizon 5\n", - "adding: mem time145, current time 149, horizon 4\n", - "adding: mem time146, current time 149, horizon 3\n", - "adding: mem time147, current time 149, horizon 2\n", - "adding: mem time148, current time 149, horizon 1\n", - "adding: mem time0, current time 150, horizon 150\n", - "adding: mem time1, current time 150, horizon 149\n", - "adding: mem time2, current time 150, horizon 148\n", - "adding: mem time3, current time 150, horizon 147\n", - "adding: mem time4, current time 150, horizon 146\n", - "adding: mem time5, current time 150, horizon 145\n", - "adding: mem time6, current time 150, horizon 144\n", - "adding: mem time7, current time 150, horizon 143\n", - "adding: mem time8, current time 150, horizon 142\n", - "adding: mem time9, current time 150, horizon 141\n", - "adding: mem time10, current time 150, horizon 140\n", - "adding: mem time11, current time 150, horizon 139\n", - "adding: mem time12, current time 150, horizon 138\n", - "adding: mem time13, current time 150, horizon 137\n", - "adding: mem time14, current time 150, horizon 136\n", - "adding: mem time15, current time 150, horizon 135\n", - "adding: mem time16, current time 150, horizon 134\n", - "adding: mem time17, current time 150, horizon 133\n", - "adding: mem time18, current time 150, horizon 132\n", - "adding: mem time19, current time 150, horizon 131\n", - "adding: mem time20, current time 150, horizon 130\n", - "adding: mem time21, current time 150, horizon 129\n", - "adding: mem time22, current time 150, horizon 128\n", - "adding: mem time23, current time 150, horizon 127\n", - "adding: mem time24, current time 150, horizon 126\n", - "adding: mem time25, current time 150, horizon 125\n", - "adding: mem time26, current time 150, horizon 124\n", - "adding: mem time27, current time 150, horizon 123\n", - "adding: mem time28, current time 150, horizon 122\n", - "adding: mem time29, current time 150, horizon 121\n", - "adding: mem time30, current time 150, horizon 120\n", - "adding: mem time31, current time 150, horizon 119\n", - "adding: mem time32, current time 150, horizon 118\n", - "adding: mem time33, current time 150, horizon 117\n", - "adding: mem time34, current time 150, horizon 116\n", - "adding: mem time35, current time 150, horizon 115\n", - "adding: mem time36, current time 150, horizon 114\n", - "adding: mem time37, current time 150, horizon 113\n", - "adding: mem time38, current time 150, horizon 112\n", - "adding: mem time39, current time 150, horizon 111\n", - "adding: mem time40, current time 150, horizon 110\n", - "adding: mem time41, current time 150, horizon 109\n", - "adding: mem time42, current time 150, horizon 108\n", - "adding: mem time43, current time 150, horizon 107\n", - "adding: mem time44, current time 150, horizon 106\n", - "adding: mem time45, current time 150, horizon 105\n", - "adding: mem time46, current time 150, horizon 104\n", - "adding: mem time47, current time 150, horizon 103\n", - "adding: mem time48, current time 150, horizon 102\n", - "adding: mem time49, current time 150, horizon 101\n", - "adding: mem time50, current time 150, horizon 100\n", - "adding: mem time51, current time 150, horizon 99\n", - "adding: mem time52, current time 150, horizon 98\n", - "adding: mem time53, current time 150, horizon 97\n", - "adding: mem time54, current time 150, horizon 96\n", - "adding: mem time55, current time 150, horizon 95\n", - "adding: mem time56, current time 150, horizon 94\n", - "adding: mem time57, current time 150, horizon 93\n", - "adding: mem time58, current time 150, horizon 92\n", - "adding: mem time59, current time 150, horizon 91\n", - "adding: mem time60, current time 150, horizon 90\n", - "adding: mem time61, current time 150, horizon 89\n", - "adding: mem time62, current time 150, horizon 88\n", - "adding: mem time63, current time 150, horizon 87\n", - "adding: mem time64, current time 150, horizon 86\n", - "adding: mem time65, current time 150, horizon 85\n", - "adding: mem time66, current time 150, horizon 84\n", - "adding: mem time67, current time 150, horizon 83\n", - "adding: mem time68, current time 150, horizon 82\n", - "adding: mem time69, current time 150, horizon 81\n", - "adding: mem time70, current time 150, horizon 80\n", - "adding: mem time71, current time 150, horizon 79\n", - "adding: mem time72, current time 150, horizon 78\n", - "adding: mem time73, current time 150, horizon 77\n", - "adding: mem time74, current time 150, horizon 76\n", - "adding: mem time75, current time 150, horizon 75\n", - "adding: mem time76, current time 150, horizon 74\n", - "adding: mem time77, current time 150, horizon 73\n", - "adding: mem time78, current time 150, horizon 72\n", - "adding: mem time79, current time 150, horizon 71\n", - "adding: mem time80, current time 150, horizon 70\n", - "adding: mem time81, current time 150, horizon 69\n", - "adding: mem time82, current time 150, horizon 68\n", - "adding: mem time83, current time 150, horizon 67\n", - "adding: mem time84, current time 150, horizon 66\n", - "adding: mem time85, current time 150, horizon 65\n", - "adding: mem time86, current time 150, horizon 64\n", - "adding: mem time87, current time 150, horizon 63\n", - "adding: mem time88, current time 150, horizon 62\n", - "adding: mem time89, current time 150, horizon 61\n", - "adding: mem time90, current time 150, horizon 60\n", - "adding: mem time91, current time 150, horizon 59\n", - "adding: mem time92, current time 150, horizon 58\n", - "adding: mem time93, current time 150, horizon 57\n", - "adding: mem time94, current time 150, horizon 56\n", - "adding: mem time95, current time 150, horizon 55\n", - "adding: mem time96, current time 150, horizon 54\n", - "adding: mem time97, current time 150, horizon 53\n", - "adding: mem time98, current time 150, horizon 52\n", - "adding: mem time99, current time 150, horizon 51\n", - "adding: mem time100, current time 150, horizon 50\n", - "adding: mem time101, current time 150, horizon 49\n", - "adding: mem time102, current time 150, horizon 48\n", - "adding: mem time103, current time 150, horizon 47\n", - "adding: mem time104, current time 150, horizon 46\n", - "adding: mem time105, current time 150, horizon 45\n", - "adding: mem time106, current time 150, horizon 44\n", - "adding: mem time107, current time 150, horizon 43\n", - "adding: mem time108, current time 150, horizon 42\n", - "adding: mem time109, current time 150, horizon 41\n", - "adding: mem time110, current time 150, horizon 40\n", - "adding: mem time111, current time 150, horizon 39\n", - "adding: mem time112, current time 150, horizon 38\n", - "adding: mem time113, current time 150, horizon 37\n", - "adding: mem time114, current time 150, horizon 36\n", - "adding: mem time115, current time 150, horizon 35\n", - "adding: mem time116, current time 150, horizon 34\n", - "adding: mem time117, current time 150, horizon 33\n", - "adding: mem time118, current time 150, horizon 32\n", - "adding: mem time119, current time 150, horizon 31\n", - "adding: mem time120, current time 150, horizon 30\n", - "adding: mem time121, current time 150, horizon 29\n", - "adding: mem time122, current time 150, horizon 28\n", - "adding: mem time123, current time 150, horizon 27\n", - "adding: mem time124, current time 150, horizon 26\n", - "adding: mem time125, current time 150, horizon 25\n", - "adding: mem time126, current time 150, horizon 24\n", - "adding: mem time127, current time 150, horizon 23\n", - "adding: mem time128, current time 150, horizon 22\n", - "adding: mem time129, current time 150, horizon 21\n", - "adding: mem time130, current time 150, horizon 20\n", - "adding: mem time131, current time 150, horizon 19\n", - "adding: mem time132, current time 150, horizon 18\n", - "adding: mem time133, current time 150, horizon 17\n", - "adding: mem time134, current time 150, horizon 16\n", - "adding: mem time135, current time 150, horizon 15\n", - "adding: mem time136, current time 150, horizon 14\n", - "adding: mem time137, current time 150, horizon 13\n", - "adding: mem time138, current time 150, horizon 12\n", - "adding: mem time139, current time 150, horizon 11\n", - "adding: mem time140, current time 150, horizon 10\n", - "adding: mem time141, current time 150, horizon 9\n", - "adding: mem time142, current time 150, horizon 8\n", - "adding: mem time143, current time 150, horizon 7\n", - "adding: mem time144, current time 150, horizon 6\n", - "adding: mem time145, current time 150, horizon 5\n", - "adding: mem time146, current time 150, horizon 4\n", - "adding: mem time147, current time 150, horizon 3\n", - "adding: mem time148, current time 150, horizon 2\n", - "adding: mem time149, current time 150, horizon 1\n", - "adding: mem time0, current time 151, horizon 151\n", - "adding: mem time1, current time 151, horizon 150\n", - "adding: mem time2, current time 151, horizon 149\n", - "adding: mem time3, current time 151, horizon 148\n", - "adding: mem time4, current time 151, horizon 147\n", - "adding: mem time5, current time 151, horizon 146\n", - "adding: mem time6, current time 151, horizon 145\n", - "adding: mem time7, current time 151, horizon 144\n", - "adding: mem time8, current time 151, horizon 143\n", - "adding: mem time9, current time 151, horizon 142\n", - "adding: mem time10, current time 151, horizon 141\n", - "adding: mem time11, current time 151, horizon 140\n", - "adding: mem time12, current time 151, horizon 139\n", - "adding: mem time13, current time 151, horizon 138\n", - "adding: mem time14, current time 151, horizon 137\n", - "adding: mem time15, current time 151, horizon 136\n", - "adding: mem time16, current time 151, horizon 135\n", - "adding: mem time17, current time 151, horizon 134\n", - "adding: mem time18, current time 151, horizon 133\n", - "adding: mem time19, current time 151, horizon 132\n", - "adding: mem time20, current time 151, horizon 131\n", - "adding: mem time21, current time 151, horizon 130\n", - "adding: mem time22, current time 151, horizon 129\n", - "adding: mem time23, current time 151, horizon 128\n", - "adding: mem time24, current time 151, horizon 127\n", - "adding: mem time25, current time 151, horizon 126\n", - "adding: mem time26, current time 151, horizon 125\n", - "adding: mem time27, current time 151, horizon 124\n", - "adding: mem time28, current time 151, horizon 123\n", - "adding: mem time29, current time 151, horizon 122\n", - "adding: mem time30, current time 151, horizon 121\n", - "adding: mem time31, current time 151, horizon 120\n", - "adding: mem time32, current time 151, horizon 119\n", - "adding: mem time33, current time 151, horizon 118\n", - "adding: mem time34, current time 151, horizon 117\n", - "adding: mem time35, current time 151, horizon 116\n", - "adding: mem time36, current time 151, horizon 115\n", - "adding: mem time37, current time 151, horizon 114\n", - "adding: mem time38, current time 151, horizon 113\n", - "adding: mem time39, current time 151, horizon 112\n", - "adding: mem time40, current time 151, horizon 111\n", - "adding: mem time41, current time 151, horizon 110\n", - "adding: mem time42, current time 151, horizon 109\n", - "adding: mem time43, current time 151, horizon 108\n", - "adding: mem time44, current time 151, horizon 107\n", - "adding: mem time45, current time 151, horizon 106\n", - "adding: mem time46, current time 151, horizon 105\n", - "adding: mem time47, current time 151, horizon 104\n", - "adding: mem time48, current time 151, horizon 103\n", - "adding: mem time49, current time 151, horizon 102\n", - "adding: mem time50, current time 151, horizon 101\n", - "adding: mem time51, current time 151, horizon 100\n", - "adding: mem time52, current time 151, horizon 99\n", - "adding: mem time53, current time 151, horizon 98\n", - "adding: mem time54, current time 151, horizon 97\n", - "adding: mem time55, current time 151, horizon 96\n", - "adding: mem time56, current time 151, horizon 95\n", - "adding: mem time57, current time 151, horizon 94\n", - "adding: mem time58, current time 151, horizon 93\n", - "adding: mem time59, current time 151, horizon 92\n", - "adding: mem time60, current time 151, horizon 91\n", - "adding: mem time61, current time 151, horizon 90\n", - "adding: mem time62, current time 151, horizon 89\n", - "adding: mem time63, current time 151, horizon 88\n", - "adding: mem time64, current time 151, horizon 87\n", - "adding: mem time65, current time 151, horizon 86\n", - "adding: mem time66, current time 151, horizon 85\n", - "adding: mem time67, current time 151, horizon 84\n", - "adding: mem time68, current time 151, horizon 83\n", - "adding: mem time69, current time 151, horizon 82\n", - "adding: mem time70, current time 151, horizon 81\n", - "adding: mem time71, current time 151, horizon 80\n", - "adding: mem time72, current time 151, horizon 79\n", - "adding: mem time73, current time 151, horizon 78\n", - "adding: mem time74, current time 151, horizon 77\n", - "adding: mem time75, current time 151, horizon 76\n", - "adding: mem time76, current time 151, horizon 75\n", - "adding: mem time77, current time 151, horizon 74\n", - "adding: mem time78, current time 151, horizon 73\n", - "adding: mem time79, current time 151, horizon 72\n", - "adding: mem time80, current time 151, horizon 71\n", - "adding: mem time81, current time 151, horizon 70\n", - "adding: mem time82, current time 151, horizon 69\n", - "adding: mem time83, current time 151, horizon 68\n", - "adding: mem time84, current time 151, horizon 67\n", - "adding: mem time85, current time 151, horizon 66\n", - "adding: mem time86, current time 151, horizon 65\n", - "adding: mem time87, current time 151, horizon 64\n", - "adding: mem time88, current time 151, horizon 63\n", - "adding: mem time89, current time 151, horizon 62\n", - "adding: mem time90, current time 151, horizon 61\n", - "adding: mem time91, current time 151, horizon 60\n", - "adding: mem time92, current time 151, horizon 59\n", - "adding: mem time93, current time 151, horizon 58\n", - "adding: mem time94, current time 151, horizon 57\n", - "adding: mem time95, current time 151, horizon 56\n", - "adding: mem time96, current time 151, horizon 55\n", - "adding: mem time97, current time 151, horizon 54\n", - "adding: mem time98, current time 151, horizon 53\n", - "adding: mem time99, current time 151, horizon 52\n", - "adding: mem time100, current time 151, horizon 51\n", - "adding: mem time101, current time 151, horizon 50\n", - "adding: mem time102, current time 151, horizon 49\n", - "adding: mem time103, current time 151, horizon 48\n", - "adding: mem time104, current time 151, horizon 47\n", - "adding: mem time105, current time 151, horizon 46\n", - "adding: mem time106, current time 151, horizon 45\n", - "adding: mem time107, current time 151, horizon 44\n", - "adding: mem time108, current time 151, horizon 43\n", - "adding: mem time109, current time 151, horizon 42\n", - "adding: mem time110, current time 151, horizon 41\n", - "adding: mem time111, current time 151, horizon 40\n", - "adding: mem time112, current time 151, horizon 39\n", - "adding: mem time113, current time 151, horizon 38\n", - "adding: mem time114, current time 151, horizon 37\n", - "adding: mem time115, current time 151, horizon 36\n", - "adding: mem time116, current time 151, horizon 35\n", - "adding: mem time117, current time 151, horizon 34\n", - "adding: mem time118, current time 151, horizon 33\n", - "adding: mem time119, current time 151, horizon 32\n", - "adding: mem time120, current time 151, horizon 31\n", - "adding: mem time121, current time 151, horizon 30\n", - "adding: mem time122, current time 151, horizon 29\n", - "adding: mem time123, current time 151, horizon 28\n", - "adding: mem time124, current time 151, horizon 27\n", - "adding: mem time125, current time 151, horizon 26\n", - "adding: mem time126, current time 151, horizon 25\n", - "adding: mem time127, current time 151, horizon 24\n", - "adding: mem time128, current time 151, horizon 23\n", - "adding: mem time129, current time 151, horizon 22\n", - "adding: mem time130, current time 151, horizon 21\n", - "adding: mem time131, current time 151, horizon 20\n", - "adding: mem time132, current time 151, horizon 19\n", - "adding: mem time133, current time 151, horizon 18\n", - "adding: mem time134, current time 151, horizon 17\n", - "adding: mem time135, current time 151, horizon 16\n", - "adding: mem time136, current time 151, horizon 15\n", - "adding: mem time137, current time 151, horizon 14\n", - "adding: mem time138, current time 151, horizon 13\n", - "adding: mem time139, current time 151, horizon 12\n", - "adding: mem time140, current time 151, horizon 11\n", - "adding: mem time141, current time 151, horizon 10\n", - "adding: mem time142, current time 151, horizon 9\n", - "adding: mem time143, current time 151, horizon 8\n", - "adding: mem time144, current time 151, horizon 7\n", - "adding: mem time145, current time 151, horizon 6\n", - "adding: mem time146, current time 151, horizon 5\n", - "adding: mem time147, current time 151, horizon 4\n", - "adding: mem time148, current time 151, horizon 3\n", - "adding: mem time149, current time 151, horizon 2\n", - "adding: mem time150, current time 151, horizon 1\n", - "adding: mem time0, current time 152, horizon 152\n", - "adding: mem time1, current time 152, horizon 151\n", - "adding: mem time2, current time 152, horizon 150\n", - "adding: mem time3, current time 152, horizon 149\n", - "adding: mem time4, current time 152, horizon 148\n", - "adding: mem time5, current time 152, horizon 147\n", - "adding: mem time6, current time 152, horizon 146\n", - "adding: mem time7, current time 152, horizon 145\n", - "adding: mem time8, current time 152, horizon 144\n", - "adding: mem time9, current time 152, horizon 143\n", - "adding: mem time10, current time 152, horizon 142\n", - "adding: mem time11, current time 152, horizon 141\n", - "adding: mem time12, current time 152, horizon 140\n", - "adding: mem time13, current time 152, horizon 139\n", - "adding: mem time14, current time 152, horizon 138\n", - "adding: mem time15, current time 152, horizon 137\n", - "adding: mem time16, current time 152, horizon 136\n", - "adding: mem time17, current time 152, horizon 135\n", - "adding: mem time18, current time 152, horizon 134\n", - "adding: mem time19, current time 152, horizon 133\n", - "adding: mem time20, current time 152, horizon 132\n", - "adding: mem time21, current time 152, horizon 131\n", - "adding: mem time22, current time 152, horizon 130\n", - "adding: mem time23, current time 152, horizon 129\n", - "adding: mem time24, current time 152, horizon 128\n", - "adding: mem time25, current time 152, horizon 127\n", - "adding: mem time26, current time 152, horizon 126\n", - "adding: mem time27, current time 152, horizon 125\n", - "adding: mem time28, current time 152, horizon 124\n", - "adding: mem time29, current time 152, horizon 123\n", - "adding: mem time30, current time 152, horizon 122\n", - "adding: mem time31, current time 152, horizon 121\n", - "adding: mem time32, current time 152, horizon 120\n", - "adding: mem time33, current time 152, horizon 119\n", - "adding: mem time34, current time 152, horizon 118\n", - "adding: mem time35, current time 152, horizon 117\n", - "adding: mem time36, current time 152, horizon 116\n", - "adding: mem time37, current time 152, horizon 115\n", - "adding: mem time38, current time 152, horizon 114\n", - "adding: mem time39, current time 152, horizon 113\n", - "adding: mem time40, current time 152, horizon 112\n", - "adding: mem time41, current time 152, horizon 111\n", - "adding: mem time42, current time 152, horizon 110\n", - "adding: mem time43, current time 152, horizon 109\n", - "adding: mem time44, current time 152, horizon 108\n", - "adding: mem time45, current time 152, horizon 107\n", - "adding: mem time46, current time 152, horizon 106\n", - "adding: mem time47, current time 152, horizon 105\n", - "adding: mem time48, current time 152, horizon 104\n", - "adding: mem time49, current time 152, horizon 103\n", - "adding: mem time50, current time 152, horizon 102\n", - "adding: mem time51, current time 152, horizon 101\n", - "adding: mem time52, current time 152, horizon 100\n", - "adding: mem time53, current time 152, horizon 99\n", - "adding: mem time54, current time 152, horizon 98\n", - "adding: mem time55, current time 152, horizon 97\n", - "adding: mem time56, current time 152, horizon 96\n", - "adding: mem time57, current time 152, horizon 95\n", - "adding: mem time58, current time 152, horizon 94\n", - "adding: mem time59, current time 152, horizon 93\n", - "adding: mem time60, current time 152, horizon 92\n", - "adding: mem time61, current time 152, horizon 91\n", - "adding: mem time62, current time 152, horizon 90\n", - "adding: mem time63, current time 152, horizon 89\n", - "adding: mem time64, current time 152, horizon 88\n", - "adding: mem time65, current time 152, horizon 87\n", - "adding: mem time66, current time 152, horizon 86\n", - "adding: mem time67, current time 152, horizon 85\n", - "adding: mem time68, current time 152, horizon 84\n", - "adding: mem time69, current time 152, horizon 83\n", - "adding: mem time70, current time 152, horizon 82\n", - "adding: mem time71, current time 152, horizon 81\n", - "adding: mem time72, current time 152, horizon 80\n", - "adding: mem time73, current time 152, horizon 79\n", - "adding: mem time74, current time 152, horizon 78\n", - "adding: mem time75, current time 152, horizon 77\n", - "adding: mem time76, current time 152, horizon 76\n", - "adding: mem time77, current time 152, horizon 75\n", - "adding: mem time78, current time 152, horizon 74\n", - "adding: mem time79, current time 152, horizon 73\n", - "adding: mem time80, current time 152, horizon 72\n", - "adding: mem time81, current time 152, horizon 71\n", - "adding: mem time82, current time 152, horizon 70\n", - "adding: mem time83, current time 152, horizon 69\n", - "adding: mem time84, current time 152, horizon 68\n", - "adding: mem time85, current time 152, horizon 67\n", - "adding: mem time86, current time 152, horizon 66\n", - "adding: mem time87, current time 152, horizon 65\n", - "adding: mem time88, current time 152, horizon 64\n", - "adding: mem time89, current time 152, horizon 63\n", - "adding: mem time90, current time 152, horizon 62\n", - "adding: mem time91, current time 152, horizon 61\n", - "adding: mem time92, current time 152, horizon 60\n", - "adding: mem time93, current time 152, horizon 59\n", - "adding: mem time94, current time 152, horizon 58\n", - "adding: mem time95, current time 152, horizon 57\n", - "adding: mem time96, current time 152, horizon 56\n", - "adding: mem time97, current time 152, horizon 55\n", - "adding: mem time98, current time 152, horizon 54\n", - "adding: mem time99, current time 152, horizon 53\n", - "adding: mem time100, current time 152, horizon 52\n", - "adding: mem time101, current time 152, horizon 51\n", - "adding: mem time102, current time 152, horizon 50\n", - "adding: mem time103, current time 152, horizon 49\n", - "adding: mem time104, current time 152, horizon 48\n", - "adding: mem time105, current time 152, horizon 47\n", - "adding: mem time106, current time 152, horizon 46\n", - "adding: mem time107, current time 152, horizon 45\n", - "adding: mem time108, current time 152, horizon 44\n", - "adding: mem time109, current time 152, horizon 43\n", - "adding: mem time110, current time 152, horizon 42\n", - "adding: mem time111, current time 152, horizon 41\n", - "adding: mem time112, current time 152, horizon 40\n", - "adding: mem time113, current time 152, horizon 39\n", - "adding: mem time114, current time 152, horizon 38\n", - "adding: mem time115, current time 152, horizon 37\n", - "adding: mem time116, current time 152, horizon 36\n", - "adding: mem time117, current time 152, horizon 35\n", - "adding: mem time118, current time 152, horizon 34\n", - "adding: mem time119, current time 152, horizon 33\n", - "adding: mem time120, current time 152, horizon 32\n", - "adding: mem time121, current time 152, horizon 31\n", - "adding: mem time122, current time 152, horizon 30\n", - "adding: mem time123, current time 152, horizon 29\n", - "adding: mem time124, current time 152, horizon 28\n", - "adding: mem time125, current time 152, horizon 27\n", - "adding: mem time126, current time 152, horizon 26\n", - "adding: mem time127, current time 152, horizon 25\n", - "adding: mem time128, current time 152, horizon 24\n", - "adding: mem time129, current time 152, horizon 23\n", - "adding: mem time130, current time 152, horizon 22\n", - "adding: mem time131, current time 152, horizon 21\n", - "adding: mem time132, current time 152, horizon 20\n", - "adding: mem time133, current time 152, horizon 19\n", - "adding: mem time134, current time 152, horizon 18\n", - "adding: mem time135, current time 152, horizon 17\n", - "adding: mem time136, current time 152, horizon 16\n", - "adding: mem time137, current time 152, horizon 15\n", - "adding: mem time138, current time 152, horizon 14\n", - "adding: mem time139, current time 152, horizon 13\n", - "adding: mem time140, current time 152, horizon 12\n", - "adding: mem time141, current time 152, horizon 11\n", - "adding: mem time142, current time 152, horizon 10\n", - "adding: mem time143, current time 152, horizon 9\n", - "adding: mem time144, current time 152, horizon 8\n", - "adding: mem time145, current time 152, horizon 7\n", - "adding: mem time146, current time 152, horizon 6\n", - "adding: mem time147, current time 152, horizon 5\n", - "adding: mem time148, current time 152, horizon 4\n", - "adding: mem time149, current time 152, horizon 3\n", - "adding: mem time150, current time 152, horizon 2\n", - "adding: mem time151, current time 152, horizon 1\n", - "adding: mem time0, current time 153, horizon 153\n", - "adding: mem time1, current time 153, horizon 152\n", - "adding: mem time2, current time 153, horizon 151\n", - "adding: mem time3, current time 153, horizon 150\n", - "adding: mem time4, current time 153, horizon 149\n", - "adding: mem time5, current time 153, horizon 148\n", - "adding: mem time6, current time 153, horizon 147\n", - "adding: mem time7, current time 153, horizon 146\n", - "adding: mem time8, current time 153, horizon 145\n", - "adding: mem time9, current time 153, horizon 144\n", - "adding: mem time10, current time 153, horizon 143\n", - "adding: mem time11, current time 153, horizon 142\n", - "adding: mem time12, current time 153, horizon 141\n", - "adding: mem time13, current time 153, horizon 140\n", - "adding: mem time14, current time 153, horizon 139\n", - "adding: mem time15, current time 153, horizon 138\n", - "adding: mem time16, current time 153, horizon 137\n", - "adding: mem time17, current time 153, horizon 136\n", - "adding: mem time18, current time 153, horizon 135\n", - "adding: mem time19, current time 153, horizon 134\n", - "adding: mem time20, current time 153, horizon 133\n", - "adding: mem time21, current time 153, horizon 132\n", - "adding: mem time22, current time 153, horizon 131\n", - "adding: mem time23, current time 153, horizon 130\n", - "adding: mem time24, current time 153, horizon 129\n", - "adding: mem time25, current time 153, horizon 128\n", - "adding: mem time26, current time 153, horizon 127\n", - "adding: mem time27, current time 153, horizon 126\n", - "adding: mem time28, current time 153, horizon 125\n", - "adding: mem time29, current time 153, horizon 124\n", - "adding: mem time30, current time 153, horizon 123\n", - "adding: mem time31, current time 153, horizon 122\n", - "adding: mem time32, current time 153, horizon 121\n", - "adding: mem time33, current time 153, horizon 120\n", - "adding: mem time34, current time 153, horizon 119\n", - "adding: mem time35, current time 153, horizon 118\n", - "adding: mem time36, current time 153, horizon 117\n", - "adding: mem time37, current time 153, horizon 116\n", - "adding: mem time38, current time 153, horizon 115\n", - "adding: mem time39, current time 153, horizon 114\n", - "adding: mem time40, current time 153, horizon 113\n", - "adding: mem time41, current time 153, horizon 112\n", - "adding: mem time42, current time 153, horizon 111\n", - "adding: mem time43, current time 153, horizon 110\n", - "adding: mem time44, current time 153, horizon 109\n", - "adding: mem time45, current time 153, horizon 108\n", - "adding: mem time46, current time 153, horizon 107\n", - "adding: mem time47, current time 153, horizon 106\n", - "adding: mem time48, current time 153, horizon 105\n", - "adding: mem time49, current time 153, horizon 104\n", - "adding: mem time50, current time 153, horizon 103\n", - "adding: mem time51, current time 153, horizon 102\n", - "adding: mem time52, current time 153, horizon 101\n", - "adding: mem time53, current time 153, horizon 100\n", - "adding: mem time54, current time 153, horizon 99\n", - "adding: mem time55, current time 153, horizon 98\n", - "adding: mem time56, current time 153, horizon 97\n", - "adding: mem time57, current time 153, horizon 96\n", - "adding: mem time58, current time 153, horizon 95\n", - "adding: mem time59, current time 153, horizon 94\n", - "adding: mem time60, current time 153, horizon 93\n", - "adding: mem time61, current time 153, horizon 92\n", - "adding: mem time62, current time 153, horizon 91\n", - "adding: mem time63, current time 153, horizon 90\n", - "adding: mem time64, current time 153, horizon 89\n", - "adding: mem time65, current time 153, horizon 88\n", - "adding: mem time66, current time 153, horizon 87\n", - "adding: mem time67, current time 153, horizon 86\n", - "adding: mem time68, current time 153, horizon 85\n", - "adding: mem time69, current time 153, horizon 84\n", - "adding: mem time70, current time 153, horizon 83\n", - "adding: mem time71, current time 153, horizon 82\n", - "adding: mem time72, current time 153, horizon 81\n", - "adding: mem time73, current time 153, horizon 80\n", - "adding: mem time74, current time 153, horizon 79\n", - "adding: mem time75, current time 153, horizon 78\n", - "adding: mem time76, current time 153, horizon 77\n", - "adding: mem time77, current time 153, horizon 76\n", - "adding: mem time78, current time 153, horizon 75\n", - "adding: mem time79, current time 153, horizon 74\n", - "adding: mem time80, current time 153, horizon 73\n", - "adding: mem time81, current time 153, horizon 72\n", - "adding: mem time82, current time 153, horizon 71\n", - "adding: mem time83, current time 153, horizon 70\n", - "adding: mem time84, current time 153, horizon 69\n", - "adding: mem time85, current time 153, horizon 68\n", - "adding: mem time86, current time 153, horizon 67\n", - "adding: mem time87, current time 153, horizon 66\n", - "adding: mem time88, current time 153, horizon 65\n", - "adding: mem time89, current time 153, horizon 64\n", - "adding: mem time90, current time 153, horizon 63\n", - "adding: mem time91, current time 153, horizon 62\n", - "adding: mem time92, current time 153, horizon 61\n", - "adding: mem time93, current time 153, horizon 60\n", - "adding: mem time94, current time 153, horizon 59\n", - "adding: mem time95, current time 153, horizon 58\n", - "adding: mem time96, current time 153, horizon 57\n", - "adding: mem time97, current time 153, horizon 56\n", - "adding: mem time98, current time 153, horizon 55\n", - "adding: mem time99, current time 153, horizon 54\n", - "adding: mem time100, current time 153, horizon 53\n", - "adding: mem time101, current time 153, horizon 52\n", - "adding: mem time102, current time 153, horizon 51\n", - "adding: mem time103, current time 153, horizon 50\n", - "adding: mem time104, current time 153, horizon 49\n", - "adding: mem time105, current time 153, horizon 48\n", - "adding: mem time106, current time 153, horizon 47\n", - "adding: mem time107, current time 153, horizon 46\n", - "adding: mem time108, current time 153, horizon 45\n", - "adding: mem time109, current time 153, horizon 44\n", - "adding: mem time110, current time 153, horizon 43\n", - "adding: mem time111, current time 153, horizon 42\n", - "adding: mem time112, current time 153, horizon 41\n", - "adding: mem time113, current time 153, horizon 40\n", - "adding: mem time114, current time 153, horizon 39\n", - "adding: mem time115, current time 153, horizon 38\n", - "adding: mem time116, current time 153, horizon 37\n", - "adding: mem time117, current time 153, horizon 36\n", - "adding: mem time118, current time 153, horizon 35\n", - "adding: mem time119, current time 153, horizon 34\n", - "adding: mem time120, current time 153, horizon 33\n", - "adding: mem time121, current time 153, horizon 32\n", - "adding: mem time122, current time 153, horizon 31\n", - "adding: mem time123, current time 153, horizon 30\n", - "adding: mem time124, current time 153, horizon 29\n", - "adding: mem time125, current time 153, horizon 28\n", - "adding: mem time126, current time 153, horizon 27\n", - "adding: mem time127, current time 153, horizon 26\n", - "adding: mem time128, current time 153, horizon 25\n", - "adding: mem time129, current time 153, horizon 24\n", - "adding: mem time130, current time 153, horizon 23\n", - "adding: mem time131, current time 153, horizon 22\n", - "adding: mem time132, current time 153, horizon 21\n", - "adding: mem time133, current time 153, horizon 20\n", - "adding: mem time134, current time 153, horizon 19\n", - "adding: mem time135, current time 153, horizon 18\n", - "adding: mem time136, current time 153, horizon 17\n", - "adding: mem time137, current time 153, horizon 16\n", - "adding: mem time138, current time 153, horizon 15\n", - "adding: mem time139, current time 153, horizon 14\n", - "adding: mem time140, current time 153, horizon 13\n", - "adding: mem time141, current time 153, horizon 12\n", - "adding: mem time142, current time 153, horizon 11\n", - "adding: mem time143, current time 153, horizon 10\n", - "adding: mem time144, current time 153, horizon 9\n", - "adding: mem time145, current time 153, horizon 8\n", - "adding: mem time146, current time 153, horizon 7\n", - "adding: mem time147, current time 153, horizon 6\n", - "adding: mem time148, current time 153, horizon 5\n", - "adding: mem time149, current time 153, horizon 4\n", - "adding: mem time150, current time 153, horizon 3\n", - "adding: mem time151, current time 153, horizon 2\n", - "adding: mem time152, current time 153, horizon 1\n", - "adding: mem time0, current time 154, horizon 154\n", - "adding: mem time1, current time 154, horizon 153\n", - "adding: mem time2, current time 154, horizon 152\n", - "adding: mem time3, current time 154, horizon 151\n", - "adding: mem time4, current time 154, horizon 150\n", - "adding: mem time5, current time 154, horizon 149\n", - "adding: mem time6, current time 154, horizon 148\n", - "adding: mem time7, current time 154, horizon 147\n", - "adding: mem time8, current time 154, horizon 146\n", - "adding: mem time9, current time 154, horizon 145\n", - "adding: mem time10, current time 154, horizon 144\n", - "adding: mem time11, current time 154, horizon 143\n", - "adding: mem time12, current time 154, horizon 142\n", - "adding: mem time13, current time 154, horizon 141\n", - "adding: mem time14, current time 154, horizon 140\n", - "adding: mem time15, current time 154, horizon 139\n", - "adding: mem time16, current time 154, horizon 138\n", - "adding: mem time17, current time 154, horizon 137\n", - "adding: mem time18, current time 154, horizon 136\n", - "adding: mem time19, current time 154, horizon 135\n", - "adding: mem time20, current time 154, horizon 134\n", - "adding: mem time21, current time 154, horizon 133\n", - "adding: mem time22, current time 154, horizon 132\n", - "adding: mem time23, current time 154, horizon 131\n", - "adding: mem time24, current time 154, horizon 130\n", - "adding: mem time25, current time 154, horizon 129\n", - "adding: mem time26, current time 154, horizon 128\n", - "adding: mem time27, current time 154, horizon 127\n", - "adding: mem time28, current time 154, horizon 126\n", - "adding: mem time29, current time 154, horizon 125\n", - "adding: mem time30, current time 154, horizon 124\n", - "adding: mem time31, current time 154, horizon 123\n", - "adding: mem time32, current time 154, horizon 122\n", - "adding: mem time33, current time 154, horizon 121\n", - "adding: mem time34, current time 154, horizon 120\n", - "adding: mem time35, current time 154, horizon 119\n", - "adding: mem time36, current time 154, horizon 118\n", - "adding: mem time37, current time 154, horizon 117\n", - "adding: mem time38, current time 154, horizon 116\n", - "adding: mem time39, current time 154, horizon 115\n", - "adding: mem time40, current time 154, horizon 114\n", - "adding: mem time41, current time 154, horizon 113\n", - "adding: mem time42, current time 154, horizon 112\n", - "adding: mem time43, current time 154, horizon 111\n", - "adding: mem time44, current time 154, horizon 110\n", - "adding: mem time45, current time 154, horizon 109\n", - "adding: mem time46, current time 154, horizon 108\n", - "adding: mem time47, current time 154, horizon 107\n", - "adding: mem time48, current time 154, horizon 106\n", - "adding: mem time49, current time 154, horizon 105\n", - "adding: mem time50, current time 154, horizon 104\n", - "adding: mem time51, current time 154, horizon 103\n", - "adding: mem time52, current time 154, horizon 102\n", - "adding: mem time53, current time 154, horizon 101\n", - "adding: mem time54, current time 154, horizon 100\n", - "adding: mem time55, current time 154, horizon 99\n", - "adding: mem time56, current time 154, horizon 98\n", - "adding: mem time57, current time 154, horizon 97\n", - "adding: mem time58, current time 154, horizon 96\n", - "adding: mem time59, current time 154, horizon 95\n", - "adding: mem time60, current time 154, horizon 94\n", - "adding: mem time61, current time 154, horizon 93\n", - "adding: mem time62, current time 154, horizon 92\n", - "adding: mem time63, current time 154, horizon 91\n", - "adding: mem time64, current time 154, horizon 90\n", - "adding: mem time65, current time 154, horizon 89\n", - "adding: mem time66, current time 154, horizon 88\n", - "adding: mem time67, current time 154, horizon 87\n", - "adding: mem time68, current time 154, horizon 86\n", - "adding: mem time69, current time 154, horizon 85\n", - "adding: mem time70, current time 154, horizon 84\n", - "adding: mem time71, current time 154, horizon 83\n", - "adding: mem time72, current time 154, horizon 82\n", - "adding: mem time73, current time 154, horizon 81\n", - "adding: mem time74, current time 154, horizon 80\n", - "adding: mem time75, current time 154, horizon 79\n", - "adding: mem time76, current time 154, horizon 78\n", - "adding: mem time77, current time 154, horizon 77\n", - "adding: mem time78, current time 154, horizon 76\n", - "adding: mem time79, current time 154, horizon 75\n", - "adding: mem time80, current time 154, horizon 74\n", - "adding: mem time81, current time 154, horizon 73\n", - "adding: mem time82, current time 154, horizon 72\n", - "adding: mem time83, current time 154, horizon 71\n", - "adding: mem time84, current time 154, horizon 70\n", - "adding: mem time85, current time 154, horizon 69\n", - "adding: mem time86, current time 154, horizon 68\n", - "adding: mem time87, current time 154, horizon 67\n", - "adding: mem time88, current time 154, horizon 66\n", - "adding: mem time89, current time 154, horizon 65\n", - "adding: mem time90, current time 154, horizon 64\n", - "adding: mem time91, current time 154, horizon 63\n", - "adding: mem time92, current time 154, horizon 62\n", - "adding: mem time93, current time 154, horizon 61\n", - "adding: mem time94, current time 154, horizon 60\n", - "adding: mem time95, current time 154, horizon 59\n", - "adding: mem time96, current time 154, horizon 58\n", - "adding: mem time97, current time 154, horizon 57\n", - "adding: mem time98, current time 154, horizon 56\n", - "adding: mem time99, current time 154, horizon 55\n", - "adding: mem time100, current time 154, horizon 54\n", - "adding: mem time101, current time 154, horizon 53\n", - "adding: mem time102, current time 154, horizon 52\n", - "adding: mem time103, current time 154, horizon 51\n", - "adding: mem time104, current time 154, horizon 50\n", - "adding: mem time105, current time 154, horizon 49\n", - "adding: mem time106, current time 154, horizon 48\n", - "adding: mem time107, current time 154, horizon 47\n", - "adding: mem time108, current time 154, horizon 46\n", - "adding: mem time109, current time 154, horizon 45\n", - "adding: mem time110, current time 154, horizon 44\n", - "adding: mem time111, current time 154, horizon 43\n", - "adding: mem time112, current time 154, horizon 42\n", - "adding: mem time113, current time 154, horizon 41\n", - "adding: mem time114, current time 154, horizon 40\n", - "adding: mem time115, current time 154, horizon 39\n", - "adding: mem time116, current time 154, horizon 38\n", - "adding: mem time117, current time 154, horizon 37\n", - "adding: mem time118, current time 154, horizon 36\n", - "adding: mem time119, current time 154, horizon 35\n", - "adding: mem time120, current time 154, horizon 34\n", - "adding: mem time121, current time 154, horizon 33\n", - "adding: mem time122, current time 154, horizon 32\n", - "adding: mem time123, current time 154, horizon 31\n", - "adding: mem time124, current time 154, horizon 30\n", - "adding: mem time125, current time 154, horizon 29\n", - "adding: mem time126, current time 154, horizon 28\n", - "adding: mem time127, current time 154, horizon 27\n", - "adding: mem time128, current time 154, horizon 26\n", - "adding: mem time129, current time 154, horizon 25\n", - "adding: mem time130, current time 154, horizon 24\n", - "adding: mem time131, current time 154, horizon 23\n", - "adding: mem time132, current time 154, horizon 22\n", - "adding: mem time133, current time 154, horizon 21\n", - "adding: mem time134, current time 154, horizon 20\n", - "adding: mem time135, current time 154, horizon 19\n", - "adding: mem time136, current time 154, horizon 18\n", - "adding: mem time137, current time 154, horizon 17\n", - "adding: mem time138, current time 154, horizon 16\n", - "adding: mem time139, current time 154, horizon 15\n", - "adding: mem time140, current time 154, horizon 14\n", - "adding: mem time141, current time 154, horizon 13\n", - "adding: mem time142, current time 154, horizon 12\n", - "adding: mem time143, current time 154, horizon 11\n", - "adding: mem time144, current time 154, horizon 10\n", - "adding: mem time145, current time 154, horizon 9\n", - "adding: mem time146, current time 154, horizon 8\n", - "adding: mem time147, current time 154, horizon 7\n", - "adding: mem time148, current time 154, horizon 6\n", - "adding: mem time149, current time 154, horizon 5\n", - "adding: mem time150, current time 154, horizon 4\n", - "adding: mem time151, current time 154, horizon 3\n", - "adding: mem time152, current time 154, horizon 2\n", - "adding: mem time153, current time 154, horizon 1\n", - "adding: mem time0, current time 155, horizon 155\n", - "adding: mem time1, current time 155, horizon 154\n", - "adding: mem time2, current time 155, horizon 153\n", - "adding: mem time3, current time 155, horizon 152\n", - "adding: mem time4, current time 155, horizon 151\n", - "adding: mem time5, current time 155, horizon 150\n", - "adding: mem time6, current time 155, horizon 149\n", - "adding: mem time7, current time 155, horizon 148\n", - "adding: mem time8, current time 155, horizon 147\n", - "adding: mem time9, current time 155, horizon 146\n", - "adding: mem time10, current time 155, horizon 145\n", - "adding: mem time11, current time 155, horizon 144\n", - "adding: mem time12, current time 155, horizon 143\n", - "adding: mem time13, current time 155, horizon 142\n", - "adding: mem time14, current time 155, horizon 141\n", - "adding: mem time15, current time 155, horizon 140\n", - "adding: mem time16, current time 155, horizon 139\n", - "adding: mem time17, current time 155, horizon 138\n", - "adding: mem time18, current time 155, horizon 137\n", - "adding: mem time19, current time 155, horizon 136\n", - "adding: mem time20, current time 155, horizon 135\n", - "adding: mem time21, current time 155, horizon 134\n", - "adding: mem time22, current time 155, horizon 133\n", - "adding: mem time23, current time 155, horizon 132\n", - "adding: mem time24, current time 155, horizon 131\n", - "adding: mem time25, current time 155, horizon 130\n", - "adding: mem time26, current time 155, horizon 129\n", - "adding: mem time27, current time 155, horizon 128\n", - "adding: mem time28, current time 155, horizon 127\n", - "adding: mem time29, current time 155, horizon 126\n", - "adding: mem time30, current time 155, horizon 125\n", - "adding: mem time31, current time 155, horizon 124\n", - "adding: mem time32, current time 155, horizon 123\n", - "adding: mem time33, current time 155, horizon 122\n", - "adding: mem time34, current time 155, horizon 121\n", - "adding: mem time35, current time 155, horizon 120\n", - "adding: mem time36, current time 155, horizon 119\n", - "adding: mem time37, current time 155, horizon 118\n", - "adding: mem time38, current time 155, horizon 117\n", - "adding: mem time39, current time 155, horizon 116\n", - "adding: mem time40, current time 155, horizon 115\n", - "adding: mem time41, current time 155, horizon 114\n", - "adding: mem time42, current time 155, horizon 113\n", - "adding: mem time43, current time 155, horizon 112\n", - "adding: mem time44, current time 155, horizon 111\n", - "adding: mem time45, current time 155, horizon 110\n", - "adding: mem time46, current time 155, horizon 109\n", - "adding: mem time47, current time 155, horizon 108\n", - "adding: mem time48, current time 155, horizon 107\n", - "adding: mem time49, current time 155, horizon 106\n", - "adding: mem time50, current time 155, horizon 105\n", - "adding: mem time51, current time 155, horizon 104\n", - "adding: mem time52, current time 155, horizon 103\n", - "adding: mem time53, current time 155, horizon 102\n", - "adding: mem time54, current time 155, horizon 101\n", - "adding: mem time55, current time 155, horizon 100\n", - "adding: mem time56, current time 155, horizon 99\n", - "adding: mem time57, current time 155, horizon 98\n", - "adding: mem time58, current time 155, horizon 97\n", - "adding: mem time59, current time 155, horizon 96\n", - "adding: mem time60, current time 155, horizon 95\n", - "adding: mem time61, current time 155, horizon 94\n", - "adding: mem time62, current time 155, horizon 93\n", - "adding: mem time63, current time 155, horizon 92\n", - "adding: mem time64, current time 155, horizon 91\n", - "adding: mem time65, current time 155, horizon 90\n", - "adding: mem time66, current time 155, horizon 89\n", - "adding: mem time67, current time 155, horizon 88\n", - "adding: mem time68, current time 155, horizon 87\n", - "adding: mem time69, current time 155, horizon 86\n", - "adding: mem time70, current time 155, horizon 85\n", - "adding: mem time71, current time 155, horizon 84\n", - "adding: mem time72, current time 155, horizon 83\n", - "adding: mem time73, current time 155, horizon 82\n", - "adding: mem time74, current time 155, horizon 81\n", - "adding: mem time75, current time 155, horizon 80\n", - "adding: mem time76, current time 155, horizon 79\n", - "adding: mem time77, current time 155, horizon 78\n", - "adding: mem time78, current time 155, horizon 77\n", - "adding: mem time79, current time 155, horizon 76\n", - "adding: mem time80, current time 155, horizon 75\n", - "adding: mem time81, current time 155, horizon 74\n", - "adding: mem time82, current time 155, horizon 73\n", - "adding: mem time83, current time 155, horizon 72\n", - "adding: mem time84, current time 155, horizon 71\n", - "adding: mem time85, current time 155, horizon 70\n", - "adding: mem time86, current time 155, horizon 69\n", - "adding: mem time87, current time 155, horizon 68\n", - "adding: mem time88, current time 155, horizon 67\n", - "adding: mem time89, current time 155, horizon 66\n", - "adding: mem time90, current time 155, horizon 65\n", - "adding: mem time91, current time 155, horizon 64\n", - "adding: mem time92, current time 155, horizon 63\n", - "adding: mem time93, current time 155, horizon 62\n", - "adding: mem time94, current time 155, horizon 61\n", - "adding: mem time95, current time 155, horizon 60\n", - "adding: mem time96, current time 155, horizon 59\n", - "adding: mem time97, current time 155, horizon 58\n", - "adding: mem time98, current time 155, horizon 57\n", - "adding: mem time99, current time 155, horizon 56\n", - "adding: mem time100, current time 155, horizon 55\n", - "adding: mem time101, current time 155, horizon 54\n", - "adding: mem time102, current time 155, horizon 53\n", - "adding: mem time103, current time 155, horizon 52\n", - "adding: mem time104, current time 155, horizon 51\n", - "adding: mem time105, current time 155, horizon 50\n", - "adding: mem time106, current time 155, horizon 49\n", - "adding: mem time107, current time 155, horizon 48\n", - "adding: mem time108, current time 155, horizon 47\n", - "adding: mem time109, current time 155, horizon 46\n", - "adding: mem time110, current time 155, horizon 45\n", - "adding: mem time111, current time 155, horizon 44\n", - "adding: mem time112, current time 155, horizon 43\n", - "adding: mem time113, current time 155, horizon 42\n", - "adding: mem time114, current time 155, horizon 41\n", - "adding: mem time115, current time 155, horizon 40\n", - "adding: mem time116, current time 155, horizon 39\n", - "adding: mem time117, current time 155, horizon 38\n", - "adding: mem time118, current time 155, horizon 37\n", - "adding: mem time119, current time 155, horizon 36\n", - "adding: mem time120, current time 155, horizon 35\n", - "adding: mem time121, current time 155, horizon 34\n", - "adding: mem time122, current time 155, horizon 33\n", - "adding: mem time123, current time 155, horizon 32\n", - "adding: mem time124, current time 155, horizon 31\n", - "adding: mem time125, current time 155, horizon 30\n", - "adding: mem time126, current time 155, horizon 29\n", - "adding: mem time127, current time 155, horizon 28\n", - "adding: mem time128, current time 155, horizon 27\n", - "adding: mem time129, current time 155, horizon 26\n", - "adding: mem time130, current time 155, horizon 25\n", - "adding: mem time131, current time 155, horizon 24\n", - "adding: mem time132, current time 155, horizon 23\n", - "adding: mem time133, current time 155, horizon 22\n", - "adding: mem time134, current time 155, horizon 21\n", - "adding: mem time135, current time 155, horizon 20\n", - "adding: mem time136, current time 155, horizon 19\n", - "adding: mem time137, current time 155, horizon 18\n", - "adding: mem time138, current time 155, horizon 17\n", - "adding: mem time139, current time 155, horizon 16\n", - "adding: mem time140, current time 155, horizon 15\n", - "adding: mem time141, current time 155, horizon 14\n", - "adding: mem time142, current time 155, horizon 13\n", - "adding: mem time143, current time 155, horizon 12\n", - "adding: mem time144, current time 155, horizon 11\n", - "adding: mem time145, current time 155, horizon 10\n", - "adding: mem time146, current time 155, horizon 9\n", - "adding: mem time147, current time 155, horizon 8\n", - "adding: mem time148, current time 155, horizon 7\n", - "adding: mem time149, current time 155, horizon 6\n", - "adding: mem time150, current time 155, horizon 5\n", - "adding: mem time151, current time 155, horizon 4\n", - "adding: mem time152, current time 155, horizon 3\n", - "adding: mem time153, current time 155, horizon 2\n", - "adding: mem time154, current time 155, horizon 1\n", - "adding: mem time0, current time 156, horizon 156\n", - "adding: mem time1, current time 156, horizon 155\n", - "adding: mem time2, current time 156, horizon 154\n", - "adding: mem time3, current time 156, horizon 153\n", - "adding: mem time4, current time 156, horizon 152\n", - "adding: mem time5, current time 156, horizon 151\n", - "adding: mem time6, current time 156, horizon 150\n", - "adding: mem time7, current time 156, horizon 149\n", - "adding: mem time8, current time 156, horizon 148\n", - "adding: mem time9, current time 156, horizon 147\n", - "adding: mem time10, current time 156, horizon 146\n", - "adding: mem time11, current time 156, horizon 145\n", - "adding: mem time12, current time 156, horizon 144\n", - "adding: mem time13, current time 156, horizon 143\n", - "adding: mem time14, current time 156, horizon 142\n", - "adding: mem time15, current time 156, horizon 141\n", - "adding: mem time16, current time 156, horizon 140\n", - "adding: mem time17, current time 156, horizon 139\n", - "adding: mem time18, current time 156, horizon 138\n", - "adding: mem time19, current time 156, horizon 137\n", - "adding: mem time20, current time 156, horizon 136\n", - "adding: mem time21, current time 156, horizon 135\n", - "adding: mem time22, current time 156, horizon 134\n", - "adding: mem time23, current time 156, horizon 133\n", - "adding: mem time24, current time 156, horizon 132\n", - "adding: mem time25, current time 156, horizon 131\n", - "adding: mem time26, current time 156, horizon 130\n", - "adding: mem time27, current time 156, horizon 129\n", - "adding: mem time28, current time 156, horizon 128\n", - "adding: mem time29, current time 156, horizon 127\n", - "adding: mem time30, current time 156, horizon 126\n", - "adding: mem time31, current time 156, horizon 125\n", - "adding: mem time32, current time 156, horizon 124\n", - "adding: mem time33, current time 156, horizon 123\n", - "adding: mem time34, current time 156, horizon 122\n", - "adding: mem time35, current time 156, horizon 121\n", - "adding: mem time36, current time 156, horizon 120\n", - "adding: mem time37, current time 156, horizon 119\n", - "adding: mem time38, current time 156, horizon 118\n", - "adding: mem time39, current time 156, horizon 117\n", - "adding: mem time40, current time 156, horizon 116\n", - "adding: mem time41, current time 156, horizon 115\n", - "adding: mem time42, current time 156, horizon 114\n", - "adding: mem time43, current time 156, horizon 113\n", - "adding: mem time44, current time 156, horizon 112\n", - "adding: mem time45, current time 156, horizon 111\n", - "adding: mem time46, current time 156, horizon 110\n", - "adding: mem time47, current time 156, horizon 109\n", - "adding: mem time48, current time 156, horizon 108\n", - "adding: mem time49, current time 156, horizon 107\n", - "adding: mem time50, current time 156, horizon 106\n", - "adding: mem time51, current time 156, horizon 105\n", - "adding: mem time52, current time 156, horizon 104\n", - "adding: mem time53, current time 156, horizon 103\n", - "adding: mem time54, current time 156, horizon 102\n", - "adding: mem time55, current time 156, horizon 101\n", - "adding: mem time56, current time 156, horizon 100\n", - "adding: mem time57, current time 156, horizon 99\n", - "adding: mem time58, current time 156, horizon 98\n", - "adding: mem time59, current time 156, horizon 97\n", - "adding: mem time60, current time 156, horizon 96\n", - "adding: mem time61, current time 156, horizon 95\n", - "adding: mem time62, current time 156, horizon 94\n", - "adding: mem time63, current time 156, horizon 93\n", - "adding: mem time64, current time 156, horizon 92\n", - "adding: mem time65, current time 156, horizon 91\n", - "adding: mem time66, current time 156, horizon 90\n", - "adding: mem time67, current time 156, horizon 89\n", - "adding: mem time68, current time 156, horizon 88\n", - "adding: mem time69, current time 156, horizon 87\n", - "adding: mem time70, current time 156, horizon 86\n", - "adding: mem time71, current time 156, horizon 85\n", - "adding: mem time72, current time 156, horizon 84\n", - "adding: mem time73, current time 156, horizon 83\n", - "adding: mem time74, current time 156, horizon 82\n", - "adding: mem time75, current time 156, horizon 81\n", - "adding: mem time76, current time 156, horizon 80\n", - "adding: mem time77, current time 156, horizon 79\n", - "adding: mem time78, current time 156, horizon 78\n", - "adding: mem time79, current time 156, horizon 77\n", - "adding: mem time80, current time 156, horizon 76\n", - "adding: mem time81, current time 156, horizon 75\n", - "adding: mem time82, current time 156, horizon 74\n", - "adding: mem time83, current time 156, horizon 73\n", - "adding: mem time84, current time 156, horizon 72\n", - "adding: mem time85, current time 156, horizon 71\n", - "adding: mem time86, current time 156, horizon 70\n", - "adding: mem time87, current time 156, horizon 69\n", - "adding: mem time88, current time 156, horizon 68\n", - "adding: mem time89, current time 156, horizon 67\n", - "adding: mem time90, current time 156, horizon 66\n", - "adding: mem time91, current time 156, horizon 65\n", - "adding: mem time92, current time 156, horizon 64\n", - "adding: mem time93, current time 156, horizon 63\n", - "adding: mem time94, current time 156, horizon 62\n", - "adding: mem time95, current time 156, horizon 61\n", - "adding: mem time96, current time 156, horizon 60\n", - "adding: mem time97, current time 156, horizon 59\n", - "adding: mem time98, current time 156, horizon 58\n", - "adding: mem time99, current time 156, horizon 57\n", - "adding: mem time100, current time 156, horizon 56\n", - "adding: mem time101, current time 156, horizon 55\n", - "adding: mem time102, current time 156, horizon 54\n", - "adding: mem time103, current time 156, horizon 53\n", - "adding: mem time104, current time 156, horizon 52\n", - "adding: mem time105, current time 156, horizon 51\n", - "adding: mem time106, current time 156, horizon 50\n", - "adding: mem time107, current time 156, horizon 49\n", - "adding: mem time108, current time 156, horizon 48\n", - "adding: mem time109, current time 156, horizon 47\n", - "adding: mem time110, current time 156, horizon 46\n", - "adding: mem time111, current time 156, horizon 45\n", - "adding: mem time112, current time 156, horizon 44\n", - "adding: mem time113, current time 156, horizon 43\n", - "adding: mem time114, current time 156, horizon 42\n", - "adding: mem time115, current time 156, horizon 41\n", - "adding: mem time116, current time 156, horizon 40\n", - "adding: mem time117, current time 156, horizon 39\n", - "adding: mem time118, current time 156, horizon 38\n", - "adding: mem time119, current time 156, horizon 37\n", - "adding: mem time120, current time 156, horizon 36\n", - "adding: mem time121, current time 156, horizon 35\n", - "adding: mem time122, current time 156, horizon 34\n", - "adding: mem time123, current time 156, horizon 33\n", - "adding: mem time124, current time 156, horizon 32\n", - "adding: mem time125, current time 156, horizon 31\n", - "adding: mem time126, current time 156, horizon 30\n", - "adding: mem time127, current time 156, horizon 29\n", - "adding: mem time128, current time 156, horizon 28\n", - "adding: mem time129, current time 156, horizon 27\n", - "adding: mem time130, current time 156, horizon 26\n", - "adding: mem time131, current time 156, horizon 25\n", - "adding: mem time132, current time 156, horizon 24\n", - "adding: mem time133, current time 156, horizon 23\n", - "adding: mem time134, current time 156, horizon 22\n", - "adding: mem time135, current time 156, horizon 21\n", - "adding: mem time136, current time 156, horizon 20\n", - "adding: mem time137, current time 156, horizon 19\n", - "adding: mem time138, current time 156, horizon 18\n", - "adding: mem time139, current time 156, horizon 17\n", - "adding: mem time140, current time 156, horizon 16\n", - "adding: mem time141, current time 156, horizon 15\n", - "adding: mem time142, current time 156, horizon 14\n", - "adding: mem time143, current time 156, horizon 13\n", - "adding: mem time144, current time 156, horizon 12\n", - "adding: mem time145, current time 156, horizon 11\n", - "adding: mem time146, current time 156, horizon 10\n", - "adding: mem time147, current time 156, horizon 9\n", - "adding: mem time148, current time 156, horizon 8\n", - "adding: mem time149, current time 156, horizon 7\n", - "adding: mem time150, current time 156, horizon 6\n", - "adding: mem time151, current time 156, horizon 5\n", - "adding: mem time152, current time 156, horizon 4\n", - "adding: mem time153, current time 156, horizon 3\n", - "adding: mem time154, current time 156, horizon 2\n", - "adding: mem time155, current time 156, horizon 1\n", - "adding: mem time0, current time 157, horizon 157\n", - "adding: mem time1, current time 157, horizon 156\n", - "adding: mem time2, current time 157, horizon 155\n", - "adding: mem time3, current time 157, horizon 154\n", - "adding: mem time4, current time 157, horizon 153\n", - "adding: mem time5, current time 157, horizon 152\n", - "adding: mem time6, current time 157, horizon 151\n", - "adding: mem time7, current time 157, horizon 150\n", - "adding: mem time8, current time 157, horizon 149\n", - "adding: mem time9, current time 157, horizon 148\n", - "adding: mem time10, current time 157, horizon 147\n", - "adding: mem time11, current time 157, horizon 146\n", - "adding: mem time12, current time 157, horizon 145\n", - "adding: mem time13, current time 157, horizon 144\n", - "adding: mem time14, current time 157, horizon 143\n", - "adding: mem time15, current time 157, horizon 142\n", - "adding: mem time16, current time 157, horizon 141\n", - "adding: mem time17, current time 157, horizon 140\n", - "adding: mem time18, current time 157, horizon 139\n", - "adding: mem time19, current time 157, horizon 138\n", - "adding: mem time20, current time 157, horizon 137\n", - "adding: mem time21, current time 157, horizon 136\n", - "adding: mem time22, current time 157, horizon 135\n", - "adding: mem time23, current time 157, horizon 134\n", - "adding: mem time24, current time 157, horizon 133\n", - "adding: mem time25, current time 157, horizon 132\n", - "adding: mem time26, current time 157, horizon 131\n", - "adding: mem time27, current time 157, horizon 130\n", - "adding: mem time28, current time 157, horizon 129\n", - "adding: mem time29, current time 157, horizon 128\n", - "adding: mem time30, current time 157, horizon 127\n", - "adding: mem time31, current time 157, horizon 126\n", - "adding: mem time32, current time 157, horizon 125\n", - "adding: mem time33, current time 157, horizon 124\n", - "adding: mem time34, current time 157, horizon 123\n", - "adding: mem time35, current time 157, horizon 122\n", - "adding: mem time36, current time 157, horizon 121\n", - "adding: mem time37, current time 157, horizon 120\n", - "adding: mem time38, current time 157, horizon 119\n", - "adding: mem time39, current time 157, horizon 118\n", - "adding: mem time40, current time 157, horizon 117\n", - "adding: mem time41, current time 157, horizon 116\n", - "adding: mem time42, current time 157, horizon 115\n", - "adding: mem time43, current time 157, horizon 114\n", - "adding: mem time44, current time 157, horizon 113\n", - "adding: mem time45, current time 157, horizon 112\n", - "adding: mem time46, current time 157, horizon 111\n", - "adding: mem time47, current time 157, horizon 110\n", - "adding: mem time48, current time 157, horizon 109\n", - "adding: mem time49, current time 157, horizon 108\n", - "adding: mem time50, current time 157, horizon 107\n", - "adding: mem time51, current time 157, horizon 106\n", - "adding: mem time52, current time 157, horizon 105\n", - "adding: mem time53, current time 157, horizon 104\n", - "adding: mem time54, current time 157, horizon 103\n", - "adding: mem time55, current time 157, horizon 102\n", - "adding: mem time56, current time 157, horizon 101\n", - "adding: mem time57, current time 157, horizon 100\n", - "adding: mem time58, current time 157, horizon 99\n", - "adding: mem time59, current time 157, horizon 98\n", - "adding: mem time60, current time 157, horizon 97\n", - "adding: mem time61, current time 157, horizon 96\n", - "adding: mem time62, current time 157, horizon 95\n", - "adding: mem time63, current time 157, horizon 94\n", - "adding: mem time64, current time 157, horizon 93\n", - "adding: mem time65, current time 157, horizon 92\n", - "adding: mem time66, current time 157, horizon 91\n", - "adding: mem time67, current time 157, horizon 90\n", - "adding: mem time68, current time 157, horizon 89\n", - "adding: mem time69, current time 157, horizon 88\n", - "adding: mem time70, current time 157, horizon 87\n", - "adding: mem time71, current time 157, horizon 86\n", - "adding: mem time72, current time 157, horizon 85\n", - "adding: mem time73, current time 157, horizon 84\n", - "adding: mem time74, current time 157, horizon 83\n", - "adding: mem time75, current time 157, horizon 82\n", - "adding: mem time76, current time 157, horizon 81\n", - "adding: mem time77, current time 157, horizon 80\n", - "adding: mem time78, current time 157, horizon 79\n", - "adding: mem time79, current time 157, horizon 78\n", - "adding: mem time80, current time 157, horizon 77\n", - "adding: mem time81, current time 157, horizon 76\n", - "adding: mem time82, current time 157, horizon 75\n", - "adding: mem time83, current time 157, horizon 74\n", - "adding: mem time84, current time 157, horizon 73\n", - "adding: mem time85, current time 157, horizon 72\n", - "adding: mem time86, current time 157, horizon 71\n", - "adding: mem time87, current time 157, horizon 70\n", - "adding: mem time88, current time 157, horizon 69\n", - "adding: mem time89, current time 157, horizon 68\n", - "adding: mem time90, current time 157, horizon 67\n", - "adding: mem time91, current time 157, horizon 66\n", - "adding: mem time92, current time 157, horizon 65\n", - "adding: mem time93, current time 157, horizon 64\n", - "adding: mem time94, current time 157, horizon 63\n", - "adding: mem time95, current time 157, horizon 62\n", - "adding: mem time96, current time 157, horizon 61\n", - "adding: mem time97, current time 157, horizon 60\n", - "adding: mem time98, current time 157, horizon 59\n", - "adding: mem time99, current time 157, horizon 58\n", - "adding: mem time100, current time 157, horizon 57\n", - "adding: mem time101, current time 157, horizon 56\n", - "adding: mem time102, current time 157, horizon 55\n", - "adding: mem time103, current time 157, horizon 54\n", - "adding: mem time104, current time 157, horizon 53\n", - "adding: mem time105, current time 157, horizon 52\n", - "adding: mem time106, current time 157, horizon 51\n", - "adding: mem time107, current time 157, horizon 50\n", - "adding: mem time108, current time 157, horizon 49\n", - "adding: mem time109, current time 157, horizon 48\n", - "adding: mem time110, current time 157, horizon 47\n", - "adding: mem time111, current time 157, horizon 46\n", - "adding: mem time112, current time 157, horizon 45\n", - "adding: mem time113, current time 157, horizon 44\n", - "adding: mem time114, current time 157, horizon 43\n", - "adding: mem time115, current time 157, horizon 42\n", - "adding: mem time116, current time 157, horizon 41\n", - "adding: mem time117, current time 157, horizon 40\n", - "adding: mem time118, current time 157, horizon 39\n", - "adding: mem time119, current time 157, horizon 38\n", - "adding: mem time120, current time 157, horizon 37\n", - "adding: mem time121, current time 157, horizon 36\n", - "adding: mem time122, current time 157, horizon 35\n", - "adding: mem time123, current time 157, horizon 34\n", - "adding: mem time124, current time 157, horizon 33\n", - "adding: mem time125, current time 157, horizon 32\n", - "adding: mem time126, current time 157, horizon 31\n", - "adding: mem time127, current time 157, horizon 30\n", - "adding: mem time128, current time 157, horizon 29\n", - "adding: mem time129, current time 157, horizon 28\n", - "adding: mem time130, current time 157, horizon 27\n", - "adding: mem time131, current time 157, horizon 26\n", - "adding: mem time132, current time 157, horizon 25\n", - "adding: mem time133, current time 157, horizon 24\n", - "adding: mem time134, current time 157, horizon 23\n", - "adding: mem time135, current time 157, horizon 22\n", - "adding: mem time136, current time 157, horizon 21\n", - "adding: mem time137, current time 157, horizon 20\n", - "adding: mem time138, current time 157, horizon 19\n", - "adding: mem time139, current time 157, horizon 18\n", - "adding: mem time140, current time 157, horizon 17\n", - "adding: mem time141, current time 157, horizon 16\n", - "adding: mem time142, current time 157, horizon 15\n", - "adding: mem time143, current time 157, horizon 14\n", - "adding: mem time144, current time 157, horizon 13\n", - "adding: mem time145, current time 157, horizon 12\n", - "adding: mem time146, current time 157, horizon 11\n", - "adding: mem time147, current time 157, horizon 10\n", - "adding: mem time148, current time 157, horizon 9\n", - "adding: mem time149, current time 157, horizon 8\n", - "adding: mem time150, current time 157, horizon 7\n", - "adding: mem time151, current time 157, horizon 6\n", - "adding: mem time152, current time 157, horizon 5\n", - "adding: mem time153, current time 157, horizon 4\n", - "adding: mem time154, current time 157, horizon 3\n", - "adding: mem time155, current time 157, horizon 2\n", - "adding: mem time156, current time 157, horizon 1\n", - "adding: mem time0, current time 158, horizon 158\n", - "adding: mem time1, current time 158, horizon 157\n", - "adding: mem time2, current time 158, horizon 156\n", - "adding: mem time3, current time 158, horizon 155\n", - "adding: mem time4, current time 158, horizon 154\n", - "adding: mem time5, current time 158, horizon 153\n", - "adding: mem time6, current time 158, horizon 152\n", - "adding: mem time7, current time 158, horizon 151\n", - "adding: mem time8, current time 158, horizon 150\n", - "adding: mem time9, current time 158, horizon 149\n", - "adding: mem time10, current time 158, horizon 148\n", - "adding: mem time11, current time 158, horizon 147\n", - "adding: mem time12, current time 158, horizon 146\n", - "adding: mem time13, current time 158, horizon 145\n", - "adding: mem time14, current time 158, horizon 144\n", - "adding: mem time15, current time 158, horizon 143\n", - "adding: mem time16, current time 158, horizon 142\n", - "adding: mem time17, current time 158, horizon 141\n", - "adding: mem time18, current time 158, horizon 140\n", - "adding: mem time19, current time 158, horizon 139\n", - "adding: mem time20, current time 158, horizon 138\n", - "adding: mem time21, current time 158, horizon 137\n", - "adding: mem time22, current time 158, horizon 136\n", - "adding: mem time23, current time 158, horizon 135\n", - "adding: mem time24, current time 158, horizon 134\n", - "adding: mem time25, current time 158, horizon 133\n", - "adding: mem time26, current time 158, horizon 132\n", - "adding: mem time27, current time 158, horizon 131\n", - "adding: mem time28, current time 158, horizon 130\n", - "adding: mem time29, current time 158, horizon 129\n", - "adding: mem time30, current time 158, horizon 128\n", - "adding: mem time31, current time 158, horizon 127\n", - "adding: mem time32, current time 158, horizon 126\n", - "adding: mem time33, current time 158, horizon 125\n", - "adding: mem time34, current time 158, horizon 124\n", - "adding: mem time35, current time 158, horizon 123\n", - "adding: mem time36, current time 158, horizon 122\n", - "adding: mem time37, current time 158, horizon 121\n", - "adding: mem time38, current time 158, horizon 120\n", - "adding: mem time39, current time 158, horizon 119\n", - "adding: mem time40, current time 158, horizon 118\n", - "adding: mem time41, current time 158, horizon 117\n", - "adding: mem time42, current time 158, horizon 116\n", - "adding: mem time43, current time 158, horizon 115\n", - "adding: mem time44, current time 158, horizon 114\n", - "adding: mem time45, current time 158, horizon 113\n", - "adding: mem time46, current time 158, horizon 112\n", - "adding: mem time47, current time 158, horizon 111\n", - "adding: mem time48, current time 158, horizon 110\n", - "adding: mem time49, current time 158, horizon 109\n", - "adding: mem time50, current time 158, horizon 108\n", - "adding: mem time51, current time 158, horizon 107\n", - "adding: mem time52, current time 158, horizon 106\n", - "adding: mem time53, current time 158, horizon 105\n", - "adding: mem time54, current time 158, horizon 104\n", - "adding: mem time55, current time 158, horizon 103\n", - "adding: mem time56, current time 158, horizon 102\n", - "adding: mem time57, current time 158, horizon 101\n", - "adding: mem time58, current time 158, horizon 100\n", - "adding: mem time59, current time 158, horizon 99\n", - "adding: mem time60, current time 158, horizon 98\n", - "adding: mem time61, current time 158, horizon 97\n", - "adding: mem time62, current time 158, horizon 96\n", - "adding: mem time63, current time 158, horizon 95\n", - "adding: mem time64, current time 158, horizon 94\n", - "adding: mem time65, current time 158, horizon 93\n", - "adding: mem time66, current time 158, horizon 92\n", - "adding: mem time67, current time 158, horizon 91\n", - "adding: mem time68, current time 158, horizon 90\n", - "adding: mem time69, current time 158, horizon 89\n", - "adding: mem time70, current time 158, horizon 88\n", - "adding: mem time71, current time 158, horizon 87\n", - "adding: mem time72, current time 158, horizon 86\n", - "adding: mem time73, current time 158, horizon 85\n", - "adding: mem time74, current time 158, horizon 84\n", - "adding: mem time75, current time 158, horizon 83\n", - "adding: mem time76, current time 158, horizon 82\n", - "adding: mem time77, current time 158, horizon 81\n", - "adding: mem time78, current time 158, horizon 80\n", - "adding: mem time79, current time 158, horizon 79\n", - "adding: mem time80, current time 158, horizon 78\n", - "adding: mem time81, current time 158, horizon 77\n", - "adding: mem time82, current time 158, horizon 76\n", - "adding: mem time83, current time 158, horizon 75\n", - "adding: mem time84, current time 158, horizon 74\n", - "adding: mem time85, current time 158, horizon 73\n", - "adding: mem time86, current time 158, horizon 72\n", - "adding: mem time87, current time 158, horizon 71\n", - "adding: mem time88, current time 158, horizon 70\n", - "adding: mem time89, current time 158, horizon 69\n", - "adding: mem time90, current time 158, horizon 68\n", - "adding: mem time91, current time 158, horizon 67\n", - "adding: mem time92, current time 158, horizon 66\n", - "adding: mem time93, current time 158, horizon 65\n", - "adding: mem time94, current time 158, horizon 64\n", - "adding: mem time95, current time 158, horizon 63\n", - "adding: mem time96, current time 158, horizon 62\n", - "adding: mem time97, current time 158, horizon 61\n", - "adding: mem time98, current time 158, horizon 60\n", - "adding: mem time99, current time 158, horizon 59\n", - "adding: mem time100, current time 158, horizon 58\n", - "adding: mem time101, current time 158, horizon 57\n", - "adding: mem time102, current time 158, horizon 56\n", - "adding: mem time103, current time 158, horizon 55\n", - "adding: mem time104, current time 158, horizon 54\n", - "adding: mem time105, current time 158, horizon 53\n", - "adding: mem time106, current time 158, horizon 52\n", - "adding: mem time107, current time 158, horizon 51\n", - "adding: mem time108, current time 158, horizon 50\n", - "adding: mem time109, current time 158, horizon 49\n", - "adding: mem time110, current time 158, horizon 48\n", - "adding: mem time111, current time 158, horizon 47\n", - "adding: mem time112, current time 158, horizon 46\n", - "adding: mem time113, current time 158, horizon 45\n", - "adding: mem time114, current time 158, horizon 44\n", - "adding: mem time115, current time 158, horizon 43\n", - "adding: mem time116, current time 158, horizon 42\n", - "adding: mem time117, current time 158, horizon 41\n", - "adding: mem time118, current time 158, horizon 40\n", - "adding: mem time119, current time 158, horizon 39\n", - "adding: mem time120, current time 158, horizon 38\n", - "adding: mem time121, current time 158, horizon 37\n", - "adding: mem time122, current time 158, horizon 36\n", - "adding: mem time123, current time 158, horizon 35\n", - "adding: mem time124, current time 158, horizon 34\n", - "adding: mem time125, current time 158, horizon 33\n", - "adding: mem time126, current time 158, horizon 32\n", - "adding: mem time127, current time 158, horizon 31\n", - "adding: mem time128, current time 158, horizon 30\n", - "adding: mem time129, current time 158, horizon 29\n", - "adding: mem time130, current time 158, horizon 28\n", - "adding: mem time131, current time 158, horizon 27\n", - "adding: mem time132, current time 158, horizon 26\n", - "adding: mem time133, current time 158, horizon 25\n", - "adding: mem time134, current time 158, horizon 24\n", - "adding: mem time135, current time 158, horizon 23\n", - "adding: mem time136, current time 158, horizon 22\n", - "adding: mem time137, current time 158, horizon 21\n", - "adding: mem time138, current time 158, horizon 20\n", - "adding: mem time139, current time 158, horizon 19\n", - "adding: mem time140, current time 158, horizon 18\n", - "adding: mem time141, current time 158, horizon 17\n", - "adding: mem time142, current time 158, horizon 16\n", - "adding: mem time143, current time 158, horizon 15\n", - "adding: mem time144, current time 158, horizon 14\n", - "adding: mem time145, current time 158, horizon 13\n", - "adding: mem time146, current time 158, horizon 12\n", - "adding: mem time147, current time 158, horizon 11\n", - "adding: mem time148, current time 158, horizon 10\n", - "adding: mem time149, current time 158, horizon 9\n", - "adding: mem time150, current time 158, horizon 8\n", - "adding: mem time151, current time 158, horizon 7\n", - "adding: mem time152, current time 158, horizon 6\n", - "adding: mem time153, current time 158, horizon 5\n", - "adding: mem time154, current time 158, horizon 4\n", - "adding: mem time155, current time 158, horizon 3\n", - "adding: mem time156, current time 158, horizon 2\n", - "adding: mem time157, current time 158, horizon 1\n", - "adding: mem time0, current time 159, horizon 159\n", - "adding: mem time1, current time 159, horizon 158\n", - "adding: mem time2, current time 159, horizon 157\n", - "adding: mem time3, current time 159, horizon 156\n", - "adding: mem time4, current time 159, horizon 155\n", - "adding: mem time5, current time 159, horizon 154\n", - "adding: mem time6, current time 159, horizon 153\n", - "adding: mem time7, current time 159, horizon 152\n", - "adding: mem time8, current time 159, horizon 151\n", - "adding: mem time9, current time 159, horizon 150\n", - "adding: mem time10, current time 159, horizon 149\n", - "adding: mem time11, current time 159, horizon 148\n", - "adding: mem time12, current time 159, horizon 147\n", - "adding: mem time13, current time 159, horizon 146\n", - "adding: mem time14, current time 159, horizon 145\n", - "adding: mem time15, current time 159, horizon 144\n", - "adding: mem time16, current time 159, horizon 143\n", - "adding: mem time17, current time 159, horizon 142\n", - "adding: mem time18, current time 159, horizon 141\n", - "adding: mem time19, current time 159, horizon 140\n", - "adding: mem time20, current time 159, horizon 139\n", - "adding: mem time21, current time 159, horizon 138\n", - "adding: mem time22, current time 159, horizon 137\n", - "adding: mem time23, current time 159, horizon 136\n", - "adding: mem time24, current time 159, horizon 135\n", - "adding: mem time25, current time 159, horizon 134\n", - "adding: mem time26, current time 159, horizon 133\n", - "adding: mem time27, current time 159, horizon 132\n", - "adding: mem time28, current time 159, horizon 131\n", - "adding: mem time29, current time 159, horizon 130\n", - "adding: mem time30, current time 159, horizon 129\n", - "adding: mem time31, current time 159, horizon 128\n", - "adding: mem time32, current time 159, horizon 127\n", - "adding: mem time33, current time 159, horizon 126\n", - "adding: mem time34, current time 159, horizon 125\n", - "adding: mem time35, current time 159, horizon 124\n", - "adding: mem time36, current time 159, horizon 123\n", - "adding: mem time37, current time 159, horizon 122\n", - "adding: mem time38, current time 159, horizon 121\n", - "adding: mem time39, current time 159, horizon 120\n", - "adding: mem time40, current time 159, horizon 119\n", - "adding: mem time41, current time 159, horizon 118\n", - "adding: mem time42, current time 159, horizon 117\n", - "adding: mem time43, current time 159, horizon 116\n", - "adding: mem time44, current time 159, horizon 115\n", - "adding: mem time45, current time 159, horizon 114\n", - "adding: mem time46, current time 159, horizon 113\n", - "adding: mem time47, current time 159, horizon 112\n", - "adding: mem time48, current time 159, horizon 111\n", - "adding: mem time49, current time 159, horizon 110\n", - "adding: mem time50, current time 159, horizon 109\n", - "adding: mem time51, current time 159, horizon 108\n", - "adding: mem time52, current time 159, horizon 107\n", - "adding: mem time53, current time 159, horizon 106\n", - "adding: mem time54, current time 159, horizon 105\n", - "adding: mem time55, current time 159, horizon 104\n", - "adding: mem time56, current time 159, horizon 103\n", - "adding: mem time57, current time 159, horizon 102\n", - "adding: mem time58, current time 159, horizon 101\n", - "adding: mem time59, current time 159, horizon 100\n", - "adding: mem time60, current time 159, horizon 99\n", - "adding: mem time61, current time 159, horizon 98\n", - "adding: mem time62, current time 159, horizon 97\n", - "adding: mem time63, current time 159, horizon 96\n", - "adding: mem time64, current time 159, horizon 95\n", - "adding: mem time65, current time 159, horizon 94\n", - "adding: mem time66, current time 159, horizon 93\n", - "adding: mem time67, current time 159, horizon 92\n", - "adding: mem time68, current time 159, horizon 91\n", - "adding: mem time69, current time 159, horizon 90\n", - "adding: mem time70, current time 159, horizon 89\n", - "adding: mem time71, current time 159, horizon 88\n", - "adding: mem time72, current time 159, horizon 87\n", - "adding: mem time73, current time 159, horizon 86\n", - "adding: mem time74, current time 159, horizon 85\n", - "adding: mem time75, current time 159, horizon 84\n", - "adding: mem time76, current time 159, horizon 83\n", - "adding: mem time77, current time 159, horizon 82\n", - "adding: mem time78, current time 159, horizon 81\n", - "adding: mem time79, current time 159, horizon 80\n", - "adding: mem time80, current time 159, horizon 79\n", - "adding: mem time81, current time 159, horizon 78\n", - "adding: mem time82, current time 159, horizon 77\n", - "adding: mem time83, current time 159, horizon 76\n", - "adding: mem time84, current time 159, horizon 75\n", - "adding: mem time85, current time 159, horizon 74\n", - "adding: mem time86, current time 159, horizon 73\n", - "adding: mem time87, current time 159, horizon 72\n", - "adding: mem time88, current time 159, horizon 71\n", - "adding: mem time89, current time 159, horizon 70\n", - "adding: mem time90, current time 159, horizon 69\n", - "adding: mem time91, current time 159, horizon 68\n", - "adding: mem time92, current time 159, horizon 67\n", - "adding: mem time93, current time 159, horizon 66\n", - "adding: mem time94, current time 159, horizon 65\n", - "adding: mem time95, current time 159, horizon 64\n", - "adding: mem time96, current time 159, horizon 63\n", - "adding: mem time97, current time 159, horizon 62\n", - "adding: mem time98, current time 159, horizon 61\n", - "adding: mem time99, current time 159, horizon 60\n", - "adding: mem time100, current time 159, horizon 59\n", - "adding: mem time101, current time 159, horizon 58\n", - "adding: mem time102, current time 159, horizon 57\n", - "adding: mem time103, current time 159, horizon 56\n", - "adding: mem time104, current time 159, horizon 55\n", - "adding: mem time105, current time 159, horizon 54\n", - "adding: mem time106, current time 159, horizon 53\n", - "adding: mem time107, current time 159, horizon 52\n", - "adding: mem time108, current time 159, horizon 51\n", - "adding: mem time109, current time 159, horizon 50\n", - "adding: mem time110, current time 159, horizon 49\n", - "adding: mem time111, current time 159, horizon 48\n", - "adding: mem time112, current time 159, horizon 47\n", - "adding: mem time113, current time 159, horizon 46\n", - "adding: mem time114, current time 159, horizon 45\n", - "adding: mem time115, current time 159, horizon 44\n", - "adding: mem time116, current time 159, horizon 43\n", - "adding: mem time117, current time 159, horizon 42\n", - "adding: mem time118, current time 159, horizon 41\n", - "adding: mem time119, current time 159, horizon 40\n", - "adding: mem time120, current time 159, horizon 39\n", - "adding: mem time121, current time 159, horizon 38\n", - "adding: mem time122, current time 159, horizon 37\n", - "adding: mem time123, current time 159, horizon 36\n", - "adding: mem time124, current time 159, horizon 35\n", - "adding: mem time125, current time 159, horizon 34\n", - "adding: mem time126, current time 159, horizon 33\n", - "adding: mem time127, current time 159, horizon 32\n", - "adding: mem time128, current time 159, horizon 31\n", - "adding: mem time129, current time 159, horizon 30\n", - "adding: mem time130, current time 159, horizon 29\n", - "adding: mem time131, current time 159, horizon 28\n", - "adding: mem time132, current time 159, horizon 27\n", - "adding: mem time133, current time 159, horizon 26\n", - "adding: mem time134, current time 159, horizon 25\n", - "adding: mem time135, current time 159, horizon 24\n", - "adding: mem time136, current time 159, horizon 23\n", - "adding: mem time137, current time 159, horizon 22\n", - "adding: mem time138, current time 159, horizon 21\n", - "adding: mem time139, current time 159, horizon 20\n", - "adding: mem time140, current time 159, horizon 19\n", - "adding: mem time141, current time 159, horizon 18\n", - "adding: mem time142, current time 159, horizon 17\n", - "adding: mem time143, current time 159, horizon 16\n", - "adding: mem time144, current time 159, horizon 15\n", - "adding: mem time145, current time 159, horizon 14\n", - "adding: mem time146, current time 159, horizon 13\n", - "adding: mem time147, current time 159, horizon 12\n", - "adding: mem time148, current time 159, horizon 11\n", - "adding: mem time149, current time 159, horizon 10\n", - "adding: mem time150, current time 159, horizon 9\n", - "adding: mem time151, current time 159, horizon 8\n", - "adding: mem time152, current time 159, horizon 7\n", - "adding: mem time153, current time 159, horizon 6\n", - "adding: mem time154, current time 159, horizon 5\n", - "adding: mem time155, current time 159, horizon 4\n", - "adding: mem time156, current time 159, horizon 3\n", - "adding: mem time157, current time 159, horizon 2\n", - "adding: mem time158, current time 159, horizon 1\n", - "adding: mem time0, current time 160, horizon 160\n", - "adding: mem time1, current time 160, horizon 159\n", - "adding: mem time2, current time 160, horizon 158\n", - "adding: mem time3, current time 160, horizon 157\n", - "adding: mem time4, current time 160, horizon 156\n", - "adding: mem time5, current time 160, horizon 155\n", - "adding: mem time6, current time 160, horizon 154\n", - "adding: mem time7, current time 160, horizon 153\n", - "adding: mem time8, current time 160, horizon 152\n", - "adding: mem time9, current time 160, horizon 151\n", - "adding: mem time10, current time 160, horizon 150\n", - "adding: mem time11, current time 160, horizon 149\n", - "adding: mem time12, current time 160, horizon 148\n", - "adding: mem time13, current time 160, horizon 147\n", - "adding: mem time14, current time 160, horizon 146\n", - "adding: mem time15, current time 160, horizon 145\n", - "adding: mem time16, current time 160, horizon 144\n", - "adding: mem time17, current time 160, horizon 143\n", - "adding: mem time18, current time 160, horizon 142\n", - "adding: mem time19, current time 160, horizon 141\n", - "adding: mem time20, current time 160, horizon 140\n", - "adding: mem time21, current time 160, horizon 139\n", - "adding: mem time22, current time 160, horizon 138\n", - "adding: mem time23, current time 160, horizon 137\n", - "adding: mem time24, current time 160, horizon 136\n", - "adding: mem time25, current time 160, horizon 135\n", - "adding: mem time26, current time 160, horizon 134\n", - "adding: mem time27, current time 160, horizon 133\n", - "adding: mem time28, current time 160, horizon 132\n", - "adding: mem time29, current time 160, horizon 131\n", - "adding: mem time30, current time 160, horizon 130\n", - "adding: mem time31, current time 160, horizon 129\n", - "adding: mem time32, current time 160, horizon 128\n", - "adding: mem time33, current time 160, horizon 127\n", - "adding: mem time34, current time 160, horizon 126\n", - "adding: mem time35, current time 160, horizon 125\n", - "adding: mem time36, current time 160, horizon 124\n", - "adding: mem time37, current time 160, horizon 123\n", - "adding: mem time38, current time 160, horizon 122\n", - "adding: mem time39, current time 160, horizon 121\n", - "adding: mem time40, current time 160, horizon 120\n", - "adding: mem time41, current time 160, horizon 119\n", - "adding: mem time42, current time 160, horizon 118\n", - "adding: mem time43, current time 160, horizon 117\n", - "adding: mem time44, current time 160, horizon 116\n", - "adding: mem time45, current time 160, horizon 115\n", - "adding: mem time46, current time 160, horizon 114\n", - "adding: mem time47, current time 160, horizon 113\n", - "adding: mem time48, current time 160, horizon 112\n", - "adding: mem time49, current time 160, horizon 111\n", - "adding: mem time50, current time 160, horizon 110\n", - "adding: mem time51, current time 160, horizon 109\n", - "adding: mem time52, current time 160, horizon 108\n", - "adding: mem time53, current time 160, horizon 107\n", - "adding: mem time54, current time 160, horizon 106\n", - "adding: mem time55, current time 160, horizon 105\n", - "adding: mem time56, current time 160, horizon 104\n", - "adding: mem time57, current time 160, horizon 103\n", - "adding: mem time58, current time 160, horizon 102\n", - "adding: mem time59, current time 160, horizon 101\n", - "adding: mem time60, current time 160, horizon 100\n", - "adding: mem time61, current time 160, horizon 99\n", - "adding: mem time62, current time 160, horizon 98\n", - "adding: mem time63, current time 160, horizon 97\n", - "adding: mem time64, current time 160, horizon 96\n", - "adding: mem time65, current time 160, horizon 95\n", - "adding: mem time66, current time 160, horizon 94\n", - "adding: mem time67, current time 160, horizon 93\n", - "adding: mem time68, current time 160, horizon 92\n", - "adding: mem time69, current time 160, horizon 91\n", - "adding: mem time70, current time 160, horizon 90\n", - "adding: mem time71, current time 160, horizon 89\n", - "adding: mem time72, current time 160, horizon 88\n", - "adding: mem time73, current time 160, horizon 87\n", - "adding: mem time74, current time 160, horizon 86\n", - "adding: mem time75, current time 160, horizon 85\n", - "adding: mem time76, current time 160, horizon 84\n", - "adding: mem time77, current time 160, horizon 83\n", - "adding: mem time78, current time 160, horizon 82\n", - "adding: mem time79, current time 160, horizon 81\n", - "adding: mem time80, current time 160, horizon 80\n", - "adding: mem time81, current time 160, horizon 79\n", - "adding: mem time82, current time 160, horizon 78\n", - "adding: mem time83, current time 160, horizon 77\n", - "adding: mem time84, current time 160, horizon 76\n", - "adding: mem time85, current time 160, horizon 75\n", - "adding: mem time86, current time 160, horizon 74\n", - "adding: mem time87, current time 160, horizon 73\n", - "adding: mem time88, current time 160, horizon 72\n", - "adding: mem time89, current time 160, horizon 71\n", - "adding: mem time90, current time 160, horizon 70\n", - "adding: mem time91, current time 160, horizon 69\n", - "adding: mem time92, current time 160, horizon 68\n", - "adding: mem time93, current time 160, horizon 67\n", - "adding: mem time94, current time 160, horizon 66\n", - "adding: mem time95, current time 160, horizon 65\n", - "adding: mem time96, current time 160, horizon 64\n", - "adding: mem time97, current time 160, horizon 63\n", - "adding: mem time98, current time 160, horizon 62\n", - "adding: mem time99, current time 160, horizon 61\n", - "adding: mem time100, current time 160, horizon 60\n", - "adding: mem time101, current time 160, horizon 59\n", - "adding: mem time102, current time 160, horizon 58\n", - "adding: mem time103, current time 160, horizon 57\n", - "adding: mem time104, current time 160, horizon 56\n", - "adding: mem time105, current time 160, horizon 55\n", - "adding: mem time106, current time 160, horizon 54\n", - "adding: mem time107, current time 160, horizon 53\n", - "adding: mem time108, current time 160, horizon 52\n", - "adding: mem time109, current time 160, horizon 51\n", - "adding: mem time110, current time 160, horizon 50\n", - "adding: mem time111, current time 160, horizon 49\n", - "adding: mem time112, current time 160, horizon 48\n", - "adding: mem time113, current time 160, horizon 47\n", - "adding: mem time114, current time 160, horizon 46\n", - "adding: mem time115, current time 160, horizon 45\n", - "adding: mem time116, current time 160, horizon 44\n", - "adding: mem time117, current time 160, horizon 43\n", - "adding: mem time118, current time 160, horizon 42\n", - "adding: mem time119, current time 160, horizon 41\n", - "adding: mem time120, current time 160, horizon 40\n", - "adding: mem time121, current time 160, horizon 39\n", - "adding: mem time122, current time 160, horizon 38\n", - "adding: mem time123, current time 160, horizon 37\n", - "adding: mem time124, current time 160, horizon 36\n", - "adding: mem time125, current time 160, horizon 35\n", - "adding: mem time126, current time 160, horizon 34\n", - "adding: mem time127, current time 160, horizon 33\n", - "adding: mem time128, current time 160, horizon 32\n", - "adding: mem time129, current time 160, horizon 31\n", - "adding: mem time130, current time 160, horizon 30\n", - "adding: mem time131, current time 160, horizon 29\n", - "adding: mem time132, current time 160, horizon 28\n", - "adding: mem time133, current time 160, horizon 27\n", - "adding: mem time134, current time 160, horizon 26\n", - "adding: mem time135, current time 160, horizon 25\n", - "adding: mem time136, current time 160, horizon 24\n", - "adding: mem time137, current time 160, horizon 23\n", - "adding: mem time138, current time 160, horizon 22\n", - "adding: mem time139, current time 160, horizon 21\n", - "adding: mem time140, current time 160, horizon 20\n", - "adding: mem time141, current time 160, horizon 19\n", - "adding: mem time142, current time 160, horizon 18\n", - "adding: mem time143, current time 160, horizon 17\n", - "adding: mem time144, current time 160, horizon 16\n", - "adding: mem time145, current time 160, horizon 15\n", - "adding: mem time146, current time 160, horizon 14\n", - "adding: mem time147, current time 160, horizon 13\n", - "adding: mem time148, current time 160, horizon 12\n", - "adding: mem time149, current time 160, horizon 11\n", - "adding: mem time150, current time 160, horizon 10\n", - "adding: mem time151, current time 160, horizon 9\n", - "adding: mem time152, current time 160, horizon 8\n", - "adding: mem time153, current time 160, horizon 7\n", - "adding: mem time154, current time 160, horizon 6\n", - "adding: mem time155, current time 160, horizon 5\n", - "adding: mem time156, current time 160, horizon 4\n", - "adding: mem time157, current time 160, horizon 3\n", - "adding: mem time158, current time 160, horizon 2\n", - "adding: mem time159, current time 160, horizon 1\n", - "adding: mem time0, current time 161, horizon 161\n", - "adding: mem time1, current time 161, horizon 160\n", - "adding: mem time2, current time 161, horizon 159\n", - "adding: mem time3, current time 161, horizon 158\n", - "adding: mem time4, current time 161, horizon 157\n", - "adding: mem time5, current time 161, horizon 156\n", - "adding: mem time6, current time 161, horizon 155\n", - "adding: mem time7, current time 161, horizon 154\n", - "adding: mem time8, current time 161, horizon 153\n", - "adding: mem time9, current time 161, horizon 152\n", - "adding: mem time10, current time 161, horizon 151\n", - "adding: mem time11, current time 161, horizon 150\n", - "adding: mem time12, current time 161, horizon 149\n", - "adding: mem time13, current time 161, horizon 148\n", - "adding: mem time14, current time 161, horizon 147\n", - "adding: mem time15, current time 161, horizon 146\n", - "adding: mem time16, current time 161, horizon 145\n", - "adding: mem time17, current time 161, horizon 144\n", - "adding: mem time18, current time 161, horizon 143\n", - "adding: mem time19, current time 161, horizon 142\n", - "adding: mem time20, current time 161, horizon 141\n", - "adding: mem time21, current time 161, horizon 140\n", - "adding: mem time22, current time 161, horizon 139\n", - "adding: mem time23, current time 161, horizon 138\n", - "adding: mem time24, current time 161, horizon 137\n", - "adding: mem time25, current time 161, horizon 136\n", - "adding: mem time26, current time 161, horizon 135\n", - "adding: mem time27, current time 161, horizon 134\n", - "adding: mem time28, current time 161, horizon 133\n", - "adding: mem time29, current time 161, horizon 132\n", - "adding: mem time30, current time 161, horizon 131\n", - "adding: mem time31, current time 161, horizon 130\n", - "adding: mem time32, current time 161, horizon 129\n", - "adding: mem time33, current time 161, horizon 128\n", - "adding: mem time34, current time 161, horizon 127\n", - "adding: mem time35, current time 161, horizon 126\n", - "adding: mem time36, current time 161, horizon 125\n", - "adding: mem time37, current time 161, horizon 124\n", - "adding: mem time38, current time 161, horizon 123\n", - "adding: mem time39, current time 161, horizon 122\n", - "adding: mem time40, current time 161, horizon 121\n", - "adding: mem time41, current time 161, horizon 120\n", - "adding: mem time42, current time 161, horizon 119\n", - "adding: mem time43, current time 161, horizon 118\n", - "adding: mem time44, current time 161, horizon 117\n", - "adding: mem time45, current time 161, horizon 116\n", - "adding: mem time46, current time 161, horizon 115\n", - "adding: mem time47, current time 161, horizon 114\n", - "adding: mem time48, current time 161, horizon 113\n", - "adding: mem time49, current time 161, horizon 112\n", - "adding: mem time50, current time 161, horizon 111\n", - "adding: mem time51, current time 161, horizon 110\n", - "adding: mem time52, current time 161, horizon 109\n", - "adding: mem time53, current time 161, horizon 108\n", - "adding: mem time54, current time 161, horizon 107\n", - "adding: mem time55, current time 161, horizon 106\n", - "adding: mem time56, current time 161, horizon 105\n", - "adding: mem time57, current time 161, horizon 104\n", - "adding: mem time58, current time 161, horizon 103\n", - "adding: mem time59, current time 161, horizon 102\n", - "adding: mem time60, current time 161, horizon 101\n", - "adding: mem time61, current time 161, horizon 100\n", - "adding: mem time62, current time 161, horizon 99\n", - "adding: mem time63, current time 161, horizon 98\n", - "adding: mem time64, current time 161, horizon 97\n", - "adding: mem time65, current time 161, horizon 96\n", - "adding: mem time66, current time 161, horizon 95\n", - "adding: mem time67, current time 161, horizon 94\n", - "adding: mem time68, current time 161, horizon 93\n", - "adding: mem time69, current time 161, horizon 92\n", - "adding: mem time70, current time 161, horizon 91\n", - "adding: mem time71, current time 161, horizon 90\n", - "adding: mem time72, current time 161, horizon 89\n", - "adding: mem time73, current time 161, horizon 88\n", - "adding: mem time74, current time 161, horizon 87\n", - "adding: mem time75, current time 161, horizon 86\n", - "adding: mem time76, current time 161, horizon 85\n", - "adding: mem time77, current time 161, horizon 84\n", - "adding: mem time78, current time 161, horizon 83\n", - "adding: mem time79, current time 161, horizon 82\n", - "adding: mem time80, current time 161, horizon 81\n", - "adding: mem time81, current time 161, horizon 80\n", - "adding: mem time82, current time 161, horizon 79\n", - "adding: mem time83, current time 161, horizon 78\n", - "adding: mem time84, current time 161, horizon 77\n", - "adding: mem time85, current time 161, horizon 76\n", - "adding: mem time86, current time 161, horizon 75\n", - "adding: mem time87, current time 161, horizon 74\n", - "adding: mem time88, current time 161, horizon 73\n", - "adding: mem time89, current time 161, horizon 72\n", - "adding: mem time90, current time 161, horizon 71\n", - "adding: mem time91, current time 161, horizon 70\n", - "adding: mem time92, current time 161, horizon 69\n", - "adding: mem time93, current time 161, horizon 68\n", - "adding: mem time94, current time 161, horizon 67\n", - "adding: mem time95, current time 161, horizon 66\n", - "adding: mem time96, current time 161, horizon 65\n", - "adding: mem time97, current time 161, horizon 64\n", - "adding: mem time98, current time 161, horizon 63\n", - "adding: mem time99, current time 161, horizon 62\n", - "adding: mem time100, current time 161, horizon 61\n", - "adding: mem time101, current time 161, horizon 60\n", - "adding: mem time102, current time 161, horizon 59\n", - "adding: mem time103, current time 161, horizon 58\n", - "adding: mem time104, current time 161, horizon 57\n", - "adding: mem time105, current time 161, horizon 56\n", - "adding: mem time106, current time 161, horizon 55\n", - "adding: mem time107, current time 161, horizon 54\n", - "adding: mem time108, current time 161, horizon 53\n", - "adding: mem time109, current time 161, horizon 52\n", - "adding: mem time110, current time 161, horizon 51\n", - "adding: mem time111, current time 161, horizon 50\n", - "adding: mem time112, current time 161, horizon 49\n", - "adding: mem time113, current time 161, horizon 48\n", - "adding: mem time114, current time 161, horizon 47\n", - "adding: mem time115, current time 161, horizon 46\n", - "adding: mem time116, current time 161, horizon 45\n", - "adding: mem time117, current time 161, horizon 44\n", - "adding: mem time118, current time 161, horizon 43\n", - "adding: mem time119, current time 161, horizon 42\n", - "adding: mem time120, current time 161, horizon 41\n", - "adding: mem time121, current time 161, horizon 40\n", - "adding: mem time122, current time 161, horizon 39\n", - "adding: mem time123, current time 161, horizon 38\n", - "adding: mem time124, current time 161, horizon 37\n", - "adding: mem time125, current time 161, horizon 36\n", - "adding: mem time126, current time 161, horizon 35\n", - "adding: mem time127, current time 161, horizon 34\n", - "adding: mem time128, current time 161, horizon 33\n", - "adding: mem time129, current time 161, horizon 32\n", - "adding: mem time130, current time 161, horizon 31\n", - "adding: mem time131, current time 161, horizon 30\n", - "adding: mem time132, current time 161, horizon 29\n", - "adding: mem time133, current time 161, horizon 28\n", - "adding: mem time134, current time 161, horizon 27\n", - "adding: mem time135, current time 161, horizon 26\n", - "adding: mem time136, current time 161, horizon 25\n", - "adding: mem time137, current time 161, horizon 24\n", - "adding: mem time138, current time 161, horizon 23\n", - "adding: mem time139, current time 161, horizon 22\n", - "adding: mem time140, current time 161, horizon 21\n", - "adding: mem time141, current time 161, horizon 20\n", - "adding: mem time142, current time 161, horizon 19\n", - "adding: mem time143, current time 161, horizon 18\n", - "adding: mem time144, current time 161, horizon 17\n", - "adding: mem time145, current time 161, horizon 16\n", - "adding: mem time146, current time 161, horizon 15\n", - "adding: mem time147, current time 161, horizon 14\n", - "adding: mem time148, current time 161, horizon 13\n", - "adding: mem time149, current time 161, horizon 12\n", - "adding: mem time150, current time 161, horizon 11\n", - "adding: mem time151, current time 161, horizon 10\n", - "adding: mem time152, current time 161, horizon 9\n", - "adding: mem time153, current time 161, horizon 8\n", - "adding: mem time154, current time 161, horizon 7\n", - "adding: mem time155, current time 161, horizon 6\n", - "adding: mem time156, current time 161, horizon 5\n", - "adding: mem time157, current time 161, horizon 4\n", - "adding: mem time158, current time 161, horizon 3\n", - "adding: mem time159, current time 161, horizon 2\n", - "adding: mem time160, current time 161, horizon 1\n", - "adding: mem time0, current time 162, horizon 162\n", - "adding: mem time1, current time 162, horizon 161\n", - "adding: mem time2, current time 162, horizon 160\n", - "adding: mem time3, current time 162, horizon 159\n", - "adding: mem time4, current time 162, horizon 158\n", - "adding: mem time5, current time 162, horizon 157\n", - "adding: mem time6, current time 162, horizon 156\n", - "adding: mem time7, current time 162, horizon 155\n", - "adding: mem time8, current time 162, horizon 154\n", - "adding: mem time9, current time 162, horizon 153\n", - "adding: mem time10, current time 162, horizon 152\n", - "adding: mem time11, current time 162, horizon 151\n", - "adding: mem time12, current time 162, horizon 150\n", - "adding: mem time13, current time 162, horizon 149\n", - "adding: mem time14, current time 162, horizon 148\n", - "adding: mem time15, current time 162, horizon 147\n", - "adding: mem time16, current time 162, horizon 146\n", - "adding: mem time17, current time 162, horizon 145\n", - "adding: mem time18, current time 162, horizon 144\n", - "adding: mem time19, current time 162, horizon 143\n", - "adding: mem time20, current time 162, horizon 142\n", - "adding: mem time21, current time 162, horizon 141\n", - "adding: mem time22, current time 162, horizon 140\n", - "adding: mem time23, current time 162, horizon 139\n", - "adding: mem time24, current time 162, horizon 138\n", - "adding: mem time25, current time 162, horizon 137\n", - "adding: mem time26, current time 162, horizon 136\n", - "adding: mem time27, current time 162, horizon 135\n", - "adding: mem time28, current time 162, horizon 134\n", - "adding: mem time29, current time 162, horizon 133\n", - "adding: mem time30, current time 162, horizon 132\n", - "adding: mem time31, current time 162, horizon 131\n", - "adding: mem time32, current time 162, horizon 130\n", - "adding: mem time33, current time 162, horizon 129\n", - "adding: mem time34, current time 162, horizon 128\n", - "adding: mem time35, current time 162, horizon 127\n", - "adding: mem time36, current time 162, horizon 126\n", - "adding: mem time37, current time 162, horizon 125\n", - "adding: mem time38, current time 162, horizon 124\n", - "adding: mem time39, current time 162, horizon 123\n", - "adding: mem time40, current time 162, horizon 122\n", - "adding: mem time41, current time 162, horizon 121\n", - "adding: mem time42, current time 162, horizon 120\n", - "adding: mem time43, current time 162, horizon 119\n", - "adding: mem time44, current time 162, horizon 118\n", - "adding: mem time45, current time 162, horizon 117\n", - "adding: mem time46, current time 162, horizon 116\n", - "adding: mem time47, current time 162, horizon 115\n", - "adding: mem time48, current time 162, horizon 114\n", - "adding: mem time49, current time 162, horizon 113\n", - "adding: mem time50, current time 162, horizon 112\n", - "adding: mem time51, current time 162, horizon 111\n", - "adding: mem time52, current time 162, horizon 110\n", - "adding: mem time53, current time 162, horizon 109\n", - "adding: mem time54, current time 162, horizon 108\n", - "adding: mem time55, current time 162, horizon 107\n", - "adding: mem time56, current time 162, horizon 106\n", - "adding: mem time57, current time 162, horizon 105\n", - "adding: mem time58, current time 162, horizon 104\n", - "adding: mem time59, current time 162, horizon 103\n", - "adding: mem time60, current time 162, horizon 102\n", - "adding: mem time61, current time 162, horizon 101\n", - "adding: mem time62, current time 162, horizon 100\n", - "adding: mem time63, current time 162, horizon 99\n", - "adding: mem time64, current time 162, horizon 98\n", - "adding: mem time65, current time 162, horizon 97\n", - "adding: mem time66, current time 162, horizon 96\n", - "adding: mem time67, current time 162, horizon 95\n", - "adding: mem time68, current time 162, horizon 94\n", - "adding: mem time69, current time 162, horizon 93\n", - "adding: mem time70, current time 162, horizon 92\n", - "adding: mem time71, current time 162, horizon 91\n", - "adding: mem time72, current time 162, horizon 90\n", - "adding: mem time73, current time 162, horizon 89\n", - "adding: mem time74, current time 162, horizon 88\n", - "adding: mem time75, current time 162, horizon 87\n", - "adding: mem time76, current time 162, horizon 86\n", - "adding: mem time77, current time 162, horizon 85\n", - "adding: mem time78, current time 162, horizon 84\n", - "adding: mem time79, current time 162, horizon 83\n", - "adding: mem time80, current time 162, horizon 82\n", - "adding: mem time81, current time 162, horizon 81\n", - "adding: mem time82, current time 162, horizon 80\n", - "adding: mem time83, current time 162, horizon 79\n", - "adding: mem time84, current time 162, horizon 78\n", - "adding: mem time85, current time 162, horizon 77\n", - "adding: mem time86, current time 162, horizon 76\n", - "adding: mem time87, current time 162, horizon 75\n", - "adding: mem time88, current time 162, horizon 74\n", - "adding: mem time89, current time 162, horizon 73\n", - "adding: mem time90, current time 162, horizon 72\n", - "adding: mem time91, current time 162, horizon 71\n", - "adding: mem time92, current time 162, horizon 70\n", - "adding: mem time93, current time 162, horizon 69\n", - "adding: mem time94, current time 162, horizon 68\n", - "adding: mem time95, current time 162, horizon 67\n", - "adding: mem time96, current time 162, horizon 66\n", - "adding: mem time97, current time 162, horizon 65\n", - "adding: mem time98, current time 162, horizon 64\n", - "adding: mem time99, current time 162, horizon 63\n", - "adding: mem time100, current time 162, horizon 62\n", - "adding: mem time101, current time 162, horizon 61\n", - "adding: mem time102, current time 162, horizon 60\n", - "adding: mem time103, current time 162, horizon 59\n", - "adding: mem time104, current time 162, horizon 58\n", - "adding: mem time105, current time 162, horizon 57\n", - "adding: mem time106, current time 162, horizon 56\n", - "adding: mem time107, current time 162, horizon 55\n", - "adding: mem time108, current time 162, horizon 54\n", - "adding: mem time109, current time 162, horizon 53\n", - "adding: mem time110, current time 162, horizon 52\n", - "adding: mem time111, current time 162, horizon 51\n", - "adding: mem time112, current time 162, horizon 50\n", - "adding: mem time113, current time 162, horizon 49\n", - "adding: mem time114, current time 162, horizon 48\n", - "adding: mem time115, current time 162, horizon 47\n", - "adding: mem time116, current time 162, horizon 46\n", - "adding: mem time117, current time 162, horizon 45\n", - "adding: mem time118, current time 162, horizon 44\n", - "adding: mem time119, current time 162, horizon 43\n", - "adding: mem time120, current time 162, horizon 42\n", - "adding: mem time121, current time 162, horizon 41\n", - "adding: mem time122, current time 162, horizon 40\n", - "adding: mem time123, current time 162, horizon 39\n", - "adding: mem time124, current time 162, horizon 38\n", - "adding: mem time125, current time 162, horizon 37\n", - "adding: mem time126, current time 162, horizon 36\n", - "adding: mem time127, current time 162, horizon 35\n", - "adding: mem time128, current time 162, horizon 34\n", - "adding: mem time129, current time 162, horizon 33\n", - "adding: mem time130, current time 162, horizon 32\n", - "adding: mem time131, current time 162, horizon 31\n", - "adding: mem time132, current time 162, horizon 30\n", - "adding: mem time133, current time 162, horizon 29\n", - "adding: mem time134, current time 162, horizon 28\n", - "adding: mem time135, current time 162, horizon 27\n", - "adding: mem time136, current time 162, horizon 26\n", - "adding: mem time137, current time 162, horizon 25\n", - "adding: mem time138, current time 162, horizon 24\n", - "adding: mem time139, current time 162, horizon 23\n", - "adding: mem time140, current time 162, horizon 22\n", - "adding: mem time141, current time 162, horizon 21\n", - "adding: mem time142, current time 162, horizon 20\n", - "adding: mem time143, current time 162, horizon 19\n", - "adding: mem time144, current time 162, horizon 18\n", - "adding: mem time145, current time 162, horizon 17\n", - "adding: mem time146, current time 162, horizon 16\n", - "adding: mem time147, current time 162, horizon 15\n", - "adding: mem time148, current time 162, horizon 14\n", - "adding: mem time149, current time 162, horizon 13\n", - "adding: mem time150, current time 162, horizon 12\n", - "adding: mem time151, current time 162, horizon 11\n", - "adding: mem time152, current time 162, horizon 10\n", - "adding: mem time153, current time 162, horizon 9\n", - "adding: mem time154, current time 162, horizon 8\n", - "adding: mem time155, current time 162, horizon 7\n", - "adding: mem time156, current time 162, horizon 6\n", - "adding: mem time157, current time 162, horizon 5\n", - "adding: mem time158, current time 162, horizon 4\n", - "adding: mem time159, current time 162, horizon 3\n", - "adding: mem time160, current time 162, horizon 2\n", - "adding: mem time161, current time 162, horizon 1\n", - "adding: mem time0, current time 163, horizon 163\n", - "adding: mem time1, current time 163, horizon 162\n", - "adding: mem time2, current time 163, horizon 161\n", - "adding: mem time3, current time 163, horizon 160\n", - "adding: mem time4, current time 163, horizon 159\n", - "adding: mem time5, current time 163, horizon 158\n", - "adding: mem time6, current time 163, horizon 157\n", - "adding: mem time7, current time 163, horizon 156\n", - "adding: mem time8, current time 163, horizon 155\n", - "adding: mem time9, current time 163, horizon 154\n", - "adding: mem time10, current time 163, horizon 153\n", - "adding: mem time11, current time 163, horizon 152\n", - "adding: mem time12, current time 163, horizon 151\n", - "adding: mem time13, current time 163, horizon 150\n", - "adding: mem time14, current time 163, horizon 149\n", - "adding: mem time15, current time 163, horizon 148\n", - "adding: mem time16, current time 163, horizon 147\n", - "adding: mem time17, current time 163, horizon 146\n", - "adding: mem time18, current time 163, horizon 145\n", - "adding: mem time19, current time 163, horizon 144\n", - "adding: mem time20, current time 163, horizon 143\n", - "adding: mem time21, current time 163, horizon 142\n", - "adding: mem time22, current time 163, horizon 141\n", - "adding: mem time23, current time 163, horizon 140\n", - "adding: mem time24, current time 163, horizon 139\n", - "adding: mem time25, current time 163, horizon 138\n", - "adding: mem time26, current time 163, horizon 137\n", - "adding: mem time27, current time 163, horizon 136\n", - "adding: mem time28, current time 163, horizon 135\n", - "adding: mem time29, current time 163, horizon 134\n", - "adding: mem time30, current time 163, horizon 133\n", - "adding: mem time31, current time 163, horizon 132\n", - "adding: mem time32, current time 163, horizon 131\n", - "adding: mem time33, current time 163, horizon 130\n", - "adding: mem time34, current time 163, horizon 129\n", - "adding: mem time35, current time 163, horizon 128\n", - "adding: mem time36, current time 163, horizon 127\n", - "adding: mem time37, current time 163, horizon 126\n", - "adding: mem time38, current time 163, horizon 125\n", - "adding: mem time39, current time 163, horizon 124\n", - "adding: mem time40, current time 163, horizon 123\n", - "adding: mem time41, current time 163, horizon 122\n", - "adding: mem time42, current time 163, horizon 121\n", - "adding: mem time43, current time 163, horizon 120\n", - "adding: mem time44, current time 163, horizon 119\n", - "adding: mem time45, current time 163, horizon 118\n", - "adding: mem time46, current time 163, horizon 117\n", - "adding: mem time47, current time 163, horizon 116\n", - "adding: mem time48, current time 163, horizon 115\n", - "adding: mem time49, current time 163, horizon 114\n", - "adding: mem time50, current time 163, horizon 113\n", - "adding: mem time51, current time 163, horizon 112\n", - "adding: mem time52, current time 163, horizon 111\n", - "adding: mem time53, current time 163, horizon 110\n", - "adding: mem time54, current time 163, horizon 109\n", - "adding: mem time55, current time 163, horizon 108\n", - "adding: mem time56, current time 163, horizon 107\n", - "adding: mem time57, current time 163, horizon 106\n", - "adding: mem time58, current time 163, horizon 105\n", - "adding: mem time59, current time 163, horizon 104\n", - "adding: mem time60, current time 163, horizon 103\n", - "adding: mem time61, current time 163, horizon 102\n", - "adding: mem time62, current time 163, horizon 101\n", - "adding: mem time63, current time 163, horizon 100\n", - "adding: mem time64, current time 163, horizon 99\n", - "adding: mem time65, current time 163, horizon 98\n", - "adding: mem time66, current time 163, horizon 97\n", - "adding: mem time67, current time 163, horizon 96\n", - "adding: mem time68, current time 163, horizon 95\n", - "adding: mem time69, current time 163, horizon 94\n", - "adding: mem time70, current time 163, horizon 93\n", - "adding: mem time71, current time 163, horizon 92\n", - "adding: mem time72, current time 163, horizon 91\n", - "adding: mem time73, current time 163, horizon 90\n", - "adding: mem time74, current time 163, horizon 89\n", - "adding: mem time75, current time 163, horizon 88\n", - "adding: mem time76, current time 163, horizon 87\n", - "adding: mem time77, current time 163, horizon 86\n", - "adding: mem time78, current time 163, horizon 85\n", - "adding: mem time79, current time 163, horizon 84\n", - "adding: mem time80, current time 163, horizon 83\n", - "adding: mem time81, current time 163, horizon 82\n", - "adding: mem time82, current time 163, horizon 81\n", - "adding: mem time83, current time 163, horizon 80\n", - "adding: mem time84, current time 163, horizon 79\n", - "adding: mem time85, current time 163, horizon 78\n", - "adding: mem time86, current time 163, horizon 77\n", - "adding: mem time87, current time 163, horizon 76\n", - "adding: mem time88, current time 163, horizon 75\n", - "adding: mem time89, current time 163, horizon 74\n", - "adding: mem time90, current time 163, horizon 73\n", - "adding: mem time91, current time 163, horizon 72\n", - "adding: mem time92, current time 163, horizon 71\n", - "adding: mem time93, current time 163, horizon 70\n", - "adding: mem time94, current time 163, horizon 69\n", - "adding: mem time95, current time 163, horizon 68\n", - "adding: mem time96, current time 163, horizon 67\n", - "adding: mem time97, current time 163, horizon 66\n", - "adding: mem time98, current time 163, horizon 65\n", - "adding: mem time99, current time 163, horizon 64\n", - "adding: mem time100, current time 163, horizon 63\n", - "adding: mem time101, current time 163, horizon 62\n", - "adding: mem time102, current time 163, horizon 61\n", - "adding: mem time103, current time 163, horizon 60\n", - "adding: mem time104, current time 163, horizon 59\n", - "adding: mem time105, current time 163, horizon 58\n", - "adding: mem time106, current time 163, horizon 57\n", - "adding: mem time107, current time 163, horizon 56\n", - "adding: mem time108, current time 163, horizon 55\n", - "adding: mem time109, current time 163, horizon 54\n", - "adding: mem time110, current time 163, horizon 53\n", - "adding: mem time111, current time 163, horizon 52\n", - "adding: mem time112, current time 163, horizon 51\n", - "adding: mem time113, current time 163, horizon 50\n", - "adding: mem time114, current time 163, horizon 49\n", - "adding: mem time115, current time 163, horizon 48\n", - "adding: mem time116, current time 163, horizon 47\n", - "adding: mem time117, current time 163, horizon 46\n", - "adding: mem time118, current time 163, horizon 45\n", - "adding: mem time119, current time 163, horizon 44\n", - "adding: mem time120, current time 163, horizon 43\n", - "adding: mem time121, current time 163, horizon 42\n", - "adding: mem time122, current time 163, horizon 41\n", - "adding: mem time123, current time 163, horizon 40\n", - "adding: mem time124, current time 163, horizon 39\n", - "adding: mem time125, current time 163, horizon 38\n", - "adding: mem time126, current time 163, horizon 37\n", - "adding: mem time127, current time 163, horizon 36\n", - "adding: mem time128, current time 163, horizon 35\n", - "adding: mem time129, current time 163, horizon 34\n", - "adding: mem time130, current time 163, horizon 33\n", - "adding: mem time131, current time 163, horizon 32\n", - "adding: mem time132, current time 163, horizon 31\n", - "adding: mem time133, current time 163, horizon 30\n", - "adding: mem time134, current time 163, horizon 29\n", - "adding: mem time135, current time 163, horizon 28\n", - "adding: mem time136, current time 163, horizon 27\n", - "adding: mem time137, current time 163, horizon 26\n", - "adding: mem time138, current time 163, horizon 25\n", - "adding: mem time139, current time 163, horizon 24\n", - "adding: mem time140, current time 163, horizon 23\n", - "adding: mem time141, current time 163, horizon 22\n", - "adding: mem time142, current time 163, horizon 21\n", - "adding: mem time143, current time 163, horizon 20\n", - "adding: mem time144, current time 163, horizon 19\n", - "adding: mem time145, current time 163, horizon 18\n", - "adding: mem time146, current time 163, horizon 17\n", - "adding: mem time147, current time 163, horizon 16\n", - "adding: mem time148, current time 163, horizon 15\n", - "adding: mem time149, current time 163, horizon 14\n", - "adding: mem time150, current time 163, horizon 13\n", - "adding: mem time151, current time 163, horizon 12\n", - "adding: mem time152, current time 163, horizon 11\n", - "adding: mem time153, current time 163, horizon 10\n", - "adding: mem time154, current time 163, horizon 9\n", - "adding: mem time155, current time 163, horizon 8\n", - "adding: mem time156, current time 163, horizon 7\n", - "adding: mem time157, current time 163, horizon 6\n", - "adding: mem time158, current time 163, horizon 5\n", - "adding: mem time159, current time 163, horizon 4\n", - "adding: mem time160, current time 163, horizon 3\n", - "adding: mem time161, current time 163, horizon 2\n", - "adding: mem time162, current time 163, horizon 1\n", - "adding: mem time0, current time 164, horizon 164\n", - "adding: mem time1, current time 164, horizon 163\n", - "adding: mem time2, current time 164, horizon 162\n", - "adding: mem time3, current time 164, horizon 161\n", - "adding: mem time4, current time 164, horizon 160\n", - "adding: mem time5, current time 164, horizon 159\n", - "adding: mem time6, current time 164, horizon 158\n", - "adding: mem time7, current time 164, horizon 157\n", - "adding: mem time8, current time 164, horizon 156\n", - "adding: mem time9, current time 164, horizon 155\n", - "adding: mem time10, current time 164, horizon 154\n", - "adding: mem time11, current time 164, horizon 153\n", - "adding: mem time12, current time 164, horizon 152\n", - "adding: mem time13, current time 164, horizon 151\n", - "adding: mem time14, current time 164, horizon 150\n", - "adding: mem time15, current time 164, horizon 149\n", - "adding: mem time16, current time 164, horizon 148\n", - "adding: mem time17, current time 164, horizon 147\n", - "adding: mem time18, current time 164, horizon 146\n", - "adding: mem time19, current time 164, horizon 145\n", - "adding: mem time20, current time 164, horizon 144\n", - "adding: mem time21, current time 164, horizon 143\n", - "adding: mem time22, current time 164, horizon 142\n", - "adding: mem time23, current time 164, horizon 141\n", - "adding: mem time24, current time 164, horizon 140\n", - "adding: mem time25, current time 164, horizon 139\n", - "adding: mem time26, current time 164, horizon 138\n", - "adding: mem time27, current time 164, horizon 137\n", - "adding: mem time28, current time 164, horizon 136\n", - "adding: mem time29, current time 164, horizon 135\n", - "adding: mem time30, current time 164, horizon 134\n", - "adding: mem time31, current time 164, horizon 133\n", - "adding: mem time32, current time 164, horizon 132\n", - "adding: mem time33, current time 164, horizon 131\n", - "adding: mem time34, current time 164, horizon 130\n", - "adding: mem time35, current time 164, horizon 129\n", - "adding: mem time36, current time 164, horizon 128\n", - "adding: mem time37, current time 164, horizon 127\n", - "adding: mem time38, current time 164, horizon 126\n", - "adding: mem time39, current time 164, horizon 125\n", - "adding: mem time40, current time 164, horizon 124\n", - "adding: mem time41, current time 164, horizon 123\n", - "adding: mem time42, current time 164, horizon 122\n", - "adding: mem time43, current time 164, horizon 121\n", - "adding: mem time44, current time 164, horizon 120\n", - "adding: mem time45, current time 164, horizon 119\n", - "adding: mem time46, current time 164, horizon 118\n", - "adding: mem time47, current time 164, horizon 117\n", - "adding: mem time48, current time 164, horizon 116\n", - "adding: mem time49, current time 164, horizon 115\n", - "adding: mem time50, current time 164, horizon 114\n", - "adding: mem time51, current time 164, horizon 113\n", - "adding: mem time52, current time 164, horizon 112\n", - "adding: mem time53, current time 164, horizon 111\n", - "adding: mem time54, current time 164, horizon 110\n", - "adding: mem time55, current time 164, horizon 109\n", - "adding: mem time56, current time 164, horizon 108\n", - "adding: mem time57, current time 164, horizon 107\n", - "adding: mem time58, current time 164, horizon 106\n", - "adding: mem time59, current time 164, horizon 105\n", - "adding: mem time60, current time 164, horizon 104\n", - "adding: mem time61, current time 164, horizon 103\n", - "adding: mem time62, current time 164, horizon 102\n", - "adding: mem time63, current time 164, horizon 101\n", - "adding: mem time64, current time 164, horizon 100\n", - "adding: mem time65, current time 164, horizon 99\n", - "adding: mem time66, current time 164, horizon 98\n", - "adding: mem time67, current time 164, horizon 97\n", - "adding: mem time68, current time 164, horizon 96\n", - "adding: mem time69, current time 164, horizon 95\n", - "adding: mem time70, current time 164, horizon 94\n", - "adding: mem time71, current time 164, horizon 93\n", - "adding: mem time72, current time 164, horizon 92\n", - "adding: mem time73, current time 164, horizon 91\n", - "adding: mem time74, current time 164, horizon 90\n", - "adding: mem time75, current time 164, horizon 89\n", - "adding: mem time76, current time 164, horizon 88\n", - "adding: mem time77, current time 164, horizon 87\n", - "adding: mem time78, current time 164, horizon 86\n", - "adding: mem time79, current time 164, horizon 85\n", - "adding: mem time80, current time 164, horizon 84\n", - "adding: mem time81, current time 164, horizon 83\n", - "adding: mem time82, current time 164, horizon 82\n", - "adding: mem time83, current time 164, horizon 81\n", - "adding: mem time84, current time 164, horizon 80\n", - "adding: mem time85, current time 164, horizon 79\n", - "adding: mem time86, current time 164, horizon 78\n", - "adding: mem time87, current time 164, horizon 77\n", - "adding: mem time88, current time 164, horizon 76\n", - "adding: mem time89, current time 164, horizon 75\n", - "adding: mem time90, current time 164, horizon 74\n", - "adding: mem time91, current time 164, horizon 73\n", - "adding: mem time92, current time 164, horizon 72\n", - "adding: mem time93, current time 164, horizon 71\n", - "adding: mem time94, current time 164, horizon 70\n", - "adding: mem time95, current time 164, horizon 69\n", - "adding: mem time96, current time 164, horizon 68\n", - "adding: mem time97, current time 164, horizon 67\n", - "adding: mem time98, current time 164, horizon 66\n", - "adding: mem time99, current time 164, horizon 65\n", - "adding: mem time100, current time 164, horizon 64\n", - "adding: mem time101, current time 164, horizon 63\n", - "adding: mem time102, current time 164, horizon 62\n", - "adding: mem time103, current time 164, horizon 61\n", - "adding: mem time104, current time 164, horizon 60\n", - "adding: mem time105, current time 164, horizon 59\n", - "adding: mem time106, current time 164, horizon 58\n", - "adding: mem time107, current time 164, horizon 57\n", - "adding: mem time108, current time 164, horizon 56\n", - "adding: mem time109, current time 164, horizon 55\n", - "adding: mem time110, current time 164, horizon 54\n", - "adding: mem time111, current time 164, horizon 53\n", - "adding: mem time112, current time 164, horizon 52\n", - "adding: mem time113, current time 164, horizon 51\n", - "adding: mem time114, current time 164, horizon 50\n", - "adding: mem time115, current time 164, horizon 49\n", - "adding: mem time116, current time 164, horizon 48\n", - "adding: mem time117, current time 164, horizon 47\n", - "adding: mem time118, current time 164, horizon 46\n", - "adding: mem time119, current time 164, horizon 45\n", - "adding: mem time120, current time 164, horizon 44\n", - "adding: mem time121, current time 164, horizon 43\n", - "adding: mem time122, current time 164, horizon 42\n", - "adding: mem time123, current time 164, horizon 41\n", - "adding: mem time124, current time 164, horizon 40\n", - "adding: mem time125, current time 164, horizon 39\n", - "adding: mem time126, current time 164, horizon 38\n", - "adding: mem time127, current time 164, horizon 37\n", - "adding: mem time128, current time 164, horizon 36\n", - "adding: mem time129, current time 164, horizon 35\n", - "adding: mem time130, current time 164, horizon 34\n", - "adding: mem time131, current time 164, horizon 33\n", - "adding: mem time132, current time 164, horizon 32\n", - "adding: mem time133, current time 164, horizon 31\n", - "adding: mem time134, current time 164, horizon 30\n", - "adding: mem time135, current time 164, horizon 29\n", - "adding: mem time136, current time 164, horizon 28\n", - "adding: mem time137, current time 164, horizon 27\n", - "adding: mem time138, current time 164, horizon 26\n", - "adding: mem time139, current time 164, horizon 25\n", - "adding: mem time140, current time 164, horizon 24\n", - "adding: mem time141, current time 164, horizon 23\n", - "adding: mem time142, current time 164, horizon 22\n", - "adding: mem time143, current time 164, horizon 21\n", - "adding: mem time144, current time 164, horizon 20\n", - "adding: mem time145, current time 164, horizon 19\n", - "adding: mem time146, current time 164, horizon 18\n", - "adding: mem time147, current time 164, horizon 17\n", - "adding: mem time148, current time 164, horizon 16\n", - "adding: mem time149, current time 164, horizon 15\n", - "adding: mem time150, current time 164, horizon 14\n", - "adding: mem time151, current time 164, horizon 13\n", - "adding: mem time152, current time 164, horizon 12\n", - "adding: mem time153, current time 164, horizon 11\n", - "adding: mem time154, current time 164, horizon 10\n", - "adding: mem time155, current time 164, horizon 9\n", - "adding: mem time156, current time 164, horizon 8\n", - "adding: mem time157, current time 164, horizon 7\n", - "adding: mem time158, current time 164, horizon 6\n", - "adding: mem time159, current time 164, horizon 5\n", - "adding: mem time160, current time 164, horizon 4\n", - "adding: mem time161, current time 164, horizon 3\n", - "adding: mem time162, current time 164, horizon 2\n", - "adding: mem time163, current time 164, horizon 1\n", - "adding: mem time0, current time 165, horizon 165\n", - "adding: mem time1, current time 165, horizon 164\n", - "adding: mem time2, current time 165, horizon 163\n", - "adding: mem time3, current time 165, horizon 162\n", - "adding: mem time4, current time 165, horizon 161\n", - "adding: mem time5, current time 165, horizon 160\n", - "adding: mem time6, current time 165, horizon 159\n", - "adding: mem time7, current time 165, horizon 158\n", - "adding: mem time8, current time 165, horizon 157\n", - "adding: mem time9, current time 165, horizon 156\n", - "adding: mem time10, current time 165, horizon 155\n", - "adding: mem time11, current time 165, horizon 154\n", - "adding: mem time12, current time 165, horizon 153\n", - "adding: mem time13, current time 165, horizon 152\n", - "adding: mem time14, current time 165, horizon 151\n", - "adding: mem time15, current time 165, horizon 150\n", - "adding: mem time16, current time 165, horizon 149\n", - "adding: mem time17, current time 165, horizon 148\n", - "adding: mem time18, current time 165, horizon 147\n", - "adding: mem time19, current time 165, horizon 146\n", - "adding: mem time20, current time 165, horizon 145\n", - "adding: mem time21, current time 165, horizon 144\n", - "adding: mem time22, current time 165, horizon 143\n", - "adding: mem time23, current time 165, horizon 142\n", - "adding: mem time24, current time 165, horizon 141\n", - "adding: mem time25, current time 165, horizon 140\n", - "adding: mem time26, current time 165, horizon 139\n", - "adding: mem time27, current time 165, horizon 138\n", - "adding: mem time28, current time 165, horizon 137\n", - "adding: mem time29, current time 165, horizon 136\n", - "adding: mem time30, current time 165, horizon 135\n", - "adding: mem time31, current time 165, horizon 134\n", - "adding: mem time32, current time 165, horizon 133\n", - "adding: mem time33, current time 165, horizon 132\n", - "adding: mem time34, current time 165, horizon 131\n", - "adding: mem time35, current time 165, horizon 130\n", - "adding: mem time36, current time 165, horizon 129\n", - "adding: mem time37, current time 165, horizon 128\n", - "adding: mem time38, current time 165, horizon 127\n", - "adding: mem time39, current time 165, horizon 126\n", - "adding: mem time40, current time 165, horizon 125\n", - "adding: mem time41, current time 165, horizon 124\n", - "adding: mem time42, current time 165, horizon 123\n", - "adding: mem time43, current time 165, horizon 122\n", - "adding: mem time44, current time 165, horizon 121\n", - "adding: mem time45, current time 165, horizon 120\n", - "adding: mem time46, current time 165, horizon 119\n", - "adding: mem time47, current time 165, horizon 118\n", - "adding: mem time48, current time 165, horizon 117\n", - "adding: mem time49, current time 165, horizon 116\n", - "adding: mem time50, current time 165, horizon 115\n", - "adding: mem time51, current time 165, horizon 114\n", - "adding: mem time52, current time 165, horizon 113\n", - "adding: mem time53, current time 165, horizon 112\n", - "adding: mem time54, current time 165, horizon 111\n", - "adding: mem time55, current time 165, horizon 110\n", - "adding: mem time56, current time 165, horizon 109\n", - "adding: mem time57, current time 165, horizon 108\n", - "adding: mem time58, current time 165, horizon 107\n", - "adding: mem time59, current time 165, horizon 106\n", - "adding: mem time60, current time 165, horizon 105\n", - "adding: mem time61, current time 165, horizon 104\n", - "adding: mem time62, current time 165, horizon 103\n", - "adding: mem time63, current time 165, horizon 102\n", - "adding: mem time64, current time 165, horizon 101\n", - "adding: mem time65, current time 165, horizon 100\n", - "adding: mem time66, current time 165, horizon 99\n", - "adding: mem time67, current time 165, horizon 98\n", - "adding: mem time68, current time 165, horizon 97\n", - "adding: mem time69, current time 165, horizon 96\n", - "adding: mem time70, current time 165, horizon 95\n", - "adding: mem time71, current time 165, horizon 94\n", - "adding: mem time72, current time 165, horizon 93\n", - "adding: mem time73, current time 165, horizon 92\n", - "adding: mem time74, current time 165, horizon 91\n", - "adding: mem time75, current time 165, horizon 90\n", - "adding: mem time76, current time 165, horizon 89\n", - "adding: mem time77, current time 165, horizon 88\n", - "adding: mem time78, current time 165, horizon 87\n", - "adding: mem time79, current time 165, horizon 86\n", - "adding: mem time80, current time 165, horizon 85\n", - "adding: mem time81, current time 165, horizon 84\n", - "adding: mem time82, current time 165, horizon 83\n", - "adding: mem time83, current time 165, horizon 82\n", - "adding: mem time84, current time 165, horizon 81\n", - "adding: mem time85, current time 165, horizon 80\n", - "adding: mem time86, current time 165, horizon 79\n", - "adding: mem time87, current time 165, horizon 78\n", - "adding: mem time88, current time 165, horizon 77\n", - "adding: mem time89, current time 165, horizon 76\n", - "adding: mem time90, current time 165, horizon 75\n", - "adding: mem time91, current time 165, horizon 74\n", - "adding: mem time92, current time 165, horizon 73\n", - "adding: mem time93, current time 165, horizon 72\n", - "adding: mem time94, current time 165, horizon 71\n", - "adding: mem time95, current time 165, horizon 70\n", - "adding: mem time96, current time 165, horizon 69\n", - "adding: mem time97, current time 165, horizon 68\n", - "adding: mem time98, current time 165, horizon 67\n", - "adding: mem time99, current time 165, horizon 66\n", - "adding: mem time100, current time 165, horizon 65\n", - "adding: mem time101, current time 165, horizon 64\n", - "adding: mem time102, current time 165, horizon 63\n", - "adding: mem time103, current time 165, horizon 62\n", - "adding: mem time104, current time 165, horizon 61\n", - "adding: mem time105, current time 165, horizon 60\n", - "adding: mem time106, current time 165, horizon 59\n", - "adding: mem time107, current time 165, horizon 58\n", - "adding: mem time108, current time 165, horizon 57\n", - "adding: mem time109, current time 165, horizon 56\n", - "adding: mem time110, current time 165, horizon 55\n", - "adding: mem time111, current time 165, horizon 54\n", - "adding: mem time112, current time 165, horizon 53\n", - "adding: mem time113, current time 165, horizon 52\n", - "adding: mem time114, current time 165, horizon 51\n", - "adding: mem time115, current time 165, horizon 50\n", - "adding: mem time116, current time 165, horizon 49\n", - "adding: mem time117, current time 165, horizon 48\n", - "adding: mem time118, current time 165, horizon 47\n", - "adding: mem time119, current time 165, horizon 46\n", - "adding: mem time120, current time 165, horizon 45\n", - "adding: mem time121, current time 165, horizon 44\n", - "adding: mem time122, current time 165, horizon 43\n", - "adding: mem time123, current time 165, horizon 42\n", - "adding: mem time124, current time 165, horizon 41\n", - "adding: mem time125, current time 165, horizon 40\n", - "adding: mem time126, current time 165, horizon 39\n", - "adding: mem time127, current time 165, horizon 38\n", - "adding: mem time128, current time 165, horizon 37\n", - "adding: mem time129, current time 165, horizon 36\n", - "adding: mem time130, current time 165, horizon 35\n", - "adding: mem time131, current time 165, horizon 34\n", - "adding: mem time132, current time 165, horizon 33\n", - "adding: mem time133, current time 165, horizon 32\n", - "adding: mem time134, current time 165, horizon 31\n", - "adding: mem time135, current time 165, horizon 30\n", - "adding: mem time136, current time 165, horizon 29\n", - "adding: mem time137, current time 165, horizon 28\n", - "adding: mem time138, current time 165, horizon 27\n", - "adding: mem time139, current time 165, horizon 26\n", - "adding: mem time140, current time 165, horizon 25\n", - "adding: mem time141, current time 165, horizon 24\n", - "adding: mem time142, current time 165, horizon 23\n", - "adding: mem time143, current time 165, horizon 22\n", - "adding: mem time144, current time 165, horizon 21\n", - "adding: mem time145, current time 165, horizon 20\n", - "adding: mem time146, current time 165, horizon 19\n", - "adding: mem time147, current time 165, horizon 18\n", - "adding: mem time148, current time 165, horizon 17\n", - "adding: mem time149, current time 165, horizon 16\n", - "adding: mem time150, current time 165, horizon 15\n", - "adding: mem time151, current time 165, horizon 14\n", - "adding: mem time152, current time 165, horizon 13\n", - "adding: mem time153, current time 165, horizon 12\n", - "adding: mem time154, current time 165, horizon 11\n", - "adding: mem time155, current time 165, horizon 10\n", - "adding: mem time156, current time 165, horizon 9\n", - "adding: mem time157, current time 165, horizon 8\n", - "adding: mem time158, current time 165, horizon 7\n", - "adding: mem time159, current time 165, horizon 6\n", - "adding: mem time160, current time 165, horizon 5\n", - "adding: mem time161, current time 165, horizon 4\n", - "adding: mem time162, current time 165, horizon 3\n", - "adding: mem time163, current time 165, horizon 2\n", - "adding: mem time164, current time 165, horizon 1\n", - "adding: mem time0, current time 166, horizon 166\n", - "adding: mem time1, current time 166, horizon 165\n", - "adding: mem time2, current time 166, horizon 164\n", - "adding: mem time3, current time 166, horizon 163\n", - "adding: mem time4, current time 166, horizon 162\n", - "adding: mem time5, current time 166, horizon 161\n", - "adding: mem time6, current time 166, horizon 160\n", - "adding: mem time7, current time 166, horizon 159\n", - "adding: mem time8, current time 166, horizon 158\n", - "adding: mem time9, current time 166, horizon 157\n", - "adding: mem time10, current time 166, horizon 156\n", - "adding: mem time11, current time 166, horizon 155\n", - "adding: mem time12, current time 166, horizon 154\n", - "adding: mem time13, current time 166, horizon 153\n", - "adding: mem time14, current time 166, horizon 152\n", - "adding: mem time15, current time 166, horizon 151\n", - "adding: mem time16, current time 166, horizon 150\n", - "adding: mem time17, current time 166, horizon 149\n", - "adding: mem time18, current time 166, horizon 148\n", - "adding: mem time19, current time 166, horizon 147\n", - "adding: mem time20, current time 166, horizon 146\n", - "adding: mem time21, current time 166, horizon 145\n", - "adding: mem time22, current time 166, horizon 144\n", - "adding: mem time23, current time 166, horizon 143\n", - "adding: mem time24, current time 166, horizon 142\n", - "adding: mem time25, current time 166, horizon 141\n", - "adding: mem time26, current time 166, horizon 140\n", - "adding: mem time27, current time 166, horizon 139\n", - "adding: mem time28, current time 166, horizon 138\n", - "adding: mem time29, current time 166, horizon 137\n", - "adding: mem time30, current time 166, horizon 136\n", - "adding: mem time31, current time 166, horizon 135\n", - "adding: mem time32, current time 166, horizon 134\n", - "adding: mem time33, current time 166, horizon 133\n", - "adding: mem time34, current time 166, horizon 132\n", - "adding: mem time35, current time 166, horizon 131\n", - "adding: mem time36, current time 166, horizon 130\n", - "adding: mem time37, current time 166, horizon 129\n", - "adding: mem time38, current time 166, horizon 128\n", - "adding: mem time39, current time 166, horizon 127\n", - "adding: mem time40, current time 166, horizon 126\n", - "adding: mem time41, current time 166, horizon 125\n", - "adding: mem time42, current time 166, horizon 124\n", - "adding: mem time43, current time 166, horizon 123\n", - "adding: mem time44, current time 166, horizon 122\n", - "adding: mem time45, current time 166, horizon 121\n", - "adding: mem time46, current time 166, horizon 120\n", - "adding: mem time47, current time 166, horizon 119\n", - "adding: mem time48, current time 166, horizon 118\n", - "adding: mem time49, current time 166, horizon 117\n", - "adding: mem time50, current time 166, horizon 116\n", - "adding: mem time51, current time 166, horizon 115\n", - "adding: mem time52, current time 166, horizon 114\n", - "adding: mem time53, current time 166, horizon 113\n", - "adding: mem time54, current time 166, horizon 112\n", - "adding: mem time55, current time 166, horizon 111\n", - "adding: mem time56, current time 166, horizon 110\n", - "adding: mem time57, current time 166, horizon 109\n", - "adding: mem time58, current time 166, horizon 108\n", - "adding: mem time59, current time 166, horizon 107\n", - "adding: mem time60, current time 166, horizon 106\n", - "adding: mem time61, current time 166, horizon 105\n", - "adding: mem time62, current time 166, horizon 104\n", - "adding: mem time63, current time 166, horizon 103\n", - "adding: mem time64, current time 166, horizon 102\n", - "adding: mem time65, current time 166, horizon 101\n", - "adding: mem time66, current time 166, horizon 100\n", - "adding: mem time67, current time 166, horizon 99\n", - "adding: mem time68, current time 166, horizon 98\n", - "adding: mem time69, current time 166, horizon 97\n", - "adding: mem time70, current time 166, horizon 96\n", - "adding: mem time71, current time 166, horizon 95\n", - "adding: mem time72, current time 166, horizon 94\n", - "adding: mem time73, current time 166, horizon 93\n", - "adding: mem time74, current time 166, horizon 92\n", - "adding: mem time75, current time 166, horizon 91\n", - "adding: mem time76, current time 166, horizon 90\n", - "adding: mem time77, current time 166, horizon 89\n", - "adding: mem time78, current time 166, horizon 88\n", - "adding: mem time79, current time 166, horizon 87\n", - "adding: mem time80, current time 166, horizon 86\n", - "adding: mem time81, current time 166, horizon 85\n", - "adding: mem time82, current time 166, horizon 84\n", - "adding: mem time83, current time 166, horizon 83\n", - "adding: mem time84, current time 166, horizon 82\n", - "adding: mem time85, current time 166, horizon 81\n", - "adding: mem time86, current time 166, horizon 80\n", - "adding: mem time87, current time 166, horizon 79\n", - "adding: mem time88, current time 166, horizon 78\n", - "adding: mem time89, current time 166, horizon 77\n", - "adding: mem time90, current time 166, horizon 76\n", - "adding: mem time91, current time 166, horizon 75\n", - "adding: mem time92, current time 166, horizon 74\n", - "adding: mem time93, current time 166, horizon 73\n", - "adding: mem time94, current time 166, horizon 72\n", - "adding: mem time95, current time 166, horizon 71\n", - "adding: mem time96, current time 166, horizon 70\n", - "adding: mem time97, current time 166, horizon 69\n", - "adding: mem time98, current time 166, horizon 68\n", - "adding: mem time99, current time 166, horizon 67\n", - "adding: mem time100, current time 166, horizon 66\n", - "adding: mem time101, current time 166, horizon 65\n", - "adding: mem time102, current time 166, horizon 64\n", - "adding: mem time103, current time 166, horizon 63\n", - "adding: mem time104, current time 166, horizon 62\n", - "adding: mem time105, current time 166, horizon 61\n", - "adding: mem time106, current time 166, horizon 60\n", - "adding: mem time107, current time 166, horizon 59\n", - "adding: mem time108, current time 166, horizon 58\n", - "adding: mem time109, current time 166, horizon 57\n", - "adding: mem time110, current time 166, horizon 56\n", - "adding: mem time111, current time 166, horizon 55\n", - "adding: mem time112, current time 166, horizon 54\n", - "adding: mem time113, current time 166, horizon 53\n", - "adding: mem time114, current time 166, horizon 52\n", - "adding: mem time115, current time 166, horizon 51\n", - "adding: mem time116, current time 166, horizon 50\n", - "adding: mem time117, current time 166, horizon 49\n", - "adding: mem time118, current time 166, horizon 48\n", - "adding: mem time119, current time 166, horizon 47\n", - "adding: mem time120, current time 166, horizon 46\n", - "adding: mem time121, current time 166, horizon 45\n", - "adding: mem time122, current time 166, horizon 44\n", - "adding: mem time123, current time 166, horizon 43\n", - "adding: mem time124, current time 166, horizon 42\n", - "adding: mem time125, current time 166, horizon 41\n", - "adding: mem time126, current time 166, horizon 40\n", - "adding: mem time127, current time 166, horizon 39\n", - "adding: mem time128, current time 166, horizon 38\n", - "adding: mem time129, current time 166, horizon 37\n", - "adding: mem time130, current time 166, horizon 36\n", - "adding: mem time131, current time 166, horizon 35\n", - "adding: mem time132, current time 166, horizon 34\n", - "adding: mem time133, current time 166, horizon 33\n", - "adding: mem time134, current time 166, horizon 32\n", - "adding: mem time135, current time 166, horizon 31\n", - "adding: mem time136, current time 166, horizon 30\n", - "adding: mem time137, current time 166, horizon 29\n", - "adding: mem time138, current time 166, horizon 28\n", - "adding: mem time139, current time 166, horizon 27\n", - "adding: mem time140, current time 166, horizon 26\n", - "adding: mem time141, current time 166, horizon 25\n", - "adding: mem time142, current time 166, horizon 24\n", - "adding: mem time143, current time 166, horizon 23\n", - "adding: mem time144, current time 166, horizon 22\n", - "adding: mem time145, current time 166, horizon 21\n", - "adding: mem time146, current time 166, horizon 20\n", - "adding: mem time147, current time 166, horizon 19\n", - "adding: mem time148, current time 166, horizon 18\n", - "adding: mem time149, current time 166, horizon 17\n", - "adding: mem time150, current time 166, horizon 16\n", - "adding: mem time151, current time 166, horizon 15\n", - "adding: mem time152, current time 166, horizon 14\n", - "adding: mem time153, current time 166, horizon 13\n", - "adding: mem time154, current time 166, horizon 12\n", - "adding: mem time155, current time 166, horizon 11\n", - "adding: mem time156, current time 166, horizon 10\n", - "adding: mem time157, current time 166, horizon 9\n", - "adding: mem time158, current time 166, horizon 8\n", - "adding: mem time159, current time 166, horizon 7\n", - "adding: mem time160, current time 166, horizon 6\n", - "adding: mem time161, current time 166, horizon 5\n", - "adding: mem time162, current time 166, horizon 4\n", - "adding: mem time163, current time 166, horizon 3\n", - "adding: mem time164, current time 166, horizon 2\n", - "adding: mem time165, current time 166, horizon 1\n", - "adding: mem time0, current time 167, horizon 167\n", - "adding: mem time1, current time 167, horizon 166\n", - "adding: mem time2, current time 167, horizon 165\n", - "adding: mem time3, current time 167, horizon 164\n", - "adding: mem time4, current time 167, horizon 163\n", - "adding: mem time5, current time 167, horizon 162\n", - "adding: mem time6, current time 167, horizon 161\n", - "adding: mem time7, current time 167, horizon 160\n", - "adding: mem time8, current time 167, horizon 159\n", - "adding: mem time9, current time 167, horizon 158\n", - "adding: mem time10, current time 167, horizon 157\n", - "adding: mem time11, current time 167, horizon 156\n", - "adding: mem time12, current time 167, horizon 155\n", - "adding: mem time13, current time 167, horizon 154\n", - "adding: mem time14, current time 167, horizon 153\n", - "adding: mem time15, current time 167, horizon 152\n", - "adding: mem time16, current time 167, horizon 151\n", - "adding: mem time17, current time 167, horizon 150\n", - "adding: mem time18, current time 167, horizon 149\n", - "adding: mem time19, current time 167, horizon 148\n", - "adding: mem time20, current time 167, horizon 147\n", - "adding: mem time21, current time 167, horizon 146\n", - "adding: mem time22, current time 167, horizon 145\n", - "adding: mem time23, current time 167, horizon 144\n", - "adding: mem time24, current time 167, horizon 143\n", - "adding: mem time25, current time 167, horizon 142\n", - "adding: mem time26, current time 167, horizon 141\n", - "adding: mem time27, current time 167, horizon 140\n", - "adding: mem time28, current time 167, horizon 139\n", - "adding: mem time29, current time 167, horizon 138\n", - "adding: mem time30, current time 167, horizon 137\n", - "adding: mem time31, current time 167, horizon 136\n", - "adding: mem time32, current time 167, horizon 135\n", - "adding: mem time33, current time 167, horizon 134\n", - "adding: mem time34, current time 167, horizon 133\n", - "adding: mem time35, current time 167, horizon 132\n", - "adding: mem time36, current time 167, horizon 131\n", - "adding: mem time37, current time 167, horizon 130\n", - "adding: mem time38, current time 167, horizon 129\n", - "adding: mem time39, current time 167, horizon 128\n", - "adding: mem time40, current time 167, horizon 127\n", - "adding: mem time41, current time 167, horizon 126\n", - "adding: mem time42, current time 167, horizon 125\n", - "adding: mem time43, current time 167, horizon 124\n", - "adding: mem time44, current time 167, horizon 123\n", - "adding: mem time45, current time 167, horizon 122\n", - "adding: mem time46, current time 167, horizon 121\n", - "adding: mem time47, current time 167, horizon 120\n", - "adding: mem time48, current time 167, horizon 119\n", - "adding: mem time49, current time 167, horizon 118\n", - "adding: mem time50, current time 167, horizon 117\n", - "adding: mem time51, current time 167, horizon 116\n", - "adding: mem time52, current time 167, horizon 115\n", - "adding: mem time53, current time 167, horizon 114\n", - "adding: mem time54, current time 167, horizon 113\n", - "adding: mem time55, current time 167, horizon 112\n", - "adding: mem time56, current time 167, horizon 111\n", - "adding: mem time57, current time 167, horizon 110\n", - "adding: mem time58, current time 167, horizon 109\n", - "adding: mem time59, current time 167, horizon 108\n", - "adding: mem time60, current time 167, horizon 107\n", - "adding: mem time61, current time 167, horizon 106\n", - "adding: mem time62, current time 167, horizon 105\n", - "adding: mem time63, current time 167, horizon 104\n", - "adding: mem time64, current time 167, horizon 103\n", - "adding: mem time65, current time 167, horizon 102\n", - "adding: mem time66, current time 167, horizon 101\n", - "adding: mem time67, current time 167, horizon 100\n", - "adding: mem time68, current time 167, horizon 99\n", - "adding: mem time69, current time 167, horizon 98\n", - "adding: mem time70, current time 167, horizon 97\n", - "adding: mem time71, current time 167, horizon 96\n", - "adding: mem time72, current time 167, horizon 95\n", - "adding: mem time73, current time 167, horizon 94\n", - "adding: mem time74, current time 167, horizon 93\n", - "adding: mem time75, current time 167, horizon 92\n", - "adding: mem time76, current time 167, horizon 91\n", - "adding: mem time77, current time 167, horizon 90\n", - "adding: mem time78, current time 167, horizon 89\n", - "adding: mem time79, current time 167, horizon 88\n", - "adding: mem time80, current time 167, horizon 87\n", - "adding: mem time81, current time 167, horizon 86\n", - "adding: mem time82, current time 167, horizon 85\n", - "adding: mem time83, current time 167, horizon 84\n", - "adding: mem time84, current time 167, horizon 83\n", - "adding: mem time85, current time 167, horizon 82\n", - "adding: mem time86, current time 167, horizon 81\n", - "adding: mem time87, current time 167, horizon 80\n", - "adding: mem time88, current time 167, horizon 79\n", - "adding: mem time89, current time 167, horizon 78\n", - "adding: mem time90, current time 167, horizon 77\n", - "adding: mem time91, current time 167, horizon 76\n", - "adding: mem time92, current time 167, horizon 75\n", - "adding: mem time93, current time 167, horizon 74\n", - "adding: mem time94, current time 167, horizon 73\n", - "adding: mem time95, current time 167, horizon 72\n", - "adding: mem time96, current time 167, horizon 71\n", - "adding: mem time97, current time 167, horizon 70\n", - "adding: mem time98, current time 167, horizon 69\n", - "adding: mem time99, current time 167, horizon 68\n", - "adding: mem time100, current time 167, horizon 67\n", - "adding: mem time101, current time 167, horizon 66\n", - "adding: mem time102, current time 167, horizon 65\n", - "adding: mem time103, current time 167, horizon 64\n", - "adding: mem time104, current time 167, horizon 63\n", - "adding: mem time105, current time 167, horizon 62\n", - "adding: mem time106, current time 167, horizon 61\n", - "adding: mem time107, current time 167, horizon 60\n", - "adding: mem time108, current time 167, horizon 59\n", - "adding: mem time109, current time 167, horizon 58\n", - "adding: mem time110, current time 167, horizon 57\n", - "adding: mem time111, current time 167, horizon 56\n", - "adding: mem time112, current time 167, horizon 55\n", - "adding: mem time113, current time 167, horizon 54\n", - "adding: mem time114, current time 167, horizon 53\n", - "adding: mem time115, current time 167, horizon 52\n", - "adding: mem time116, current time 167, horizon 51\n", - "adding: mem time117, current time 167, horizon 50\n", - "adding: mem time118, current time 167, horizon 49\n", - "adding: mem time119, current time 167, horizon 48\n", - "adding: mem time120, current time 167, horizon 47\n", - "adding: mem time121, current time 167, horizon 46\n", - "adding: mem time122, current time 167, horizon 45\n", - "adding: mem time123, current time 167, horizon 44\n", - "adding: mem time124, current time 167, horizon 43\n", - "adding: mem time125, current time 167, horizon 42\n", - "adding: mem time126, current time 167, horizon 41\n", - "adding: mem time127, current time 167, horizon 40\n", - "adding: mem time128, current time 167, horizon 39\n", - "adding: mem time129, current time 167, horizon 38\n", - "adding: mem time130, current time 167, horizon 37\n", - "adding: mem time131, current time 167, horizon 36\n", - "adding: mem time132, current time 167, horizon 35\n", - "adding: mem time133, current time 167, horizon 34\n", - "adding: mem time134, current time 167, horizon 33\n", - "adding: mem time135, current time 167, horizon 32\n", - "adding: mem time136, current time 167, horizon 31\n", - "adding: mem time137, current time 167, horizon 30\n", - "adding: mem time138, current time 167, horizon 29\n", - "adding: mem time139, current time 167, horizon 28\n", - "adding: mem time140, current time 167, horizon 27\n", - "adding: mem time141, current time 167, horizon 26\n", - "adding: mem time142, current time 167, horizon 25\n", - "adding: mem time143, current time 167, horizon 24\n", - "adding: mem time144, current time 167, horizon 23\n", - "adding: mem time145, current time 167, horizon 22\n", - "adding: mem time146, current time 167, horizon 21\n", - "adding: mem time147, current time 167, horizon 20\n", - "adding: mem time148, current time 167, horizon 19\n", - "adding: mem time149, current time 167, horizon 18\n", - "adding: mem time150, current time 167, horizon 17\n", - "adding: mem time151, current time 167, horizon 16\n", - "adding: mem time152, current time 167, horizon 15\n", - "adding: mem time153, current time 167, horizon 14\n", - "adding: mem time154, current time 167, horizon 13\n", - "adding: mem time155, current time 167, horizon 12\n", - "adding: mem time156, current time 167, horizon 11\n", - "adding: mem time157, current time 167, horizon 10\n", - "adding: mem time158, current time 167, horizon 9\n", - "adding: mem time159, current time 167, horizon 8\n", - "adding: mem time160, current time 167, horizon 7\n", - "adding: mem time161, current time 167, horizon 6\n", - "adding: mem time162, current time 167, horizon 5\n", - "adding: mem time163, current time 167, horizon 4\n", - "adding: mem time164, current time 167, horizon 3\n", - "adding: mem time165, current time 167, horizon 2\n", - "adding: mem time166, current time 167, horizon 1\n", - "adding: mem time0, current time 168, horizon 168\n", - "adding: mem time1, current time 168, horizon 167\n", - "adding: mem time2, current time 168, horizon 166\n", - "adding: mem time3, current time 168, horizon 165\n", - "adding: mem time4, current time 168, horizon 164\n", - "adding: mem time5, current time 168, horizon 163\n", - "adding: mem time6, current time 168, horizon 162\n", - "adding: mem time7, current time 168, horizon 161\n", - "adding: mem time8, current time 168, horizon 160\n", - "adding: mem time9, current time 168, horizon 159\n", - "adding: mem time10, current time 168, horizon 158\n", - "adding: mem time11, current time 168, horizon 157\n", - "adding: mem time12, current time 168, horizon 156\n", - "adding: mem time13, current time 168, horizon 155\n", - "adding: mem time14, current time 168, horizon 154\n", - "adding: mem time15, current time 168, horizon 153\n", - "adding: mem time16, current time 168, horizon 152\n", - "adding: mem time17, current time 168, horizon 151\n", - "adding: mem time18, current time 168, horizon 150\n", - "adding: mem time19, current time 168, horizon 149\n", - "adding: mem time20, current time 168, horizon 148\n", - "adding: mem time21, current time 168, horizon 147\n", - "adding: mem time22, current time 168, horizon 146\n", - "adding: mem time23, current time 168, horizon 145\n", - "adding: mem time24, current time 168, horizon 144\n", - "adding: mem time25, current time 168, horizon 143\n", - "adding: mem time26, current time 168, horizon 142\n", - "adding: mem time27, current time 168, horizon 141\n", - "adding: mem time28, current time 168, horizon 140\n", - "adding: mem time29, current time 168, horizon 139\n", - "adding: mem time30, current time 168, horizon 138\n", - "adding: mem time31, current time 168, horizon 137\n", - "adding: mem time32, current time 168, horizon 136\n", - "adding: mem time33, current time 168, horizon 135\n", - "adding: mem time34, current time 168, horizon 134\n", - "adding: mem time35, current time 168, horizon 133\n", - "adding: mem time36, current time 168, horizon 132\n", - "adding: mem time37, current time 168, horizon 131\n", - "adding: mem time38, current time 168, horizon 130\n", - "adding: mem time39, current time 168, horizon 129\n", - "adding: mem time40, current time 168, horizon 128\n", - "adding: mem time41, current time 168, horizon 127\n", - "adding: mem time42, current time 168, horizon 126\n", - "adding: mem time43, current time 168, horizon 125\n", - "adding: mem time44, current time 168, horizon 124\n", - "adding: mem time45, current time 168, horizon 123\n", - "adding: mem time46, current time 168, horizon 122\n", - "adding: mem time47, current time 168, horizon 121\n", - "adding: mem time48, current time 168, horizon 120\n", - "adding: mem time49, current time 168, horizon 119\n", - "adding: mem time50, current time 168, horizon 118\n", - "adding: mem time51, current time 168, horizon 117\n", - "adding: mem time52, current time 168, horizon 116\n", - "adding: mem time53, current time 168, horizon 115\n", - "adding: mem time54, current time 168, horizon 114\n", - "adding: mem time55, current time 168, horizon 113\n", - "adding: mem time56, current time 168, horizon 112\n", - "adding: mem time57, current time 168, horizon 111\n", - "adding: mem time58, current time 168, horizon 110\n", - "adding: mem time59, current time 168, horizon 109\n", - "adding: mem time60, current time 168, horizon 108\n", - "adding: mem time61, current time 168, horizon 107\n", - "adding: mem time62, current time 168, horizon 106\n", - "adding: mem time63, current time 168, horizon 105\n", - "adding: mem time64, current time 168, horizon 104\n", - "adding: mem time65, current time 168, horizon 103\n", - "adding: mem time66, current time 168, horizon 102\n", - "adding: mem time67, current time 168, horizon 101\n", - "adding: mem time68, current time 168, horizon 100\n", - "adding: mem time69, current time 168, horizon 99\n", - "adding: mem time70, current time 168, horizon 98\n", - "adding: mem time71, current time 168, horizon 97\n", - "adding: mem time72, current time 168, horizon 96\n", - "adding: mem time73, current time 168, horizon 95\n", - "adding: mem time74, current time 168, horizon 94\n", - "adding: mem time75, current time 168, horizon 93\n", - "adding: mem time76, current time 168, horizon 92\n", - "adding: mem time77, current time 168, horizon 91\n", - "adding: mem time78, current time 168, horizon 90\n", - "adding: mem time79, current time 168, horizon 89\n", - "adding: mem time80, current time 168, horizon 88\n", - "adding: mem time81, current time 168, horizon 87\n", - "adding: mem time82, current time 168, horizon 86\n", - "adding: mem time83, current time 168, horizon 85\n", - "adding: mem time84, current time 168, horizon 84\n", - "adding: mem time85, current time 168, horizon 83\n", - "adding: mem time86, current time 168, horizon 82\n", - "adding: mem time87, current time 168, horizon 81\n", - "adding: mem time88, current time 168, horizon 80\n", - "adding: mem time89, current time 168, horizon 79\n", - "adding: mem time90, current time 168, horizon 78\n", - "adding: mem time91, current time 168, horizon 77\n", - "adding: mem time92, current time 168, horizon 76\n", - "adding: mem time93, current time 168, horizon 75\n", - "adding: mem time94, current time 168, horizon 74\n", - "adding: mem time95, current time 168, horizon 73\n", - "adding: mem time96, current time 168, horizon 72\n", - "adding: mem time97, current time 168, horizon 71\n", - "adding: mem time98, current time 168, horizon 70\n", - "adding: mem time99, current time 168, horizon 69\n", - "adding: mem time100, current time 168, horizon 68\n", - "adding: mem time101, current time 168, horizon 67\n", - "adding: mem time102, current time 168, horizon 66\n", - "adding: mem time103, current time 168, horizon 65\n", - "adding: mem time104, current time 168, horizon 64\n", - "adding: mem time105, current time 168, horizon 63\n", - "adding: mem time106, current time 168, horizon 62\n", - "adding: mem time107, current time 168, horizon 61\n", - "adding: mem time108, current time 168, horizon 60\n", - "adding: mem time109, current time 168, horizon 59\n", - "adding: mem time110, current time 168, horizon 58\n", - "adding: mem time111, current time 168, horizon 57\n", - "adding: mem time112, current time 168, horizon 56\n", - "adding: mem time113, current time 168, horizon 55\n", - "adding: mem time114, current time 168, horizon 54\n", - "adding: mem time115, current time 168, horizon 53\n", - "adding: mem time116, current time 168, horizon 52\n", - "adding: mem time117, current time 168, horizon 51\n", - "adding: mem time118, current time 168, horizon 50\n", - "adding: mem time119, current time 168, horizon 49\n", - "adding: mem time120, current time 168, horizon 48\n", - "adding: mem time121, current time 168, horizon 47\n", - "adding: mem time122, current time 168, horizon 46\n", - "adding: mem time123, current time 168, horizon 45\n", - "adding: mem time124, current time 168, horizon 44\n", - "adding: mem time125, current time 168, horizon 43\n", - "adding: mem time126, current time 168, horizon 42\n", - "adding: mem time127, current time 168, horizon 41\n", - "adding: mem time128, current time 168, horizon 40\n", - "adding: mem time129, current time 168, horizon 39\n", - "adding: mem time130, current time 168, horizon 38\n", - "adding: mem time131, current time 168, horizon 37\n", - "adding: mem time132, current time 168, horizon 36\n", - "adding: mem time133, current time 168, horizon 35\n", - "adding: mem time134, current time 168, horizon 34\n", - "adding: mem time135, current time 168, horizon 33\n", - "adding: mem time136, current time 168, horizon 32\n", - "adding: mem time137, current time 168, horizon 31\n", - "adding: mem time138, current time 168, horizon 30\n", - "adding: mem time139, current time 168, horizon 29\n", - "adding: mem time140, current time 168, horizon 28\n", - "adding: mem time141, current time 168, horizon 27\n", - "adding: mem time142, current time 168, horizon 26\n", - "adding: mem time143, current time 168, horizon 25\n", - "adding: mem time144, current time 168, horizon 24\n", - "adding: mem time145, current time 168, horizon 23\n", - "adding: mem time146, current time 168, horizon 22\n", - "adding: mem time147, current time 168, horizon 21\n", - "adding: mem time148, current time 168, horizon 20\n", - "adding: mem time149, current time 168, horizon 19\n", - "adding: mem time150, current time 168, horizon 18\n", - "adding: mem time151, current time 168, horizon 17\n", - "adding: mem time152, current time 168, horizon 16\n", - "adding: mem time153, current time 168, horizon 15\n", - "adding: mem time154, current time 168, horizon 14\n", - "adding: mem time155, current time 168, horizon 13\n", - "adding: mem time156, current time 168, horizon 12\n", - "adding: mem time157, current time 168, horizon 11\n", - "adding: mem time158, current time 168, horizon 10\n", - "adding: mem time159, current time 168, horizon 9\n", - "adding: mem time160, current time 168, horizon 8\n", - "adding: mem time161, current time 168, horizon 7\n", - "adding: mem time162, current time 168, horizon 6\n", - "adding: mem time163, current time 168, horizon 5\n", - "adding: mem time164, current time 168, horizon 4\n", - "adding: mem time165, current time 168, horizon 3\n", - "adding: mem time166, current time 168, horizon 2\n", - "adding: mem time167, current time 168, horizon 1\n", - "adding: mem time0, current time 169, horizon 169\n", - "adding: mem time1, current time 169, horizon 168\n", - "adding: mem time2, current time 169, horizon 167\n", - "adding: mem time3, current time 169, horizon 166\n", - "adding: mem time4, current time 169, horizon 165\n", - "adding: mem time5, current time 169, horizon 164\n", - "adding: mem time6, current time 169, horizon 163\n", - "adding: mem time7, current time 169, horizon 162\n", - "adding: mem time8, current time 169, horizon 161\n", - "adding: mem time9, current time 169, horizon 160\n", - "adding: mem time10, current time 169, horizon 159\n", - "adding: mem time11, current time 169, horizon 158\n", - "adding: mem time12, current time 169, horizon 157\n", - "adding: mem time13, current time 169, horizon 156\n", - "adding: mem time14, current time 169, horizon 155\n", - "adding: mem time15, current time 169, horizon 154\n", - "adding: mem time16, current time 169, horizon 153\n", - "adding: mem time17, current time 169, horizon 152\n", - "adding: mem time18, current time 169, horizon 151\n", - "adding: mem time19, current time 169, horizon 150\n", - "adding: mem time20, current time 169, horizon 149\n", - "adding: mem time21, current time 169, horizon 148\n", - "adding: mem time22, current time 169, horizon 147\n", - "adding: mem time23, current time 169, horizon 146\n", - "adding: mem time24, current time 169, horizon 145\n", - "adding: mem time25, current time 169, horizon 144\n", - "adding: mem time26, current time 169, horizon 143\n", - "adding: mem time27, current time 169, horizon 142\n", - "adding: mem time28, current time 169, horizon 141\n", - "adding: mem time29, current time 169, horizon 140\n", - "adding: mem time30, current time 169, horizon 139\n", - "adding: mem time31, current time 169, horizon 138\n", - "adding: mem time32, current time 169, horizon 137\n", - "adding: mem time33, current time 169, horizon 136\n", - "adding: mem time34, current time 169, horizon 135\n", - "adding: mem time35, current time 169, horizon 134\n", - "adding: mem time36, current time 169, horizon 133\n", - "adding: mem time37, current time 169, horizon 132\n", - "adding: mem time38, current time 169, horizon 131\n", - "adding: mem time39, current time 169, horizon 130\n", - "adding: mem time40, current time 169, horizon 129\n", - "adding: mem time41, current time 169, horizon 128\n", - "adding: mem time42, current time 169, horizon 127\n", - "adding: mem time43, current time 169, horizon 126\n", - "adding: mem time44, current time 169, horizon 125\n", - "adding: mem time45, current time 169, horizon 124\n", - "adding: mem time46, current time 169, horizon 123\n", - "adding: mem time47, current time 169, horizon 122\n", - "adding: mem time48, current time 169, horizon 121\n", - "adding: mem time49, current time 169, horizon 120\n", - "adding: mem time50, current time 169, horizon 119\n", - "adding: mem time51, current time 169, horizon 118\n", - "adding: mem time52, current time 169, horizon 117\n", - "adding: mem time53, current time 169, horizon 116\n", - "adding: mem time54, current time 169, horizon 115\n", - "adding: mem time55, current time 169, horizon 114\n", - "adding: mem time56, current time 169, horizon 113\n", - "adding: mem time57, current time 169, horizon 112\n", - "adding: mem time58, current time 169, horizon 111\n", - "adding: mem time59, current time 169, horizon 110\n", - "adding: mem time60, current time 169, horizon 109\n", - "adding: mem time61, current time 169, horizon 108\n", - "adding: mem time62, current time 169, horizon 107\n", - "adding: mem time63, current time 169, horizon 106\n", - "adding: mem time64, current time 169, horizon 105\n", - "adding: mem time65, current time 169, horizon 104\n", - "adding: mem time66, current time 169, horizon 103\n", - "adding: mem time67, current time 169, horizon 102\n", - "adding: mem time68, current time 169, horizon 101\n", - "adding: mem time69, current time 169, horizon 100\n", - "adding: mem time70, current time 169, horizon 99\n", - "adding: mem time71, current time 169, horizon 98\n", - "adding: mem time72, current time 169, horizon 97\n", - "adding: mem time73, current time 169, horizon 96\n", - "adding: mem time74, current time 169, horizon 95\n", - "adding: mem time75, current time 169, horizon 94\n", - "adding: mem time76, current time 169, horizon 93\n", - "adding: mem time77, current time 169, horizon 92\n", - "adding: mem time78, current time 169, horizon 91\n", - "adding: mem time79, current time 169, horizon 90\n", - "adding: mem time80, current time 169, horizon 89\n", - "adding: mem time81, current time 169, horizon 88\n", - "adding: mem time82, current time 169, horizon 87\n", - "adding: mem time83, current time 169, horizon 86\n", - "adding: mem time84, current time 169, horizon 85\n", - "adding: mem time85, current time 169, horizon 84\n", - "adding: mem time86, current time 169, horizon 83\n", - "adding: mem time87, current time 169, horizon 82\n", - "adding: mem time88, current time 169, horizon 81\n", - "adding: mem time89, current time 169, horizon 80\n", - "adding: mem time90, current time 169, horizon 79\n", - "adding: mem time91, current time 169, horizon 78\n", - "adding: mem time92, current time 169, horizon 77\n", - "adding: mem time93, current time 169, horizon 76\n", - "adding: mem time94, current time 169, horizon 75\n", - "adding: mem time95, current time 169, horizon 74\n", - "adding: mem time96, current time 169, horizon 73\n", - "adding: mem time97, current time 169, horizon 72\n", - "adding: mem time98, current time 169, horizon 71\n", - "adding: mem time99, current time 169, horizon 70\n", - "adding: mem time100, current time 169, horizon 69\n", - "adding: mem time101, current time 169, horizon 68\n", - "adding: mem time102, current time 169, horizon 67\n", - "adding: mem time103, current time 169, horizon 66\n", - "adding: mem time104, current time 169, horizon 65\n", - "adding: mem time105, current time 169, horizon 64\n", - "adding: mem time106, current time 169, horizon 63\n", - "adding: mem time107, current time 169, horizon 62\n", - "adding: mem time108, current time 169, horizon 61\n", - "adding: mem time109, current time 169, horizon 60\n", - "adding: mem time110, current time 169, horizon 59\n", - "adding: mem time111, current time 169, horizon 58\n", - "adding: mem time112, current time 169, horizon 57\n", - "adding: mem time113, current time 169, horizon 56\n", - "adding: mem time114, current time 169, horizon 55\n", - "adding: mem time115, current time 169, horizon 54\n", - "adding: mem time116, current time 169, horizon 53\n", - "adding: mem time117, current time 169, horizon 52\n", - "adding: mem time118, current time 169, horizon 51\n", - "adding: mem time119, current time 169, horizon 50\n", - "adding: mem time120, current time 169, horizon 49\n", - "adding: mem time121, current time 169, horizon 48\n", - "adding: mem time122, current time 169, horizon 47\n", - "adding: mem time123, current time 169, horizon 46\n", - "adding: mem time124, current time 169, horizon 45\n", - "adding: mem time125, current time 169, horizon 44\n", - "adding: mem time126, current time 169, horizon 43\n", - "adding: mem time127, current time 169, horizon 42\n", - "adding: mem time128, current time 169, horizon 41\n", - "adding: mem time129, current time 169, horizon 40\n", - "adding: mem time130, current time 169, horizon 39\n", - "adding: mem time131, current time 169, horizon 38\n", - "adding: mem time132, current time 169, horizon 37\n", - "adding: mem time133, current time 169, horizon 36\n", - "adding: mem time134, current time 169, horizon 35\n", - "adding: mem time135, current time 169, horizon 34\n", - "adding: mem time136, current time 169, horizon 33\n", - "adding: mem time137, current time 169, horizon 32\n", - "adding: mem time138, current time 169, horizon 31\n", - "adding: mem time139, current time 169, horizon 30\n", - "adding: mem time140, current time 169, horizon 29\n", - "adding: mem time141, current time 169, horizon 28\n", - "adding: mem time142, current time 169, horizon 27\n", - "adding: mem time143, current time 169, horizon 26\n", - "adding: mem time144, current time 169, horizon 25\n", - "adding: mem time145, current time 169, horizon 24\n", - "adding: mem time146, current time 169, horizon 23\n", - "adding: mem time147, current time 169, horizon 22\n", - "adding: mem time148, current time 169, horizon 21\n", - "adding: mem time149, current time 169, horizon 20\n", - "adding: mem time150, current time 169, horizon 19\n", - "adding: mem time151, current time 169, horizon 18\n", - "adding: mem time152, current time 169, horizon 17\n", - "adding: mem time153, current time 169, horizon 16\n", - "adding: mem time154, current time 169, horizon 15\n", - "adding: mem time155, current time 169, horizon 14\n", - "adding: mem time156, current time 169, horizon 13\n", - "adding: mem time157, current time 169, horizon 12\n", - "adding: mem time158, current time 169, horizon 11\n", - "adding: mem time159, current time 169, horizon 10\n", - "adding: mem time160, current time 169, horizon 9\n", - "adding: mem time161, current time 169, horizon 8\n", - "adding: mem time162, current time 169, horizon 7\n", - "adding: mem time163, current time 169, horizon 6\n", - "adding: mem time164, current time 169, horizon 5\n", - "adding: mem time165, current time 169, horizon 4\n", - "adding: mem time166, current time 169, horizon 3\n", - "adding: mem time167, current time 169, horizon 2\n", - "adding: mem time168, current time 169, horizon 1\n", - "adding: mem time0, current time 170, horizon 170\n", - "adding: mem time1, current time 170, horizon 169\n", - "adding: mem time2, current time 170, horizon 168\n", - "adding: mem time3, current time 170, horizon 167\n", - "adding: mem time4, current time 170, horizon 166\n", - "adding: mem time5, current time 170, horizon 165\n", - "adding: mem time6, current time 170, horizon 164\n", - "adding: mem time7, current time 170, horizon 163\n", - "adding: mem time8, current time 170, horizon 162\n", - "adding: mem time9, current time 170, horizon 161\n", - "adding: mem time10, current time 170, horizon 160\n", - "adding: mem time11, current time 170, horizon 159\n", - "adding: mem time12, current time 170, horizon 158\n", - "adding: mem time13, current time 170, horizon 157\n", - "adding: mem time14, current time 170, horizon 156\n", - "adding: mem time15, current time 170, horizon 155\n", - "adding: mem time16, current time 170, horizon 154\n", - "adding: mem time17, current time 170, horizon 153\n", - "adding: mem time18, current time 170, horizon 152\n", - "adding: mem time19, current time 170, horizon 151\n", - "adding: mem time20, current time 170, horizon 150\n", - "adding: mem time21, current time 170, horizon 149\n", - "adding: mem time22, current time 170, horizon 148\n", - "adding: mem time23, current time 170, horizon 147\n", - "adding: mem time24, current time 170, horizon 146\n", - "adding: mem time25, current time 170, horizon 145\n", - "adding: mem time26, current time 170, horizon 144\n", - "adding: mem time27, current time 170, horizon 143\n", - "adding: mem time28, current time 170, horizon 142\n", - "adding: mem time29, current time 170, horizon 141\n", - "adding: mem time30, current time 170, horizon 140\n", - "adding: mem time31, current time 170, horizon 139\n", - "adding: mem time32, current time 170, horizon 138\n", - "adding: mem time33, current time 170, horizon 137\n", - "adding: mem time34, current time 170, horizon 136\n", - "adding: mem time35, current time 170, horizon 135\n", - "adding: mem time36, current time 170, horizon 134\n", - "adding: mem time37, current time 170, horizon 133\n", - "adding: mem time38, current time 170, horizon 132\n", - "adding: mem time39, current time 170, horizon 131\n", - "adding: mem time40, current time 170, horizon 130\n", - "adding: mem time41, current time 170, horizon 129\n", - "adding: mem time42, current time 170, horizon 128\n", - "adding: mem time43, current time 170, horizon 127\n", - "adding: mem time44, current time 170, horizon 126\n", - "adding: mem time45, current time 170, horizon 125\n", - "adding: mem time46, current time 170, horizon 124\n", - "adding: mem time47, current time 170, horizon 123\n", - "adding: mem time48, current time 170, horizon 122\n", - "adding: mem time49, current time 170, horizon 121\n", - "adding: mem time50, current time 170, horizon 120\n", - "adding: mem time51, current time 170, horizon 119\n", - "adding: mem time52, current time 170, horizon 118\n", - "adding: mem time53, current time 170, horizon 117\n", - "adding: mem time54, current time 170, horizon 116\n", - "adding: mem time55, current time 170, horizon 115\n", - "adding: mem time56, current time 170, horizon 114\n", - "adding: mem time57, current time 170, horizon 113\n", - "adding: mem time58, current time 170, horizon 112\n", - "adding: mem time59, current time 170, horizon 111\n", - "adding: mem time60, current time 170, horizon 110\n", - "adding: mem time61, current time 170, horizon 109\n", - "adding: mem time62, current time 170, horizon 108\n", - "adding: mem time63, current time 170, horizon 107\n", - "adding: mem time64, current time 170, horizon 106\n", - "adding: mem time65, current time 170, horizon 105\n", - "adding: mem time66, current time 170, horizon 104\n", - "adding: mem time67, current time 170, horizon 103\n", - "adding: mem time68, current time 170, horizon 102\n", - "adding: mem time69, current time 170, horizon 101\n", - "adding: mem time70, current time 170, horizon 100\n", - "adding: mem time71, current time 170, horizon 99\n", - "adding: mem time72, current time 170, horizon 98\n", - "adding: mem time73, current time 170, horizon 97\n", - "adding: mem time74, current time 170, horizon 96\n", - "adding: mem time75, current time 170, horizon 95\n", - "adding: mem time76, current time 170, horizon 94\n", - "adding: mem time77, current time 170, horizon 93\n", - "adding: mem time78, current time 170, horizon 92\n", - "adding: mem time79, current time 170, horizon 91\n", - "adding: mem time80, current time 170, horizon 90\n", - "adding: mem time81, current time 170, horizon 89\n", - "adding: mem time82, current time 170, horizon 88\n", - "adding: mem time83, current time 170, horizon 87\n", - "adding: mem time84, current time 170, horizon 86\n", - "adding: mem time85, current time 170, horizon 85\n", - "adding: mem time86, current time 170, horizon 84\n", - "adding: mem time87, current time 170, horizon 83\n", - "adding: mem time88, current time 170, horizon 82\n", - "adding: mem time89, current time 170, horizon 81\n", - "adding: mem time90, current time 170, horizon 80\n", - "adding: mem time91, current time 170, horizon 79\n", - "adding: mem time92, current time 170, horizon 78\n", - "adding: mem time93, current time 170, horizon 77\n", - "adding: mem time94, current time 170, horizon 76\n", - "adding: mem time95, current time 170, horizon 75\n", - "adding: mem time96, current time 170, horizon 74\n", - "adding: mem time97, current time 170, horizon 73\n", - "adding: mem time98, current time 170, horizon 72\n", - "adding: mem time99, current time 170, horizon 71\n", - "adding: mem time100, current time 170, horizon 70\n", - "adding: mem time101, current time 170, horizon 69\n", - "adding: mem time102, current time 170, horizon 68\n", - "adding: mem time103, current time 170, horizon 67\n", - "adding: mem time104, current time 170, horizon 66\n", - "adding: mem time105, current time 170, horizon 65\n", - "adding: mem time106, current time 170, horizon 64\n", - "adding: mem time107, current time 170, horizon 63\n", - "adding: mem time108, current time 170, horizon 62\n", - "adding: mem time109, current time 170, horizon 61\n", - "adding: mem time110, current time 170, horizon 60\n", - "adding: mem time111, current time 170, horizon 59\n", - "adding: mem time112, current time 170, horizon 58\n", - "adding: mem time113, current time 170, horizon 57\n", - "adding: mem time114, current time 170, horizon 56\n", - "adding: mem time115, current time 170, horizon 55\n", - "adding: mem time116, current time 170, horizon 54\n", - "adding: mem time117, current time 170, horizon 53\n", - "adding: mem time118, current time 170, horizon 52\n", - "adding: mem time119, current time 170, horizon 51\n", - "adding: mem time120, current time 170, horizon 50\n", - "adding: mem time121, current time 170, horizon 49\n", - "adding: mem time122, current time 170, horizon 48\n", - "adding: mem time123, current time 170, horizon 47\n", - "adding: mem time124, current time 170, horizon 46\n", - "adding: mem time125, current time 170, horizon 45\n", - "adding: mem time126, current time 170, horizon 44\n", - "adding: mem time127, current time 170, horizon 43\n", - "adding: mem time128, current time 170, horizon 42\n", - "adding: mem time129, current time 170, horizon 41\n", - "adding: mem time130, current time 170, horizon 40\n", - "adding: mem time131, current time 170, horizon 39\n", - "adding: mem time132, current time 170, horizon 38\n", - "adding: mem time133, current time 170, horizon 37\n", - "adding: mem time134, current time 170, horizon 36\n", - "adding: mem time135, current time 170, horizon 35\n", - "adding: mem time136, current time 170, horizon 34\n", - "adding: mem time137, current time 170, horizon 33\n", - "adding: mem time138, current time 170, horizon 32\n", - "adding: mem time139, current time 170, horizon 31\n", - "adding: mem time140, current time 170, horizon 30\n", - "adding: mem time141, current time 170, horizon 29\n", - "adding: mem time142, current time 170, horizon 28\n", - "adding: mem time143, current time 170, horizon 27\n", - "adding: mem time144, current time 170, horizon 26\n", - "adding: mem time145, current time 170, horizon 25\n", - "adding: mem time146, current time 170, horizon 24\n", - "adding: mem time147, current time 170, horizon 23\n", - "adding: mem time148, current time 170, horizon 22\n", - "adding: mem time149, current time 170, horizon 21\n", - "adding: mem time150, current time 170, horizon 20\n", - "adding: mem time151, current time 170, horizon 19\n", - "adding: mem time152, current time 170, horizon 18\n", - "adding: mem time153, current time 170, horizon 17\n", - "adding: mem time154, current time 170, horizon 16\n", - "adding: mem time155, current time 170, horizon 15\n", - "adding: mem time156, current time 170, horizon 14\n", - "adding: mem time157, current time 170, horizon 13\n", - "adding: mem time158, current time 170, horizon 12\n", - "adding: mem time159, current time 170, horizon 11\n", - "adding: mem time160, current time 170, horizon 10\n", - "adding: mem time161, current time 170, horizon 9\n", - "adding: mem time162, current time 170, horizon 8\n", - "adding: mem time163, current time 170, horizon 7\n", - "adding: mem time164, current time 170, horizon 6\n", - "adding: mem time165, current time 170, horizon 5\n", - "adding: mem time166, current time 170, horizon 4\n", - "adding: mem time167, current time 170, horizon 3\n", - "adding: mem time168, current time 170, horizon 2\n", - "adding: mem time169, current time 170, horizon 1\n", - "adding: mem time0, current time 171, horizon 171\n", - "adding: mem time1, current time 171, horizon 170\n", - "adding: mem time2, current time 171, horizon 169\n", - "adding: mem time3, current time 171, horizon 168\n", - "adding: mem time4, current time 171, horizon 167\n", - "adding: mem time5, current time 171, horizon 166\n", - "adding: mem time6, current time 171, horizon 165\n", - "adding: mem time7, current time 171, horizon 164\n", - "adding: mem time8, current time 171, horizon 163\n", - "adding: mem time9, current time 171, horizon 162\n", - "adding: mem time10, current time 171, horizon 161\n", - "adding: mem time11, current time 171, horizon 160\n", - "adding: mem time12, current time 171, horizon 159\n", - "adding: mem time13, current time 171, horizon 158\n", - "adding: mem time14, current time 171, horizon 157\n", - "adding: mem time15, current time 171, horizon 156\n", - "adding: mem time16, current time 171, horizon 155\n", - "adding: mem time17, current time 171, horizon 154\n", - "adding: mem time18, current time 171, horizon 153\n", - "adding: mem time19, current time 171, horizon 152\n", - "adding: mem time20, current time 171, horizon 151\n", - "adding: mem time21, current time 171, horizon 150\n", - "adding: mem time22, current time 171, horizon 149\n", - "adding: mem time23, current time 171, horizon 148\n", - "adding: mem time24, current time 171, horizon 147\n", - "adding: mem time25, current time 171, horizon 146\n", - "adding: mem time26, current time 171, horizon 145\n", - "adding: mem time27, current time 171, horizon 144\n", - "adding: mem time28, current time 171, horizon 143\n", - "adding: mem time29, current time 171, horizon 142\n", - "adding: mem time30, current time 171, horizon 141\n", - "adding: mem time31, current time 171, horizon 140\n", - "adding: mem time32, current time 171, horizon 139\n", - "adding: mem time33, current time 171, horizon 138\n", - "adding: mem time34, current time 171, horizon 137\n", - "adding: mem time35, current time 171, horizon 136\n", - "adding: mem time36, current time 171, horizon 135\n", - "adding: mem time37, current time 171, horizon 134\n", - "adding: mem time38, current time 171, horizon 133\n", - "adding: mem time39, current time 171, horizon 132\n", - "adding: mem time40, current time 171, horizon 131\n", - "adding: mem time41, current time 171, horizon 130\n", - "adding: mem time42, current time 171, horizon 129\n", - "adding: mem time43, current time 171, horizon 128\n", - "adding: mem time44, current time 171, horizon 127\n", - "adding: mem time45, current time 171, horizon 126\n", - "adding: mem time46, current time 171, horizon 125\n", - "adding: mem time47, current time 171, horizon 124\n", - "adding: mem time48, current time 171, horizon 123\n", - "adding: mem time49, current time 171, horizon 122\n", - "adding: mem time50, current time 171, horizon 121\n", - "adding: mem time51, current time 171, horizon 120\n", - "adding: mem time52, current time 171, horizon 119\n", - "adding: mem time53, current time 171, horizon 118\n", - "adding: mem time54, current time 171, horizon 117\n", - "adding: mem time55, current time 171, horizon 116\n", - "adding: mem time56, current time 171, horizon 115\n", - "adding: mem time57, current time 171, horizon 114\n", - "adding: mem time58, current time 171, horizon 113\n", - "adding: mem time59, current time 171, horizon 112\n", - "adding: mem time60, current time 171, horizon 111\n", - "adding: mem time61, current time 171, horizon 110\n", - "adding: mem time62, current time 171, horizon 109\n", - "adding: mem time63, current time 171, horizon 108\n", - "adding: mem time64, current time 171, horizon 107\n", - "adding: mem time65, current time 171, horizon 106\n", - "adding: mem time66, current time 171, horizon 105\n", - "adding: mem time67, current time 171, horizon 104\n", - "adding: mem time68, current time 171, horizon 103\n", - "adding: mem time69, current time 171, horizon 102\n", - "adding: mem time70, current time 171, horizon 101\n", - "adding: mem time71, current time 171, horizon 100\n", - "adding: mem time72, current time 171, horizon 99\n", - "adding: mem time73, current time 171, horizon 98\n", - "adding: mem time74, current time 171, horizon 97\n", - "adding: mem time75, current time 171, horizon 96\n", - "adding: mem time76, current time 171, horizon 95\n", - "adding: mem time77, current time 171, horizon 94\n", - "adding: mem time78, current time 171, horizon 93\n", - "adding: mem time79, current time 171, horizon 92\n", - "adding: mem time80, current time 171, horizon 91\n", - "adding: mem time81, current time 171, horizon 90\n", - "adding: mem time82, current time 171, horizon 89\n", - "adding: mem time83, current time 171, horizon 88\n", - "adding: mem time84, current time 171, horizon 87\n", - "adding: mem time85, current time 171, horizon 86\n", - "adding: mem time86, current time 171, horizon 85\n", - "adding: mem time87, current time 171, horizon 84\n", - "adding: mem time88, current time 171, horizon 83\n", - "adding: mem time89, current time 171, horizon 82\n", - "adding: mem time90, current time 171, horizon 81\n", - "adding: mem time91, current time 171, horizon 80\n", - "adding: mem time92, current time 171, horizon 79\n", - "adding: mem time93, current time 171, horizon 78\n", - "adding: mem time94, current time 171, horizon 77\n", - "adding: mem time95, current time 171, horizon 76\n", - "adding: mem time96, current time 171, horizon 75\n", - "adding: mem time97, current time 171, horizon 74\n", - "adding: mem time98, current time 171, horizon 73\n", - "adding: mem time99, current time 171, horizon 72\n", - "adding: mem time100, current time 171, horizon 71\n", - "adding: mem time101, current time 171, horizon 70\n", - "adding: mem time102, current time 171, horizon 69\n", - "adding: mem time103, current time 171, horizon 68\n", - "adding: mem time104, current time 171, horizon 67\n", - "adding: mem time105, current time 171, horizon 66\n", - "adding: mem time106, current time 171, horizon 65\n", - "adding: mem time107, current time 171, horizon 64\n", - "adding: mem time108, current time 171, horizon 63\n", - "adding: mem time109, current time 171, horizon 62\n", - "adding: mem time110, current time 171, horizon 61\n", - "adding: mem time111, current time 171, horizon 60\n", - "adding: mem time112, current time 171, horizon 59\n", - "adding: mem time113, current time 171, horizon 58\n", - "adding: mem time114, current time 171, horizon 57\n", - "adding: mem time115, current time 171, horizon 56\n", - "adding: mem time116, current time 171, horizon 55\n", - "adding: mem time117, current time 171, horizon 54\n", - "adding: mem time118, current time 171, horizon 53\n", - "adding: mem time119, current time 171, horizon 52\n", - "adding: mem time120, current time 171, horizon 51\n", - "adding: mem time121, current time 171, horizon 50\n", - "adding: mem time122, current time 171, horizon 49\n", - "adding: mem time123, current time 171, horizon 48\n", - "adding: mem time124, current time 171, horizon 47\n", - "adding: mem time125, current time 171, horizon 46\n", - "adding: mem time126, current time 171, horizon 45\n", - "adding: mem time127, current time 171, horizon 44\n", - "adding: mem time128, current time 171, horizon 43\n", - "adding: mem time129, current time 171, horizon 42\n", - "adding: mem time130, current time 171, horizon 41\n", - "adding: mem time131, current time 171, horizon 40\n", - "adding: mem time132, current time 171, horizon 39\n", - "adding: mem time133, current time 171, horizon 38\n", - "adding: mem time134, current time 171, horizon 37\n", - "adding: mem time135, current time 171, horizon 36\n", - "adding: mem time136, current time 171, horizon 35\n", - "adding: mem time137, current time 171, horizon 34\n", - "adding: mem time138, current time 171, horizon 33\n", - "adding: mem time139, current time 171, horizon 32\n", - "adding: mem time140, current time 171, horizon 31\n", - "adding: mem time141, current time 171, horizon 30\n", - "adding: mem time142, current time 171, horizon 29\n", - "adding: mem time143, current time 171, horizon 28\n", - "adding: mem time144, current time 171, horizon 27\n", - "adding: mem time145, current time 171, horizon 26\n", - "adding: mem time146, current time 171, horizon 25\n", - "adding: mem time147, current time 171, horizon 24\n", - "adding: mem time148, current time 171, horizon 23\n", - "adding: mem time149, current time 171, horizon 22\n", - "adding: mem time150, current time 171, horizon 21\n", - "adding: mem time151, current time 171, horizon 20\n", - "adding: mem time152, current time 171, horizon 19\n", - "adding: mem time153, current time 171, horizon 18\n", - "adding: mem time154, current time 171, horizon 17\n", - "adding: mem time155, current time 171, horizon 16\n", - "adding: mem time156, current time 171, horizon 15\n", - "adding: mem time157, current time 171, horizon 14\n", - "adding: mem time158, current time 171, horizon 13\n", - "adding: mem time159, current time 171, horizon 12\n", - "adding: mem time160, current time 171, horizon 11\n", - "adding: mem time161, current time 171, horizon 10\n", - "adding: mem time162, current time 171, horizon 9\n", - "adding: mem time163, current time 171, horizon 8\n", - "adding: mem time164, current time 171, horizon 7\n", - "adding: mem time165, current time 171, horizon 6\n", - "adding: mem time166, current time 171, horizon 5\n", - "adding: mem time167, current time 171, horizon 4\n", - "adding: mem time168, current time 171, horizon 3\n", - "adding: mem time169, current time 171, horizon 2\n", - "adding: mem time170, current time 171, horizon 1\n", - "adding: mem time0, current time 172, horizon 172\n", - "adding: mem time1, current time 172, horizon 171\n", - "adding: mem time2, current time 172, horizon 170\n", - "adding: mem time3, current time 172, horizon 169\n", - "adding: mem time4, current time 172, horizon 168\n", - "adding: mem time5, current time 172, horizon 167\n", - "adding: mem time6, current time 172, horizon 166\n", - "adding: mem time7, current time 172, horizon 165\n", - "adding: mem time8, current time 172, horizon 164\n", - "adding: mem time9, current time 172, horizon 163\n", - "adding: mem time10, current time 172, horizon 162\n", - "adding: mem time11, current time 172, horizon 161\n", - "adding: mem time12, current time 172, horizon 160\n", - "adding: mem time13, current time 172, horizon 159\n", - "adding: mem time14, current time 172, horizon 158\n", - "adding: mem time15, current time 172, horizon 157\n", - "adding: mem time16, current time 172, horizon 156\n", - "adding: mem time17, current time 172, horizon 155\n", - "adding: mem time18, current time 172, horizon 154\n", - "adding: mem time19, current time 172, horizon 153\n", - "adding: mem time20, current time 172, horizon 152\n", - "adding: mem time21, current time 172, horizon 151\n", - "adding: mem time22, current time 172, horizon 150\n", - "adding: mem time23, current time 172, horizon 149\n", - "adding: mem time24, current time 172, horizon 148\n", - "adding: mem time25, current time 172, horizon 147\n", - "adding: mem time26, current time 172, horizon 146\n", - "adding: mem time27, current time 172, horizon 145\n", - "adding: mem time28, current time 172, horizon 144\n", - "adding: mem time29, current time 172, horizon 143\n", - "adding: mem time30, current time 172, horizon 142\n", - "adding: mem time31, current time 172, horizon 141\n", - "adding: mem time32, current time 172, horizon 140\n", - "adding: mem time33, current time 172, horizon 139\n", - "adding: mem time34, current time 172, horizon 138\n", - "adding: mem time35, current time 172, horizon 137\n", - "adding: mem time36, current time 172, horizon 136\n", - "adding: mem time37, current time 172, horizon 135\n", - "adding: mem time38, current time 172, horizon 134\n", - "adding: mem time39, current time 172, horizon 133\n", - "adding: mem time40, current time 172, horizon 132\n", - "adding: mem time41, current time 172, horizon 131\n", - "adding: mem time42, current time 172, horizon 130\n", - "adding: mem time43, current time 172, horizon 129\n", - "adding: mem time44, current time 172, horizon 128\n", - "adding: mem time45, current time 172, horizon 127\n", - "adding: mem time46, current time 172, horizon 126\n", - "adding: mem time47, current time 172, horizon 125\n", - "adding: mem time48, current time 172, horizon 124\n", - "adding: mem time49, current time 172, horizon 123\n", - "adding: mem time50, current time 172, horizon 122\n", - "adding: mem time51, current time 172, horizon 121\n", - "adding: mem time52, current time 172, horizon 120\n", - "adding: mem time53, current time 172, horizon 119\n", - "adding: mem time54, current time 172, horizon 118\n", - "adding: mem time55, current time 172, horizon 117\n", - "adding: mem time56, current time 172, horizon 116\n", - "adding: mem time57, current time 172, horizon 115\n", - "adding: mem time58, current time 172, horizon 114\n", - "adding: mem time59, current time 172, horizon 113\n", - "adding: mem time60, current time 172, horizon 112\n", - "adding: mem time61, current time 172, horizon 111\n", - "adding: mem time62, current time 172, horizon 110\n", - "adding: mem time63, current time 172, horizon 109\n", - "adding: mem time64, current time 172, horizon 108\n", - "adding: mem time65, current time 172, horizon 107\n", - "adding: mem time66, current time 172, horizon 106\n", - "adding: mem time67, current time 172, horizon 105\n", - "adding: mem time68, current time 172, horizon 104\n", - "adding: mem time69, current time 172, horizon 103\n", - "adding: mem time70, current time 172, horizon 102\n", - "adding: mem time71, current time 172, horizon 101\n", - "adding: mem time72, current time 172, horizon 100\n", - "adding: mem time73, current time 172, horizon 99\n", - "adding: mem time74, current time 172, horizon 98\n", - "adding: mem time75, current time 172, horizon 97\n", - "adding: mem time76, current time 172, horizon 96\n", - "adding: mem time77, current time 172, horizon 95\n", - "adding: mem time78, current time 172, horizon 94\n", - "adding: mem time79, current time 172, horizon 93\n", - "adding: mem time80, current time 172, horizon 92\n", - "adding: mem time81, current time 172, horizon 91\n", - "adding: mem time82, current time 172, horizon 90\n", - "adding: mem time83, current time 172, horizon 89\n", - "adding: mem time84, current time 172, horizon 88\n", - "adding: mem time85, current time 172, horizon 87\n", - "adding: mem time86, current time 172, horizon 86\n", - "adding: mem time87, current time 172, horizon 85\n", - "adding: mem time88, current time 172, horizon 84\n", - "adding: mem time89, current time 172, horizon 83\n", - "adding: mem time90, current time 172, horizon 82\n", - "adding: mem time91, current time 172, horizon 81\n", - "adding: mem time92, current time 172, horizon 80\n", - "adding: mem time93, current time 172, horizon 79\n", - "adding: mem time94, current time 172, horizon 78\n", - "adding: mem time95, current time 172, horizon 77\n", - "adding: mem time96, current time 172, horizon 76\n", - "adding: mem time97, current time 172, horizon 75\n", - "adding: mem time98, current time 172, horizon 74\n", - "adding: mem time99, current time 172, horizon 73\n", - "adding: mem time100, current time 172, horizon 72\n", - "adding: mem time101, current time 172, horizon 71\n", - "adding: mem time102, current time 172, horizon 70\n", - "adding: mem time103, current time 172, horizon 69\n", - "adding: mem time104, current time 172, horizon 68\n", - "adding: mem time105, current time 172, horizon 67\n", - "adding: mem time106, current time 172, horizon 66\n", - "adding: mem time107, current time 172, horizon 65\n", - "adding: mem time108, current time 172, horizon 64\n", - "adding: mem time109, current time 172, horizon 63\n", - "adding: mem time110, current time 172, horizon 62\n", - "adding: mem time111, current time 172, horizon 61\n", - "adding: mem time112, current time 172, horizon 60\n", - "adding: mem time113, current time 172, horizon 59\n", - "adding: mem time114, current time 172, horizon 58\n", - "adding: mem time115, current time 172, horizon 57\n", - "adding: mem time116, current time 172, horizon 56\n", - "adding: mem time117, current time 172, horizon 55\n", - "adding: mem time118, current time 172, horizon 54\n", - "adding: mem time119, current time 172, horizon 53\n", - "adding: mem time120, current time 172, horizon 52\n", - "adding: mem time121, current time 172, horizon 51\n", - "adding: mem time122, current time 172, horizon 50\n", - "adding: mem time123, current time 172, horizon 49\n", - "adding: mem time124, current time 172, horizon 48\n", - "adding: mem time125, current time 172, horizon 47\n", - "adding: mem time126, current time 172, horizon 46\n", - "adding: mem time127, current time 172, horizon 45\n", - "adding: mem time128, current time 172, horizon 44\n", - "adding: mem time129, current time 172, horizon 43\n", - "adding: mem time130, current time 172, horizon 42\n", - "adding: mem time131, current time 172, horizon 41\n", - "adding: mem time132, current time 172, horizon 40\n", - "adding: mem time133, current time 172, horizon 39\n", - "adding: mem time134, current time 172, horizon 38\n", - "adding: mem time135, current time 172, horizon 37\n", - "adding: mem time136, current time 172, horizon 36\n", - "adding: mem time137, current time 172, horizon 35\n", - "adding: mem time138, current time 172, horizon 34\n", - "adding: mem time139, current time 172, horizon 33\n", - "adding: mem time140, current time 172, horizon 32\n", - "adding: mem time141, current time 172, horizon 31\n", - "adding: mem time142, current time 172, horizon 30\n", - "adding: mem time143, current time 172, horizon 29\n", - "adding: mem time144, current time 172, horizon 28\n", - "adding: mem time145, current time 172, horizon 27\n", - "adding: mem time146, current time 172, horizon 26\n", - "adding: mem time147, current time 172, horizon 25\n", - "adding: mem time148, current time 172, horizon 24\n", - "adding: mem time149, current time 172, horizon 23\n", - "adding: mem time150, current time 172, horizon 22\n", - "adding: mem time151, current time 172, horizon 21\n", - "adding: mem time152, current time 172, horizon 20\n", - "adding: mem time153, current time 172, horizon 19\n", - "adding: mem time154, current time 172, horizon 18\n", - "adding: mem time155, current time 172, horizon 17\n", - "adding: mem time156, current time 172, horizon 16\n", - "adding: mem time157, current time 172, horizon 15\n", - "adding: mem time158, current time 172, horizon 14\n", - "adding: mem time159, current time 172, horizon 13\n", - "adding: mem time160, current time 172, horizon 12\n", - "adding: mem time161, current time 172, horizon 11\n", - "adding: mem time162, current time 172, horizon 10\n", - "adding: mem time163, current time 172, horizon 9\n", - "adding: mem time164, current time 172, horizon 8\n", - "adding: mem time165, current time 172, horizon 7\n", - "adding: mem time166, current time 172, horizon 6\n", - "adding: mem time167, current time 172, horizon 5\n", - "adding: mem time168, current time 172, horizon 4\n", - "adding: mem time169, current time 172, horizon 3\n", - "adding: mem time170, current time 172, horizon 2\n", - "adding: mem time171, current time 172, horizon 1\n", - "adding: mem time0, current time 173, horizon 173\n", - "adding: mem time1, current time 173, horizon 172\n", - "adding: mem time2, current time 173, horizon 171\n", - "adding: mem time3, current time 173, horizon 170\n", - "adding: mem time4, current time 173, horizon 169\n", - "adding: mem time5, current time 173, horizon 168\n", - "adding: mem time6, current time 173, horizon 167\n", - "adding: mem time7, current time 173, horizon 166\n", - "adding: mem time8, current time 173, horizon 165\n", - "adding: mem time9, current time 173, horizon 164\n", - "adding: mem time10, current time 173, horizon 163\n", - "adding: mem time11, current time 173, horizon 162\n", - "adding: mem time12, current time 173, horizon 161\n", - "adding: mem time13, current time 173, horizon 160\n", - "adding: mem time14, current time 173, horizon 159\n", - "adding: mem time15, current time 173, horizon 158\n", - "adding: mem time16, current time 173, horizon 157\n", - "adding: mem time17, current time 173, horizon 156\n", - "adding: mem time18, current time 173, horizon 155\n", - "adding: mem time19, current time 173, horizon 154\n", - "adding: mem time20, current time 173, horizon 153\n", - "adding: mem time21, current time 173, horizon 152\n", - "adding: mem time22, current time 173, horizon 151\n", - "adding: mem time23, current time 173, horizon 150\n", - "adding: mem time24, current time 173, horizon 149\n", - "adding: mem time25, current time 173, horizon 148\n", - "adding: mem time26, current time 173, horizon 147\n", - "adding: mem time27, current time 173, horizon 146\n", - "adding: mem time28, current time 173, horizon 145\n", - "adding: mem time29, current time 173, horizon 144\n", - "adding: mem time30, current time 173, horizon 143\n", - "adding: mem time31, current time 173, horizon 142\n", - "adding: mem time32, current time 173, horizon 141\n", - "adding: mem time33, current time 173, horizon 140\n", - "adding: mem time34, current time 173, horizon 139\n", - "adding: mem time35, current time 173, horizon 138\n", - "adding: mem time36, current time 173, horizon 137\n", - "adding: mem time37, current time 173, horizon 136\n", - "adding: mem time38, current time 173, horizon 135\n", - "adding: mem time39, current time 173, horizon 134\n", - "adding: mem time40, current time 173, horizon 133\n", - "adding: mem time41, current time 173, horizon 132\n", - "adding: mem time42, current time 173, horizon 131\n", - "adding: mem time43, current time 173, horizon 130\n", - "adding: mem time44, current time 173, horizon 129\n", - "adding: mem time45, current time 173, horizon 128\n", - "adding: mem time46, current time 173, horizon 127\n", - "adding: mem time47, current time 173, horizon 126\n", - "adding: mem time48, current time 173, horizon 125\n", - "adding: mem time49, current time 173, horizon 124\n", - "adding: mem time50, current time 173, horizon 123\n", - "adding: mem time51, current time 173, horizon 122\n", - "adding: mem time52, current time 173, horizon 121\n", - "adding: mem time53, current time 173, horizon 120\n", - "adding: mem time54, current time 173, horizon 119\n", - "adding: mem time55, current time 173, horizon 118\n", - "adding: mem time56, current time 173, horizon 117\n", - "adding: mem time57, current time 173, horizon 116\n", - "adding: mem time58, current time 173, horizon 115\n", - "adding: mem time59, current time 173, horizon 114\n", - "adding: mem time60, current time 173, horizon 113\n", - "adding: mem time61, current time 173, horizon 112\n", - "adding: mem time62, current time 173, horizon 111\n", - "adding: mem time63, current time 173, horizon 110\n", - "adding: mem time64, current time 173, horizon 109\n", - "adding: mem time65, current time 173, horizon 108\n", - "adding: mem time66, current time 173, horizon 107\n", - "adding: mem time67, current time 173, horizon 106\n", - "adding: mem time68, current time 173, horizon 105\n", - "adding: mem time69, current time 173, horizon 104\n", - "adding: mem time70, current time 173, horizon 103\n", - "adding: mem time71, current time 173, horizon 102\n", - "adding: mem time72, current time 173, horizon 101\n", - "adding: mem time73, current time 173, horizon 100\n", - "adding: mem time74, current time 173, horizon 99\n", - "adding: mem time75, current time 173, horizon 98\n", - "adding: mem time76, current time 173, horizon 97\n", - "adding: mem time77, current time 173, horizon 96\n", - "adding: mem time78, current time 173, horizon 95\n", - "adding: mem time79, current time 173, horizon 94\n", - "adding: mem time80, current time 173, horizon 93\n", - "adding: mem time81, current time 173, horizon 92\n", - "adding: mem time82, current time 173, horizon 91\n", - "adding: mem time83, current time 173, horizon 90\n", - "adding: mem time84, current time 173, horizon 89\n", - "adding: mem time85, current time 173, horizon 88\n", - "adding: mem time86, current time 173, horizon 87\n", - "adding: mem time87, current time 173, horizon 86\n", - "adding: mem time88, current time 173, horizon 85\n", - "adding: mem time89, current time 173, horizon 84\n", - "adding: mem time90, current time 173, horizon 83\n", - "adding: mem time91, current time 173, horizon 82\n", - "adding: mem time92, current time 173, horizon 81\n", - "adding: mem time93, current time 173, horizon 80\n", - "adding: mem time94, current time 173, horizon 79\n", - "adding: mem time95, current time 173, horizon 78\n", - "adding: mem time96, current time 173, horizon 77\n", - "adding: mem time97, current time 173, horizon 76\n", - "adding: mem time98, current time 173, horizon 75\n", - "adding: mem time99, current time 173, horizon 74\n", - "adding: mem time100, current time 173, horizon 73\n", - "adding: mem time101, current time 173, horizon 72\n", - "adding: mem time102, current time 173, horizon 71\n", - "adding: mem time103, current time 173, horizon 70\n", - "adding: mem time104, current time 173, horizon 69\n", - "adding: mem time105, current time 173, horizon 68\n", - "adding: mem time106, current time 173, horizon 67\n", - "adding: mem time107, current time 173, horizon 66\n", - "adding: mem time108, current time 173, horizon 65\n", - "adding: mem time109, current time 173, horizon 64\n", - "adding: mem time110, current time 173, horizon 63\n", - "adding: mem time111, current time 173, horizon 62\n", - "adding: mem time112, current time 173, horizon 61\n", - "adding: mem time113, current time 173, horizon 60\n", - "adding: mem time114, current time 173, horizon 59\n", - "adding: mem time115, current time 173, horizon 58\n", - "adding: mem time116, current time 173, horizon 57\n", - "adding: mem time117, current time 173, horizon 56\n", - "adding: mem time118, current time 173, horizon 55\n", - "adding: mem time119, current time 173, horizon 54\n", - "adding: mem time120, current time 173, horizon 53\n", - "adding: mem time121, current time 173, horizon 52\n", - "adding: mem time122, current time 173, horizon 51\n", - "adding: mem time123, current time 173, horizon 50\n", - "adding: mem time124, current time 173, horizon 49\n", - "adding: mem time125, current time 173, horizon 48\n", - "adding: mem time126, current time 173, horizon 47\n", - "adding: mem time127, current time 173, horizon 46\n", - "adding: mem time128, current time 173, horizon 45\n", - "adding: mem time129, current time 173, horizon 44\n", - "adding: mem time130, current time 173, horizon 43\n", - "adding: mem time131, current time 173, horizon 42\n", - "adding: mem time132, current time 173, horizon 41\n", - "adding: mem time133, current time 173, horizon 40\n", - "adding: mem time134, current time 173, horizon 39\n", - "adding: mem time135, current time 173, horizon 38\n", - "adding: mem time136, current time 173, horizon 37\n", - "adding: mem time137, current time 173, horizon 36\n", - "adding: mem time138, current time 173, horizon 35\n", - "adding: mem time139, current time 173, horizon 34\n", - "adding: mem time140, current time 173, horizon 33\n", - "adding: mem time141, current time 173, horizon 32\n", - "adding: mem time142, current time 173, horizon 31\n", - "adding: mem time143, current time 173, horizon 30\n", - "adding: mem time144, current time 173, horizon 29\n", - "adding: mem time145, current time 173, horizon 28\n", - "adding: mem time146, current time 173, horizon 27\n", - "adding: mem time147, current time 173, horizon 26\n", - "adding: mem time148, current time 173, horizon 25\n", - "adding: mem time149, current time 173, horizon 24\n", - "adding: mem time150, current time 173, horizon 23\n", - "adding: mem time151, current time 173, horizon 22\n", - "adding: mem time152, current time 173, horizon 21\n", - "adding: mem time153, current time 173, horizon 20\n", - "adding: mem time154, current time 173, horizon 19\n", - "adding: mem time155, current time 173, horizon 18\n", - "adding: mem time156, current time 173, horizon 17\n", - "adding: mem time157, current time 173, horizon 16\n", - "adding: mem time158, current time 173, horizon 15\n", - "adding: mem time159, current time 173, horizon 14\n", - "adding: mem time160, current time 173, horizon 13\n", - "adding: mem time161, current time 173, horizon 12\n", - "adding: mem time162, current time 173, horizon 11\n", - "adding: mem time163, current time 173, horizon 10\n", - "adding: mem time164, current time 173, horizon 9\n", - "adding: mem time165, current time 173, horizon 8\n", - "adding: mem time166, current time 173, horizon 7\n", - "adding: mem time167, current time 173, horizon 6\n", - "adding: mem time168, current time 173, horizon 5\n", - "adding: mem time169, current time 173, horizon 4\n", - "adding: mem time170, current time 173, horizon 3\n", - "adding: mem time171, current time 173, horizon 2\n", - "adding: mem time172, current time 173, horizon 1\n", - "adding: mem time0, current time 174, horizon 174\n", - "adding: mem time1, current time 174, horizon 173\n", - "adding: mem time2, current time 174, horizon 172\n", - "adding: mem time3, current time 174, horizon 171\n", - "adding: mem time4, current time 174, horizon 170\n", - "adding: mem time5, current time 174, horizon 169\n", - "adding: mem time6, current time 174, horizon 168\n", - "adding: mem time7, current time 174, horizon 167\n", - "adding: mem time8, current time 174, horizon 166\n", - "adding: mem time9, current time 174, horizon 165\n", - "adding: mem time10, current time 174, horizon 164\n", - "adding: mem time11, current time 174, horizon 163\n", - "adding: mem time12, current time 174, horizon 162\n", - "adding: mem time13, current time 174, horizon 161\n", - "adding: mem time14, current time 174, horizon 160\n", - "adding: mem time15, current time 174, horizon 159\n", - "adding: mem time16, current time 174, horizon 158\n", - "adding: mem time17, current time 174, horizon 157\n", - "adding: mem time18, current time 174, horizon 156\n", - "adding: mem time19, current time 174, horizon 155\n", - "adding: mem time20, current time 174, horizon 154\n", - "adding: mem time21, current time 174, horizon 153\n", - "adding: mem time22, current time 174, horizon 152\n", - "adding: mem time23, current time 174, horizon 151\n", - "adding: mem time24, current time 174, horizon 150\n", - "adding: mem time25, current time 174, horizon 149\n", - "adding: mem time26, current time 174, horizon 148\n", - "adding: mem time27, current time 174, horizon 147\n", - "adding: mem time28, current time 174, horizon 146\n", - "adding: mem time29, current time 174, horizon 145\n", - "adding: mem time30, current time 174, horizon 144\n", - "adding: mem time31, current time 174, horizon 143\n", - "adding: mem time32, current time 174, horizon 142\n", - "adding: mem time33, current time 174, horizon 141\n", - "adding: mem time34, current time 174, horizon 140\n", - "adding: mem time35, current time 174, horizon 139\n", - "adding: mem time36, current time 174, horizon 138\n", - "adding: mem time37, current time 174, horizon 137\n", - "adding: mem time38, current time 174, horizon 136\n", - "adding: mem time39, current time 174, horizon 135\n", - "adding: mem time40, current time 174, horizon 134\n", - "adding: mem time41, current time 174, horizon 133\n", - "adding: mem time42, current time 174, horizon 132\n", - "adding: mem time43, current time 174, horizon 131\n", - "adding: mem time44, current time 174, horizon 130\n", - "adding: mem time45, current time 174, horizon 129\n", - "adding: mem time46, current time 174, horizon 128\n", - "adding: mem time47, current time 174, horizon 127\n", - "adding: mem time48, current time 174, horizon 126\n", - "adding: mem time49, current time 174, horizon 125\n", - "adding: mem time50, current time 174, horizon 124\n", - "adding: mem time51, current time 174, horizon 123\n", - "adding: mem time52, current time 174, horizon 122\n", - "adding: mem time53, current time 174, horizon 121\n", - "adding: mem time54, current time 174, horizon 120\n", - "adding: mem time55, current time 174, horizon 119\n", - "adding: mem time56, current time 174, horizon 118\n", - "adding: mem time57, current time 174, horizon 117\n", - "adding: mem time58, current time 174, horizon 116\n", - "adding: mem time59, current time 174, horizon 115\n", - "adding: mem time60, current time 174, horizon 114\n", - "adding: mem time61, current time 174, horizon 113\n", - "adding: mem time62, current time 174, horizon 112\n", - "adding: mem time63, current time 174, horizon 111\n", - "adding: mem time64, current time 174, horizon 110\n", - "adding: mem time65, current time 174, horizon 109\n", - "adding: mem time66, current time 174, horizon 108\n", - "adding: mem time67, current time 174, horizon 107\n", - "adding: mem time68, current time 174, horizon 106\n", - "adding: mem time69, current time 174, horizon 105\n", - "adding: mem time70, current time 174, horizon 104\n", - "adding: mem time71, current time 174, horizon 103\n", - "adding: mem time72, current time 174, horizon 102\n", - "adding: mem time73, current time 174, horizon 101\n", - "adding: mem time74, current time 174, horizon 100\n", - "adding: mem time75, current time 174, horizon 99\n", - "adding: mem time76, current time 174, horizon 98\n", - "adding: mem time77, current time 174, horizon 97\n", - "adding: mem time78, current time 174, horizon 96\n", - "adding: mem time79, current time 174, horizon 95\n", - "adding: mem time80, current time 174, horizon 94\n", - "adding: mem time81, current time 174, horizon 93\n", - "adding: mem time82, current time 174, horizon 92\n", - "adding: mem time83, current time 174, horizon 91\n", - "adding: mem time84, current time 174, horizon 90\n", - "adding: mem time85, current time 174, horizon 89\n", - "adding: mem time86, current time 174, horizon 88\n", - "adding: mem time87, current time 174, horizon 87\n", - "adding: mem time88, current time 174, horizon 86\n", - "adding: mem time89, current time 174, horizon 85\n", - "adding: mem time90, current time 174, horizon 84\n", - "adding: mem time91, current time 174, horizon 83\n", - "adding: mem time92, current time 174, horizon 82\n", - "adding: mem time93, current time 174, horizon 81\n", - "adding: mem time94, current time 174, horizon 80\n", - "adding: mem time95, current time 174, horizon 79\n", - "adding: mem time96, current time 174, horizon 78\n", - "adding: mem time97, current time 174, horizon 77\n", - "adding: mem time98, current time 174, horizon 76\n", - "adding: mem time99, current time 174, horizon 75\n", - "adding: mem time100, current time 174, horizon 74\n", - "adding: mem time101, current time 174, horizon 73\n", - "adding: mem time102, current time 174, horizon 72\n", - "adding: mem time103, current time 174, horizon 71\n", - "adding: mem time104, current time 174, horizon 70\n", - "adding: mem time105, current time 174, horizon 69\n", - "adding: mem time106, current time 174, horizon 68\n", - "adding: mem time107, current time 174, horizon 67\n", - "adding: mem time108, current time 174, horizon 66\n", - "adding: mem time109, current time 174, horizon 65\n", - "adding: mem time110, current time 174, horizon 64\n", - "adding: mem time111, current time 174, horizon 63\n", - "adding: mem time112, current time 174, horizon 62\n", - "adding: mem time113, current time 174, horizon 61\n", - "adding: mem time114, current time 174, horizon 60\n", - "adding: mem time115, current time 174, horizon 59\n", - "adding: mem time116, current time 174, horizon 58\n", - "adding: mem time117, current time 174, horizon 57\n", - "adding: mem time118, current time 174, horizon 56\n", - "adding: mem time119, current time 174, horizon 55\n", - "adding: mem time120, current time 174, horizon 54\n", - "adding: mem time121, current time 174, horizon 53\n", - "adding: mem time122, current time 174, horizon 52\n", - "adding: mem time123, current time 174, horizon 51\n", - "adding: mem time124, current time 174, horizon 50\n", - "adding: mem time125, current time 174, horizon 49\n", - "adding: mem time126, current time 174, horizon 48\n", - "adding: mem time127, current time 174, horizon 47\n", - "adding: mem time128, current time 174, horizon 46\n", - "adding: mem time129, current time 174, horizon 45\n", - "adding: mem time130, current time 174, horizon 44\n", - "adding: mem time131, current time 174, horizon 43\n", - "adding: mem time132, current time 174, horizon 42\n", - "adding: mem time133, current time 174, horizon 41\n", - "adding: mem time134, current time 174, horizon 40\n", - "adding: mem time135, current time 174, horizon 39\n", - "adding: mem time136, current time 174, horizon 38\n", - "adding: mem time137, current time 174, horizon 37\n", - "adding: mem time138, current time 174, horizon 36\n", - "adding: mem time139, current time 174, horizon 35\n", - "adding: mem time140, current time 174, horizon 34\n", - "adding: mem time141, current time 174, horizon 33\n", - "adding: mem time142, current time 174, horizon 32\n", - "adding: mem time143, current time 174, horizon 31\n", - "adding: mem time144, current time 174, horizon 30\n", - "adding: mem time145, current time 174, horizon 29\n", - "adding: mem time146, current time 174, horizon 28\n", - "adding: mem time147, current time 174, horizon 27\n", - "adding: mem time148, current time 174, horizon 26\n", - "adding: mem time149, current time 174, horizon 25\n", - "adding: mem time150, current time 174, horizon 24\n", - "adding: mem time151, current time 174, horizon 23\n", - "adding: mem time152, current time 174, horizon 22\n", - "adding: mem time153, current time 174, horizon 21\n", - "adding: mem time154, current time 174, horizon 20\n", - "adding: mem time155, current time 174, horizon 19\n", - "adding: mem time156, current time 174, horizon 18\n", - "adding: mem time157, current time 174, horizon 17\n", - "adding: mem time158, current time 174, horizon 16\n", - "adding: mem time159, current time 174, horizon 15\n", - "adding: mem time160, current time 174, horizon 14\n", - "adding: mem time161, current time 174, horizon 13\n", - "adding: mem time162, current time 174, horizon 12\n", - "adding: mem time163, current time 174, horizon 11\n", - "adding: mem time164, current time 174, horizon 10\n", - "adding: mem time165, current time 174, horizon 9\n", - "adding: mem time166, current time 174, horizon 8\n", - "adding: mem time167, current time 174, horizon 7\n", - "adding: mem time168, current time 174, horizon 6\n", - "adding: mem time169, current time 174, horizon 5\n", - "adding: mem time170, current time 174, horizon 4\n", - "adding: mem time171, current time 174, horizon 3\n", - "adding: mem time172, current time 174, horizon 2\n", - "adding: mem time173, current time 174, horizon 1\n", - "adding: mem time0, current time 175, horizon 175\n", - "adding: mem time1, current time 175, horizon 174\n", - "adding: mem time2, current time 175, horizon 173\n", - "adding: mem time3, current time 175, horizon 172\n", - "adding: mem time4, current time 175, horizon 171\n", - "adding: mem time5, current time 175, horizon 170\n", - "adding: mem time6, current time 175, horizon 169\n", - "adding: mem time7, current time 175, horizon 168\n", - "adding: mem time8, current time 175, horizon 167\n", - "adding: mem time9, current time 175, horizon 166\n", - "adding: mem time10, current time 175, horizon 165\n", - "adding: mem time11, current time 175, horizon 164\n", - "adding: mem time12, current time 175, horizon 163\n", - "adding: mem time13, current time 175, horizon 162\n", - "adding: mem time14, current time 175, horizon 161\n", - "adding: mem time15, current time 175, horizon 160\n", - "adding: mem time16, current time 175, horizon 159\n", - "adding: mem time17, current time 175, horizon 158\n", - "adding: mem time18, current time 175, horizon 157\n", - "adding: mem time19, current time 175, horizon 156\n", - "adding: mem time20, current time 175, horizon 155\n", - "adding: mem time21, current time 175, horizon 154\n", - "adding: mem time22, current time 175, horizon 153\n", - "adding: mem time23, current time 175, horizon 152\n", - "adding: mem time24, current time 175, horizon 151\n", - "adding: mem time25, current time 175, horizon 150\n", - "adding: mem time26, current time 175, horizon 149\n", - "adding: mem time27, current time 175, horizon 148\n", - "adding: mem time28, current time 175, horizon 147\n", - "adding: mem time29, current time 175, horizon 146\n", - "adding: mem time30, current time 175, horizon 145\n", - "adding: mem time31, current time 175, horizon 144\n", - "adding: mem time32, current time 175, horizon 143\n", - "adding: mem time33, current time 175, horizon 142\n", - "adding: mem time34, current time 175, horizon 141\n", - "adding: mem time35, current time 175, horizon 140\n", - "adding: mem time36, current time 175, horizon 139\n", - "adding: mem time37, current time 175, horizon 138\n", - "adding: mem time38, current time 175, horizon 137\n", - "adding: mem time39, current time 175, horizon 136\n", - "adding: mem time40, current time 175, horizon 135\n", - "adding: mem time41, current time 175, horizon 134\n", - "adding: mem time42, current time 175, horizon 133\n", - "adding: mem time43, current time 175, horizon 132\n", - "adding: mem time44, current time 175, horizon 131\n", - "adding: mem time45, current time 175, horizon 130\n", - "adding: mem time46, current time 175, horizon 129\n", - "adding: mem time47, current time 175, horizon 128\n", - "adding: mem time48, current time 175, horizon 127\n", - "adding: mem time49, current time 175, horizon 126\n", - "adding: mem time50, current time 175, horizon 125\n", - "adding: mem time51, current time 175, horizon 124\n", - "adding: mem time52, current time 175, horizon 123\n", - "adding: mem time53, current time 175, horizon 122\n", - "adding: mem time54, current time 175, horizon 121\n", - "adding: mem time55, current time 175, horizon 120\n", - "adding: mem time56, current time 175, horizon 119\n", - "adding: mem time57, current time 175, horizon 118\n", - "adding: mem time58, current time 175, horizon 117\n", - "adding: mem time59, current time 175, horizon 116\n", - "adding: mem time60, current time 175, horizon 115\n", - "adding: mem time61, current time 175, horizon 114\n", - "adding: mem time62, current time 175, horizon 113\n", - "adding: mem time63, current time 175, horizon 112\n", - "adding: mem time64, current time 175, horizon 111\n", - "adding: mem time65, current time 175, horizon 110\n", - "adding: mem time66, current time 175, horizon 109\n", - "adding: mem time67, current time 175, horizon 108\n", - "adding: mem time68, current time 175, horizon 107\n", - "adding: mem time69, current time 175, horizon 106\n", - "adding: mem time70, current time 175, horizon 105\n", - "adding: mem time71, current time 175, horizon 104\n", - "adding: mem time72, current time 175, horizon 103\n", - "adding: mem time73, current time 175, horizon 102\n", - "adding: mem time74, current time 175, horizon 101\n", - "adding: mem time75, current time 175, horizon 100\n", - "adding: mem time76, current time 175, horizon 99\n", - "adding: mem time77, current time 175, horizon 98\n", - "adding: mem time78, current time 175, horizon 97\n", - "adding: mem time79, current time 175, horizon 96\n", - "adding: mem time80, current time 175, horizon 95\n", - "adding: mem time81, current time 175, horizon 94\n", - "adding: mem time82, current time 175, horizon 93\n", - "adding: mem time83, current time 175, horizon 92\n", - "adding: mem time84, current time 175, horizon 91\n", - "adding: mem time85, current time 175, horizon 90\n", - "adding: mem time86, current time 175, horizon 89\n", - "adding: mem time87, current time 175, horizon 88\n", - "adding: mem time88, current time 175, horizon 87\n", - "adding: mem time89, current time 175, horizon 86\n", - "adding: mem time90, current time 175, horizon 85\n", - "adding: mem time91, current time 175, horizon 84\n", - "adding: mem time92, current time 175, horizon 83\n", - "adding: mem time93, current time 175, horizon 82\n", - "adding: mem time94, current time 175, horizon 81\n", - "adding: mem time95, current time 175, horizon 80\n", - "adding: mem time96, current time 175, horizon 79\n", - "adding: mem time97, current time 175, horizon 78\n", - "adding: mem time98, current time 175, horizon 77\n", - "adding: mem time99, current time 175, horizon 76\n", - "adding: mem time100, current time 175, horizon 75\n", - "adding: mem time101, current time 175, horizon 74\n", - "adding: mem time102, current time 175, horizon 73\n", - "adding: mem time103, current time 175, horizon 72\n", - "adding: mem time104, current time 175, horizon 71\n", - "adding: mem time105, current time 175, horizon 70\n", - "adding: mem time106, current time 175, horizon 69\n", - "adding: mem time107, current time 175, horizon 68\n", - "adding: mem time108, current time 175, horizon 67\n", - "adding: mem time109, current time 175, horizon 66\n", - "adding: mem time110, current time 175, horizon 65\n", - "adding: mem time111, current time 175, horizon 64\n", - "adding: mem time112, current time 175, horizon 63\n", - "adding: mem time113, current time 175, horizon 62\n", - "adding: mem time114, current time 175, horizon 61\n", - "adding: mem time115, current time 175, horizon 60\n", - "adding: mem time116, current time 175, horizon 59\n", - "adding: mem time117, current time 175, horizon 58\n", - "adding: mem time118, current time 175, horizon 57\n", - "adding: mem time119, current time 175, horizon 56\n", - "adding: mem time120, current time 175, horizon 55\n", - "adding: mem time121, current time 175, horizon 54\n", - "adding: mem time122, current time 175, horizon 53\n", - "adding: mem time123, current time 175, horizon 52\n", - "adding: mem time124, current time 175, horizon 51\n", - "adding: mem time125, current time 175, horizon 50\n", - "adding: mem time126, current time 175, horizon 49\n", - "adding: mem time127, current time 175, horizon 48\n", - "adding: mem time128, current time 175, horizon 47\n", - "adding: mem time129, current time 175, horizon 46\n", - "adding: mem time130, current time 175, horizon 45\n", - "adding: mem time131, current time 175, horizon 44\n", - "adding: mem time132, current time 175, horizon 43\n", - "adding: mem time133, current time 175, horizon 42\n", - "adding: mem time134, current time 175, horizon 41\n", - "adding: mem time135, current time 175, horizon 40\n", - "adding: mem time136, current time 175, horizon 39\n", - "adding: mem time137, current time 175, horizon 38\n", - "adding: mem time138, current time 175, horizon 37\n", - "adding: mem time139, current time 175, horizon 36\n", - "adding: mem time140, current time 175, horizon 35\n", - "adding: mem time141, current time 175, horizon 34\n", - "adding: mem time142, current time 175, horizon 33\n", - "adding: mem time143, current time 175, horizon 32\n", - "adding: mem time144, current time 175, horizon 31\n", - "adding: mem time145, current time 175, horizon 30\n", - "adding: mem time146, current time 175, horizon 29\n", - "adding: mem time147, current time 175, horizon 28\n", - "adding: mem time148, current time 175, horizon 27\n", - "adding: mem time149, current time 175, horizon 26\n", - "adding: mem time150, current time 175, horizon 25\n", - "adding: mem time151, current time 175, horizon 24\n", - "adding: mem time152, current time 175, horizon 23\n", - "adding: mem time153, current time 175, horizon 22\n", - "adding: mem time154, current time 175, horizon 21\n", - "adding: mem time155, current time 175, horizon 20\n", - "adding: mem time156, current time 175, horizon 19\n", - "adding: mem time157, current time 175, horizon 18\n", - "adding: mem time158, current time 175, horizon 17\n", - "adding: mem time159, current time 175, horizon 16\n", - "adding: mem time160, current time 175, horizon 15\n", - "adding: mem time161, current time 175, horizon 14\n", - "adding: mem time162, current time 175, horizon 13\n", - "adding: mem time163, current time 175, horizon 12\n", - "adding: mem time164, current time 175, horizon 11\n", - "adding: mem time165, current time 175, horizon 10\n", - "adding: mem time166, current time 175, horizon 9\n", - "adding: mem time167, current time 175, horizon 8\n", - "adding: mem time168, current time 175, horizon 7\n", - "adding: mem time169, current time 175, horizon 6\n", - "adding: mem time170, current time 175, horizon 5\n", - "adding: mem time171, current time 175, horizon 4\n", - "adding: mem time172, current time 175, horizon 3\n", - "adding: mem time173, current time 175, horizon 2\n", - "adding: mem time174, current time 175, horizon 1\n", - "adding: mem time0, current time 176, horizon 176\n", - "adding: mem time1, current time 176, horizon 175\n", - "adding: mem time2, current time 176, horizon 174\n", - "adding: mem time3, current time 176, horizon 173\n", - "adding: mem time4, current time 176, horizon 172\n", - "adding: mem time5, current time 176, horizon 171\n", - "adding: mem time6, current time 176, horizon 170\n", - "adding: mem time7, current time 176, horizon 169\n", - "adding: mem time8, current time 176, horizon 168\n", - "adding: mem time9, current time 176, horizon 167\n", - "adding: mem time10, current time 176, horizon 166\n", - "adding: mem time11, current time 176, horizon 165\n", - "adding: mem time12, current time 176, horizon 164\n", - "adding: mem time13, current time 176, horizon 163\n", - "adding: mem time14, current time 176, horizon 162\n", - "adding: mem time15, current time 176, horizon 161\n", - "adding: mem time16, current time 176, horizon 160\n", - "adding: mem time17, current time 176, horizon 159\n", - "adding: mem time18, current time 176, horizon 158\n", - "adding: mem time19, current time 176, horizon 157\n", - "adding: mem time20, current time 176, horizon 156\n", - "adding: mem time21, current time 176, horizon 155\n", - "adding: mem time22, current time 176, horizon 154\n", - "adding: mem time23, current time 176, horizon 153\n", - "adding: mem time24, current time 176, horizon 152\n", - "adding: mem time25, current time 176, horizon 151\n", - "adding: mem time26, current time 176, horizon 150\n", - "adding: mem time27, current time 176, horizon 149\n", - "adding: mem time28, current time 176, horizon 148\n", - "adding: mem time29, current time 176, horizon 147\n", - "adding: mem time30, current time 176, horizon 146\n", - "adding: mem time31, current time 176, horizon 145\n", - "adding: mem time32, current time 176, horizon 144\n", - "adding: mem time33, current time 176, horizon 143\n", - "adding: mem time34, current time 176, horizon 142\n", - "adding: mem time35, current time 176, horizon 141\n", - "adding: mem time36, current time 176, horizon 140\n", - "adding: mem time37, current time 176, horizon 139\n", - "adding: mem time38, current time 176, horizon 138\n", - "adding: mem time39, current time 176, horizon 137\n", - "adding: mem time40, current time 176, horizon 136\n", - "adding: mem time41, current time 176, horizon 135\n", - "adding: mem time42, current time 176, horizon 134\n", - "adding: mem time43, current time 176, horizon 133\n", - "adding: mem time44, current time 176, horizon 132\n", - "adding: mem time45, current time 176, horizon 131\n", - "adding: mem time46, current time 176, horizon 130\n", - "adding: mem time47, current time 176, horizon 129\n", - "adding: mem time48, current time 176, horizon 128\n", - "adding: mem time49, current time 176, horizon 127\n", - "adding: mem time50, current time 176, horizon 126\n", - "adding: mem time51, current time 176, horizon 125\n", - "adding: mem time52, current time 176, horizon 124\n", - "adding: mem time53, current time 176, horizon 123\n", - "adding: mem time54, current time 176, horizon 122\n", - "adding: mem time55, current time 176, horizon 121\n", - "adding: mem time56, current time 176, horizon 120\n", - "adding: mem time57, current time 176, horizon 119\n", - "adding: mem time58, current time 176, horizon 118\n", - "adding: mem time59, current time 176, horizon 117\n", - "adding: mem time60, current time 176, horizon 116\n", - "adding: mem time61, current time 176, horizon 115\n", - "adding: mem time62, current time 176, horizon 114\n", - "adding: mem time63, current time 176, horizon 113\n", - "adding: mem time64, current time 176, horizon 112\n", - "adding: mem time65, current time 176, horizon 111\n", - "adding: mem time66, current time 176, horizon 110\n", - "adding: mem time67, current time 176, horizon 109\n", - "adding: mem time68, current time 176, horizon 108\n", - "adding: mem time69, current time 176, horizon 107\n", - "adding: mem time70, current time 176, horizon 106\n", - "adding: mem time71, current time 176, horizon 105\n", - "adding: mem time72, current time 176, horizon 104\n", - "adding: mem time73, current time 176, horizon 103\n", - "adding: mem time74, current time 176, horizon 102\n", - "adding: mem time75, current time 176, horizon 101\n", - "adding: mem time76, current time 176, horizon 100\n", - "adding: mem time77, current time 176, horizon 99\n", - "adding: mem time78, current time 176, horizon 98\n", - "adding: mem time79, current time 176, horizon 97\n", - "adding: mem time80, current time 176, horizon 96\n", - "adding: mem time81, current time 176, horizon 95\n", - "adding: mem time82, current time 176, horizon 94\n", - "adding: mem time83, current time 176, horizon 93\n", - "adding: mem time84, current time 176, horizon 92\n", - "adding: mem time85, current time 176, horizon 91\n", - "adding: mem time86, current time 176, horizon 90\n", - "adding: mem time87, current time 176, horizon 89\n", - "adding: mem time88, current time 176, horizon 88\n", - "adding: mem time89, current time 176, horizon 87\n", - "adding: mem time90, current time 176, horizon 86\n", - "adding: mem time91, current time 176, horizon 85\n", - "adding: mem time92, current time 176, horizon 84\n", - "adding: mem time93, current time 176, horizon 83\n", - "adding: mem time94, current time 176, horizon 82\n", - "adding: mem time95, current time 176, horizon 81\n", - "adding: mem time96, current time 176, horizon 80\n", - "adding: mem time97, current time 176, horizon 79\n", - "adding: mem time98, current time 176, horizon 78\n", - "adding: mem time99, current time 176, horizon 77\n", - "adding: mem time100, current time 176, horizon 76\n", - "adding: mem time101, current time 176, horizon 75\n", - "adding: mem time102, current time 176, horizon 74\n", - "adding: mem time103, current time 176, horizon 73\n", - "adding: mem time104, current time 176, horizon 72\n", - "adding: mem time105, current time 176, horizon 71\n", - "adding: mem time106, current time 176, horizon 70\n", - "adding: mem time107, current time 176, horizon 69\n", - "adding: mem time108, current time 176, horizon 68\n", - "adding: mem time109, current time 176, horizon 67\n", - "adding: mem time110, current time 176, horizon 66\n", - "adding: mem time111, current time 176, horizon 65\n", - "adding: mem time112, current time 176, horizon 64\n", - "adding: mem time113, current time 176, horizon 63\n", - "adding: mem time114, current time 176, horizon 62\n", - "adding: mem time115, current time 176, horizon 61\n", - "adding: mem time116, current time 176, horizon 60\n", - "adding: mem time117, current time 176, horizon 59\n", - "adding: mem time118, current time 176, horizon 58\n", - "adding: mem time119, current time 176, horizon 57\n", - "adding: mem time120, current time 176, horizon 56\n", - "adding: mem time121, current time 176, horizon 55\n", - "adding: mem time122, current time 176, horizon 54\n", - "adding: mem time123, current time 176, horizon 53\n", - "adding: mem time124, current time 176, horizon 52\n", - "adding: mem time125, current time 176, horizon 51\n", - "adding: mem time126, current time 176, horizon 50\n", - "adding: mem time127, current time 176, horizon 49\n", - "adding: mem time128, current time 176, horizon 48\n", - "adding: mem time129, current time 176, horizon 47\n", - "adding: mem time130, current time 176, horizon 46\n", - "adding: mem time131, current time 176, horizon 45\n", - "adding: mem time132, current time 176, horizon 44\n", - "adding: mem time133, current time 176, horizon 43\n", - "adding: mem time134, current time 176, horizon 42\n", - "adding: mem time135, current time 176, horizon 41\n", - "adding: mem time136, current time 176, horizon 40\n", - "adding: mem time137, current time 176, horizon 39\n", - "adding: mem time138, current time 176, horizon 38\n", - "adding: mem time139, current time 176, horizon 37\n", - "adding: mem time140, current time 176, horizon 36\n", - "adding: mem time141, current time 176, horizon 35\n", - "adding: mem time142, current time 176, horizon 34\n", - "adding: mem time143, current time 176, horizon 33\n", - "adding: mem time144, current time 176, horizon 32\n", - "adding: mem time145, current time 176, horizon 31\n", - "adding: mem time146, current time 176, horizon 30\n", - "adding: mem time147, current time 176, horizon 29\n", - "adding: mem time148, current time 176, horizon 28\n", - "adding: mem time149, current time 176, horizon 27\n", - "adding: mem time150, current time 176, horizon 26\n", - "adding: mem time151, current time 176, horizon 25\n", - "adding: mem time152, current time 176, horizon 24\n", - "adding: mem time153, current time 176, horizon 23\n", - "adding: mem time154, current time 176, horizon 22\n", - "adding: mem time155, current time 176, horizon 21\n", - "adding: mem time156, current time 176, horizon 20\n", - "adding: mem time157, current time 176, horizon 19\n", - "adding: mem time158, current time 176, horizon 18\n", - "adding: mem time159, current time 176, horizon 17\n", - "adding: mem time160, current time 176, horizon 16\n", - "adding: mem time161, current time 176, horizon 15\n", - "adding: mem time162, current time 176, horizon 14\n", - "adding: mem time163, current time 176, horizon 13\n", - "adding: mem time164, current time 176, horizon 12\n", - "adding: mem time165, current time 176, horizon 11\n", - "adding: mem time166, current time 176, horizon 10\n", - "adding: mem time167, current time 176, horizon 9\n", - "adding: mem time168, current time 176, horizon 8\n", - "adding: mem time169, current time 176, horizon 7\n", - "adding: mem time170, current time 176, horizon 6\n", - "adding: mem time171, current time 176, horizon 5\n", - "adding: mem time172, current time 176, horizon 4\n", - "adding: mem time173, current time 176, horizon 3\n", - "adding: mem time174, current time 176, horizon 2\n", - "adding: mem time175, current time 176, horizon 1\n", - "adding: mem time0, current time 177, horizon 177\n", - "adding: mem time1, current time 177, horizon 176\n", - "adding: mem time2, current time 177, horizon 175\n", - "adding: mem time3, current time 177, horizon 174\n", - "adding: mem time4, current time 177, horizon 173\n", - "adding: mem time5, current time 177, horizon 172\n", - "adding: mem time6, current time 177, horizon 171\n", - "adding: mem time7, current time 177, horizon 170\n", - "adding: mem time8, current time 177, horizon 169\n", - "adding: mem time9, current time 177, horizon 168\n", - "adding: mem time10, current time 177, horizon 167\n", - "adding: mem time11, current time 177, horizon 166\n", - "adding: mem time12, current time 177, horizon 165\n", - "adding: mem time13, current time 177, horizon 164\n", - "adding: mem time14, current time 177, horizon 163\n", - "adding: mem time15, current time 177, horizon 162\n", - "adding: mem time16, current time 177, horizon 161\n", - "adding: mem time17, current time 177, horizon 160\n", - "adding: mem time18, current time 177, horizon 159\n", - "adding: mem time19, current time 177, horizon 158\n", - "adding: mem time20, current time 177, horizon 157\n", - "adding: mem time21, current time 177, horizon 156\n", - "adding: mem time22, current time 177, horizon 155\n", - "adding: mem time23, current time 177, horizon 154\n", - "adding: mem time24, current time 177, horizon 153\n", - "adding: mem time25, current time 177, horizon 152\n", - "adding: mem time26, current time 177, horizon 151\n", - "adding: mem time27, current time 177, horizon 150\n", - "adding: mem time28, current time 177, horizon 149\n", - "adding: mem time29, current time 177, horizon 148\n", - "adding: mem time30, current time 177, horizon 147\n", - "adding: mem time31, current time 177, horizon 146\n", - "adding: mem time32, current time 177, horizon 145\n", - "adding: mem time33, current time 177, horizon 144\n", - "adding: mem time34, current time 177, horizon 143\n", - "adding: mem time35, current time 177, horizon 142\n", - "adding: mem time36, current time 177, horizon 141\n", - "adding: mem time37, current time 177, horizon 140\n", - "adding: mem time38, current time 177, horizon 139\n", - "adding: mem time39, current time 177, horizon 138\n", - "adding: mem time40, current time 177, horizon 137\n", - "adding: mem time41, current time 177, horizon 136\n", - "adding: mem time42, current time 177, horizon 135\n", - "adding: mem time43, current time 177, horizon 134\n", - "adding: mem time44, current time 177, horizon 133\n", - "adding: mem time45, current time 177, horizon 132\n", - "adding: mem time46, current time 177, horizon 131\n", - "adding: mem time47, current time 177, horizon 130\n", - "adding: mem time48, current time 177, horizon 129\n", - "adding: mem time49, current time 177, horizon 128\n", - "adding: mem time50, current time 177, horizon 127\n", - "adding: mem time51, current time 177, horizon 126\n", - "adding: mem time52, current time 177, horizon 125\n", - "adding: mem time53, current time 177, horizon 124\n", - "adding: mem time54, current time 177, horizon 123\n", - "adding: mem time55, current time 177, horizon 122\n", - "adding: mem time56, current time 177, horizon 121\n", - "adding: mem time57, current time 177, horizon 120\n", - "adding: mem time58, current time 177, horizon 119\n", - "adding: mem time59, current time 177, horizon 118\n", - "adding: mem time60, current time 177, horizon 117\n", - "adding: mem time61, current time 177, horizon 116\n", - "adding: mem time62, current time 177, horizon 115\n", - "adding: mem time63, current time 177, horizon 114\n", - "adding: mem time64, current time 177, horizon 113\n", - "adding: mem time65, current time 177, horizon 112\n", - "adding: mem time66, current time 177, horizon 111\n", - "adding: mem time67, current time 177, horizon 110\n", - "adding: mem time68, current time 177, horizon 109\n", - "adding: mem time69, current time 177, horizon 108\n", - "adding: mem time70, current time 177, horizon 107\n", - "adding: mem time71, current time 177, horizon 106\n", - "adding: mem time72, current time 177, horizon 105\n", - "adding: mem time73, current time 177, horizon 104\n", - "adding: mem time74, current time 177, horizon 103\n", - "adding: mem time75, current time 177, horizon 102\n", - "adding: mem time76, current time 177, horizon 101\n", - "adding: mem time77, current time 177, horizon 100\n", - "adding: mem time78, current time 177, horizon 99\n", - "adding: mem time79, current time 177, horizon 98\n", - "adding: mem time80, current time 177, horizon 97\n", - "adding: mem time81, current time 177, horizon 96\n", - "adding: mem time82, current time 177, horizon 95\n", - "adding: mem time83, current time 177, horizon 94\n", - "adding: mem time84, current time 177, horizon 93\n", - "adding: mem time85, current time 177, horizon 92\n", - "adding: mem time86, current time 177, horizon 91\n", - "adding: mem time87, current time 177, horizon 90\n", - "adding: mem time88, current time 177, horizon 89\n", - "adding: mem time89, current time 177, horizon 88\n", - "adding: mem time90, current time 177, horizon 87\n", - "adding: mem time91, current time 177, horizon 86\n", - "adding: mem time92, current time 177, horizon 85\n", - "adding: mem time93, current time 177, horizon 84\n", - "adding: mem time94, current time 177, horizon 83\n", - "adding: mem time95, current time 177, horizon 82\n", - "adding: mem time96, current time 177, horizon 81\n", - "adding: mem time97, current time 177, horizon 80\n", - "adding: mem time98, current time 177, horizon 79\n", - "adding: mem time99, current time 177, horizon 78\n", - "adding: mem time100, current time 177, horizon 77\n", - "adding: mem time101, current time 177, horizon 76\n", - "adding: mem time102, current time 177, horizon 75\n", - "adding: mem time103, current time 177, horizon 74\n", - "adding: mem time104, current time 177, horizon 73\n", - "adding: mem time105, current time 177, horizon 72\n", - "adding: mem time106, current time 177, horizon 71\n", - "adding: mem time107, current time 177, horizon 70\n", - "adding: mem time108, current time 177, horizon 69\n", - "adding: mem time109, current time 177, horizon 68\n", - "adding: mem time110, current time 177, horizon 67\n", - "adding: mem time111, current time 177, horizon 66\n", - "adding: mem time112, current time 177, horizon 65\n", - "adding: mem time113, current time 177, horizon 64\n", - "adding: mem time114, current time 177, horizon 63\n", - "adding: mem time115, current time 177, horizon 62\n", - "adding: mem time116, current time 177, horizon 61\n", - "adding: mem time117, current time 177, horizon 60\n", - "adding: mem time118, current time 177, horizon 59\n", - "adding: mem time119, current time 177, horizon 58\n", - "adding: mem time120, current time 177, horizon 57\n", - "adding: mem time121, current time 177, horizon 56\n", - "adding: mem time122, current time 177, horizon 55\n", - "adding: mem time123, current time 177, horizon 54\n", - "adding: mem time124, current time 177, horizon 53\n", - "adding: mem time125, current time 177, horizon 52\n", - "adding: mem time126, current time 177, horizon 51\n", - "adding: mem time127, current time 177, horizon 50\n", - "adding: mem time128, current time 177, horizon 49\n", - "adding: mem time129, current time 177, horizon 48\n", - "adding: mem time130, current time 177, horizon 47\n", - "adding: mem time131, current time 177, horizon 46\n", - "adding: mem time132, current time 177, horizon 45\n", - "adding: mem time133, current time 177, horizon 44\n", - "adding: mem time134, current time 177, horizon 43\n", - "adding: mem time135, current time 177, horizon 42\n", - "adding: mem time136, current time 177, horizon 41\n", - "adding: mem time137, current time 177, horizon 40\n", - "adding: mem time138, current time 177, horizon 39\n", - "adding: mem time139, current time 177, horizon 38\n", - "adding: mem time140, current time 177, horizon 37\n", - "adding: mem time141, current time 177, horizon 36\n", - "adding: mem time142, current time 177, horizon 35\n", - "adding: mem time143, current time 177, horizon 34\n", - "adding: mem time144, current time 177, horizon 33\n", - "adding: mem time145, current time 177, horizon 32\n", - "adding: mem time146, current time 177, horizon 31\n", - "adding: mem time147, current time 177, horizon 30\n", - "adding: mem time148, current time 177, horizon 29\n", - "adding: mem time149, current time 177, horizon 28\n", - "adding: mem time150, current time 177, horizon 27\n", - "adding: mem time151, current time 177, horizon 26\n", - "adding: mem time152, current time 177, horizon 25\n", - "adding: mem time153, current time 177, horizon 24\n", - "adding: mem time154, current time 177, horizon 23\n", - "adding: mem time155, current time 177, horizon 22\n", - "adding: mem time156, current time 177, horizon 21\n", - "adding: mem time157, current time 177, horizon 20\n", - "adding: mem time158, current time 177, horizon 19\n", - "adding: mem time159, current time 177, horizon 18\n", - "adding: mem time160, current time 177, horizon 17\n", - "adding: mem time161, current time 177, horizon 16\n", - "adding: mem time162, current time 177, horizon 15\n", - "adding: mem time163, current time 177, horizon 14\n", - "adding: mem time164, current time 177, horizon 13\n", - "adding: mem time165, current time 177, horizon 12\n", - "adding: mem time166, current time 177, horizon 11\n", - "adding: mem time167, current time 177, horizon 10\n", - "adding: mem time168, current time 177, horizon 9\n", - "adding: mem time169, current time 177, horizon 8\n", - "adding: mem time170, current time 177, horizon 7\n", - "adding: mem time171, current time 177, horizon 6\n", - "adding: mem time172, current time 177, horizon 5\n", - "adding: mem time173, current time 177, horizon 4\n", - "adding: mem time174, current time 177, horizon 3\n", - "adding: mem time175, current time 177, horizon 2\n", - "adding: mem time176, current time 177, horizon 1\n", - "adding: mem time0, current time 178, horizon 178\n", - "adding: mem time1, current time 178, horizon 177\n", - "adding: mem time2, current time 178, horizon 176\n", - "adding: mem time3, current time 178, horizon 175\n", - "adding: mem time4, current time 178, horizon 174\n", - "adding: mem time5, current time 178, horizon 173\n", - "adding: mem time6, current time 178, horizon 172\n", - "adding: mem time7, current time 178, horizon 171\n", - "adding: mem time8, current time 178, horizon 170\n", - "adding: mem time9, current time 178, horizon 169\n", - "adding: mem time10, current time 178, horizon 168\n", - "adding: mem time11, current time 178, horizon 167\n", - "adding: mem time12, current time 178, horizon 166\n", - "adding: mem time13, current time 178, horizon 165\n", - "adding: mem time14, current time 178, horizon 164\n", - "adding: mem time15, current time 178, horizon 163\n", - "adding: mem time16, current time 178, horizon 162\n", - "adding: mem time17, current time 178, horizon 161\n", - "adding: mem time18, current time 178, horizon 160\n", - "adding: mem time19, current time 178, horizon 159\n", - "adding: mem time20, current time 178, horizon 158\n", - "adding: mem time21, current time 178, horizon 157\n", - "adding: mem time22, current time 178, horizon 156\n", - "adding: mem time23, current time 178, horizon 155\n", - "adding: mem time24, current time 178, horizon 154\n", - "adding: mem time25, current time 178, horizon 153\n", - "adding: mem time26, current time 178, horizon 152\n", - "adding: mem time27, current time 178, horizon 151\n", - "adding: mem time28, current time 178, horizon 150\n", - "adding: mem time29, current time 178, horizon 149\n", - "adding: mem time30, current time 178, horizon 148\n", - "adding: mem time31, current time 178, horizon 147\n", - "adding: mem time32, current time 178, horizon 146\n", - "adding: mem time33, current time 178, horizon 145\n", - "adding: mem time34, current time 178, horizon 144\n", - "adding: mem time35, current time 178, horizon 143\n", - "adding: mem time36, current time 178, horizon 142\n", - "adding: mem time37, current time 178, horizon 141\n", - "adding: mem time38, current time 178, horizon 140\n", - "adding: mem time39, current time 178, horizon 139\n", - "adding: mem time40, current time 178, horizon 138\n", - "adding: mem time41, current time 178, horizon 137\n", - "adding: mem time42, current time 178, horizon 136\n", - "adding: mem time43, current time 178, horizon 135\n", - "adding: mem time44, current time 178, horizon 134\n", - "adding: mem time45, current time 178, horizon 133\n", - "adding: mem time46, current time 178, horizon 132\n", - "adding: mem time47, current time 178, horizon 131\n", - "adding: mem time48, current time 178, horizon 130\n", - "adding: mem time49, current time 178, horizon 129\n", - "adding: mem time50, current time 178, horizon 128\n", - "adding: mem time51, current time 178, horizon 127\n", - "adding: mem time52, current time 178, horizon 126\n", - "adding: mem time53, current time 178, horizon 125\n", - "adding: mem time54, current time 178, horizon 124\n", - "adding: mem time55, current time 178, horizon 123\n", - "adding: mem time56, current time 178, horizon 122\n", - "adding: mem time57, current time 178, horizon 121\n", - "adding: mem time58, current time 178, horizon 120\n", - "adding: mem time59, current time 178, horizon 119\n", - "adding: mem time60, current time 178, horizon 118\n", - "adding: mem time61, current time 178, horizon 117\n", - "adding: mem time62, current time 178, horizon 116\n", - "adding: mem time63, current time 178, horizon 115\n", - "adding: mem time64, current time 178, horizon 114\n", - "adding: mem time65, current time 178, horizon 113\n", - "adding: mem time66, current time 178, horizon 112\n", - "adding: mem time67, current time 178, horizon 111\n", - "adding: mem time68, current time 178, horizon 110\n", - "adding: mem time69, current time 178, horizon 109\n", - "adding: mem time70, current time 178, horizon 108\n", - "adding: mem time71, current time 178, horizon 107\n", - "adding: mem time72, current time 178, horizon 106\n", - "adding: mem time73, current time 178, horizon 105\n", - "adding: mem time74, current time 178, horizon 104\n", - "adding: mem time75, current time 178, horizon 103\n", - "adding: mem time76, current time 178, horizon 102\n", - "adding: mem time77, current time 178, horizon 101\n", - "adding: mem time78, current time 178, horizon 100\n", - "adding: mem time79, current time 178, horizon 99\n", - "adding: mem time80, current time 178, horizon 98\n", - "adding: mem time81, current time 178, horizon 97\n", - "adding: mem time82, current time 178, horizon 96\n", - "adding: mem time83, current time 178, horizon 95\n", - "adding: mem time84, current time 178, horizon 94\n", - "adding: mem time85, current time 178, horizon 93\n", - "adding: mem time86, current time 178, horizon 92\n", - "adding: mem time87, current time 178, horizon 91\n", - "adding: mem time88, current time 178, horizon 90\n", - "adding: mem time89, current time 178, horizon 89\n", - "adding: mem time90, current time 178, horizon 88\n", - "adding: mem time91, current time 178, horizon 87\n", - "adding: mem time92, current time 178, horizon 86\n", - "adding: mem time93, current time 178, horizon 85\n", - "adding: mem time94, current time 178, horizon 84\n", - "adding: mem time95, current time 178, horizon 83\n", - "adding: mem time96, current time 178, horizon 82\n", - "adding: mem time97, current time 178, horizon 81\n", - "adding: mem time98, current time 178, horizon 80\n", - "adding: mem time99, current time 178, horizon 79\n", - "adding: mem time100, current time 178, horizon 78\n", - "adding: mem time101, current time 178, horizon 77\n", - "adding: mem time102, current time 178, horizon 76\n", - "adding: mem time103, current time 178, horizon 75\n", - "adding: mem time104, current time 178, horizon 74\n", - "adding: mem time105, current time 178, horizon 73\n", - "adding: mem time106, current time 178, horizon 72\n", - "adding: mem time107, current time 178, horizon 71\n", - "adding: mem time108, current time 178, horizon 70\n", - "adding: mem time109, current time 178, horizon 69\n", - "adding: mem time110, current time 178, horizon 68\n", - "adding: mem time111, current time 178, horizon 67\n", - "adding: mem time112, current time 178, horizon 66\n", - "adding: mem time113, current time 178, horizon 65\n", - "adding: mem time114, current time 178, horizon 64\n", - "adding: mem time115, current time 178, horizon 63\n", - "adding: mem time116, current time 178, horizon 62\n", - "adding: mem time117, current time 178, horizon 61\n", - "adding: mem time118, current time 178, horizon 60\n", - "adding: mem time119, current time 178, horizon 59\n", - "adding: mem time120, current time 178, horizon 58\n", - "adding: mem time121, current time 178, horizon 57\n", - "adding: mem time122, current time 178, horizon 56\n", - "adding: mem time123, current time 178, horizon 55\n", - "adding: mem time124, current time 178, horizon 54\n", - "adding: mem time125, current time 178, horizon 53\n", - "adding: mem time126, current time 178, horizon 52\n", - "adding: mem time127, current time 178, horizon 51\n", - "adding: mem time128, current time 178, horizon 50\n", - "adding: mem time129, current time 178, horizon 49\n", - "adding: mem time130, current time 178, horizon 48\n", - "adding: mem time131, current time 178, horizon 47\n", - "adding: mem time132, current time 178, horizon 46\n", - "adding: mem time133, current time 178, horizon 45\n", - "adding: mem time134, current time 178, horizon 44\n", - "adding: mem time135, current time 178, horizon 43\n", - "adding: mem time136, current time 178, horizon 42\n", - "adding: mem time137, current time 178, horizon 41\n", - "adding: mem time138, current time 178, horizon 40\n", - "adding: mem time139, current time 178, horizon 39\n", - "adding: mem time140, current time 178, horizon 38\n", - "adding: mem time141, current time 178, horizon 37\n", - "adding: mem time142, current time 178, horizon 36\n", - "adding: mem time143, current time 178, horizon 35\n", - "adding: mem time144, current time 178, horizon 34\n", - "adding: mem time145, current time 178, horizon 33\n", - "adding: mem time146, current time 178, horizon 32\n", - "adding: mem time147, current time 178, horizon 31\n", - "adding: mem time148, current time 178, horizon 30\n", - "adding: mem time149, current time 178, horizon 29\n", - "adding: mem time150, current time 178, horizon 28\n", - "adding: mem time151, current time 178, horizon 27\n", - "adding: mem time152, current time 178, horizon 26\n", - "adding: mem time153, current time 178, horizon 25\n", - "adding: mem time154, current time 178, horizon 24\n", - "adding: mem time155, current time 178, horizon 23\n", - "adding: mem time156, current time 178, horizon 22\n", - "adding: mem time157, current time 178, horizon 21\n", - "adding: mem time158, current time 178, horizon 20\n", - "adding: mem time159, current time 178, horizon 19\n", - "adding: mem time160, current time 178, horizon 18\n", - "adding: mem time161, current time 178, horizon 17\n", - "adding: mem time162, current time 178, horizon 16\n", - "adding: mem time163, current time 178, horizon 15\n", - "adding: mem time164, current time 178, horizon 14\n", - "adding: mem time165, current time 178, horizon 13\n", - "adding: mem time166, current time 178, horizon 12\n", - "adding: mem time167, current time 178, horizon 11\n", - "adding: mem time168, current time 178, horizon 10\n", - "adding: mem time169, current time 178, horizon 9\n", - "adding: mem time170, current time 178, horizon 8\n", - "adding: mem time171, current time 178, horizon 7\n", - "adding: mem time172, current time 178, horizon 6\n", - "adding: mem time173, current time 178, horizon 5\n", - "adding: mem time174, current time 178, horizon 4\n", - "adding: mem time175, current time 178, horizon 3\n", - "adding: mem time176, current time 178, horizon 2\n", - "adding: mem time177, current time 178, horizon 1\n", - "adding: mem time0, current time 179, horizon 179\n", - "adding: mem time1, current time 179, horizon 178\n", - "adding: mem time2, current time 179, horizon 177\n", - "adding: mem time3, current time 179, horizon 176\n", - "adding: mem time4, current time 179, horizon 175\n", - "adding: mem time5, current time 179, horizon 174\n", - "adding: mem time6, current time 179, horizon 173\n", - "adding: mem time7, current time 179, horizon 172\n", - "adding: mem time8, current time 179, horizon 171\n", - "adding: mem time9, current time 179, horizon 170\n", - "adding: mem time10, current time 179, horizon 169\n", - "adding: mem time11, current time 179, horizon 168\n", - "adding: mem time12, current time 179, horizon 167\n", - "adding: mem time13, current time 179, horizon 166\n", - "adding: mem time14, current time 179, horizon 165\n", - "adding: mem time15, current time 179, horizon 164\n", - "adding: mem time16, current time 179, horizon 163\n", - "adding: mem time17, current time 179, horizon 162\n", - "adding: mem time18, current time 179, horizon 161\n", - "adding: mem time19, current time 179, horizon 160\n", - "adding: mem time20, current time 179, horizon 159\n", - "adding: mem time21, current time 179, horizon 158\n", - "adding: mem time22, current time 179, horizon 157\n", - "adding: mem time23, current time 179, horizon 156\n", - "adding: mem time24, current time 179, horizon 155\n", - "adding: mem time25, current time 179, horizon 154\n", - "adding: mem time26, current time 179, horizon 153\n", - "adding: mem time27, current time 179, horizon 152\n", - "adding: mem time28, current time 179, horizon 151\n", - "adding: mem time29, current time 179, horizon 150\n", - "adding: mem time30, current time 179, horizon 149\n", - "adding: mem time31, current time 179, horizon 148\n", - "adding: mem time32, current time 179, horizon 147\n", - "adding: mem time33, current time 179, horizon 146\n", - "adding: mem time34, current time 179, horizon 145\n", - "adding: mem time35, current time 179, horizon 144\n", - "adding: mem time36, current time 179, horizon 143\n", - "adding: mem time37, current time 179, horizon 142\n", - "adding: mem time38, current time 179, horizon 141\n", - "adding: mem time39, current time 179, horizon 140\n", - "adding: mem time40, current time 179, horizon 139\n", - "adding: mem time41, current time 179, horizon 138\n", - "adding: mem time42, current time 179, horizon 137\n", - "adding: mem time43, current time 179, horizon 136\n", - "adding: mem time44, current time 179, horizon 135\n", - "adding: mem time45, current time 179, horizon 134\n", - "adding: mem time46, current time 179, horizon 133\n", - "adding: mem time47, current time 179, horizon 132\n", - "adding: mem time48, current time 179, horizon 131\n", - "adding: mem time49, current time 179, horizon 130\n", - "adding: mem time50, current time 179, horizon 129\n", - "adding: mem time51, current time 179, horizon 128\n", - "adding: mem time52, current time 179, horizon 127\n", - "adding: mem time53, current time 179, horizon 126\n", - "adding: mem time54, current time 179, horizon 125\n", - "adding: mem time55, current time 179, horizon 124\n", - "adding: mem time56, current time 179, horizon 123\n", - "adding: mem time57, current time 179, horizon 122\n", - "adding: mem time58, current time 179, horizon 121\n", - "adding: mem time59, current time 179, horizon 120\n", - "adding: mem time60, current time 179, horizon 119\n", - "adding: mem time61, current time 179, horizon 118\n", - "adding: mem time62, current time 179, horizon 117\n", - "adding: mem time63, current time 179, horizon 116\n", - "adding: mem time64, current time 179, horizon 115\n", - "adding: mem time65, current time 179, horizon 114\n", - "adding: mem time66, current time 179, horizon 113\n", - "adding: mem time67, current time 179, horizon 112\n", - "adding: mem time68, current time 179, horizon 111\n", - "adding: mem time69, current time 179, horizon 110\n", - "adding: mem time70, current time 179, horizon 109\n", - "adding: mem time71, current time 179, horizon 108\n", - "adding: mem time72, current time 179, horizon 107\n", - "adding: mem time73, current time 179, horizon 106\n", - "adding: mem time74, current time 179, horizon 105\n", - "adding: mem time75, current time 179, horizon 104\n", - "adding: mem time76, current time 179, horizon 103\n", - "adding: mem time77, current time 179, horizon 102\n", - "adding: mem time78, current time 179, horizon 101\n", - "adding: mem time79, current time 179, horizon 100\n", - "adding: mem time80, current time 179, horizon 99\n", - "adding: mem time81, current time 179, horizon 98\n", - "adding: mem time82, current time 179, horizon 97\n", - "adding: mem time83, current time 179, horizon 96\n", - "adding: mem time84, current time 179, horizon 95\n", - "adding: mem time85, current time 179, horizon 94\n", - "adding: mem time86, current time 179, horizon 93\n", - "adding: mem time87, current time 179, horizon 92\n", - "adding: mem time88, current time 179, horizon 91\n", - "adding: mem time89, current time 179, horizon 90\n", - "adding: mem time90, current time 179, horizon 89\n", - "adding: mem time91, current time 179, horizon 88\n", - "adding: mem time92, current time 179, horizon 87\n", - "adding: mem time93, current time 179, horizon 86\n", - "adding: mem time94, current time 179, horizon 85\n", - "adding: mem time95, current time 179, horizon 84\n", - "adding: mem time96, current time 179, horizon 83\n", - "adding: mem time97, current time 179, horizon 82\n", - "adding: mem time98, current time 179, horizon 81\n", - "adding: mem time99, current time 179, horizon 80\n", - "adding: mem time100, current time 179, horizon 79\n", - "adding: mem time101, current time 179, horizon 78\n", - "adding: mem time102, current time 179, horizon 77\n", - "adding: mem time103, current time 179, horizon 76\n", - "adding: mem time104, current time 179, horizon 75\n", - "adding: mem time105, current time 179, horizon 74\n", - "adding: mem time106, current time 179, horizon 73\n", - "adding: mem time107, current time 179, horizon 72\n", - "adding: mem time108, current time 179, horizon 71\n", - "adding: mem time109, current time 179, horizon 70\n", - "adding: mem time110, current time 179, horizon 69\n", - "adding: mem time111, current time 179, horizon 68\n", - "adding: mem time112, current time 179, horizon 67\n", - "adding: mem time113, current time 179, horizon 66\n", - "adding: mem time114, current time 179, horizon 65\n", - "adding: mem time115, current time 179, horizon 64\n", - "adding: mem time116, current time 179, horizon 63\n", - "adding: mem time117, current time 179, horizon 62\n", - "adding: mem time118, current time 179, horizon 61\n", - "adding: mem time119, current time 179, horizon 60\n", - "adding: mem time120, current time 179, horizon 59\n", - "adding: mem time121, current time 179, horizon 58\n", - "adding: mem time122, current time 179, horizon 57\n", - "adding: mem time123, current time 179, horizon 56\n", - "adding: mem time124, current time 179, horizon 55\n", - "adding: mem time125, current time 179, horizon 54\n", - "adding: mem time126, current time 179, horizon 53\n", - "adding: mem time127, current time 179, horizon 52\n", - "adding: mem time128, current time 179, horizon 51\n", - "adding: mem time129, current time 179, horizon 50\n", - "adding: mem time130, current time 179, horizon 49\n", - "adding: mem time131, current time 179, horizon 48\n", - "adding: mem time132, current time 179, horizon 47\n", - "adding: mem time133, current time 179, horizon 46\n", - "adding: mem time134, current time 179, horizon 45\n", - "adding: mem time135, current time 179, horizon 44\n", - "adding: mem time136, current time 179, horizon 43\n", - "adding: mem time137, current time 179, horizon 42\n", - "adding: mem time138, current time 179, horizon 41\n", - "adding: mem time139, current time 179, horizon 40\n", - "adding: mem time140, current time 179, horizon 39\n", - "adding: mem time141, current time 179, horizon 38\n", - "adding: mem time142, current time 179, horizon 37\n", - "adding: mem time143, current time 179, horizon 36\n", - "adding: mem time144, current time 179, horizon 35\n", - "adding: mem time145, current time 179, horizon 34\n", - "adding: mem time146, current time 179, horizon 33\n", - "adding: mem time147, current time 179, horizon 32\n", - "adding: mem time148, current time 179, horizon 31\n", - "adding: mem time149, current time 179, horizon 30\n", - "adding: mem time150, current time 179, horizon 29\n", - "adding: mem time151, current time 179, horizon 28\n", - "adding: mem time152, current time 179, horizon 27\n", - "adding: mem time153, current time 179, horizon 26\n", - "adding: mem time154, current time 179, horizon 25\n", - "adding: mem time155, current time 179, horizon 24\n", - "adding: mem time156, current time 179, horizon 23\n", - "adding: mem time157, current time 179, horizon 22\n", - "adding: mem time158, current time 179, horizon 21\n", - "adding: mem time159, current time 179, horizon 20\n", - "adding: mem time160, current time 179, horizon 19\n", - "adding: mem time161, current time 179, horizon 18\n", - "adding: mem time162, current time 179, horizon 17\n", - "adding: mem time163, current time 179, horizon 16\n", - "adding: mem time164, current time 179, horizon 15\n", - "adding: mem time165, current time 179, horizon 14\n", - "adding: mem time166, current time 179, horizon 13\n", - "adding: mem time167, current time 179, horizon 12\n", - "adding: mem time168, current time 179, horizon 11\n", - "adding: mem time169, current time 179, horizon 10\n", - "adding: mem time170, current time 179, horizon 9\n", - "adding: mem time171, current time 179, horizon 8\n", - "adding: mem time172, current time 179, horizon 7\n", - "adding: mem time173, current time 179, horizon 6\n", - "adding: mem time174, current time 179, horizon 5\n", - "adding: mem time175, current time 179, horizon 4\n", - "adding: mem time176, current time 179, horizon 3\n", - "adding: mem time177, current time 179, horizon 2\n", - "adding: mem time178, current time 179, horizon 1\n", - "adding: mem time0, current time 180, horizon 180\n", - "adding: mem time1, current time 180, horizon 179\n", - "adding: mem time2, current time 180, horizon 178\n", - "adding: mem time3, current time 180, horizon 177\n", - "adding: mem time4, current time 180, horizon 176\n", - "adding: mem time5, current time 180, horizon 175\n", - "adding: mem time6, current time 180, horizon 174\n", - "adding: mem time7, current time 180, horizon 173\n", - "adding: mem time8, current time 180, horizon 172\n", - "adding: mem time9, current time 180, horizon 171\n", - "adding: mem time10, current time 180, horizon 170\n", - "adding: mem time11, current time 180, horizon 169\n", - "adding: mem time12, current time 180, horizon 168\n", - "adding: mem time13, current time 180, horizon 167\n", - "adding: mem time14, current time 180, horizon 166\n", - "adding: mem time15, current time 180, horizon 165\n", - "adding: mem time16, current time 180, horizon 164\n", - "adding: mem time17, current time 180, horizon 163\n", - "adding: mem time18, current time 180, horizon 162\n", - "adding: mem time19, current time 180, horizon 161\n", - "adding: mem time20, current time 180, horizon 160\n", - "adding: mem time21, current time 180, horizon 159\n", - "adding: mem time22, current time 180, horizon 158\n", - "adding: mem time23, current time 180, horizon 157\n", - "adding: mem time24, current time 180, horizon 156\n", - "adding: mem time25, current time 180, horizon 155\n", - "adding: mem time26, current time 180, horizon 154\n", - "adding: mem time27, current time 180, horizon 153\n", - "adding: mem time28, current time 180, horizon 152\n", - "adding: mem time29, current time 180, horizon 151\n", - "adding: mem time30, current time 180, horizon 150\n", - "adding: mem time31, current time 180, horizon 149\n", - "adding: mem time32, current time 180, horizon 148\n", - "adding: mem time33, current time 180, horizon 147\n", - "adding: mem time34, current time 180, horizon 146\n", - "adding: mem time35, current time 180, horizon 145\n", - "adding: mem time36, current time 180, horizon 144\n", - "adding: mem time37, current time 180, horizon 143\n", - "adding: mem time38, current time 180, horizon 142\n", - "adding: mem time39, current time 180, horizon 141\n", - "adding: mem time40, current time 180, horizon 140\n", - "adding: mem time41, current time 180, horizon 139\n", - "adding: mem time42, current time 180, horizon 138\n", - "adding: mem time43, current time 180, horizon 137\n", - "adding: mem time44, current time 180, horizon 136\n", - "adding: mem time45, current time 180, horizon 135\n", - "adding: mem time46, current time 180, horizon 134\n", - "adding: mem time47, current time 180, horizon 133\n", - "adding: mem time48, current time 180, horizon 132\n", - "adding: mem time49, current time 180, horizon 131\n", - "adding: mem time50, current time 180, horizon 130\n", - "adding: mem time51, current time 180, horizon 129\n", - "adding: mem time52, current time 180, horizon 128\n", - "adding: mem time53, current time 180, horizon 127\n", - "adding: mem time54, current time 180, horizon 126\n", - "adding: mem time55, current time 180, horizon 125\n", - "adding: mem time56, current time 180, horizon 124\n", - "adding: mem time57, current time 180, horizon 123\n", - "adding: mem time58, current time 180, horizon 122\n", - "adding: mem time59, current time 180, horizon 121\n", - "adding: mem time60, current time 180, horizon 120\n", - "adding: mem time61, current time 180, horizon 119\n", - "adding: mem time62, current time 180, horizon 118\n", - "adding: mem time63, current time 180, horizon 117\n", - "adding: mem time64, current time 180, horizon 116\n", - "adding: mem time65, current time 180, horizon 115\n", - "adding: mem time66, current time 180, horizon 114\n", - "adding: mem time67, current time 180, horizon 113\n", - "adding: mem time68, current time 180, horizon 112\n", - "adding: mem time69, current time 180, horizon 111\n", - "adding: mem time70, current time 180, horizon 110\n", - "adding: mem time71, current time 180, horizon 109\n", - "adding: mem time72, current time 180, horizon 108\n", - "adding: mem time73, current time 180, horizon 107\n", - "adding: mem time74, current time 180, horizon 106\n", - "adding: mem time75, current time 180, horizon 105\n", - "adding: mem time76, current time 180, horizon 104\n", - "adding: mem time77, current time 180, horizon 103\n", - "adding: mem time78, current time 180, horizon 102\n", - "adding: mem time79, current time 180, horizon 101\n", - "adding: mem time80, current time 180, horizon 100\n", - "adding: mem time81, current time 180, horizon 99\n", - "adding: mem time82, current time 180, horizon 98\n", - "adding: mem time83, current time 180, horizon 97\n", - "adding: mem time84, current time 180, horizon 96\n", - "adding: mem time85, current time 180, horizon 95\n", - "adding: mem time86, current time 180, horizon 94\n", - "adding: mem time87, current time 180, horizon 93\n", - "adding: mem time88, current time 180, horizon 92\n", - "adding: mem time89, current time 180, horizon 91\n", - "adding: mem time90, current time 180, horizon 90\n", - "adding: mem time91, current time 180, horizon 89\n", - "adding: mem time92, current time 180, horizon 88\n", - "adding: mem time93, current time 180, horizon 87\n", - "adding: mem time94, current time 180, horizon 86\n", - "adding: mem time95, current time 180, horizon 85\n", - "adding: mem time96, current time 180, horizon 84\n", - "adding: mem time97, current time 180, horizon 83\n", - "adding: mem time98, current time 180, horizon 82\n", - "adding: mem time99, current time 180, horizon 81\n", - "adding: mem time100, current time 180, horizon 80\n", - "adding: mem time101, current time 180, horizon 79\n", - "adding: mem time102, current time 180, horizon 78\n", - "adding: mem time103, current time 180, horizon 77\n", - "adding: mem time104, current time 180, horizon 76\n", - "adding: mem time105, current time 180, horizon 75\n", - "adding: mem time106, current time 180, horizon 74\n", - "adding: mem time107, current time 180, horizon 73\n", - "adding: mem time108, current time 180, horizon 72\n", - "adding: mem time109, current time 180, horizon 71\n", - "adding: mem time110, current time 180, horizon 70\n", - "adding: mem time111, current time 180, horizon 69\n", - "adding: mem time112, current time 180, horizon 68\n", - "adding: mem time113, current time 180, horizon 67\n", - "adding: mem time114, current time 180, horizon 66\n", - "adding: mem time115, current time 180, horizon 65\n", - "adding: mem time116, current time 180, horizon 64\n", - "adding: mem time117, current time 180, horizon 63\n", - "adding: mem time118, current time 180, horizon 62\n", - "adding: mem time119, current time 180, horizon 61\n", - "adding: mem time120, current time 180, horizon 60\n", - "adding: mem time121, current time 180, horizon 59\n", - "adding: mem time122, current time 180, horizon 58\n", - "adding: mem time123, current time 180, horizon 57\n", - "adding: mem time124, current time 180, horizon 56\n", - "adding: mem time125, current time 180, horizon 55\n", - "adding: mem time126, current time 180, horizon 54\n", - "adding: mem time127, current time 180, horizon 53\n", - "adding: mem time128, current time 180, horizon 52\n", - "adding: mem time129, current time 180, horizon 51\n", - "adding: mem time130, current time 180, horizon 50\n", - "adding: mem time131, current time 180, horizon 49\n", - "adding: mem time132, current time 180, horizon 48\n", - "adding: mem time133, current time 180, horizon 47\n", - "adding: mem time134, current time 180, horizon 46\n", - "adding: mem time135, current time 180, horizon 45\n", - "adding: mem time136, current time 180, horizon 44\n", - "adding: mem time137, current time 180, horizon 43\n", - "adding: mem time138, current time 180, horizon 42\n", - "adding: mem time139, current time 180, horizon 41\n", - "adding: mem time140, current time 180, horizon 40\n", - "adding: mem time141, current time 180, horizon 39\n", - "adding: mem time142, current time 180, horizon 38\n", - "adding: mem time143, current time 180, horizon 37\n", - "adding: mem time144, current time 180, horizon 36\n", - "adding: mem time145, current time 180, horizon 35\n", - "adding: mem time146, current time 180, horizon 34\n", - "adding: mem time147, current time 180, horizon 33\n", - "adding: mem time148, current time 180, horizon 32\n", - "adding: mem time149, current time 180, horizon 31\n", - "adding: mem time150, current time 180, horizon 30\n", - "adding: mem time151, current time 180, horizon 29\n", - "adding: mem time152, current time 180, horizon 28\n", - "adding: mem time153, current time 180, horizon 27\n", - "adding: mem time154, current time 180, horizon 26\n", - "adding: mem time155, current time 180, horizon 25\n", - "adding: mem time156, current time 180, horizon 24\n", - "adding: mem time157, current time 180, horizon 23\n", - "adding: mem time158, current time 180, horizon 22\n", - "adding: mem time159, current time 180, horizon 21\n", - "adding: mem time160, current time 180, horizon 20\n", - "adding: mem time161, current time 180, horizon 19\n", - "adding: mem time162, current time 180, horizon 18\n", - "adding: mem time163, current time 180, horizon 17\n", - "adding: mem time164, current time 180, horizon 16\n", - "adding: mem time165, current time 180, horizon 15\n", - "adding: mem time166, current time 180, horizon 14\n", - "adding: mem time167, current time 180, horizon 13\n", - "adding: mem time168, current time 180, horizon 12\n", - "adding: mem time169, current time 180, horizon 11\n", - "adding: mem time170, current time 180, horizon 10\n", - "adding: mem time171, current time 180, horizon 9\n", - "adding: mem time172, current time 180, horizon 8\n", - "adding: mem time173, current time 180, horizon 7\n", - "adding: mem time174, current time 180, horizon 6\n", - "adding: mem time175, current time 180, horizon 5\n", - "adding: mem time176, current time 180, horizon 4\n", - "adding: mem time177, current time 180, horizon 3\n", - "adding: mem time178, current time 180, horizon 2\n", - "adding: mem time179, current time 180, horizon 1\n", - "adding: mem time0, current time 181, horizon 181\n", - "adding: mem time1, current time 181, horizon 180\n", - "adding: mem time2, current time 181, horizon 179\n", - "adding: mem time3, current time 181, horizon 178\n", - "adding: mem time4, current time 181, horizon 177\n", - "adding: mem time5, current time 181, horizon 176\n", - "adding: mem time6, current time 181, horizon 175\n", - "adding: mem time7, current time 181, horizon 174\n", - "adding: mem time8, current time 181, horizon 173\n", - "adding: mem time9, current time 181, horizon 172\n", - "adding: mem time10, current time 181, horizon 171\n", - "adding: mem time11, current time 181, horizon 170\n", - "adding: mem time12, current time 181, horizon 169\n", - "adding: mem time13, current time 181, horizon 168\n", - "adding: mem time14, current time 181, horizon 167\n", - "adding: mem time15, current time 181, horizon 166\n", - "adding: mem time16, current time 181, horizon 165\n", - "adding: mem time17, current time 181, horizon 164\n", - "adding: mem time18, current time 181, horizon 163\n", - "adding: mem time19, current time 181, horizon 162\n", - "adding: mem time20, current time 181, horizon 161\n", - "adding: mem time21, current time 181, horizon 160\n", - "adding: mem time22, current time 181, horizon 159\n", - "adding: mem time23, current time 181, horizon 158\n", - "adding: mem time24, current time 181, horizon 157\n", - "adding: mem time25, current time 181, horizon 156\n", - "adding: mem time26, current time 181, horizon 155\n", - "adding: mem time27, current time 181, horizon 154\n", - "adding: mem time28, current time 181, horizon 153\n", - "adding: mem time29, current time 181, horizon 152\n", - "adding: mem time30, current time 181, horizon 151\n", - "adding: mem time31, current time 181, horizon 150\n", - "adding: mem time32, current time 181, horizon 149\n", - "adding: mem time33, current time 181, horizon 148\n", - "adding: mem time34, current time 181, horizon 147\n", - "adding: mem time35, current time 181, horizon 146\n", - "adding: mem time36, current time 181, horizon 145\n", - "adding: mem time37, current time 181, horizon 144\n", - "adding: mem time38, current time 181, horizon 143\n", - "adding: mem time39, current time 181, horizon 142\n", - "adding: mem time40, current time 181, horizon 141\n", - "adding: mem time41, current time 181, horizon 140\n", - "adding: mem time42, current time 181, horizon 139\n", - "adding: mem time43, current time 181, horizon 138\n", - "adding: mem time44, current time 181, horizon 137\n", - "adding: mem time45, current time 181, horizon 136\n", - "adding: mem time46, current time 181, horizon 135\n", - "adding: mem time47, current time 181, horizon 134\n", - "adding: mem time48, current time 181, horizon 133\n", - "adding: mem time49, current time 181, horizon 132\n", - "adding: mem time50, current time 181, horizon 131\n", - "adding: mem time51, current time 181, horizon 130\n", - "adding: mem time52, current time 181, horizon 129\n", - "adding: mem time53, current time 181, horizon 128\n", - "adding: mem time54, current time 181, horizon 127\n", - "adding: mem time55, current time 181, horizon 126\n", - "adding: mem time56, current time 181, horizon 125\n", - "adding: mem time57, current time 181, horizon 124\n", - "adding: mem time58, current time 181, horizon 123\n", - "adding: mem time59, current time 181, horizon 122\n", - "adding: mem time60, current time 181, horizon 121\n", - "adding: mem time61, current time 181, horizon 120\n", - "adding: mem time62, current time 181, horizon 119\n", - "adding: mem time63, current time 181, horizon 118\n", - "adding: mem time64, current time 181, horizon 117\n", - "adding: mem time65, current time 181, horizon 116\n", - "adding: mem time66, current time 181, horizon 115\n", - "adding: mem time67, current time 181, horizon 114\n", - "adding: mem time68, current time 181, horizon 113\n", - "adding: mem time69, current time 181, horizon 112\n", - "adding: mem time70, current time 181, horizon 111\n", - "adding: mem time71, current time 181, horizon 110\n", - "adding: mem time72, current time 181, horizon 109\n", - "adding: mem time73, current time 181, horizon 108\n", - "adding: mem time74, current time 181, horizon 107\n", - "adding: mem time75, current time 181, horizon 106\n", - "adding: mem time76, current time 181, horizon 105\n", - "adding: mem time77, current time 181, horizon 104\n", - "adding: mem time78, current time 181, horizon 103\n", - "adding: mem time79, current time 181, horizon 102\n", - "adding: mem time80, current time 181, horizon 101\n", - "adding: mem time81, current time 181, horizon 100\n", - "adding: mem time82, current time 181, horizon 99\n", - "adding: mem time83, current time 181, horizon 98\n", - "adding: mem time84, current time 181, horizon 97\n", - "adding: mem time85, current time 181, horizon 96\n", - "adding: mem time86, current time 181, horizon 95\n", - "adding: mem time87, current time 181, horizon 94\n", - "adding: mem time88, current time 181, horizon 93\n", - "adding: mem time89, current time 181, horizon 92\n", - "adding: mem time90, current time 181, horizon 91\n", - "adding: mem time91, current time 181, horizon 90\n", - "adding: mem time92, current time 181, horizon 89\n", - "adding: mem time93, current time 181, horizon 88\n", - "adding: mem time94, current time 181, horizon 87\n", - "adding: mem time95, current time 181, horizon 86\n", - "adding: mem time96, current time 181, horizon 85\n", - "adding: mem time97, current time 181, horizon 84\n", - "adding: mem time98, current time 181, horizon 83\n", - "adding: mem time99, current time 181, horizon 82\n", - "adding: mem time100, current time 181, horizon 81\n", - "adding: mem time101, current time 181, horizon 80\n", - "adding: mem time102, current time 181, horizon 79\n", - "adding: mem time103, current time 181, horizon 78\n", - "adding: mem time104, current time 181, horizon 77\n", - "adding: mem time105, current time 181, horizon 76\n", - "adding: mem time106, current time 181, horizon 75\n", - "adding: mem time107, current time 181, horizon 74\n", - "adding: mem time108, current time 181, horizon 73\n", - "adding: mem time109, current time 181, horizon 72\n", - "adding: mem time110, current time 181, horizon 71\n", - "adding: mem time111, current time 181, horizon 70\n", - "adding: mem time112, current time 181, horizon 69\n", - "adding: mem time113, current time 181, horizon 68\n", - "adding: mem time114, current time 181, horizon 67\n", - "adding: mem time115, current time 181, horizon 66\n", - "adding: mem time116, current time 181, horizon 65\n", - "adding: mem time117, current time 181, horizon 64\n", - "adding: mem time118, current time 181, horizon 63\n", - "adding: mem time119, current time 181, horizon 62\n", - "adding: mem time120, current time 181, horizon 61\n", - "adding: mem time121, current time 181, horizon 60\n", - "adding: mem time122, current time 181, horizon 59\n", - "adding: mem time123, current time 181, horizon 58\n", - "adding: mem time124, current time 181, horizon 57\n", - "adding: mem time125, current time 181, horizon 56\n", - "adding: mem time126, current time 181, horizon 55\n", - "adding: mem time127, current time 181, horizon 54\n", - "adding: mem time128, current time 181, horizon 53\n", - "adding: mem time129, current time 181, horizon 52\n", - "adding: mem time130, current time 181, horizon 51\n", - "adding: mem time131, current time 181, horizon 50\n", - "adding: mem time132, current time 181, horizon 49\n", - "adding: mem time133, current time 181, horizon 48\n", - "adding: mem time134, current time 181, horizon 47\n", - "adding: mem time135, current time 181, horizon 46\n", - "adding: mem time136, current time 181, horizon 45\n", - "adding: mem time137, current time 181, horizon 44\n", - "adding: mem time138, current time 181, horizon 43\n", - "adding: mem time139, current time 181, horizon 42\n", - "adding: mem time140, current time 181, horizon 41\n", - "adding: mem time141, current time 181, horizon 40\n", - "adding: mem time142, current time 181, horizon 39\n", - "adding: mem time143, current time 181, horizon 38\n", - "adding: mem time144, current time 181, horizon 37\n", - "adding: mem time145, current time 181, horizon 36\n", - "adding: mem time146, current time 181, horizon 35\n", - "adding: mem time147, current time 181, horizon 34\n", - "adding: mem time148, current time 181, horizon 33\n", - "adding: mem time149, current time 181, horizon 32\n", - "adding: mem time150, current time 181, horizon 31\n", - "adding: mem time151, current time 181, horizon 30\n", - "adding: mem time152, current time 181, horizon 29\n", - "adding: mem time153, current time 181, horizon 28\n", - "adding: mem time154, current time 181, horizon 27\n", - "adding: mem time155, current time 181, horizon 26\n", - "adding: mem time156, current time 181, horizon 25\n", - "adding: mem time157, current time 181, horizon 24\n", - "adding: mem time158, current time 181, horizon 23\n", - "adding: mem time159, current time 181, horizon 22\n", - "adding: mem time160, current time 181, horizon 21\n", - "adding: mem time161, current time 181, horizon 20\n", - "adding: mem time162, current time 181, horizon 19\n", - "adding: mem time163, current time 181, horizon 18\n", - "adding: mem time164, current time 181, horizon 17\n", - "adding: mem time165, current time 181, horizon 16\n", - "adding: mem time166, current time 181, horizon 15\n", - "adding: mem time167, current time 181, horizon 14\n", - "adding: mem time168, current time 181, horizon 13\n", - "adding: mem time169, current time 181, horizon 12\n", - "adding: mem time170, current time 181, horizon 11\n", - "adding: mem time171, current time 181, horizon 10\n", - "adding: mem time172, current time 181, horizon 9\n", - "adding: mem time173, current time 181, horizon 8\n", - "adding: mem time174, current time 181, horizon 7\n", - "adding: mem time175, current time 181, horizon 6\n", - "adding: mem time176, current time 181, horizon 5\n", - "adding: mem time177, current time 181, horizon 4\n", - "adding: mem time178, current time 181, horizon 3\n", - "adding: mem time179, current time 181, horizon 2\n", - "adding: mem time180, current time 181, horizon 1\n", - "adding: mem time0, current time 182, horizon 182\n", - "adding: mem time1, current time 182, horizon 181\n", - "adding: mem time2, current time 182, horizon 180\n", - "adding: mem time3, current time 182, horizon 179\n", - "adding: mem time4, current time 182, horizon 178\n", - "adding: mem time5, current time 182, horizon 177\n", - "adding: mem time6, current time 182, horizon 176\n", - "adding: mem time7, current time 182, horizon 175\n", - "adding: mem time8, current time 182, horizon 174\n", - "adding: mem time9, current time 182, horizon 173\n", - "adding: mem time10, current time 182, horizon 172\n", - "adding: mem time11, current time 182, horizon 171\n", - "adding: mem time12, current time 182, horizon 170\n", - "adding: mem time13, current time 182, horizon 169\n", - "adding: mem time14, current time 182, horizon 168\n", - "adding: mem time15, current time 182, horizon 167\n", - "adding: mem time16, current time 182, horizon 166\n", - "adding: mem time17, current time 182, horizon 165\n", - "adding: mem time18, current time 182, horizon 164\n", - "adding: mem time19, current time 182, horizon 163\n", - "adding: mem time20, current time 182, horizon 162\n", - "adding: mem time21, current time 182, horizon 161\n", - "adding: mem time22, current time 182, horizon 160\n", - "adding: mem time23, current time 182, horizon 159\n", - "adding: mem time24, current time 182, horizon 158\n", - "adding: mem time25, current time 182, horizon 157\n", - "adding: mem time26, current time 182, horizon 156\n", - "adding: mem time27, current time 182, horizon 155\n", - "adding: mem time28, current time 182, horizon 154\n", - "adding: mem time29, current time 182, horizon 153\n", - "adding: mem time30, current time 182, horizon 152\n", - "adding: mem time31, current time 182, horizon 151\n", - "adding: mem time32, current time 182, horizon 150\n", - "adding: mem time33, current time 182, horizon 149\n", - "adding: mem time34, current time 182, horizon 148\n", - "adding: mem time35, current time 182, horizon 147\n", - "adding: mem time36, current time 182, horizon 146\n", - "adding: mem time37, current time 182, horizon 145\n", - "adding: mem time38, current time 182, horizon 144\n", - "adding: mem time39, current time 182, horizon 143\n", - "adding: mem time40, current time 182, horizon 142\n", - "adding: mem time41, current time 182, horizon 141\n", - "adding: mem time42, current time 182, horizon 140\n", - "adding: mem time43, current time 182, horizon 139\n", - "adding: mem time44, current time 182, horizon 138\n", - "adding: mem time45, current time 182, horizon 137\n", - "adding: mem time46, current time 182, horizon 136\n", - "adding: mem time47, current time 182, horizon 135\n", - "adding: mem time48, current time 182, horizon 134\n", - "adding: mem time49, current time 182, horizon 133\n", - "adding: mem time50, current time 182, horizon 132\n", - "adding: mem time51, current time 182, horizon 131\n", - "adding: mem time52, current time 182, horizon 130\n", - "adding: mem time53, current time 182, horizon 129\n", - "adding: mem time54, current time 182, horizon 128\n", - "adding: mem time55, current time 182, horizon 127\n", - "adding: mem time56, current time 182, horizon 126\n", - "adding: mem time57, current time 182, horizon 125\n", - "adding: mem time58, current time 182, horizon 124\n", - "adding: mem time59, current time 182, horizon 123\n", - "adding: mem time60, current time 182, horizon 122\n", - "adding: mem time61, current time 182, horizon 121\n", - "adding: mem time62, current time 182, horizon 120\n", - "adding: mem time63, current time 182, horizon 119\n", - "adding: mem time64, current time 182, horizon 118\n", - "adding: mem time65, current time 182, horizon 117\n", - "adding: mem time66, current time 182, horizon 116\n", - "adding: mem time67, current time 182, horizon 115\n", - "adding: mem time68, current time 182, horizon 114\n", - "adding: mem time69, current time 182, horizon 113\n", - "adding: mem time70, current time 182, horizon 112\n", - "adding: mem time71, current time 182, horizon 111\n", - "adding: mem time72, current time 182, horizon 110\n", - "adding: mem time73, current time 182, horizon 109\n", - "adding: mem time74, current time 182, horizon 108\n", - "adding: mem time75, current time 182, horizon 107\n", - "adding: mem time76, current time 182, horizon 106\n", - "adding: mem time77, current time 182, horizon 105\n", - "adding: mem time78, current time 182, horizon 104\n", - "adding: mem time79, current time 182, horizon 103\n", - "adding: mem time80, current time 182, horizon 102\n", - "adding: mem time81, current time 182, horizon 101\n", - "adding: mem time82, current time 182, horizon 100\n", - "adding: mem time83, current time 182, horizon 99\n", - "adding: mem time84, current time 182, horizon 98\n", - "adding: mem time85, current time 182, horizon 97\n", - "adding: mem time86, current time 182, horizon 96\n", - "adding: mem time87, current time 182, horizon 95\n", - "adding: mem time88, current time 182, horizon 94\n", - "adding: mem time89, current time 182, horizon 93\n", - "adding: mem time90, current time 182, horizon 92\n", - "adding: mem time91, current time 182, horizon 91\n", - "adding: mem time92, current time 182, horizon 90\n", - "adding: mem time93, current time 182, horizon 89\n", - "adding: mem time94, current time 182, horizon 88\n", - "adding: mem time95, current time 182, horizon 87\n", - "adding: mem time96, current time 182, horizon 86\n", - "adding: mem time97, current time 182, horizon 85\n", - "adding: mem time98, current time 182, horizon 84\n", - "adding: mem time99, current time 182, horizon 83\n", - "adding: mem time100, current time 182, horizon 82\n", - "adding: mem time101, current time 182, horizon 81\n", - "adding: mem time102, current time 182, horizon 80\n", - "adding: mem time103, current time 182, horizon 79\n", - "adding: mem time104, current time 182, horizon 78\n", - "adding: mem time105, current time 182, horizon 77\n", - "adding: mem time106, current time 182, horizon 76\n", - "adding: mem time107, current time 182, horizon 75\n", - "adding: mem time108, current time 182, horizon 74\n", - "adding: mem time109, current time 182, horizon 73\n", - "adding: mem time110, current time 182, horizon 72\n", - "adding: mem time111, current time 182, horizon 71\n", - "adding: mem time112, current time 182, horizon 70\n", - "adding: mem time113, current time 182, horizon 69\n", - "adding: mem time114, current time 182, horizon 68\n", - "adding: mem time115, current time 182, horizon 67\n", - "adding: mem time116, current time 182, horizon 66\n", - "adding: mem time117, current time 182, horizon 65\n", - "adding: mem time118, current time 182, horizon 64\n", - "adding: mem time119, current time 182, horizon 63\n", - "adding: mem time120, current time 182, horizon 62\n", - "adding: mem time121, current time 182, horizon 61\n", - "adding: mem time122, current time 182, horizon 60\n", - "adding: mem time123, current time 182, horizon 59\n", - "adding: mem time124, current time 182, horizon 58\n", - "adding: mem time125, current time 182, horizon 57\n", - "adding: mem time126, current time 182, horizon 56\n", - "adding: mem time127, current time 182, horizon 55\n", - "adding: mem time128, current time 182, horizon 54\n", - "adding: mem time129, current time 182, horizon 53\n", - "adding: mem time130, current time 182, horizon 52\n", - "adding: mem time131, current time 182, horizon 51\n", - "adding: mem time132, current time 182, horizon 50\n", - "adding: mem time133, current time 182, horizon 49\n", - "adding: mem time134, current time 182, horizon 48\n", - "adding: mem time135, current time 182, horizon 47\n", - "adding: mem time136, current time 182, horizon 46\n", - "adding: mem time137, current time 182, horizon 45\n", - "adding: mem time138, current time 182, horizon 44\n", - "adding: mem time139, current time 182, horizon 43\n", - "adding: mem time140, current time 182, horizon 42\n", - "adding: mem time141, current time 182, horizon 41\n", - "adding: mem time142, current time 182, horizon 40\n", - "adding: mem time143, current time 182, horizon 39\n", - "adding: mem time144, current time 182, horizon 38\n", - "adding: mem time145, current time 182, horizon 37\n", - "adding: mem time146, current time 182, horizon 36\n", - "adding: mem time147, current time 182, horizon 35\n", - "adding: mem time148, current time 182, horizon 34\n", - "adding: mem time149, current time 182, horizon 33\n", - "adding: mem time150, current time 182, horizon 32\n", - "adding: mem time151, current time 182, horizon 31\n", - "adding: mem time152, current time 182, horizon 30\n", - "adding: mem time153, current time 182, horizon 29\n", - "adding: mem time154, current time 182, horizon 28\n", - "adding: mem time155, current time 182, horizon 27\n", - "adding: mem time156, current time 182, horizon 26\n", - "adding: mem time157, current time 182, horizon 25\n", - "adding: mem time158, current time 182, horizon 24\n", - "adding: mem time159, current time 182, horizon 23\n", - "adding: mem time160, current time 182, horizon 22\n", - "adding: mem time161, current time 182, horizon 21\n", - "adding: mem time162, current time 182, horizon 20\n", - "adding: mem time163, current time 182, horizon 19\n", - "adding: mem time164, current time 182, horizon 18\n", - "adding: mem time165, current time 182, horizon 17\n", - "adding: mem time166, current time 182, horizon 16\n", - "adding: mem time167, current time 182, horizon 15\n", - "adding: mem time168, current time 182, horizon 14\n", - "adding: mem time169, current time 182, horizon 13\n", - "adding: mem time170, current time 182, horizon 12\n", - "adding: mem time171, current time 182, horizon 11\n", - "adding: mem time172, current time 182, horizon 10\n", - "adding: mem time173, current time 182, horizon 9\n", - "adding: mem time174, current time 182, horizon 8\n", - "adding: mem time175, current time 182, horizon 7\n", - "adding: mem time176, current time 182, horizon 6\n", - "adding: mem time177, current time 182, horizon 5\n", - "adding: mem time178, current time 182, horizon 4\n", - "adding: mem time179, current time 182, horizon 3\n", - "adding: mem time180, current time 182, horizon 2\n", - "adding: mem time181, current time 182, horizon 1\n", - "adding: mem time0, current time 183, horizon 183\n", - "adding: mem time1, current time 183, horizon 182\n", - "adding: mem time2, current time 183, horizon 181\n", - "adding: mem time3, current time 183, horizon 180\n", - "adding: mem time4, current time 183, horizon 179\n", - "adding: mem time5, current time 183, horizon 178\n", - "adding: mem time6, current time 183, horizon 177\n", - "adding: mem time7, current time 183, horizon 176\n", - "adding: mem time8, current time 183, horizon 175\n", - "adding: mem time9, current time 183, horizon 174\n", - "adding: mem time10, current time 183, horizon 173\n", - "adding: mem time11, current time 183, horizon 172\n", - "adding: mem time12, current time 183, horizon 171\n", - "adding: mem time13, current time 183, horizon 170\n", - "adding: mem time14, current time 183, horizon 169\n", - "adding: mem time15, current time 183, horizon 168\n", - "adding: mem time16, current time 183, horizon 167\n", - "adding: mem time17, current time 183, horizon 166\n", - "adding: mem time18, current time 183, horizon 165\n", - "adding: mem time19, current time 183, horizon 164\n", - "adding: mem time20, current time 183, horizon 163\n", - "adding: mem time21, current time 183, horizon 162\n", - "adding: mem time22, current time 183, horizon 161\n", - "adding: mem time23, current time 183, horizon 160\n", - "adding: mem time24, current time 183, horizon 159\n", - "adding: mem time25, current time 183, horizon 158\n", - "adding: mem time26, current time 183, horizon 157\n", - "adding: mem time27, current time 183, horizon 156\n", - "adding: mem time28, current time 183, horizon 155\n", - "adding: mem time29, current time 183, horizon 154\n", - "adding: mem time30, current time 183, horizon 153\n", - "adding: mem time31, current time 183, horizon 152\n", - "adding: mem time32, current time 183, horizon 151\n", - "adding: mem time33, current time 183, horizon 150\n", - "adding: mem time34, current time 183, horizon 149\n", - "adding: mem time35, current time 183, horizon 148\n", - "adding: mem time36, current time 183, horizon 147\n", - "adding: mem time37, current time 183, horizon 146\n", - "adding: mem time38, current time 183, horizon 145\n", - "adding: mem time39, current time 183, horizon 144\n", - "adding: mem time40, current time 183, horizon 143\n", - "adding: mem time41, current time 183, horizon 142\n", - "adding: mem time42, current time 183, horizon 141\n", - "adding: mem time43, current time 183, horizon 140\n", - "adding: mem time44, current time 183, horizon 139\n", - "adding: mem time45, current time 183, horizon 138\n", - "adding: mem time46, current time 183, horizon 137\n", - "adding: mem time47, current time 183, horizon 136\n", - "adding: mem time48, current time 183, horizon 135\n", - "adding: mem time49, current time 183, horizon 134\n", - "adding: mem time50, current time 183, horizon 133\n", - "adding: mem time51, current time 183, horizon 132\n", - "adding: mem time52, current time 183, horizon 131\n", - "adding: mem time53, current time 183, horizon 130\n", - "adding: mem time54, current time 183, horizon 129\n", - "adding: mem time55, current time 183, horizon 128\n", - "adding: mem time56, current time 183, horizon 127\n", - "adding: mem time57, current time 183, horizon 126\n", - "adding: mem time58, current time 183, horizon 125\n", - "adding: mem time59, current time 183, horizon 124\n", - "adding: mem time60, current time 183, horizon 123\n", - "adding: mem time61, current time 183, horizon 122\n", - "adding: mem time62, current time 183, horizon 121\n", - "adding: mem time63, current time 183, horizon 120\n", - "adding: mem time64, current time 183, horizon 119\n", - "adding: mem time65, current time 183, horizon 118\n", - "adding: mem time66, current time 183, horizon 117\n", - "adding: mem time67, current time 183, horizon 116\n", - "adding: mem time68, current time 183, horizon 115\n", - "adding: mem time69, current time 183, horizon 114\n", - "adding: mem time70, current time 183, horizon 113\n", - "adding: mem time71, current time 183, horizon 112\n", - "adding: mem time72, current time 183, horizon 111\n", - "adding: mem time73, current time 183, horizon 110\n", - "adding: mem time74, current time 183, horizon 109\n", - "adding: mem time75, current time 183, horizon 108\n", - "adding: mem time76, current time 183, horizon 107\n", - "adding: mem time77, current time 183, horizon 106\n", - "adding: mem time78, current time 183, horizon 105\n", - "adding: mem time79, current time 183, horizon 104\n", - "adding: mem time80, current time 183, horizon 103\n", - "adding: mem time81, current time 183, horizon 102\n", - "adding: mem time82, current time 183, horizon 101\n", - "adding: mem time83, current time 183, horizon 100\n", - "adding: mem time84, current time 183, horizon 99\n", - "adding: mem time85, current time 183, horizon 98\n", - "adding: mem time86, current time 183, horizon 97\n", - "adding: mem time87, current time 183, horizon 96\n", - "adding: mem time88, current time 183, horizon 95\n", - "adding: mem time89, current time 183, horizon 94\n", - "adding: mem time90, current time 183, horizon 93\n", - "adding: mem time91, current time 183, horizon 92\n", - "adding: mem time92, current time 183, horizon 91\n", - "adding: mem time93, current time 183, horizon 90\n", - "adding: mem time94, current time 183, horizon 89\n", - "adding: mem time95, current time 183, horizon 88\n", - "adding: mem time96, current time 183, horizon 87\n", - "adding: mem time97, current time 183, horizon 86\n", - "adding: mem time98, current time 183, horizon 85\n", - "adding: mem time99, current time 183, horizon 84\n", - "adding: mem time100, current time 183, horizon 83\n", - "adding: mem time101, current time 183, horizon 82\n", - "adding: mem time102, current time 183, horizon 81\n", - "adding: mem time103, current time 183, horizon 80\n", - "adding: mem time104, current time 183, horizon 79\n", - "adding: mem time105, current time 183, horizon 78\n", - "adding: mem time106, current time 183, horizon 77\n", - "adding: mem time107, current time 183, horizon 76\n", - "adding: mem time108, current time 183, horizon 75\n", - "adding: mem time109, current time 183, horizon 74\n", - "adding: mem time110, current time 183, horizon 73\n", - "adding: mem time111, current time 183, horizon 72\n", - "adding: mem time112, current time 183, horizon 71\n", - "adding: mem time113, current time 183, horizon 70\n", - "adding: mem time114, current time 183, horizon 69\n", - "adding: mem time115, current time 183, horizon 68\n", - "adding: mem time116, current time 183, horizon 67\n", - "adding: mem time117, current time 183, horizon 66\n", - "adding: mem time118, current time 183, horizon 65\n", - "adding: mem time119, current time 183, horizon 64\n", - "adding: mem time120, current time 183, horizon 63\n", - "adding: mem time121, current time 183, horizon 62\n", - "adding: mem time122, current time 183, horizon 61\n", - "adding: mem time123, current time 183, horizon 60\n", - "adding: mem time124, current time 183, horizon 59\n", - "adding: mem time125, current time 183, horizon 58\n", - "adding: mem time126, current time 183, horizon 57\n", - "adding: mem time127, current time 183, horizon 56\n", - "adding: mem time128, current time 183, horizon 55\n", - "adding: mem time129, current time 183, horizon 54\n", - "adding: mem time130, current time 183, horizon 53\n", - "adding: mem time131, current time 183, horizon 52\n", - "adding: mem time132, current time 183, horizon 51\n", - "adding: mem time133, current time 183, horizon 50\n", - "adding: mem time134, current time 183, horizon 49\n", - "adding: mem time135, current time 183, horizon 48\n", - "adding: mem time136, current time 183, horizon 47\n", - "adding: mem time137, current time 183, horizon 46\n", - "adding: mem time138, current time 183, horizon 45\n", - "adding: mem time139, current time 183, horizon 44\n", - "adding: mem time140, current time 183, horizon 43\n", - "adding: mem time141, current time 183, horizon 42\n", - "adding: mem time142, current time 183, horizon 41\n", - "adding: mem time143, current time 183, horizon 40\n", - "adding: mem time144, current time 183, horizon 39\n", - "adding: mem time145, current time 183, horizon 38\n", - "adding: mem time146, current time 183, horizon 37\n", - "adding: mem time147, current time 183, horizon 36\n", - "adding: mem time148, current time 183, horizon 35\n", - "adding: mem time149, current time 183, horizon 34\n", - "adding: mem time150, current time 183, horizon 33\n", - "adding: mem time151, current time 183, horizon 32\n", - "adding: mem time152, current time 183, horizon 31\n", - "adding: mem time153, current time 183, horizon 30\n", - "adding: mem time154, current time 183, horizon 29\n", - "adding: mem time155, current time 183, horizon 28\n", - "adding: mem time156, current time 183, horizon 27\n", - "adding: mem time157, current time 183, horizon 26\n", - "adding: mem time158, current time 183, horizon 25\n", - "adding: mem time159, current time 183, horizon 24\n", - "adding: mem time160, current time 183, horizon 23\n", - "adding: mem time161, current time 183, horizon 22\n", - "adding: mem time162, current time 183, horizon 21\n", - "adding: mem time163, current time 183, horizon 20\n", - "adding: mem time164, current time 183, horizon 19\n", - "adding: mem time165, current time 183, horizon 18\n", - "adding: mem time166, current time 183, horizon 17\n", - "adding: mem time167, current time 183, horizon 16\n", - "adding: mem time168, current time 183, horizon 15\n", - "adding: mem time169, current time 183, horizon 14\n", - "adding: mem time170, current time 183, horizon 13\n", - "adding: mem time171, current time 183, horizon 12\n", - "adding: mem time172, current time 183, horizon 11\n", - "adding: mem time173, current time 183, horizon 10\n", - "adding: mem time174, current time 183, horizon 9\n", - "adding: mem time175, current time 183, horizon 8\n", - "adding: mem time176, current time 183, horizon 7\n", - "adding: mem time177, current time 183, horizon 6\n", - "adding: mem time178, current time 183, horizon 5\n", - "adding: mem time179, current time 183, horizon 4\n", - "adding: mem time180, current time 183, horizon 3\n", - "adding: mem time181, current time 183, horizon 2\n", - "adding: mem time182, current time 183, horizon 1\n", - "adding: mem time0, current time 184, horizon 184\n", - "adding: mem time1, current time 184, horizon 183\n", - "adding: mem time2, current time 184, horizon 182\n", - "adding: mem time3, current time 184, horizon 181\n", - "adding: mem time4, current time 184, horizon 180\n", - "adding: mem time5, current time 184, horizon 179\n", - "adding: mem time6, current time 184, horizon 178\n", - "adding: mem time7, current time 184, horizon 177\n", - "adding: mem time8, current time 184, horizon 176\n", - "adding: mem time9, current time 184, horizon 175\n", - "adding: mem time10, current time 184, horizon 174\n", - "adding: mem time11, current time 184, horizon 173\n", - "adding: mem time12, current time 184, horizon 172\n", - "adding: mem time13, current time 184, horizon 171\n", - "adding: mem time14, current time 184, horizon 170\n", - "adding: mem time15, current time 184, horizon 169\n", - "adding: mem time16, current time 184, horizon 168\n", - "adding: mem time17, current time 184, horizon 167\n", - "adding: mem time18, current time 184, horizon 166\n", - "adding: mem time19, current time 184, horizon 165\n", - "adding: mem time20, current time 184, horizon 164\n", - "adding: mem time21, current time 184, horizon 163\n", - "adding: mem time22, current time 184, horizon 162\n", - "adding: mem time23, current time 184, horizon 161\n", - "adding: mem time24, current time 184, horizon 160\n", - "adding: mem time25, current time 184, horizon 159\n", - "adding: mem time26, current time 184, horizon 158\n", - "adding: mem time27, current time 184, horizon 157\n", - "adding: mem time28, current time 184, horizon 156\n", - "adding: mem time29, current time 184, horizon 155\n", - "adding: mem time30, current time 184, horizon 154\n", - "adding: mem time31, current time 184, horizon 153\n", - "adding: mem time32, current time 184, horizon 152\n", - "adding: mem time33, current time 184, horizon 151\n", - "adding: mem time34, current time 184, horizon 150\n", - "adding: mem time35, current time 184, horizon 149\n", - "adding: mem time36, current time 184, horizon 148\n", - "adding: mem time37, current time 184, horizon 147\n", - "adding: mem time38, current time 184, horizon 146\n", - "adding: mem time39, current time 184, horizon 145\n", - "adding: mem time40, current time 184, horizon 144\n", - "adding: mem time41, current time 184, horizon 143\n", - "adding: mem time42, current time 184, horizon 142\n", - "adding: mem time43, current time 184, horizon 141\n", - "adding: mem time44, current time 184, horizon 140\n", - "adding: mem time45, current time 184, horizon 139\n", - "adding: mem time46, current time 184, horizon 138\n", - "adding: mem time47, current time 184, horizon 137\n", - "adding: mem time48, current time 184, horizon 136\n", - "adding: mem time49, current time 184, horizon 135\n", - "adding: mem time50, current time 184, horizon 134\n", - "adding: mem time51, current time 184, horizon 133\n", - "adding: mem time52, current time 184, horizon 132\n", - "adding: mem time53, current time 184, horizon 131\n", - "adding: mem time54, current time 184, horizon 130\n", - "adding: mem time55, current time 184, horizon 129\n", - "adding: mem time56, current time 184, horizon 128\n", - "adding: mem time57, current time 184, horizon 127\n", - "adding: mem time58, current time 184, horizon 126\n", - "adding: mem time59, current time 184, horizon 125\n", - "adding: mem time60, current time 184, horizon 124\n", - "adding: mem time61, current time 184, horizon 123\n", - "adding: mem time62, current time 184, horizon 122\n", - "adding: mem time63, current time 184, horizon 121\n", - "adding: mem time64, current time 184, horizon 120\n", - "adding: mem time65, current time 184, horizon 119\n", - "adding: mem time66, current time 184, horizon 118\n", - "adding: mem time67, current time 184, horizon 117\n", - "adding: mem time68, current time 184, horizon 116\n", - "adding: mem time69, current time 184, horizon 115\n", - "adding: mem time70, current time 184, horizon 114\n", - "adding: mem time71, current time 184, horizon 113\n", - "adding: mem time72, current time 184, horizon 112\n", - "adding: mem time73, current time 184, horizon 111\n", - "adding: mem time74, current time 184, horizon 110\n", - "adding: mem time75, current time 184, horizon 109\n", - "adding: mem time76, current time 184, horizon 108\n", - "adding: mem time77, current time 184, horizon 107\n", - "adding: mem time78, current time 184, horizon 106\n", - "adding: mem time79, current time 184, horizon 105\n", - "adding: mem time80, current time 184, horizon 104\n", - "adding: mem time81, current time 184, horizon 103\n", - "adding: mem time82, current time 184, horizon 102\n", - "adding: mem time83, current time 184, horizon 101\n", - "adding: mem time84, current time 184, horizon 100\n", - "adding: mem time85, current time 184, horizon 99\n", - "adding: mem time86, current time 184, horizon 98\n", - "adding: mem time87, current time 184, horizon 97\n", - "adding: mem time88, current time 184, horizon 96\n", - "adding: mem time89, current time 184, horizon 95\n", - "adding: mem time90, current time 184, horizon 94\n", - "adding: mem time91, current time 184, horizon 93\n", - "adding: mem time92, current time 184, horizon 92\n", - "adding: mem time93, current time 184, horizon 91\n", - "adding: mem time94, current time 184, horizon 90\n", - "adding: mem time95, current time 184, horizon 89\n", - "adding: mem time96, current time 184, horizon 88\n", - "adding: mem time97, current time 184, horizon 87\n", - "adding: mem time98, current time 184, horizon 86\n", - "adding: mem time99, current time 184, horizon 85\n", - "adding: mem time100, current time 184, horizon 84\n", - "adding: mem time101, current time 184, horizon 83\n", - "adding: mem time102, current time 184, horizon 82\n", - "adding: mem time103, current time 184, horizon 81\n", - "adding: mem time104, current time 184, horizon 80\n", - "adding: mem time105, current time 184, horizon 79\n", - "adding: mem time106, current time 184, horizon 78\n", - "adding: mem time107, current time 184, horizon 77\n", - "adding: mem time108, current time 184, horizon 76\n", - "adding: mem time109, current time 184, horizon 75\n", - "adding: mem time110, current time 184, horizon 74\n", - "adding: mem time111, current time 184, horizon 73\n", - "adding: mem time112, current time 184, horizon 72\n", - "adding: mem time113, current time 184, horizon 71\n", - "adding: mem time114, current time 184, horizon 70\n", - "adding: mem time115, current time 184, horizon 69\n", - "adding: mem time116, current time 184, horizon 68\n", - "adding: mem time117, current time 184, horizon 67\n", - "adding: mem time118, current time 184, horizon 66\n", - "adding: mem time119, current time 184, horizon 65\n", - "adding: mem time120, current time 184, horizon 64\n", - "adding: mem time121, current time 184, horizon 63\n", - "adding: mem time122, current time 184, horizon 62\n", - "adding: mem time123, current time 184, horizon 61\n", - "adding: mem time124, current time 184, horizon 60\n", - "adding: mem time125, current time 184, horizon 59\n", - "adding: mem time126, current time 184, horizon 58\n", - "adding: mem time127, current time 184, horizon 57\n", - "adding: mem time128, current time 184, horizon 56\n", - "adding: mem time129, current time 184, horizon 55\n", - "adding: mem time130, current time 184, horizon 54\n", - "adding: mem time131, current time 184, horizon 53\n", - "adding: mem time132, current time 184, horizon 52\n", - "adding: mem time133, current time 184, horizon 51\n", - "adding: mem time134, current time 184, horizon 50\n", - "adding: mem time135, current time 184, horizon 49\n", - "adding: mem time136, current time 184, horizon 48\n", - "adding: mem time137, current time 184, horizon 47\n", - "adding: mem time138, current time 184, horizon 46\n", - "adding: mem time139, current time 184, horizon 45\n", - "adding: mem time140, current time 184, horizon 44\n", - "adding: mem time141, current time 184, horizon 43\n", - "adding: mem time142, current time 184, horizon 42\n", - "adding: mem time143, current time 184, horizon 41\n", - "adding: mem time144, current time 184, horizon 40\n", - "adding: mem time145, current time 184, horizon 39\n", - "adding: mem time146, current time 184, horizon 38\n", - "adding: mem time147, current time 184, horizon 37\n", - "adding: mem time148, current time 184, horizon 36\n", - "adding: mem time149, current time 184, horizon 35\n", - "adding: mem time150, current time 184, horizon 34\n", - "adding: mem time151, current time 184, horizon 33\n", - "adding: mem time152, current time 184, horizon 32\n", - "adding: mem time153, current time 184, horizon 31\n", - "adding: mem time154, current time 184, horizon 30\n", - "adding: mem time155, current time 184, horizon 29\n", - "adding: mem time156, current time 184, horizon 28\n", - "adding: mem time157, current time 184, horizon 27\n", - "adding: mem time158, current time 184, horizon 26\n", - "adding: mem time159, current time 184, horizon 25\n", - "adding: mem time160, current time 184, horizon 24\n", - "adding: mem time161, current time 184, horizon 23\n", - "adding: mem time162, current time 184, horizon 22\n", - "adding: mem time163, current time 184, horizon 21\n", - "adding: mem time164, current time 184, horizon 20\n", - "adding: mem time165, current time 184, horizon 19\n", - "adding: mem time166, current time 184, horizon 18\n", - "adding: mem time167, current time 184, horizon 17\n", - "adding: mem time168, current time 184, horizon 16\n", - "adding: mem time169, current time 184, horizon 15\n", - "adding: mem time170, current time 184, horizon 14\n", - "adding: mem time171, current time 184, horizon 13\n", - "adding: mem time172, current time 184, horizon 12\n", - "adding: mem time173, current time 184, horizon 11\n", - "adding: mem time174, current time 184, horizon 10\n", - "adding: mem time175, current time 184, horizon 9\n", - "adding: mem time176, current time 184, horizon 8\n", - "adding: mem time177, current time 184, horizon 7\n", - "adding: mem time178, current time 184, horizon 6\n", - "adding: mem time179, current time 184, horizon 5\n", - "adding: mem time180, current time 184, horizon 4\n", - "adding: mem time181, current time 184, horizon 3\n", - "adding: mem time182, current time 184, horizon 2\n", - "adding: mem time183, current time 184, horizon 1\n", - "adding: mem time0, current time 185, horizon 185\n", - "adding: mem time1, current time 185, horizon 184\n", - "adding: mem time2, current time 185, horizon 183\n", - "adding: mem time3, current time 185, horizon 182\n", - "adding: mem time4, current time 185, horizon 181\n", - "adding: mem time5, current time 185, horizon 180\n", - "adding: mem time6, current time 185, horizon 179\n", - "adding: mem time7, current time 185, horizon 178\n", - "adding: mem time8, current time 185, horizon 177\n", - "adding: mem time9, current time 185, horizon 176\n", - "adding: mem time10, current time 185, horizon 175\n", - "adding: mem time11, current time 185, horizon 174\n", - "adding: mem time12, current time 185, horizon 173\n", - "adding: mem time13, current time 185, horizon 172\n", - "adding: mem time14, current time 185, horizon 171\n", - "adding: mem time15, current time 185, horizon 170\n", - "adding: mem time16, current time 185, horizon 169\n", - "adding: mem time17, current time 185, horizon 168\n", - "adding: mem time18, current time 185, horizon 167\n", - "adding: mem time19, current time 185, horizon 166\n", - "adding: mem time20, current time 185, horizon 165\n", - "adding: mem time21, current time 185, horizon 164\n", - "adding: mem time22, current time 185, horizon 163\n", - "adding: mem time23, current time 185, horizon 162\n", - "adding: mem time24, current time 185, horizon 161\n", - "adding: mem time25, current time 185, horizon 160\n", - "adding: mem time26, current time 185, horizon 159\n", - "adding: mem time27, current time 185, horizon 158\n", - "adding: mem time28, current time 185, horizon 157\n", - "adding: mem time29, current time 185, horizon 156\n", - "adding: mem time30, current time 185, horizon 155\n", - "adding: mem time31, current time 185, horizon 154\n", - "adding: mem time32, current time 185, horizon 153\n", - "adding: mem time33, current time 185, horizon 152\n", - "adding: mem time34, current time 185, horizon 151\n", - "adding: mem time35, current time 185, horizon 150\n", - "adding: mem time36, current time 185, horizon 149\n", - "adding: mem time37, current time 185, horizon 148\n", - "adding: mem time38, current time 185, horizon 147\n", - "adding: mem time39, current time 185, horizon 146\n", - "adding: mem time40, current time 185, horizon 145\n", - "adding: mem time41, current time 185, horizon 144\n", - "adding: mem time42, current time 185, horizon 143\n", - "adding: mem time43, current time 185, horizon 142\n", - "adding: mem time44, current time 185, horizon 141\n", - "adding: mem time45, current time 185, horizon 140\n", - "adding: mem time46, current time 185, horizon 139\n", - "adding: mem time47, current time 185, horizon 138\n", - "adding: mem time48, current time 185, horizon 137\n", - "adding: mem time49, current time 185, horizon 136\n", - "adding: mem time50, current time 185, horizon 135\n", - "adding: mem time51, current time 185, horizon 134\n", - "adding: mem time52, current time 185, horizon 133\n", - "adding: mem time53, current time 185, horizon 132\n", - "adding: mem time54, current time 185, horizon 131\n", - "adding: mem time55, current time 185, horizon 130\n", - "adding: mem time56, current time 185, horizon 129\n", - "adding: mem time57, current time 185, horizon 128\n", - "adding: mem time58, current time 185, horizon 127\n", - "adding: mem time59, current time 185, horizon 126\n", - "adding: mem time60, current time 185, horizon 125\n", - "adding: mem time61, current time 185, horizon 124\n", - "adding: mem time62, current time 185, horizon 123\n", - "adding: mem time63, current time 185, horizon 122\n", - "adding: mem time64, current time 185, horizon 121\n", - "adding: mem time65, current time 185, horizon 120\n", - "adding: mem time66, current time 185, horizon 119\n", - "adding: mem time67, current time 185, horizon 118\n", - "adding: mem time68, current time 185, horizon 117\n", - "adding: mem time69, current time 185, horizon 116\n", - "adding: mem time70, current time 185, horizon 115\n", - "adding: mem time71, current time 185, horizon 114\n", - "adding: mem time72, current time 185, horizon 113\n", - "adding: mem time73, current time 185, horizon 112\n", - "adding: mem time74, current time 185, horizon 111\n", - "adding: mem time75, current time 185, horizon 110\n", - "adding: mem time76, current time 185, horizon 109\n", - "adding: mem time77, current time 185, horizon 108\n", - "adding: mem time78, current time 185, horizon 107\n", - "adding: mem time79, current time 185, horizon 106\n", - "adding: mem time80, current time 185, horizon 105\n", - "adding: mem time81, current time 185, horizon 104\n", - "adding: mem time82, current time 185, horizon 103\n", - "adding: mem time83, current time 185, horizon 102\n", - "adding: mem time84, current time 185, horizon 101\n", - "adding: mem time85, current time 185, horizon 100\n", - "adding: mem time86, current time 185, horizon 99\n", - "adding: mem time87, current time 185, horizon 98\n", - "adding: mem time88, current time 185, horizon 97\n", - "adding: mem time89, current time 185, horizon 96\n", - "adding: mem time90, current time 185, horizon 95\n", - "adding: mem time91, current time 185, horizon 94\n", - "adding: mem time92, current time 185, horizon 93\n", - "adding: mem time93, current time 185, horizon 92\n", - "adding: mem time94, current time 185, horizon 91\n", - "adding: mem time95, current time 185, horizon 90\n", - "adding: mem time96, current time 185, horizon 89\n", - "adding: mem time97, current time 185, horizon 88\n", - "adding: mem time98, current time 185, horizon 87\n", - "adding: mem time99, current time 185, horizon 86\n", - "adding: mem time100, current time 185, horizon 85\n", - "adding: mem time101, current time 185, horizon 84\n", - "adding: mem time102, current time 185, horizon 83\n", - "adding: mem time103, current time 185, horizon 82\n", - "adding: mem time104, current time 185, horizon 81\n", - "adding: mem time105, current time 185, horizon 80\n", - "adding: mem time106, current time 185, horizon 79\n", - "adding: mem time107, current time 185, horizon 78\n", - "adding: mem time108, current time 185, horizon 77\n", - "adding: mem time109, current time 185, horizon 76\n", - "adding: mem time110, current time 185, horizon 75\n", - "adding: mem time111, current time 185, horizon 74\n", - "adding: mem time112, current time 185, horizon 73\n", - "adding: mem time113, current time 185, horizon 72\n", - "adding: mem time114, current time 185, horizon 71\n", - "adding: mem time115, current time 185, horizon 70\n", - "adding: mem time116, current time 185, horizon 69\n", - "adding: mem time117, current time 185, horizon 68\n", - "adding: mem time118, current time 185, horizon 67\n", - "adding: mem time119, current time 185, horizon 66\n", - "adding: mem time120, current time 185, horizon 65\n", - "adding: mem time121, current time 185, horizon 64\n", - "adding: mem time122, current time 185, horizon 63\n", - "adding: mem time123, current time 185, horizon 62\n", - "adding: mem time124, current time 185, horizon 61\n", - "adding: mem time125, current time 185, horizon 60\n", - "adding: mem time126, current time 185, horizon 59\n", - "adding: mem time127, current time 185, horizon 58\n", - "adding: mem time128, current time 185, horizon 57\n", - "adding: mem time129, current time 185, horizon 56\n", - "adding: mem time130, current time 185, horizon 55\n", - "adding: mem time131, current time 185, horizon 54\n", - "adding: mem time132, current time 185, horizon 53\n", - "adding: mem time133, current time 185, horizon 52\n", - "adding: mem time134, current time 185, horizon 51\n", - "adding: mem time135, current time 185, horizon 50\n", - "adding: mem time136, current time 185, horizon 49\n", - "adding: mem time137, current time 185, horizon 48\n", - "adding: mem time138, current time 185, horizon 47\n", - "adding: mem time139, current time 185, horizon 46\n", - "adding: mem time140, current time 185, horizon 45\n", - "adding: mem time141, current time 185, horizon 44\n", - "adding: mem time142, current time 185, horizon 43\n", - "adding: mem time143, current time 185, horizon 42\n", - "adding: mem time144, current time 185, horizon 41\n", - "adding: mem time145, current time 185, horizon 40\n", - "adding: mem time146, current time 185, horizon 39\n", - "adding: mem time147, current time 185, horizon 38\n", - "adding: mem time148, current time 185, horizon 37\n", - "adding: mem time149, current time 185, horizon 36\n", - "adding: mem time150, current time 185, horizon 35\n", - "adding: mem time151, current time 185, horizon 34\n", - "adding: mem time152, current time 185, horizon 33\n", - "adding: mem time153, current time 185, horizon 32\n", - "adding: mem time154, current time 185, horizon 31\n", - "adding: mem time155, current time 185, horizon 30\n", - "adding: mem time156, current time 185, horizon 29\n", - "adding: mem time157, current time 185, horizon 28\n", - "adding: mem time158, current time 185, horizon 27\n", - "adding: mem time159, current time 185, horizon 26\n", - "adding: mem time160, current time 185, horizon 25\n", - "adding: mem time161, current time 185, horizon 24\n", - "adding: mem time162, current time 185, horizon 23\n", - "adding: mem time163, current time 185, horizon 22\n", - "adding: mem time164, current time 185, horizon 21\n", - "adding: mem time165, current time 185, horizon 20\n", - "adding: mem time166, current time 185, horizon 19\n", - "adding: mem time167, current time 185, horizon 18\n", - "adding: mem time168, current time 185, horizon 17\n", - "adding: mem time169, current time 185, horizon 16\n", - "adding: mem time170, current time 185, horizon 15\n", - "adding: mem time171, current time 185, horizon 14\n", - "adding: mem time172, current time 185, horizon 13\n", - "adding: mem time173, current time 185, horizon 12\n", - "adding: mem time174, current time 185, horizon 11\n", - "adding: mem time175, current time 185, horizon 10\n", - "adding: mem time176, current time 185, horizon 9\n", - "adding: mem time177, current time 185, horizon 8\n", - "adding: mem time178, current time 185, horizon 7\n", - "adding: mem time179, current time 185, horizon 6\n", - "adding: mem time180, current time 185, horizon 5\n", - "adding: mem time181, current time 185, horizon 4\n", - "adding: mem time182, current time 185, horizon 3\n", - "adding: mem time183, current time 185, horizon 2\n", - "adding: mem time184, current time 185, horizon 1\n", - "adding: mem time0, current time 186, horizon 186\n", - "adding: mem time1, current time 186, horizon 185\n", - "adding: mem time2, current time 186, horizon 184\n", - "adding: mem time3, current time 186, horizon 183\n", - "adding: mem time4, current time 186, horizon 182\n", - "adding: mem time5, current time 186, horizon 181\n", - "adding: mem time6, current time 186, horizon 180\n", - "adding: mem time7, current time 186, horizon 179\n", - "adding: mem time8, current time 186, horizon 178\n", - "adding: mem time9, current time 186, horizon 177\n", - "adding: mem time10, current time 186, horizon 176\n", - "adding: mem time11, current time 186, horizon 175\n", - "adding: mem time12, current time 186, horizon 174\n", - "adding: mem time13, current time 186, horizon 173\n", - "adding: mem time14, current time 186, horizon 172\n", - "adding: mem time15, current time 186, horizon 171\n", - "adding: mem time16, current time 186, horizon 170\n", - "adding: mem time17, current time 186, horizon 169\n", - "adding: mem time18, current time 186, horizon 168\n", - "adding: mem time19, current time 186, horizon 167\n", - "adding: mem time20, current time 186, horizon 166\n", - "adding: mem time21, current time 186, horizon 165\n", - "adding: mem time22, current time 186, horizon 164\n", - "adding: mem time23, current time 186, horizon 163\n", - "adding: mem time24, current time 186, horizon 162\n", - "adding: mem time25, current time 186, horizon 161\n", - "adding: mem time26, current time 186, horizon 160\n", - "adding: mem time27, current time 186, horizon 159\n", - "adding: mem time28, current time 186, horizon 158\n", - "adding: mem time29, current time 186, horizon 157\n", - "adding: mem time30, current time 186, horizon 156\n", - "adding: mem time31, current time 186, horizon 155\n", - "adding: mem time32, current time 186, horizon 154\n", - "adding: mem time33, current time 186, horizon 153\n", - "adding: mem time34, current time 186, horizon 152\n", - "adding: mem time35, current time 186, horizon 151\n", - "adding: mem time36, current time 186, horizon 150\n", - "adding: mem time37, current time 186, horizon 149\n", - "adding: mem time38, current time 186, horizon 148\n", - "adding: mem time39, current time 186, horizon 147\n", - "adding: mem time40, current time 186, horizon 146\n", - "adding: mem time41, current time 186, horizon 145\n", - "adding: mem time42, current time 186, horizon 144\n", - "adding: mem time43, current time 186, horizon 143\n", - "adding: mem time44, current time 186, horizon 142\n", - "adding: mem time45, current time 186, horizon 141\n", - "adding: mem time46, current time 186, horizon 140\n", - "adding: mem time47, current time 186, horizon 139\n", - "adding: mem time48, current time 186, horizon 138\n", - "adding: mem time49, current time 186, horizon 137\n", - "adding: mem time50, current time 186, horizon 136\n", - "adding: mem time51, current time 186, horizon 135\n", - "adding: mem time52, current time 186, horizon 134\n", - "adding: mem time53, current time 186, horizon 133\n", - "adding: mem time54, current time 186, horizon 132\n", - "adding: mem time55, current time 186, horizon 131\n", - "adding: mem time56, current time 186, horizon 130\n", - "adding: mem time57, current time 186, horizon 129\n", - "adding: mem time58, current time 186, horizon 128\n", - "adding: mem time59, current time 186, horizon 127\n", - "adding: mem time60, current time 186, horizon 126\n", - "adding: mem time61, current time 186, horizon 125\n", - "adding: mem time62, current time 186, horizon 124\n", - "adding: mem time63, current time 186, horizon 123\n", - "adding: mem time64, current time 186, horizon 122\n", - "adding: mem time65, current time 186, horizon 121\n", - "adding: mem time66, current time 186, horizon 120\n", - "adding: mem time67, current time 186, horizon 119\n", - "adding: mem time68, current time 186, horizon 118\n", - "adding: mem time69, current time 186, horizon 117\n", - "adding: mem time70, current time 186, horizon 116\n", - "adding: mem time71, current time 186, horizon 115\n", - "adding: mem time72, current time 186, horizon 114\n", - "adding: mem time73, current time 186, horizon 113\n", - "adding: mem time74, current time 186, horizon 112\n", - "adding: mem time75, current time 186, horizon 111\n", - "adding: mem time76, current time 186, horizon 110\n", - "adding: mem time77, current time 186, horizon 109\n", - "adding: mem time78, current time 186, horizon 108\n", - "adding: mem time79, current time 186, horizon 107\n", - "adding: mem time80, current time 186, horizon 106\n", - "adding: mem time81, current time 186, horizon 105\n", - "adding: mem time82, current time 186, horizon 104\n", - "adding: mem time83, current time 186, horizon 103\n", - "adding: mem time84, current time 186, horizon 102\n", - "adding: mem time85, current time 186, horizon 101\n", - "adding: mem time86, current time 186, horizon 100\n", - "adding: mem time87, current time 186, horizon 99\n", - "adding: mem time88, current time 186, horizon 98\n", - "adding: mem time89, current time 186, horizon 97\n", - "adding: mem time90, current time 186, horizon 96\n", - "adding: mem time91, current time 186, horizon 95\n", - "adding: mem time92, current time 186, horizon 94\n", - "adding: mem time93, current time 186, horizon 93\n", - "adding: mem time94, current time 186, horizon 92\n", - "adding: mem time95, current time 186, horizon 91\n", - "adding: mem time96, current time 186, horizon 90\n", - "adding: mem time97, current time 186, horizon 89\n", - "adding: mem time98, current time 186, horizon 88\n", - "adding: mem time99, current time 186, horizon 87\n", - "adding: mem time100, current time 186, horizon 86\n", - "adding: mem time101, current time 186, horizon 85\n", - "adding: mem time102, current time 186, horizon 84\n", - "adding: mem time103, current time 186, horizon 83\n", - "adding: mem time104, current time 186, horizon 82\n", - "adding: mem time105, current time 186, horizon 81\n", - "adding: mem time106, current time 186, horizon 80\n", - "adding: mem time107, current time 186, horizon 79\n", - "adding: mem time108, current time 186, horizon 78\n", - "adding: mem time109, current time 186, horizon 77\n", - "adding: mem time110, current time 186, horizon 76\n", - "adding: mem time111, current time 186, horizon 75\n", - "adding: mem time112, current time 186, horizon 74\n", - "adding: mem time113, current time 186, horizon 73\n", - "adding: mem time114, current time 186, horizon 72\n", - "adding: mem time115, current time 186, horizon 71\n", - "adding: mem time116, current time 186, horizon 70\n", - "adding: mem time117, current time 186, horizon 69\n", - "adding: mem time118, current time 186, horizon 68\n", - "adding: mem time119, current time 186, horizon 67\n", - "adding: mem time120, current time 186, horizon 66\n", - "adding: mem time121, current time 186, horizon 65\n", - "adding: mem time122, current time 186, horizon 64\n", - "adding: mem time123, current time 186, horizon 63\n", - "adding: mem time124, current time 186, horizon 62\n", - "adding: mem time125, current time 186, horizon 61\n", - "adding: mem time126, current time 186, horizon 60\n", - "adding: mem time127, current time 186, horizon 59\n", - "adding: mem time128, current time 186, horizon 58\n", - "adding: mem time129, current time 186, horizon 57\n", - "adding: mem time130, current time 186, horizon 56\n", - "adding: mem time131, current time 186, horizon 55\n", - "adding: mem time132, current time 186, horizon 54\n", - "adding: mem time133, current time 186, horizon 53\n", - "adding: mem time134, current time 186, horizon 52\n", - "adding: mem time135, current time 186, horizon 51\n", - "adding: mem time136, current time 186, horizon 50\n", - "adding: mem time137, current time 186, horizon 49\n", - "adding: mem time138, current time 186, horizon 48\n", - "adding: mem time139, current time 186, horizon 47\n", - "adding: mem time140, current time 186, horizon 46\n", - "adding: mem time141, current time 186, horizon 45\n", - "adding: mem time142, current time 186, horizon 44\n", - "adding: mem time143, current time 186, horizon 43\n", - "adding: mem time144, current time 186, horizon 42\n", - "adding: mem time145, current time 186, horizon 41\n", - "adding: mem time146, current time 186, horizon 40\n", - "adding: mem time147, current time 186, horizon 39\n", - "adding: mem time148, current time 186, horizon 38\n", - "adding: mem time149, current time 186, horizon 37\n", - "adding: mem time150, current time 186, horizon 36\n", - "adding: mem time151, current time 186, horizon 35\n", - "adding: mem time152, current time 186, horizon 34\n", - "adding: mem time153, current time 186, horizon 33\n", - "adding: mem time154, current time 186, horizon 32\n", - "adding: mem time155, current time 186, horizon 31\n", - "adding: mem time156, current time 186, horizon 30\n", - "adding: mem time157, current time 186, horizon 29\n", - "adding: mem time158, current time 186, horizon 28\n", - "adding: mem time159, current time 186, horizon 27\n", - "adding: mem time160, current time 186, horizon 26\n", - "adding: mem time161, current time 186, horizon 25\n", - "adding: mem time162, current time 186, horizon 24\n", - "adding: mem time163, current time 186, horizon 23\n", - "adding: mem time164, current time 186, horizon 22\n", - "adding: mem time165, current time 186, horizon 21\n", - "adding: mem time166, current time 186, horizon 20\n", - "adding: mem time167, current time 186, horizon 19\n", - "adding: mem time168, current time 186, horizon 18\n", - "adding: mem time169, current time 186, horizon 17\n", - "adding: mem time170, current time 186, horizon 16\n", - "adding: mem time171, current time 186, horizon 15\n", - "adding: mem time172, current time 186, horizon 14\n", - "adding: mem time173, current time 186, horizon 13\n", - "adding: mem time174, current time 186, horizon 12\n", - "adding: mem time175, current time 186, horizon 11\n", - "adding: mem time176, current time 186, horizon 10\n", - "adding: mem time177, current time 186, horizon 9\n", - "adding: mem time178, current time 186, horizon 8\n", - "adding: mem time179, current time 186, horizon 7\n", - "adding: mem time180, current time 186, horizon 6\n", - "adding: mem time181, current time 186, horizon 5\n", - "adding: mem time182, current time 186, horizon 4\n", - "adding: mem time183, current time 186, horizon 3\n", - "adding: mem time184, current time 186, horizon 2\n", - "adding: mem time185, current time 186, horizon 1\n", - "adding: mem time0, current time 187, horizon 187\n", - "adding: mem time1, current time 187, horizon 186\n", - "adding: mem time2, current time 187, horizon 185\n", - "adding: mem time3, current time 187, horizon 184\n", - "adding: mem time4, current time 187, horizon 183\n", - "adding: mem time5, current time 187, horizon 182\n", - "adding: mem time6, current time 187, horizon 181\n", - "adding: mem time7, current time 187, horizon 180\n", - "adding: mem time8, current time 187, horizon 179\n", - "adding: mem time9, current time 187, horizon 178\n", - "adding: mem time10, current time 187, horizon 177\n", - "adding: mem time11, current time 187, horizon 176\n", - "adding: mem time12, current time 187, horizon 175\n", - "adding: mem time13, current time 187, horizon 174\n", - "adding: mem time14, current time 187, horizon 173\n", - "adding: mem time15, current time 187, horizon 172\n", - "adding: mem time16, current time 187, horizon 171\n", - "adding: mem time17, current time 187, horizon 170\n", - "adding: mem time18, current time 187, horizon 169\n", - "adding: mem time19, current time 187, horizon 168\n", - "adding: mem time20, current time 187, horizon 167\n", - "adding: mem time21, current time 187, horizon 166\n", - "adding: mem time22, current time 187, horizon 165\n", - "adding: mem time23, current time 187, horizon 164\n", - "adding: mem time24, current time 187, horizon 163\n", - "adding: mem time25, current time 187, horizon 162\n", - "adding: mem time26, current time 187, horizon 161\n", - "adding: mem time27, current time 187, horizon 160\n", - "adding: mem time28, current time 187, horizon 159\n", - "adding: mem time29, current time 187, horizon 158\n", - "adding: mem time30, current time 187, horizon 157\n", - "adding: mem time31, current time 187, horizon 156\n", - "adding: mem time32, current time 187, horizon 155\n", - "adding: mem time33, current time 187, horizon 154\n", - "adding: mem time34, current time 187, horizon 153\n", - "adding: mem time35, current time 187, horizon 152\n", - "adding: mem time36, current time 187, horizon 151\n", - "adding: mem time37, current time 187, horizon 150\n", - "adding: mem time38, current time 187, horizon 149\n", - "adding: mem time39, current time 187, horizon 148\n", - "adding: mem time40, current time 187, horizon 147\n", - "adding: mem time41, current time 187, horizon 146\n", - "adding: mem time42, current time 187, horizon 145\n", - "adding: mem time43, current time 187, horizon 144\n", - "adding: mem time44, current time 187, horizon 143\n", - "adding: mem time45, current time 187, horizon 142\n", - "adding: mem time46, current time 187, horizon 141\n", - "adding: mem time47, current time 187, horizon 140\n", - "adding: mem time48, current time 187, horizon 139\n", - "adding: mem time49, current time 187, horizon 138\n", - "adding: mem time50, current time 187, horizon 137\n", - "adding: mem time51, current time 187, horizon 136\n", - "adding: mem time52, current time 187, horizon 135\n", - "adding: mem time53, current time 187, horizon 134\n", - "adding: mem time54, current time 187, horizon 133\n", - "adding: mem time55, current time 187, horizon 132\n", - "adding: mem time56, current time 187, horizon 131\n", - "adding: mem time57, current time 187, horizon 130\n", - "adding: mem time58, current time 187, horizon 129\n", - "adding: mem time59, current time 187, horizon 128\n", - "adding: mem time60, current time 187, horizon 127\n", - "adding: mem time61, current time 187, horizon 126\n", - "adding: mem time62, current time 187, horizon 125\n", - "adding: mem time63, current time 187, horizon 124\n", - "adding: mem time64, current time 187, horizon 123\n", - "adding: mem time65, current time 187, horizon 122\n", - "adding: mem time66, current time 187, horizon 121\n", - "adding: mem time67, current time 187, horizon 120\n", - "adding: mem time68, current time 187, horizon 119\n", - "adding: mem time69, current time 187, horizon 118\n", - "adding: mem time70, current time 187, horizon 117\n", - "adding: mem time71, current time 187, horizon 116\n", - "adding: mem time72, current time 187, horizon 115\n", - "adding: mem time73, current time 187, horizon 114\n", - "adding: mem time74, current time 187, horizon 113\n", - "adding: mem time75, current time 187, horizon 112\n", - "adding: mem time76, current time 187, horizon 111\n", - "adding: mem time77, current time 187, horizon 110\n", - "adding: mem time78, current time 187, horizon 109\n", - "adding: mem time79, current time 187, horizon 108\n", - "adding: mem time80, current time 187, horizon 107\n", - "adding: mem time81, current time 187, horizon 106\n", - "adding: mem time82, current time 187, horizon 105\n", - "adding: mem time83, current time 187, horizon 104\n", - "adding: mem time84, current time 187, horizon 103\n", - "adding: mem time85, current time 187, horizon 102\n", - "adding: mem time86, current time 187, horizon 101\n", - "adding: mem time87, current time 187, horizon 100\n", - "adding: mem time88, current time 187, horizon 99\n", - "adding: mem time89, current time 187, horizon 98\n", - "adding: mem time90, current time 187, horizon 97\n", - "adding: mem time91, current time 187, horizon 96\n", - "adding: mem time92, current time 187, horizon 95\n", - "adding: mem time93, current time 187, horizon 94\n", - "adding: mem time94, current time 187, horizon 93\n", - "adding: mem time95, current time 187, horizon 92\n", - "adding: mem time96, current time 187, horizon 91\n", - "adding: mem time97, current time 187, horizon 90\n", - "adding: mem time98, current time 187, horizon 89\n", - "adding: mem time99, current time 187, horizon 88\n", - "adding: mem time100, current time 187, horizon 87\n", - "adding: mem time101, current time 187, horizon 86\n", - "adding: mem time102, current time 187, horizon 85\n", - "adding: mem time103, current time 187, horizon 84\n", - "adding: mem time104, current time 187, horizon 83\n", - "adding: mem time105, current time 187, horizon 82\n", - "adding: mem time106, current time 187, horizon 81\n", - "adding: mem time107, current time 187, horizon 80\n", - "adding: mem time108, current time 187, horizon 79\n", - "adding: mem time109, current time 187, horizon 78\n", - "adding: mem time110, current time 187, horizon 77\n", - "adding: mem time111, current time 187, horizon 76\n", - "adding: mem time112, current time 187, horizon 75\n", - "adding: mem time113, current time 187, horizon 74\n", - "adding: mem time114, current time 187, horizon 73\n", - "adding: mem time115, current time 187, horizon 72\n", - "adding: mem time116, current time 187, horizon 71\n", - "adding: mem time117, current time 187, horizon 70\n", - "adding: mem time118, current time 187, horizon 69\n", - "adding: mem time119, current time 187, horizon 68\n", - "adding: mem time120, current time 187, horizon 67\n", - "adding: mem time121, current time 187, horizon 66\n", - "adding: mem time122, current time 187, horizon 65\n", - "adding: mem time123, current time 187, horizon 64\n", - "adding: mem time124, current time 187, horizon 63\n", - "adding: mem time125, current time 187, horizon 62\n", - "adding: mem time126, current time 187, horizon 61\n", - "adding: mem time127, current time 187, horizon 60\n", - "adding: mem time128, current time 187, horizon 59\n", - "adding: mem time129, current time 187, horizon 58\n", - "adding: mem time130, current time 187, horizon 57\n", - "adding: mem time131, current time 187, horizon 56\n", - "adding: mem time132, current time 187, horizon 55\n", - "adding: mem time133, current time 187, horizon 54\n", - "adding: mem time134, current time 187, horizon 53\n", - "adding: mem time135, current time 187, horizon 52\n", - "adding: mem time136, current time 187, horizon 51\n", - "adding: mem time137, current time 187, horizon 50\n", - "adding: mem time138, current time 187, horizon 49\n", - "adding: mem time139, current time 187, horizon 48\n", - "adding: mem time140, current time 187, horizon 47\n", - "adding: mem time141, current time 187, horizon 46\n", - "adding: mem time142, current time 187, horizon 45\n", - "adding: mem time143, current time 187, horizon 44\n", - "adding: mem time144, current time 187, horizon 43\n", - "adding: mem time145, current time 187, horizon 42\n", - "adding: mem time146, current time 187, horizon 41\n", - "adding: mem time147, current time 187, horizon 40\n", - "adding: mem time148, current time 187, horizon 39\n", - "adding: mem time149, current time 187, horizon 38\n", - "adding: mem time150, current time 187, horizon 37\n", - "adding: mem time151, current time 187, horizon 36\n", - "adding: mem time152, current time 187, horizon 35\n", - "adding: mem time153, current time 187, horizon 34\n", - "adding: mem time154, current time 187, horizon 33\n", - "adding: mem time155, current time 187, horizon 32\n", - "adding: mem time156, current time 187, horizon 31\n", - "adding: mem time157, current time 187, horizon 30\n", - "adding: mem time158, current time 187, horizon 29\n", - "adding: mem time159, current time 187, horizon 28\n", - "adding: mem time160, current time 187, horizon 27\n", - "adding: mem time161, current time 187, horizon 26\n", - "adding: mem time162, current time 187, horizon 25\n", - "adding: mem time163, current time 187, horizon 24\n", - "adding: mem time164, current time 187, horizon 23\n", - "adding: mem time165, current time 187, horizon 22\n", - "adding: mem time166, current time 187, horizon 21\n", - "adding: mem time167, current time 187, horizon 20\n", - "adding: mem time168, current time 187, horizon 19\n", - "adding: mem time169, current time 187, horizon 18\n", - "adding: mem time170, current time 187, horizon 17\n", - "adding: mem time171, current time 187, horizon 16\n", - "adding: mem time172, current time 187, horizon 15\n", - "adding: mem time173, current time 187, horizon 14\n", - "adding: mem time174, current time 187, horizon 13\n", - "adding: mem time175, current time 187, horizon 12\n", - "adding: mem time176, current time 187, horizon 11\n", - "adding: mem time177, current time 187, horizon 10\n", - "adding: mem time178, current time 187, horizon 9\n", - "adding: mem time179, current time 187, horizon 8\n", - "adding: mem time180, current time 187, horizon 7\n", - "adding: mem time181, current time 187, horizon 6\n", - "adding: mem time182, current time 187, horizon 5\n", - "adding: mem time183, current time 187, horizon 4\n", - "adding: mem time184, current time 187, horizon 3\n", - "adding: mem time185, current time 187, horizon 2\n", - "adding: mem time186, current time 187, horizon 1\n", - "adding: mem time0, current time 188, horizon 188\n", - "adding: mem time1, current time 188, horizon 187\n", - "adding: mem time2, current time 188, horizon 186\n", - "adding: mem time3, current time 188, horizon 185\n", - "adding: mem time4, current time 188, horizon 184\n", - "adding: mem time5, current time 188, horizon 183\n", - "adding: mem time6, current time 188, horizon 182\n", - "adding: mem time7, current time 188, horizon 181\n", - "adding: mem time8, current time 188, horizon 180\n", - "adding: mem time9, current time 188, horizon 179\n", - "adding: mem time10, current time 188, horizon 178\n", - "adding: mem time11, current time 188, horizon 177\n", - "adding: mem time12, current time 188, horizon 176\n", - "adding: mem time13, current time 188, horizon 175\n", - "adding: mem time14, current time 188, horizon 174\n", - "adding: mem time15, current time 188, horizon 173\n", - "adding: mem time16, current time 188, horizon 172\n", - "adding: mem time17, current time 188, horizon 171\n", - "adding: mem time18, current time 188, horizon 170\n", - "adding: mem time19, current time 188, horizon 169\n", - "adding: mem time20, current time 188, horizon 168\n", - "adding: mem time21, current time 188, horizon 167\n", - "adding: mem time22, current time 188, horizon 166\n", - "adding: mem time23, current time 188, horizon 165\n", - "adding: mem time24, current time 188, horizon 164\n", - "adding: mem time25, current time 188, horizon 163\n", - "adding: mem time26, current time 188, horizon 162\n", - "adding: mem time27, current time 188, horizon 161\n", - "adding: mem time28, current time 188, horizon 160\n", - "adding: mem time29, current time 188, horizon 159\n", - "adding: mem time30, current time 188, horizon 158\n", - "adding: mem time31, current time 188, horizon 157\n", - "adding: mem time32, current time 188, horizon 156\n", - "adding: mem time33, current time 188, horizon 155\n", - "adding: mem time34, current time 188, horizon 154\n", - "adding: mem time35, current time 188, horizon 153\n", - "adding: mem time36, current time 188, horizon 152\n", - "adding: mem time37, current time 188, horizon 151\n", - "adding: mem time38, current time 188, horizon 150\n", - "adding: mem time39, current time 188, horizon 149\n", - "adding: mem time40, current time 188, horizon 148\n", - "adding: mem time41, current time 188, horizon 147\n", - "adding: mem time42, current time 188, horizon 146\n", - "adding: mem time43, current time 188, horizon 145\n", - "adding: mem time44, current time 188, horizon 144\n", - "adding: mem time45, current time 188, horizon 143\n", - "adding: mem time46, current time 188, horizon 142\n", - "adding: mem time47, current time 188, horizon 141\n", - "adding: mem time48, current time 188, horizon 140\n", - "adding: mem time49, current time 188, horizon 139\n", - "adding: mem time50, current time 188, horizon 138\n", - "adding: mem time51, current time 188, horizon 137\n", - "adding: mem time52, current time 188, horizon 136\n", - "adding: mem time53, current time 188, horizon 135\n", - "adding: mem time54, current time 188, horizon 134\n", - "adding: mem time55, current time 188, horizon 133\n", - "adding: mem time56, current time 188, horizon 132\n", - "adding: mem time57, current time 188, horizon 131\n", - "adding: mem time58, current time 188, horizon 130\n", - "adding: mem time59, current time 188, horizon 129\n", - "adding: mem time60, current time 188, horizon 128\n", - "adding: mem time61, current time 188, horizon 127\n", - "adding: mem time62, current time 188, horizon 126\n", - "adding: mem time63, current time 188, horizon 125\n", - "adding: mem time64, current time 188, horizon 124\n", - "adding: mem time65, current time 188, horizon 123\n", - "adding: mem time66, current time 188, horizon 122\n", - "adding: mem time67, current time 188, horizon 121\n", - "adding: mem time68, current time 188, horizon 120\n", - "adding: mem time69, current time 188, horizon 119\n", - "adding: mem time70, current time 188, horizon 118\n", - "adding: mem time71, current time 188, horizon 117\n", - "adding: mem time72, current time 188, horizon 116\n", - "adding: mem time73, current time 188, horizon 115\n", - "adding: mem time74, current time 188, horizon 114\n", - "adding: mem time75, current time 188, horizon 113\n", - "adding: mem time76, current time 188, horizon 112\n", - "adding: mem time77, current time 188, horizon 111\n", - "adding: mem time78, current time 188, horizon 110\n", - "adding: mem time79, current time 188, horizon 109\n", - "adding: mem time80, current time 188, horizon 108\n", - "adding: mem time81, current time 188, horizon 107\n", - "adding: mem time82, current time 188, horizon 106\n", - "adding: mem time83, current time 188, horizon 105\n", - "adding: mem time84, current time 188, horizon 104\n", - "adding: mem time85, current time 188, horizon 103\n", - "adding: mem time86, current time 188, horizon 102\n", - "adding: mem time87, current time 188, horizon 101\n", - "adding: mem time88, current time 188, horizon 100\n", - "adding: mem time89, current time 188, horizon 99\n", - "adding: mem time90, current time 188, horizon 98\n", - "adding: mem time91, current time 188, horizon 97\n", - "adding: mem time92, current time 188, horizon 96\n", - "adding: mem time93, current time 188, horizon 95\n", - "adding: mem time94, current time 188, horizon 94\n", - "adding: mem time95, current time 188, horizon 93\n", - "adding: mem time96, current time 188, horizon 92\n", - "adding: mem time97, current time 188, horizon 91\n", - "adding: mem time98, current time 188, horizon 90\n", - "adding: mem time99, current time 188, horizon 89\n", - "adding: mem time100, current time 188, horizon 88\n", - "adding: mem time101, current time 188, horizon 87\n", - "adding: mem time102, current time 188, horizon 86\n", - "adding: mem time103, current time 188, horizon 85\n", - "adding: mem time104, current time 188, horizon 84\n", - "adding: mem time105, current time 188, horizon 83\n", - "adding: mem time106, current time 188, horizon 82\n", - "adding: mem time107, current time 188, horizon 81\n", - "adding: mem time108, current time 188, horizon 80\n", - "adding: mem time109, current time 188, horizon 79\n", - "adding: mem time110, current time 188, horizon 78\n", - "adding: mem time111, current time 188, horizon 77\n", - "adding: mem time112, current time 188, horizon 76\n", - "adding: mem time113, current time 188, horizon 75\n", - "adding: mem time114, current time 188, horizon 74\n", - "adding: mem time115, current time 188, horizon 73\n", - "adding: mem time116, current time 188, horizon 72\n", - "adding: mem time117, current time 188, horizon 71\n", - "adding: mem time118, current time 188, horizon 70\n", - "adding: mem time119, current time 188, horizon 69\n", - "adding: mem time120, current time 188, horizon 68\n", - "adding: mem time121, current time 188, horizon 67\n", - "adding: mem time122, current time 188, horizon 66\n", - "adding: mem time123, current time 188, horizon 65\n", - "adding: mem time124, current time 188, horizon 64\n", - "adding: mem time125, current time 188, horizon 63\n", - "adding: mem time126, current time 188, horizon 62\n", - "adding: mem time127, current time 188, horizon 61\n", - "adding: mem time128, current time 188, horizon 60\n", - "adding: mem time129, current time 188, horizon 59\n", - "adding: mem time130, current time 188, horizon 58\n", - "adding: mem time131, current time 188, horizon 57\n", - "adding: mem time132, current time 188, horizon 56\n", - "adding: mem time133, current time 188, horizon 55\n", - "adding: mem time134, current time 188, horizon 54\n", - "adding: mem time135, current time 188, horizon 53\n", - "adding: mem time136, current time 188, horizon 52\n", - "adding: mem time137, current time 188, horizon 51\n", - "adding: mem time138, current time 188, horizon 50\n", - "adding: mem time139, current time 188, horizon 49\n", - "adding: mem time140, current time 188, horizon 48\n", - "adding: mem time141, current time 188, horizon 47\n", - "adding: mem time142, current time 188, horizon 46\n", - "adding: mem time143, current time 188, horizon 45\n", - "adding: mem time144, current time 188, horizon 44\n", - "adding: mem time145, current time 188, horizon 43\n", - "adding: mem time146, current time 188, horizon 42\n", - "adding: mem time147, current time 188, horizon 41\n", - "adding: mem time148, current time 188, horizon 40\n", - "adding: mem time149, current time 188, horizon 39\n", - "adding: mem time150, current time 188, horizon 38\n", - "adding: mem time151, current time 188, horizon 37\n", - "adding: mem time152, current time 188, horizon 36\n", - "adding: mem time153, current time 188, horizon 35\n", - "adding: mem time154, current time 188, horizon 34\n", - "adding: mem time155, current time 188, horizon 33\n", - "adding: mem time156, current time 188, horizon 32\n", - "adding: mem time157, current time 188, horizon 31\n", - "adding: mem time158, current time 188, horizon 30\n", - "adding: mem time159, current time 188, horizon 29\n", - "adding: mem time160, current time 188, horizon 28\n", - "adding: mem time161, current time 188, horizon 27\n", - "adding: mem time162, current time 188, horizon 26\n", - "adding: mem time163, current time 188, horizon 25\n", - "adding: mem time164, current time 188, horizon 24\n", - "adding: mem time165, current time 188, horizon 23\n", - "adding: mem time166, current time 188, horizon 22\n", - "adding: mem time167, current time 188, horizon 21\n", - "adding: mem time168, current time 188, horizon 20\n", - "adding: mem time169, current time 188, horizon 19\n", - "adding: mem time170, current time 188, horizon 18\n", - "adding: mem time171, current time 188, horizon 17\n", - "adding: mem time172, current time 188, horizon 16\n", - "adding: mem time173, current time 188, horizon 15\n", - "adding: mem time174, current time 188, horizon 14\n", - "adding: mem time175, current time 188, horizon 13\n", - "adding: mem time176, current time 188, horizon 12\n", - "adding: mem time177, current time 188, horizon 11\n", - "adding: mem time178, current time 188, horizon 10\n", - "adding: mem time179, current time 188, horizon 9\n", - "adding: mem time180, current time 188, horizon 8\n", - "adding: mem time181, current time 188, horizon 7\n", - "adding: mem time182, current time 188, horizon 6\n", - "adding: mem time183, current time 188, horizon 5\n", - "adding: mem time184, current time 188, horizon 4\n", - "adding: mem time185, current time 188, horizon 3\n", - "adding: mem time186, current time 188, horizon 2\n", - "adding: mem time187, current time 188, horizon 1\n", - "adding: mem time0, current time 189, horizon 189\n", - "adding: mem time1, current time 189, horizon 188\n", - "adding: mem time2, current time 189, horizon 187\n", - "adding: mem time3, current time 189, horizon 186\n", - "adding: mem time4, current time 189, horizon 185\n", - "adding: mem time5, current time 189, horizon 184\n", - "adding: mem time6, current time 189, horizon 183\n", - "adding: mem time7, current time 189, horizon 182\n", - "adding: mem time8, current time 189, horizon 181\n", - "adding: mem time9, current time 189, horizon 180\n", - "adding: mem time10, current time 189, horizon 179\n", - "adding: mem time11, current time 189, horizon 178\n", - "adding: mem time12, current time 189, horizon 177\n", - "adding: mem time13, current time 189, horizon 176\n", - "adding: mem time14, current time 189, horizon 175\n", - "adding: mem time15, current time 189, horizon 174\n", - "adding: mem time16, current time 189, horizon 173\n", - "adding: mem time17, current time 189, horizon 172\n", - "adding: mem time18, current time 189, horizon 171\n", - "adding: mem time19, current time 189, horizon 170\n", - "adding: mem time20, current time 189, horizon 169\n", - "adding: mem time21, current time 189, horizon 168\n", - "adding: mem time22, current time 189, horizon 167\n", - "adding: mem time23, current time 189, horizon 166\n", - "adding: mem time24, current time 189, horizon 165\n", - "adding: mem time25, current time 189, horizon 164\n", - "adding: mem time26, current time 189, horizon 163\n", - "adding: mem time27, current time 189, horizon 162\n", - "adding: mem time28, current time 189, horizon 161\n", - "adding: mem time29, current time 189, horizon 160\n", - "adding: mem time30, current time 189, horizon 159\n", - "adding: mem time31, current time 189, horizon 158\n", - "adding: mem time32, current time 189, horizon 157\n", - "adding: mem time33, current time 189, horizon 156\n", - "adding: mem time34, current time 189, horizon 155\n", - "adding: mem time35, current time 189, horizon 154\n", - "adding: mem time36, current time 189, horizon 153\n", - "adding: mem time37, current time 189, horizon 152\n", - "adding: mem time38, current time 189, horizon 151\n", - "adding: mem time39, current time 189, horizon 150\n", - "adding: mem time40, current time 189, horizon 149\n", - "adding: mem time41, current time 189, horizon 148\n", - "adding: mem time42, current time 189, horizon 147\n", - "adding: mem time43, current time 189, horizon 146\n", - "adding: mem time44, current time 189, horizon 145\n", - "adding: mem time45, current time 189, horizon 144\n", - "adding: mem time46, current time 189, horizon 143\n", - "adding: mem time47, current time 189, horizon 142\n", - "adding: mem time48, current time 189, horizon 141\n", - "adding: mem time49, current time 189, horizon 140\n", - "adding: mem time50, current time 189, horizon 139\n", - "adding: mem time51, current time 189, horizon 138\n", - "adding: mem time52, current time 189, horizon 137\n", - "adding: mem time53, current time 189, horizon 136\n", - "adding: mem time54, current time 189, horizon 135\n", - "adding: mem time55, current time 189, horizon 134\n", - "adding: mem time56, current time 189, horizon 133\n", - "adding: mem time57, current time 189, horizon 132\n", - "adding: mem time58, current time 189, horizon 131\n", - "adding: mem time59, current time 189, horizon 130\n", - "adding: mem time60, current time 189, horizon 129\n", - "adding: mem time61, current time 189, horizon 128\n", - "adding: mem time62, current time 189, horizon 127\n", - "adding: mem time63, current time 189, horizon 126\n", - "adding: mem time64, current time 189, horizon 125\n", - "adding: mem time65, current time 189, horizon 124\n", - "adding: mem time66, current time 189, horizon 123\n", - "adding: mem time67, current time 189, horizon 122\n", - "adding: mem time68, current time 189, horizon 121\n", - "adding: mem time69, current time 189, horizon 120\n", - "adding: mem time70, current time 189, horizon 119\n", - "adding: mem time71, current time 189, horizon 118\n", - "adding: mem time72, current time 189, horizon 117\n", - "adding: mem time73, current time 189, horizon 116\n", - "adding: mem time74, current time 189, horizon 115\n", - "adding: mem time75, current time 189, horizon 114\n", - "adding: mem time76, current time 189, horizon 113\n", - "adding: mem time77, current time 189, horizon 112\n", - "adding: mem time78, current time 189, horizon 111\n", - "adding: mem time79, current time 189, horizon 110\n", - "adding: mem time80, current time 189, horizon 109\n", - "adding: mem time81, current time 189, horizon 108\n", - "adding: mem time82, current time 189, horizon 107\n", - "adding: mem time83, current time 189, horizon 106\n", - "adding: mem time84, current time 189, horizon 105\n", - "adding: mem time85, current time 189, horizon 104\n", - "adding: mem time86, current time 189, horizon 103\n", - "adding: mem time87, current time 189, horizon 102\n", - "adding: mem time88, current time 189, horizon 101\n", - "adding: mem time89, current time 189, horizon 100\n", - "adding: mem time90, current time 189, horizon 99\n", - "adding: mem time91, current time 189, horizon 98\n", - "adding: mem time92, current time 189, horizon 97\n", - "adding: mem time93, current time 189, horizon 96\n", - "adding: mem time94, current time 189, horizon 95\n", - "adding: mem time95, current time 189, horizon 94\n", - "adding: mem time96, current time 189, horizon 93\n", - "adding: mem time97, current time 189, horizon 92\n", - "adding: mem time98, current time 189, horizon 91\n", - "adding: mem time99, current time 189, horizon 90\n", - "adding: mem time100, current time 189, horizon 89\n", - "adding: mem time101, current time 189, horizon 88\n", - "adding: mem time102, current time 189, horizon 87\n", - "adding: mem time103, current time 189, horizon 86\n", - "adding: mem time104, current time 189, horizon 85\n", - "adding: mem time105, current time 189, horizon 84\n", - "adding: mem time106, current time 189, horizon 83\n", - "adding: mem time107, current time 189, horizon 82\n", - "adding: mem time108, current time 189, horizon 81\n", - "adding: mem time109, current time 189, horizon 80\n", - "adding: mem time110, current time 189, horizon 79\n", - "adding: mem time111, current time 189, horizon 78\n", - "adding: mem time112, current time 189, horizon 77\n", - "adding: mem time113, current time 189, horizon 76\n", - "adding: mem time114, current time 189, horizon 75\n", - "adding: mem time115, current time 189, horizon 74\n", - "adding: mem time116, current time 189, horizon 73\n", - "adding: mem time117, current time 189, horizon 72\n", - "adding: mem time118, current time 189, horizon 71\n", - "adding: mem time119, current time 189, horizon 70\n", - "adding: mem time120, current time 189, horizon 69\n", - "adding: mem time121, current time 189, horizon 68\n", - "adding: mem time122, current time 189, horizon 67\n", - "adding: mem time123, current time 189, horizon 66\n", - "adding: mem time124, current time 189, horizon 65\n", - "adding: mem time125, current time 189, horizon 64\n", - "adding: mem time126, current time 189, horizon 63\n", - "adding: mem time127, current time 189, horizon 62\n", - "adding: mem time128, current time 189, horizon 61\n", - "adding: mem time129, current time 189, horizon 60\n", - "adding: mem time130, current time 189, horizon 59\n", - "adding: mem time131, current time 189, horizon 58\n", - "adding: mem time132, current time 189, horizon 57\n", - "adding: mem time133, current time 189, horizon 56\n", - "adding: mem time134, current time 189, horizon 55\n", - "adding: mem time135, current time 189, horizon 54\n", - "adding: mem time136, current time 189, horizon 53\n", - "adding: mem time137, current time 189, horizon 52\n", - "adding: mem time138, current time 189, horizon 51\n", - "adding: mem time139, current time 189, horizon 50\n", - "adding: mem time140, current time 189, horizon 49\n", - "adding: mem time141, current time 189, horizon 48\n", - "adding: mem time142, current time 189, horizon 47\n", - "adding: mem time143, current time 189, horizon 46\n", - "adding: mem time144, current time 189, horizon 45\n", - "adding: mem time145, current time 189, horizon 44\n", - "adding: mem time146, current time 189, horizon 43\n", - "adding: mem time147, current time 189, horizon 42\n", - "adding: mem time148, current time 189, horizon 41\n", - "adding: mem time149, current time 189, horizon 40\n", - "adding: mem time150, current time 189, horizon 39\n", - "adding: mem time151, current time 189, horizon 38\n", - "adding: mem time152, current time 189, horizon 37\n", - "adding: mem time153, current time 189, horizon 36\n", - "adding: mem time154, current time 189, horizon 35\n", - "adding: mem time155, current time 189, horizon 34\n", - "adding: mem time156, current time 189, horizon 33\n", - "adding: mem time157, current time 189, horizon 32\n", - "adding: mem time158, current time 189, horizon 31\n", - "adding: mem time159, current time 189, horizon 30\n", - "adding: mem time160, current time 189, horizon 29\n", - "adding: mem time161, current time 189, horizon 28\n", - "adding: mem time162, current time 189, horizon 27\n", - "adding: mem time163, current time 189, horizon 26\n", - "adding: mem time164, current time 189, horizon 25\n", - "adding: mem time165, current time 189, horizon 24\n", - "adding: mem time166, current time 189, horizon 23\n", - "adding: mem time167, current time 189, horizon 22\n", - "adding: mem time168, current time 189, horizon 21\n", - "adding: mem time169, current time 189, horizon 20\n", - "adding: mem time170, current time 189, horizon 19\n", - "adding: mem time171, current time 189, horizon 18\n", - "adding: mem time172, current time 189, horizon 17\n", - "adding: mem time173, current time 189, horizon 16\n", - "adding: mem time174, current time 189, horizon 15\n", - "adding: mem time175, current time 189, horizon 14\n", - "adding: mem time176, current time 189, horizon 13\n", - "adding: mem time177, current time 189, horizon 12\n", - "adding: mem time178, current time 189, horizon 11\n", - "adding: mem time179, current time 189, horizon 10\n", - "adding: mem time180, current time 189, horizon 9\n", - "adding: mem time181, current time 189, horizon 8\n", - "adding: mem time182, current time 189, horizon 7\n", - "adding: mem time183, current time 189, horizon 6\n", - "adding: mem time184, current time 189, horizon 5\n", - "adding: mem time185, current time 189, horizon 4\n", - "adding: mem time186, current time 189, horizon 3\n", - "adding: mem time187, current time 189, horizon 2\n", - "adding: mem time188, current time 189, horizon 1\n", - "adding: mem time0, current time 190, horizon 190\n", - "adding: mem time1, current time 190, horizon 189\n", - "adding: mem time2, current time 190, horizon 188\n", - "adding: mem time3, current time 190, horizon 187\n", - "adding: mem time4, current time 190, horizon 186\n", - "adding: mem time5, current time 190, horizon 185\n", - "adding: mem time6, current time 190, horizon 184\n", - "adding: mem time7, current time 190, horizon 183\n", - "adding: mem time8, current time 190, horizon 182\n", - "adding: mem time9, current time 190, horizon 181\n", - "adding: mem time10, current time 190, horizon 180\n", - "adding: mem time11, current time 190, horizon 179\n", - "adding: mem time12, current time 190, horizon 178\n", - "adding: mem time13, current time 190, horizon 177\n", - "adding: mem time14, current time 190, horizon 176\n", - "adding: mem time15, current time 190, horizon 175\n", - "adding: mem time16, current time 190, horizon 174\n", - "adding: mem time17, current time 190, horizon 173\n", - "adding: mem time18, current time 190, horizon 172\n", - "adding: mem time19, current time 190, horizon 171\n", - "adding: mem time20, current time 190, horizon 170\n", - "adding: mem time21, current time 190, horizon 169\n", - "adding: mem time22, current time 190, horizon 168\n", - "adding: mem time23, current time 190, horizon 167\n", - "adding: mem time24, current time 190, horizon 166\n", - "adding: mem time25, current time 190, horizon 165\n", - "adding: mem time26, current time 190, horizon 164\n", - "adding: mem time27, current time 190, horizon 163\n", - "adding: mem time28, current time 190, horizon 162\n", - "adding: mem time29, current time 190, horizon 161\n", - "adding: mem time30, current time 190, horizon 160\n", - "adding: mem time31, current time 190, horizon 159\n", - "adding: mem time32, current time 190, horizon 158\n", - "adding: mem time33, current time 190, horizon 157\n", - "adding: mem time34, current time 190, horizon 156\n", - "adding: mem time35, current time 190, horizon 155\n", - "adding: mem time36, current time 190, horizon 154\n", - "adding: mem time37, current time 190, horizon 153\n", - "adding: mem time38, current time 190, horizon 152\n", - "adding: mem time39, current time 190, horizon 151\n", - "adding: mem time40, current time 190, horizon 150\n", - "adding: mem time41, current time 190, horizon 149\n", - "adding: mem time42, current time 190, horizon 148\n", - "adding: mem time43, current time 190, horizon 147\n", - "adding: mem time44, current time 190, horizon 146\n", - "adding: mem time45, current time 190, horizon 145\n", - "adding: mem time46, current time 190, horizon 144\n", - "adding: mem time47, current time 190, horizon 143\n", - "adding: mem time48, current time 190, horizon 142\n", - "adding: mem time49, current time 190, horizon 141\n", - "adding: mem time50, current time 190, horizon 140\n", - "adding: mem time51, current time 190, horizon 139\n", - "adding: mem time52, current time 190, horizon 138\n", - "adding: mem time53, current time 190, horizon 137\n", - "adding: mem time54, current time 190, horizon 136\n", - "adding: mem time55, current time 190, horizon 135\n", - "adding: mem time56, current time 190, horizon 134\n", - "adding: mem time57, current time 190, horizon 133\n", - "adding: mem time58, current time 190, horizon 132\n", - "adding: mem time59, current time 190, horizon 131\n", - "adding: mem time60, current time 190, horizon 130\n", - "adding: mem time61, current time 190, horizon 129\n", - "adding: mem time62, current time 190, horizon 128\n", - "adding: mem time63, current time 190, horizon 127\n", - "adding: mem time64, current time 190, horizon 126\n", - "adding: mem time65, current time 190, horizon 125\n", - "adding: mem time66, current time 190, horizon 124\n", - "adding: mem time67, current time 190, horizon 123\n", - "adding: mem time68, current time 190, horizon 122\n", - "adding: mem time69, current time 190, horizon 121\n", - "adding: mem time70, current time 190, horizon 120\n", - "adding: mem time71, current time 190, horizon 119\n", - "adding: mem time72, current time 190, horizon 118\n", - "adding: mem time73, current time 190, horizon 117\n", - "adding: mem time74, current time 190, horizon 116\n", - "adding: mem time75, current time 190, horizon 115\n", - "adding: mem time76, current time 190, horizon 114\n", - "adding: mem time77, current time 190, horizon 113\n", - "adding: mem time78, current time 190, horizon 112\n", - "adding: mem time79, current time 190, horizon 111\n", - "adding: mem time80, current time 190, horizon 110\n", - "adding: mem time81, current time 190, horizon 109\n", - "adding: mem time82, current time 190, horizon 108\n", - "adding: mem time83, current time 190, horizon 107\n", - "adding: mem time84, current time 190, horizon 106\n", - "adding: mem time85, current time 190, horizon 105\n", - "adding: mem time86, current time 190, horizon 104\n", - "adding: mem time87, current time 190, horizon 103\n", - "adding: mem time88, current time 190, horizon 102\n", - "adding: mem time89, current time 190, horizon 101\n", - "adding: mem time90, current time 190, horizon 100\n", - "adding: mem time91, current time 190, horizon 99\n", - "adding: mem time92, current time 190, horizon 98\n", - "adding: mem time93, current time 190, horizon 97\n", - "adding: mem time94, current time 190, horizon 96\n", - "adding: mem time95, current time 190, horizon 95\n", - "adding: mem time96, current time 190, horizon 94\n", - "adding: mem time97, current time 190, horizon 93\n", - "adding: mem time98, current time 190, horizon 92\n", - "adding: mem time99, current time 190, horizon 91\n", - "adding: mem time100, current time 190, horizon 90\n", - "adding: mem time101, current time 190, horizon 89\n", - "adding: mem time102, current time 190, horizon 88\n", - "adding: mem time103, current time 190, horizon 87\n", - "adding: mem time104, current time 190, horizon 86\n", - "adding: mem time105, current time 190, horizon 85\n", - "adding: mem time106, current time 190, horizon 84\n", - "adding: mem time107, current time 190, horizon 83\n", - "adding: mem time108, current time 190, horizon 82\n", - "adding: mem time109, current time 190, horizon 81\n", - "adding: mem time110, current time 190, horizon 80\n", - "adding: mem time111, current time 190, horizon 79\n", - "adding: mem time112, current time 190, horizon 78\n", - "adding: mem time113, current time 190, horizon 77\n", - "adding: mem time114, current time 190, horizon 76\n", - "adding: mem time115, current time 190, horizon 75\n", - "adding: mem time116, current time 190, horizon 74\n", - "adding: mem time117, current time 190, horizon 73\n", - "adding: mem time118, current time 190, horizon 72\n", - "adding: mem time119, current time 190, horizon 71\n", - "adding: mem time120, current time 190, horizon 70\n", - "adding: mem time121, current time 190, horizon 69\n", - "adding: mem time122, current time 190, horizon 68\n", - "adding: mem time123, current time 190, horizon 67\n", - "adding: mem time124, current time 190, horizon 66\n", - "adding: mem time125, current time 190, horizon 65\n", - "adding: mem time126, current time 190, horizon 64\n", - "adding: mem time127, current time 190, horizon 63\n", - "adding: mem time128, current time 190, horizon 62\n", - "adding: mem time129, current time 190, horizon 61\n", - "adding: mem time130, current time 190, horizon 60\n", - "adding: mem time131, current time 190, horizon 59\n", - "adding: mem time132, current time 190, horizon 58\n", - "adding: mem time133, current time 190, horizon 57\n", - "adding: mem time134, current time 190, horizon 56\n", - "adding: mem time135, current time 190, horizon 55\n", - "adding: mem time136, current time 190, horizon 54\n", - "adding: mem time137, current time 190, horizon 53\n", - "adding: mem time138, current time 190, horizon 52\n", - "adding: mem time139, current time 190, horizon 51\n", - "adding: mem time140, current time 190, horizon 50\n", - "adding: mem time141, current time 190, horizon 49\n", - "adding: mem time142, current time 190, horizon 48\n", - "adding: mem time143, current time 190, horizon 47\n", - "adding: mem time144, current time 190, horizon 46\n", - "adding: mem time145, current time 190, horizon 45\n", - "adding: mem time146, current time 190, horizon 44\n", - "adding: mem time147, current time 190, horizon 43\n", - "adding: mem time148, current time 190, horizon 42\n", - "adding: mem time149, current time 190, horizon 41\n", - "adding: mem time150, current time 190, horizon 40\n", - "adding: mem time151, current time 190, horizon 39\n", - "adding: mem time152, current time 190, horizon 38\n", - "adding: mem time153, current time 190, horizon 37\n", - "adding: mem time154, current time 190, horizon 36\n", - "adding: mem time155, current time 190, horizon 35\n", - "adding: mem time156, current time 190, horizon 34\n", - "adding: mem time157, current time 190, horizon 33\n", - "adding: mem time158, current time 190, horizon 32\n", - "adding: mem time159, current time 190, horizon 31\n", - "adding: mem time160, current time 190, horizon 30\n", - "adding: mem time161, current time 190, horizon 29\n", - "adding: mem time162, current time 190, horizon 28\n", - "adding: mem time163, current time 190, horizon 27\n", - "adding: mem time164, current time 190, horizon 26\n", - "adding: mem time165, current time 190, horizon 25\n", - "adding: mem time166, current time 190, horizon 24\n", - "adding: mem time167, current time 190, horizon 23\n", - "adding: mem time168, current time 190, horizon 22\n", - "adding: mem time169, current time 190, horizon 21\n", - "adding: mem time170, current time 190, horizon 20\n", - "adding: mem time171, current time 190, horizon 19\n", - "adding: mem time172, current time 190, horizon 18\n", - "adding: mem time173, current time 190, horizon 17\n", - "adding: mem time174, current time 190, horizon 16\n", - "adding: mem time175, current time 190, horizon 15\n", - "adding: mem time176, current time 190, horizon 14\n", - "adding: mem time177, current time 190, horizon 13\n", - "adding: mem time178, current time 190, horizon 12\n", - "adding: mem time179, current time 190, horizon 11\n", - "adding: mem time180, current time 190, horizon 10\n", - "adding: mem time181, current time 190, horizon 9\n", - "adding: mem time182, current time 190, horizon 8\n", - "adding: mem time183, current time 190, horizon 7\n", - "adding: mem time184, current time 190, horizon 6\n", - "adding: mem time185, current time 190, horizon 5\n", - "adding: mem time186, current time 190, horizon 4\n", - "adding: mem time187, current time 190, horizon 3\n", - "adding: mem time188, current time 190, horizon 2\n", - "adding: mem time189, current time 190, horizon 1\n", - "adding: mem time0, current time 191, horizon 191\n", - "adding: mem time1, current time 191, horizon 190\n", - "adding: mem time2, current time 191, horizon 189\n", - "adding: mem time3, current time 191, horizon 188\n", - "adding: mem time4, current time 191, horizon 187\n", - "adding: mem time5, current time 191, horizon 186\n", - "adding: mem time6, current time 191, horizon 185\n", - "adding: mem time7, current time 191, horizon 184\n", - "adding: mem time8, current time 191, horizon 183\n", - "adding: mem time9, current time 191, horizon 182\n", - "adding: mem time10, current time 191, horizon 181\n", - "adding: mem time11, current time 191, horizon 180\n", - "adding: mem time12, current time 191, horizon 179\n", - "adding: mem time13, current time 191, horizon 178\n", - "adding: mem time14, current time 191, horizon 177\n", - "adding: mem time15, current time 191, horizon 176\n", - "adding: mem time16, current time 191, horizon 175\n", - "adding: mem time17, current time 191, horizon 174\n", - "adding: mem time18, current time 191, horizon 173\n", - "adding: mem time19, current time 191, horizon 172\n", - "adding: mem time20, current time 191, horizon 171\n", - "adding: mem time21, current time 191, horizon 170\n", - "adding: mem time22, current time 191, horizon 169\n", - "adding: mem time23, current time 191, horizon 168\n", - "adding: mem time24, current time 191, horizon 167\n", - "adding: mem time25, current time 191, horizon 166\n", - "adding: mem time26, current time 191, horizon 165\n", - "adding: mem time27, current time 191, horizon 164\n", - "adding: mem time28, current time 191, horizon 163\n", - "adding: mem time29, current time 191, horizon 162\n", - "adding: mem time30, current time 191, horizon 161\n", - "adding: mem time31, current time 191, horizon 160\n", - "adding: mem time32, current time 191, horizon 159\n", - "adding: mem time33, current time 191, horizon 158\n", - "adding: mem time34, current time 191, horizon 157\n", - "adding: mem time35, current time 191, horizon 156\n", - "adding: mem time36, current time 191, horizon 155\n", - "adding: mem time37, current time 191, horizon 154\n", - "adding: mem time38, current time 191, horizon 153\n", - "adding: mem time39, current time 191, horizon 152\n", - "adding: mem time40, current time 191, horizon 151\n", - "adding: mem time41, current time 191, horizon 150\n", - "adding: mem time42, current time 191, horizon 149\n", - "adding: mem time43, current time 191, horizon 148\n", - "adding: mem time44, current time 191, horizon 147\n", - "adding: mem time45, current time 191, horizon 146\n", - "adding: mem time46, current time 191, horizon 145\n", - "adding: mem time47, current time 191, horizon 144\n", - "adding: mem time48, current time 191, horizon 143\n", - "adding: mem time49, current time 191, horizon 142\n", - "adding: mem time50, current time 191, horizon 141\n", - "adding: mem time51, current time 191, horizon 140\n", - "adding: mem time52, current time 191, horizon 139\n", - "adding: mem time53, current time 191, horizon 138\n", - "adding: mem time54, current time 191, horizon 137\n", - "adding: mem time55, current time 191, horizon 136\n", - "adding: mem time56, current time 191, horizon 135\n", - "adding: mem time57, current time 191, horizon 134\n", - "adding: mem time58, current time 191, horizon 133\n", - "adding: mem time59, current time 191, horizon 132\n", - "adding: mem time60, current time 191, horizon 131\n", - "adding: mem time61, current time 191, horizon 130\n", - "adding: mem time62, current time 191, horizon 129\n", - "adding: mem time63, current time 191, horizon 128\n", - "adding: mem time64, current time 191, horizon 127\n", - "adding: mem time65, current time 191, horizon 126\n", - "adding: mem time66, current time 191, horizon 125\n", - "adding: mem time67, current time 191, horizon 124\n", - "adding: mem time68, current time 191, horizon 123\n", - "adding: mem time69, current time 191, horizon 122\n", - "adding: mem time70, current time 191, horizon 121\n", - "adding: mem time71, current time 191, horizon 120\n", - "adding: mem time72, current time 191, horizon 119\n", - "adding: mem time73, current time 191, horizon 118\n", - "adding: mem time74, current time 191, horizon 117\n", - "adding: mem time75, current time 191, horizon 116\n", - "adding: mem time76, current time 191, horizon 115\n", - "adding: mem time77, current time 191, horizon 114\n", - "adding: mem time78, current time 191, horizon 113\n", - "adding: mem time79, current time 191, horizon 112\n", - "adding: mem time80, current time 191, horizon 111\n", - "adding: mem time81, current time 191, horizon 110\n", - "adding: mem time82, current time 191, horizon 109\n", - "adding: mem time83, current time 191, horizon 108\n", - "adding: mem time84, current time 191, horizon 107\n", - "adding: mem time85, current time 191, horizon 106\n", - "adding: mem time86, current time 191, horizon 105\n", - "adding: mem time87, current time 191, horizon 104\n", - "adding: mem time88, current time 191, horizon 103\n", - "adding: mem time89, current time 191, horizon 102\n", - "adding: mem time90, current time 191, horizon 101\n", - "adding: mem time91, current time 191, horizon 100\n", - "adding: mem time92, current time 191, horizon 99\n", - "adding: mem time93, current time 191, horizon 98\n", - "adding: mem time94, current time 191, horizon 97\n", - "adding: mem time95, current time 191, horizon 96\n", - "adding: mem time96, current time 191, horizon 95\n", - "adding: mem time97, current time 191, horizon 94\n", - "adding: mem time98, current time 191, horizon 93\n", - "adding: mem time99, current time 191, horizon 92\n", - "adding: mem time100, current time 191, horizon 91\n", - "adding: mem time101, current time 191, horizon 90\n", - "adding: mem time102, current time 191, horizon 89\n", - "adding: mem time103, current time 191, horizon 88\n", - "adding: mem time104, current time 191, horizon 87\n", - "adding: mem time105, current time 191, horizon 86\n", - "adding: mem time106, current time 191, horizon 85\n", - "adding: mem time107, current time 191, horizon 84\n", - "adding: mem time108, current time 191, horizon 83\n", - "adding: mem time109, current time 191, horizon 82\n", - "adding: mem time110, current time 191, horizon 81\n", - "adding: mem time111, current time 191, horizon 80\n", - "adding: mem time112, current time 191, horizon 79\n", - "adding: mem time113, current time 191, horizon 78\n", - "adding: mem time114, current time 191, horizon 77\n", - "adding: mem time115, current time 191, horizon 76\n", - "adding: mem time116, current time 191, horizon 75\n", - "adding: mem time117, current time 191, horizon 74\n", - "adding: mem time118, current time 191, horizon 73\n", - "adding: mem time119, current time 191, horizon 72\n", - "adding: mem time120, current time 191, horizon 71\n", - "adding: mem time121, current time 191, horizon 70\n", - "adding: mem time122, current time 191, horizon 69\n", - "adding: mem time123, current time 191, horizon 68\n", - "adding: mem time124, current time 191, horizon 67\n", - "adding: mem time125, current time 191, horizon 66\n", - "adding: mem time126, current time 191, horizon 65\n", - "adding: mem time127, current time 191, horizon 64\n", - "adding: mem time128, current time 191, horizon 63\n", - "adding: mem time129, current time 191, horizon 62\n", - "adding: mem time130, current time 191, horizon 61\n", - "adding: mem time131, current time 191, horizon 60\n", - "adding: mem time132, current time 191, horizon 59\n", - "adding: mem time133, current time 191, horizon 58\n", - "adding: mem time134, current time 191, horizon 57\n", - "adding: mem time135, current time 191, horizon 56\n", - "adding: mem time136, current time 191, horizon 55\n", - "adding: mem time137, current time 191, horizon 54\n", - "adding: mem time138, current time 191, horizon 53\n", - "adding: mem time139, current time 191, horizon 52\n", - "adding: mem time140, current time 191, horizon 51\n", - "adding: mem time141, current time 191, horizon 50\n", - "adding: mem time142, current time 191, horizon 49\n", - "adding: mem time143, current time 191, horizon 48\n", - "adding: mem time144, current time 191, horizon 47\n", - "adding: mem time145, current time 191, horizon 46\n", - "adding: mem time146, current time 191, horizon 45\n", - "adding: mem time147, current time 191, horizon 44\n", - "adding: mem time148, current time 191, horizon 43\n", - "adding: mem time149, current time 191, horizon 42\n", - "adding: mem time150, current time 191, horizon 41\n", - "adding: mem time151, current time 191, horizon 40\n", - "adding: mem time152, current time 191, horizon 39\n", - "adding: mem time153, current time 191, horizon 38\n", - "adding: mem time154, current time 191, horizon 37\n", - "adding: mem time155, current time 191, horizon 36\n", - "adding: mem time156, current time 191, horizon 35\n", - "adding: mem time157, current time 191, horizon 34\n", - "adding: mem time158, current time 191, horizon 33\n", - "adding: mem time159, current time 191, horizon 32\n", - "adding: mem time160, current time 191, horizon 31\n", - "adding: mem time161, current time 191, horizon 30\n", - "adding: mem time162, current time 191, horizon 29\n", - "adding: mem time163, current time 191, horizon 28\n", - "adding: mem time164, current time 191, horizon 27\n", - "adding: mem time165, current time 191, horizon 26\n", - "adding: mem time166, current time 191, horizon 25\n", - "adding: mem time167, current time 191, horizon 24\n", - "adding: mem time168, current time 191, horizon 23\n", - "adding: mem time169, current time 191, horizon 22\n", - "adding: mem time170, current time 191, horizon 21\n", - "adding: mem time171, current time 191, horizon 20\n", - "adding: mem time172, current time 191, horizon 19\n", - "adding: mem time173, current time 191, horizon 18\n", - "adding: mem time174, current time 191, horizon 17\n", - "adding: mem time175, current time 191, horizon 16\n", - "adding: mem time176, current time 191, horizon 15\n", - "adding: mem time177, current time 191, horizon 14\n", - "adding: mem time178, current time 191, horizon 13\n", - "adding: mem time179, current time 191, horizon 12\n", - "adding: mem time180, current time 191, horizon 11\n", - "adding: mem time181, current time 191, horizon 10\n", - "adding: mem time182, current time 191, horizon 9\n", - "adding: mem time183, current time 191, horizon 8\n", - "adding: mem time184, current time 191, horizon 7\n", - "adding: mem time185, current time 191, horizon 6\n", - "adding: mem time186, current time 191, horizon 5\n", - "adding: mem time187, current time 191, horizon 4\n", - "adding: mem time188, current time 191, horizon 3\n", - "adding: mem time189, current time 191, horizon 2\n", - "adding: mem time190, current time 191, horizon 1\n", - "adding: mem time0, current time 192, horizon 192\n", - "adding: mem time1, current time 192, horizon 191\n", - "adding: mem time2, current time 192, horizon 190\n", - "adding: mem time3, current time 192, horizon 189\n", - "adding: mem time4, current time 192, horizon 188\n", - "adding: mem time5, current time 192, horizon 187\n", - "adding: mem time6, current time 192, horizon 186\n", - "adding: mem time7, current time 192, horizon 185\n", - "adding: mem time8, current time 192, horizon 184\n", - "adding: mem time9, current time 192, horizon 183\n", - "adding: mem time10, current time 192, horizon 182\n", - "adding: mem time11, current time 192, horizon 181\n", - "adding: mem time12, current time 192, horizon 180\n", - "adding: mem time13, current time 192, horizon 179\n", - "adding: mem time14, current time 192, horizon 178\n", - "adding: mem time15, current time 192, horizon 177\n", - "adding: mem time16, current time 192, horizon 176\n", - "adding: mem time17, current time 192, horizon 175\n", - "adding: mem time18, current time 192, horizon 174\n", - "adding: mem time19, current time 192, horizon 173\n", - "adding: mem time20, current time 192, horizon 172\n", - "adding: mem time21, current time 192, horizon 171\n", - "adding: mem time22, current time 192, horizon 170\n", - "adding: mem time23, current time 192, horizon 169\n", - "adding: mem time24, current time 192, horizon 168\n", - "adding: mem time25, current time 192, horizon 167\n", - "adding: mem time26, current time 192, horizon 166\n", - "adding: mem time27, current time 192, horizon 165\n", - "adding: mem time28, current time 192, horizon 164\n", - "adding: mem time29, current time 192, horizon 163\n", - "adding: mem time30, current time 192, horizon 162\n", - "adding: mem time31, current time 192, horizon 161\n", - "adding: mem time32, current time 192, horizon 160\n", - "adding: mem time33, current time 192, horizon 159\n", - "adding: mem time34, current time 192, horizon 158\n", - "adding: mem time35, current time 192, horizon 157\n", - "adding: mem time36, current time 192, horizon 156\n", - "adding: mem time37, current time 192, horizon 155\n", - "adding: mem time38, current time 192, horizon 154\n", - "adding: mem time39, current time 192, horizon 153\n", - "adding: mem time40, current time 192, horizon 152\n", - "adding: mem time41, current time 192, horizon 151\n", - "adding: mem time42, current time 192, horizon 150\n", - "adding: mem time43, current time 192, horizon 149\n", - "adding: mem time44, current time 192, horizon 148\n", - "adding: mem time45, current time 192, horizon 147\n", - "adding: mem time46, current time 192, horizon 146\n", - "adding: mem time47, current time 192, horizon 145\n", - "adding: mem time48, current time 192, horizon 144\n", - "adding: mem time49, current time 192, horizon 143\n", - "adding: mem time50, current time 192, horizon 142\n", - "adding: mem time51, current time 192, horizon 141\n", - "adding: mem time52, current time 192, horizon 140\n", - "adding: mem time53, current time 192, horizon 139\n", - "adding: mem time54, current time 192, horizon 138\n", - "adding: mem time55, current time 192, horizon 137\n", - "adding: mem time56, current time 192, horizon 136\n", - "adding: mem time57, current time 192, horizon 135\n", - "adding: mem time58, current time 192, horizon 134\n", - "adding: mem time59, current time 192, horizon 133\n", - "adding: mem time60, current time 192, horizon 132\n", - "adding: mem time61, current time 192, horizon 131\n", - "adding: mem time62, current time 192, horizon 130\n", - "adding: mem time63, current time 192, horizon 129\n", - "adding: mem time64, current time 192, horizon 128\n", - "adding: mem time65, current time 192, horizon 127\n", - "adding: mem time66, current time 192, horizon 126\n", - "adding: mem time67, current time 192, horizon 125\n", - "adding: mem time68, current time 192, horizon 124\n", - "adding: mem time69, current time 192, horizon 123\n", - "adding: mem time70, current time 192, horizon 122\n", - "adding: mem time71, current time 192, horizon 121\n", - "adding: mem time72, current time 192, horizon 120\n", - "adding: mem time73, current time 192, horizon 119\n", - "adding: mem time74, current time 192, horizon 118\n", - "adding: mem time75, current time 192, horizon 117\n", - "adding: mem time76, current time 192, horizon 116\n", - "adding: mem time77, current time 192, horizon 115\n", - "adding: mem time78, current time 192, horizon 114\n", - "adding: mem time79, current time 192, horizon 113\n", - "adding: mem time80, current time 192, horizon 112\n", - "adding: mem time81, current time 192, horizon 111\n", - "adding: mem time82, current time 192, horizon 110\n", - "adding: mem time83, current time 192, horizon 109\n", - "adding: mem time84, current time 192, horizon 108\n", - "adding: mem time85, current time 192, horizon 107\n", - "adding: mem time86, current time 192, horizon 106\n", - "adding: mem time87, current time 192, horizon 105\n", - "adding: mem time88, current time 192, horizon 104\n", - "adding: mem time89, current time 192, horizon 103\n", - "adding: mem time90, current time 192, horizon 102\n", - "adding: mem time91, current time 192, horizon 101\n", - "adding: mem time92, current time 192, horizon 100\n", - "adding: mem time93, current time 192, horizon 99\n", - "adding: mem time94, current time 192, horizon 98\n", - "adding: mem time95, current time 192, horizon 97\n", - "adding: mem time96, current time 192, horizon 96\n", - "adding: mem time97, current time 192, horizon 95\n", - "adding: mem time98, current time 192, horizon 94\n", - "adding: mem time99, current time 192, horizon 93\n", - "adding: mem time100, current time 192, horizon 92\n", - "adding: mem time101, current time 192, horizon 91\n", - "adding: mem time102, current time 192, horizon 90\n", - "adding: mem time103, current time 192, horizon 89\n", - "adding: mem time104, current time 192, horizon 88\n", - "adding: mem time105, current time 192, horizon 87\n", - "adding: mem time106, current time 192, horizon 86\n", - "adding: mem time107, current time 192, horizon 85\n", - "adding: mem time108, current time 192, horizon 84\n", - "adding: mem time109, current time 192, horizon 83\n", - "adding: mem time110, current time 192, horizon 82\n", - "adding: mem time111, current time 192, horizon 81\n", - "adding: mem time112, current time 192, horizon 80\n", - "adding: mem time113, current time 192, horizon 79\n", - "adding: mem time114, current time 192, horizon 78\n", - "adding: mem time115, current time 192, horizon 77\n", - "adding: mem time116, current time 192, horizon 76\n", - "adding: mem time117, current time 192, horizon 75\n", - "adding: mem time118, current time 192, horizon 74\n", - "adding: mem time119, current time 192, horizon 73\n", - "adding: mem time120, current time 192, horizon 72\n", - "adding: mem time121, current time 192, horizon 71\n", - "adding: mem time122, current time 192, horizon 70\n", - "adding: mem time123, current time 192, horizon 69\n", - "adding: mem time124, current time 192, horizon 68\n", - "adding: mem time125, current time 192, horizon 67\n", - "adding: mem time126, current time 192, horizon 66\n", - "adding: mem time127, current time 192, horizon 65\n", - "adding: mem time128, current time 192, horizon 64\n", - "adding: mem time129, current time 192, horizon 63\n", - "adding: mem time130, current time 192, horizon 62\n", - "adding: mem time131, current time 192, horizon 61\n", - "adding: mem time132, current time 192, horizon 60\n", - "adding: mem time133, current time 192, horizon 59\n", - "adding: mem time134, current time 192, horizon 58\n", - "adding: mem time135, current time 192, horizon 57\n", - "adding: mem time136, current time 192, horizon 56\n", - "adding: mem time137, current time 192, horizon 55\n", - "adding: mem time138, current time 192, horizon 54\n", - "adding: mem time139, current time 192, horizon 53\n", - "adding: mem time140, current time 192, horizon 52\n", - "adding: mem time141, current time 192, horizon 51\n", - "adding: mem time142, current time 192, horizon 50\n", - "adding: mem time143, current time 192, horizon 49\n", - "adding: mem time144, current time 192, horizon 48\n", - "adding: mem time145, current time 192, horizon 47\n", - "adding: mem time146, current time 192, horizon 46\n", - "adding: mem time147, current time 192, horizon 45\n", - "adding: mem time148, current time 192, horizon 44\n", - "adding: mem time149, current time 192, horizon 43\n", - "adding: mem time150, current time 192, horizon 42\n", - "adding: mem time151, current time 192, horizon 41\n", - "adding: mem time152, current time 192, horizon 40\n", - "adding: mem time153, current time 192, horizon 39\n", - "adding: mem time154, current time 192, horizon 38\n", - "adding: mem time155, current time 192, horizon 37\n", - "adding: mem time156, current time 192, horizon 36\n", - "adding: mem time157, current time 192, horizon 35\n", - "adding: mem time158, current time 192, horizon 34\n", - "adding: mem time159, current time 192, horizon 33\n", - "adding: mem time160, current time 192, horizon 32\n", - "adding: mem time161, current time 192, horizon 31\n", - "adding: mem time162, current time 192, horizon 30\n", - "adding: mem time163, current time 192, horizon 29\n", - "adding: mem time164, current time 192, horizon 28\n", - "adding: mem time165, current time 192, horizon 27\n", - "adding: mem time166, current time 192, horizon 26\n", - "adding: mem time167, current time 192, horizon 25\n", - "adding: mem time168, current time 192, horizon 24\n", - "adding: mem time169, current time 192, horizon 23\n", - "adding: mem time170, current time 192, horizon 22\n", - "adding: mem time171, current time 192, horizon 21\n", - "adding: mem time172, current time 192, horizon 20\n", - "adding: mem time173, current time 192, horizon 19\n", - "adding: mem time174, current time 192, horizon 18\n", - "adding: mem time175, current time 192, horizon 17\n", - "adding: mem time176, current time 192, horizon 16\n", - "adding: mem time177, current time 192, horizon 15\n", - "adding: mem time178, current time 192, horizon 14\n", - "adding: mem time179, current time 192, horizon 13\n", - "adding: mem time180, current time 192, horizon 12\n", - "adding: mem time181, current time 192, horizon 11\n", - "adding: mem time182, current time 192, horizon 10\n", - "adding: mem time183, current time 192, horizon 9\n", - "adding: mem time184, current time 192, horizon 8\n", - "adding: mem time185, current time 192, horizon 7\n", - "adding: mem time186, current time 192, horizon 6\n", - "adding: mem time187, current time 192, horizon 5\n", - "adding: mem time188, current time 192, horizon 4\n", - "adding: mem time189, current time 192, horizon 3\n", - "adding: mem time190, current time 192, horizon 2\n", - "adding: mem time191, current time 192, horizon 1\n", - "adding: mem time0, current time 193, horizon 193\n", - "adding: mem time1, current time 193, horizon 192\n", - "adding: mem time2, current time 193, horizon 191\n", - "adding: mem time3, current time 193, horizon 190\n", - "adding: mem time4, current time 193, horizon 189\n", - "adding: mem time5, current time 193, horizon 188\n", - "adding: mem time6, current time 193, horizon 187\n", - "adding: mem time7, current time 193, horizon 186\n", - "adding: mem time8, current time 193, horizon 185\n", - "adding: mem time9, current time 193, horizon 184\n", - "adding: mem time10, current time 193, horizon 183\n", - "adding: mem time11, current time 193, horizon 182\n", - "adding: mem time12, current time 193, horizon 181\n", - "adding: mem time13, current time 193, horizon 180\n", - "adding: mem time14, current time 193, horizon 179\n", - "adding: mem time15, current time 193, horizon 178\n", - "adding: mem time16, current time 193, horizon 177\n", - "adding: mem time17, current time 193, horizon 176\n", - "adding: mem time18, current time 193, horizon 175\n", - "adding: mem time19, current time 193, horizon 174\n", - "adding: mem time20, current time 193, horizon 173\n", - "adding: mem time21, current time 193, horizon 172\n", - "adding: mem time22, current time 193, horizon 171\n", - "adding: mem time23, current time 193, horizon 170\n", - "adding: mem time24, current time 193, horizon 169\n", - "adding: mem time25, current time 193, horizon 168\n", - "adding: mem time26, current time 193, horizon 167\n", - "adding: mem time27, current time 193, horizon 166\n", - "adding: mem time28, current time 193, horizon 165\n", - "adding: mem time29, current time 193, horizon 164\n", - "adding: mem time30, current time 193, horizon 163\n", - "adding: mem time31, current time 193, horizon 162\n", - "adding: mem time32, current time 193, horizon 161\n", - "adding: mem time33, current time 193, horizon 160\n", - "adding: mem time34, current time 193, horizon 159\n", - "adding: mem time35, current time 193, horizon 158\n", - "adding: mem time36, current time 193, horizon 157\n", - "adding: mem time37, current time 193, horizon 156\n", - "adding: mem time38, current time 193, horizon 155\n", - "adding: mem time39, current time 193, horizon 154\n", - "adding: mem time40, current time 193, horizon 153\n", - "adding: mem time41, current time 193, horizon 152\n", - "adding: mem time42, current time 193, horizon 151\n", - "adding: mem time43, current time 193, horizon 150\n", - "adding: mem time44, current time 193, horizon 149\n", - "adding: mem time45, current time 193, horizon 148\n", - "adding: mem time46, current time 193, horizon 147\n", - "adding: mem time47, current time 193, horizon 146\n", - "adding: mem time48, current time 193, horizon 145\n", - "adding: mem time49, current time 193, horizon 144\n", - "adding: mem time50, current time 193, horizon 143\n", - "adding: mem time51, current time 193, horizon 142\n", - "adding: mem time52, current time 193, horizon 141\n", - "adding: mem time53, current time 193, horizon 140\n", - "adding: mem time54, current time 193, horizon 139\n", - "adding: mem time55, current time 193, horizon 138\n", - "adding: mem time56, current time 193, horizon 137\n", - "adding: mem time57, current time 193, horizon 136\n", - "adding: mem time58, current time 193, horizon 135\n", - "adding: mem time59, current time 193, horizon 134\n", - "adding: mem time60, current time 193, horizon 133\n", - "adding: mem time61, current time 193, horizon 132\n", - "adding: mem time62, current time 193, horizon 131\n", - "adding: mem time63, current time 193, horizon 130\n", - "adding: mem time64, current time 193, horizon 129\n", - "adding: mem time65, current time 193, horizon 128\n", - "adding: mem time66, current time 193, horizon 127\n", - "adding: mem time67, current time 193, horizon 126\n", - "adding: mem time68, current time 193, horizon 125\n", - "adding: mem time69, current time 193, horizon 124\n", - "adding: mem time70, current time 193, horizon 123\n", - "adding: mem time71, current time 193, horizon 122\n", - "adding: mem time72, current time 193, horizon 121\n", - "adding: mem time73, current time 193, horizon 120\n", - "adding: mem time74, current time 193, horizon 119\n", - "adding: mem time75, current time 193, horizon 118\n", - "adding: mem time76, current time 193, horizon 117\n", - "adding: mem time77, current time 193, horizon 116\n", - "adding: mem time78, current time 193, horizon 115\n", - "adding: mem time79, current time 193, horizon 114\n", - "adding: mem time80, current time 193, horizon 113\n", - "adding: mem time81, current time 193, horizon 112\n", - "adding: mem time82, current time 193, horizon 111\n", - "adding: mem time83, current time 193, horizon 110\n", - "adding: mem time84, current time 193, horizon 109\n", - "adding: mem time85, current time 193, horizon 108\n", - "adding: mem time86, current time 193, horizon 107\n", - "adding: mem time87, current time 193, horizon 106\n", - "adding: mem time88, current time 193, horizon 105\n", - "adding: mem time89, current time 193, horizon 104\n", - "adding: mem time90, current time 193, horizon 103\n", - "adding: mem time91, current time 193, horizon 102\n", - "adding: mem time92, current time 193, horizon 101\n", - "adding: mem time93, current time 193, horizon 100\n", - "adding: mem time94, current time 193, horizon 99\n", - "adding: mem time95, current time 193, horizon 98\n", - "adding: mem time96, current time 193, horizon 97\n", - "adding: mem time97, current time 193, horizon 96\n", - "adding: mem time98, current time 193, horizon 95\n", - "adding: mem time99, current time 193, horizon 94\n", - "adding: mem time100, current time 193, horizon 93\n", - "adding: mem time101, current time 193, horizon 92\n", - "adding: mem time102, current time 193, horizon 91\n", - "adding: mem time103, current time 193, horizon 90\n", - "adding: mem time104, current time 193, horizon 89\n", - "adding: mem time105, current time 193, horizon 88\n", - "adding: mem time106, current time 193, horizon 87\n", - "adding: mem time107, current time 193, horizon 86\n", - "adding: mem time108, current time 193, horizon 85\n", - "adding: mem time109, current time 193, horizon 84\n", - "adding: mem time110, current time 193, horizon 83\n", - "adding: mem time111, current time 193, horizon 82\n", - "adding: mem time112, current time 193, horizon 81\n", - "adding: mem time113, current time 193, horizon 80\n", - "adding: mem time114, current time 193, horizon 79\n", - "adding: mem time115, current time 193, horizon 78\n", - "adding: mem time116, current time 193, horizon 77\n", - "adding: mem time117, current time 193, horizon 76\n", - "adding: mem time118, current time 193, horizon 75\n", - "adding: mem time119, current time 193, horizon 74\n", - "adding: mem time120, current time 193, horizon 73\n", - "adding: mem time121, current time 193, horizon 72\n", - "adding: mem time122, current time 193, horizon 71\n", - "adding: mem time123, current time 193, horizon 70\n", - "adding: mem time124, current time 193, horizon 69\n", - "adding: mem time125, current time 193, horizon 68\n", - "adding: mem time126, current time 193, horizon 67\n", - "adding: mem time127, current time 193, horizon 66\n", - "adding: mem time128, current time 193, horizon 65\n", - "adding: mem time129, current time 193, horizon 64\n", - "adding: mem time130, current time 193, horizon 63\n", - "adding: mem time131, current time 193, horizon 62\n", - "adding: mem time132, current time 193, horizon 61\n", - "adding: mem time133, current time 193, horizon 60\n", - "adding: mem time134, current time 193, horizon 59\n", - "adding: mem time135, current time 193, horizon 58\n", - "adding: mem time136, current time 193, horizon 57\n", - "adding: mem time137, current time 193, horizon 56\n", - "adding: mem time138, current time 193, horizon 55\n", - "adding: mem time139, current time 193, horizon 54\n", - "adding: mem time140, current time 193, horizon 53\n", - "adding: mem time141, current time 193, horizon 52\n", - "adding: mem time142, current time 193, horizon 51\n", - "adding: mem time143, current time 193, horizon 50\n", - "adding: mem time144, current time 193, horizon 49\n", - "adding: mem time145, current time 193, horizon 48\n", - "adding: mem time146, current time 193, horizon 47\n", - "adding: mem time147, current time 193, horizon 46\n", - "adding: mem time148, current time 193, horizon 45\n", - "adding: mem time149, current time 193, horizon 44\n", - "adding: mem time150, current time 193, horizon 43\n", - "adding: mem time151, current time 193, horizon 42\n", - "adding: mem time152, current time 193, horizon 41\n", - "adding: mem time153, current time 193, horizon 40\n", - "adding: mem time154, current time 193, horizon 39\n", - "adding: mem time155, current time 193, horizon 38\n", - "adding: mem time156, current time 193, horizon 37\n", - "adding: mem time157, current time 193, horizon 36\n", - "adding: mem time158, current time 193, horizon 35\n", - "adding: mem time159, current time 193, horizon 34\n", - "adding: mem time160, current time 193, horizon 33\n", - "adding: mem time161, current time 193, horizon 32\n", - "adding: mem time162, current time 193, horizon 31\n", - "adding: mem time163, current time 193, horizon 30\n", - "adding: mem time164, current time 193, horizon 29\n", - "adding: mem time165, current time 193, horizon 28\n", - "adding: mem time166, current time 193, horizon 27\n", - "adding: mem time167, current time 193, horizon 26\n", - "adding: mem time168, current time 193, horizon 25\n", - "adding: mem time169, current time 193, horizon 24\n", - "adding: mem time170, current time 193, horizon 23\n", - "adding: mem time171, current time 193, horizon 22\n", - "adding: mem time172, current time 193, horizon 21\n", - "adding: mem time173, current time 193, horizon 20\n", - "adding: mem time174, current time 193, horizon 19\n", - "adding: mem time175, current time 193, horizon 18\n", - "adding: mem time176, current time 193, horizon 17\n", - "adding: mem time177, current time 193, horizon 16\n", - "adding: mem time178, current time 193, horizon 15\n", - "adding: mem time179, current time 193, horizon 14\n", - "adding: mem time180, current time 193, horizon 13\n", - "adding: mem time181, current time 193, horizon 12\n", - "adding: mem time182, current time 193, horizon 11\n", - "adding: mem time183, current time 193, horizon 10\n", - "adding: mem time184, current time 193, horizon 9\n", - "adding: mem time185, current time 193, horizon 8\n", - "adding: mem time186, current time 193, horizon 7\n", - "adding: mem time187, current time 193, horizon 6\n", - "adding: mem time188, current time 193, horizon 5\n", - "adding: mem time189, current time 193, horizon 4\n", - "adding: mem time190, current time 193, horizon 3\n", - "adding: mem time191, current time 193, horizon 2\n", - "adding: mem time192, current time 193, horizon 1\n", - "adding: mem time0, current time 194, horizon 194\n", - "adding: mem time1, current time 194, horizon 193\n", - "adding: mem time2, current time 194, horizon 192\n", - "adding: mem time3, current time 194, horizon 191\n", - "adding: mem time4, current time 194, horizon 190\n", - "adding: mem time5, current time 194, horizon 189\n", - "adding: mem time6, current time 194, horizon 188\n", - "adding: mem time7, current time 194, horizon 187\n", - "adding: mem time8, current time 194, horizon 186\n", - "adding: mem time9, current time 194, horizon 185\n", - "adding: mem time10, current time 194, horizon 184\n", - "adding: mem time11, current time 194, horizon 183\n", - "adding: mem time12, current time 194, horizon 182\n", - "adding: mem time13, current time 194, horizon 181\n", - "adding: mem time14, current time 194, horizon 180\n", - "adding: mem time15, current time 194, horizon 179\n", - "adding: mem time16, current time 194, horizon 178\n", - "adding: mem time17, current time 194, horizon 177\n", - "adding: mem time18, current time 194, horizon 176\n", - "adding: mem time19, current time 194, horizon 175\n", - "adding: mem time20, current time 194, horizon 174\n", - "adding: mem time21, current time 194, horizon 173\n", - "adding: mem time22, current time 194, horizon 172\n", - "adding: mem time23, current time 194, horizon 171\n", - "adding: mem time24, current time 194, horizon 170\n", - "adding: mem time25, current time 194, horizon 169\n", - "adding: mem time26, current time 194, horizon 168\n", - "adding: mem time27, current time 194, horizon 167\n", - "adding: mem time28, current time 194, horizon 166\n", - "adding: mem time29, current time 194, horizon 165\n", - "adding: mem time30, current time 194, horizon 164\n", - "adding: mem time31, current time 194, horizon 163\n", - "adding: mem time32, current time 194, horizon 162\n", - "adding: mem time33, current time 194, horizon 161\n", - "adding: mem time34, current time 194, horizon 160\n", - "adding: mem time35, current time 194, horizon 159\n", - "adding: mem time36, current time 194, horizon 158\n", - "adding: mem time37, current time 194, horizon 157\n", - "adding: mem time38, current time 194, horizon 156\n", - "adding: mem time39, current time 194, horizon 155\n", - "adding: mem time40, current time 194, horizon 154\n", - "adding: mem time41, current time 194, horizon 153\n", - "adding: mem time42, current time 194, horizon 152\n", - "adding: mem time43, current time 194, horizon 151\n", - "adding: mem time44, current time 194, horizon 150\n", - "adding: mem time45, current time 194, horizon 149\n", - "adding: mem time46, current time 194, horizon 148\n", - "adding: mem time47, current time 194, horizon 147\n", - "adding: mem time48, current time 194, horizon 146\n", - "adding: mem time49, current time 194, horizon 145\n", - "adding: mem time50, current time 194, horizon 144\n", - "adding: mem time51, current time 194, horizon 143\n", - "adding: mem time52, current time 194, horizon 142\n", - "adding: mem time53, current time 194, horizon 141\n", - "adding: mem time54, current time 194, horizon 140\n", - "adding: mem time55, current time 194, horizon 139\n", - "adding: mem time56, current time 194, horizon 138\n", - "adding: mem time57, current time 194, horizon 137\n", - "adding: mem time58, current time 194, horizon 136\n", - "adding: mem time59, current time 194, horizon 135\n", - "adding: mem time60, current time 194, horizon 134\n", - "adding: mem time61, current time 194, horizon 133\n", - "adding: mem time62, current time 194, horizon 132\n", - "adding: mem time63, current time 194, horizon 131\n", - "adding: mem time64, current time 194, horizon 130\n", - "adding: mem time65, current time 194, horizon 129\n", - "adding: mem time66, current time 194, horizon 128\n", - "adding: mem time67, current time 194, horizon 127\n", - "adding: mem time68, current time 194, horizon 126\n", - "adding: mem time69, current time 194, horizon 125\n", - "adding: mem time70, current time 194, horizon 124\n", - "adding: mem time71, current time 194, horizon 123\n", - "adding: mem time72, current time 194, horizon 122\n", - "adding: mem time73, current time 194, horizon 121\n", - "adding: mem time74, current time 194, horizon 120\n", - "adding: mem time75, current time 194, horizon 119\n", - "adding: mem time76, current time 194, horizon 118\n", - "adding: mem time77, current time 194, horizon 117\n", - "adding: mem time78, current time 194, horizon 116\n", - "adding: mem time79, current time 194, horizon 115\n", - "adding: mem time80, current time 194, horizon 114\n", - "adding: mem time81, current time 194, horizon 113\n", - "adding: mem time82, current time 194, horizon 112\n", - "adding: mem time83, current time 194, horizon 111\n", - "adding: mem time84, current time 194, horizon 110\n", - "adding: mem time85, current time 194, horizon 109\n", - "adding: mem time86, current time 194, horizon 108\n", - "adding: mem time87, current time 194, horizon 107\n", - "adding: mem time88, current time 194, horizon 106\n", - "adding: mem time89, current time 194, horizon 105\n", - "adding: mem time90, current time 194, horizon 104\n", - "adding: mem time91, current time 194, horizon 103\n", - "adding: mem time92, current time 194, horizon 102\n", - "adding: mem time93, current time 194, horizon 101\n", - "adding: mem time94, current time 194, horizon 100\n", - "adding: mem time95, current time 194, horizon 99\n", - "adding: mem time96, current time 194, horizon 98\n", - "adding: mem time97, current time 194, horizon 97\n", - "adding: mem time98, current time 194, horizon 96\n", - "adding: mem time99, current time 194, horizon 95\n", - "adding: mem time100, current time 194, horizon 94\n", - "adding: mem time101, current time 194, horizon 93\n", - "adding: mem time102, current time 194, horizon 92\n", - "adding: mem time103, current time 194, horizon 91\n", - "adding: mem time104, current time 194, horizon 90\n", - "adding: mem time105, current time 194, horizon 89\n", - "adding: mem time106, current time 194, horizon 88\n", - "adding: mem time107, current time 194, horizon 87\n", - "adding: mem time108, current time 194, horizon 86\n", - "adding: mem time109, current time 194, horizon 85\n", - "adding: mem time110, current time 194, horizon 84\n", - "adding: mem time111, current time 194, horizon 83\n", - "adding: mem time112, current time 194, horizon 82\n", - "adding: mem time113, current time 194, horizon 81\n", - "adding: mem time114, current time 194, horizon 80\n", - "adding: mem time115, current time 194, horizon 79\n", - "adding: mem time116, current time 194, horizon 78\n", - "adding: mem time117, current time 194, horizon 77\n", - "adding: mem time118, current time 194, horizon 76\n", - "adding: mem time119, current time 194, horizon 75\n", - "adding: mem time120, current time 194, horizon 74\n", - "adding: mem time121, current time 194, horizon 73\n", - "adding: mem time122, current time 194, horizon 72\n", - "adding: mem time123, current time 194, horizon 71\n", - "adding: mem time124, current time 194, horizon 70\n", - "adding: mem time125, current time 194, horizon 69\n", - "adding: mem time126, current time 194, horizon 68\n", - "adding: mem time127, current time 194, horizon 67\n", - "adding: mem time128, current time 194, horizon 66\n", - "adding: mem time129, current time 194, horizon 65\n", - "adding: mem time130, current time 194, horizon 64\n", - "adding: mem time131, current time 194, horizon 63\n", - "adding: mem time132, current time 194, horizon 62\n", - "adding: mem time133, current time 194, horizon 61\n", - "adding: mem time134, current time 194, horizon 60\n", - "adding: mem time135, current time 194, horizon 59\n", - "adding: mem time136, current time 194, horizon 58\n", - "adding: mem time137, current time 194, horizon 57\n", - "adding: mem time138, current time 194, horizon 56\n", - "adding: mem time139, current time 194, horizon 55\n", - "adding: mem time140, current time 194, horizon 54\n", - "adding: mem time141, current time 194, horizon 53\n", - "adding: mem time142, current time 194, horizon 52\n", - "adding: mem time143, current time 194, horizon 51\n", - "adding: mem time144, current time 194, horizon 50\n", - "adding: mem time145, current time 194, horizon 49\n", - "adding: mem time146, current time 194, horizon 48\n", - "adding: mem time147, current time 194, horizon 47\n", - "adding: mem time148, current time 194, horizon 46\n", - "adding: mem time149, current time 194, horizon 45\n", - "adding: mem time150, current time 194, horizon 44\n", - "adding: mem time151, current time 194, horizon 43\n", - "adding: mem time152, current time 194, horizon 42\n", - "adding: mem time153, current time 194, horizon 41\n", - "adding: mem time154, current time 194, horizon 40\n", - "adding: mem time155, current time 194, horizon 39\n", - "adding: mem time156, current time 194, horizon 38\n", - "adding: mem time157, current time 194, horizon 37\n", - "adding: mem time158, current time 194, horizon 36\n", - "adding: mem time159, current time 194, horizon 35\n", - "adding: mem time160, current time 194, horizon 34\n", - "adding: mem time161, current time 194, horizon 33\n", - "adding: mem time162, current time 194, horizon 32\n", - "adding: mem time163, current time 194, horizon 31\n", - "adding: mem time164, current time 194, horizon 30\n", - "adding: mem time165, current time 194, horizon 29\n", - "adding: mem time166, current time 194, horizon 28\n", - "adding: mem time167, current time 194, horizon 27\n", - "adding: mem time168, current time 194, horizon 26\n", - "adding: mem time169, current time 194, horizon 25\n", - "adding: mem time170, current time 194, horizon 24\n", - "adding: mem time171, current time 194, horizon 23\n", - "adding: mem time172, current time 194, horizon 22\n", - "adding: mem time173, current time 194, horizon 21\n", - "adding: mem time174, current time 194, horizon 20\n", - "adding: mem time175, current time 194, horizon 19\n", - "adding: mem time176, current time 194, horizon 18\n", - "adding: mem time177, current time 194, horizon 17\n", - "adding: mem time178, current time 194, horizon 16\n", - "adding: mem time179, current time 194, horizon 15\n", - "adding: mem time180, current time 194, horizon 14\n", - "adding: mem time181, current time 194, horizon 13\n", - "adding: mem time182, current time 194, horizon 12\n", - "adding: mem time183, current time 194, horizon 11\n", - "adding: mem time184, current time 194, horizon 10\n", - "adding: mem time185, current time 194, horizon 9\n", - "adding: mem time186, current time 194, horizon 8\n", - "adding: mem time187, current time 194, horizon 7\n", - "adding: mem time188, current time 194, horizon 6\n", - "adding: mem time189, current time 194, horizon 5\n", - "adding: mem time190, current time 194, horizon 4\n", - "adding: mem time191, current time 194, horizon 3\n", - "adding: mem time192, current time 194, horizon 2\n", - "adding: mem time193, current time 194, horizon 1\n", - "adding: mem time0, current time 195, horizon 195\n", - "adding: mem time1, current time 195, horizon 194\n", - "adding: mem time2, current time 195, horizon 193\n", - "adding: mem time3, current time 195, horizon 192\n", - "adding: mem time4, current time 195, horizon 191\n", - "adding: mem time5, current time 195, horizon 190\n", - "adding: mem time6, current time 195, horizon 189\n", - "adding: mem time7, current time 195, horizon 188\n", - "adding: mem time8, current time 195, horizon 187\n", - "adding: mem time9, current time 195, horizon 186\n", - "adding: mem time10, current time 195, horizon 185\n", - "adding: mem time11, current time 195, horizon 184\n", - "adding: mem time12, current time 195, horizon 183\n", - "adding: mem time13, current time 195, horizon 182\n", - "adding: mem time14, current time 195, horizon 181\n", - "adding: mem time15, current time 195, horizon 180\n", - "adding: mem time16, current time 195, horizon 179\n", - "adding: mem time17, current time 195, horizon 178\n", - "adding: mem time18, current time 195, horizon 177\n", - "adding: mem time19, current time 195, horizon 176\n", - "adding: mem time20, current time 195, horizon 175\n", - "adding: mem time21, current time 195, horizon 174\n", - "adding: mem time22, current time 195, horizon 173\n", - "adding: mem time23, current time 195, horizon 172\n", - "adding: mem time24, current time 195, horizon 171\n", - "adding: mem time25, current time 195, horizon 170\n", - "adding: mem time26, current time 195, horizon 169\n", - "adding: mem time27, current time 195, horizon 168\n", - "adding: mem time28, current time 195, horizon 167\n", - "adding: mem time29, current time 195, horizon 166\n", - "adding: mem time30, current time 195, horizon 165\n", - "adding: mem time31, current time 195, horizon 164\n", - "adding: mem time32, current time 195, horizon 163\n", - "adding: mem time33, current time 195, horizon 162\n", - "adding: mem time34, current time 195, horizon 161\n", - "adding: mem time35, current time 195, horizon 160\n", - "adding: mem time36, current time 195, horizon 159\n", - "adding: mem time37, current time 195, horizon 158\n", - "adding: mem time38, current time 195, horizon 157\n", - "adding: mem time39, current time 195, horizon 156\n", - "adding: mem time40, current time 195, horizon 155\n", - "adding: mem time41, current time 195, horizon 154\n", - "adding: mem time42, current time 195, horizon 153\n", - "adding: mem time43, current time 195, horizon 152\n", - "adding: mem time44, current time 195, horizon 151\n", - "adding: mem time45, current time 195, horizon 150\n", - "adding: mem time46, current time 195, horizon 149\n", - "adding: mem time47, current time 195, horizon 148\n", - "adding: mem time48, current time 195, horizon 147\n", - "adding: mem time49, current time 195, horizon 146\n", - "adding: mem time50, current time 195, horizon 145\n", - "adding: mem time51, current time 195, horizon 144\n", - "adding: mem time52, current time 195, horizon 143\n", - "adding: mem time53, current time 195, horizon 142\n", - "adding: mem time54, current time 195, horizon 141\n", - "adding: mem time55, current time 195, horizon 140\n", - "adding: mem time56, current time 195, horizon 139\n", - "adding: mem time57, current time 195, horizon 138\n", - "adding: mem time58, current time 195, horizon 137\n", - "adding: mem time59, current time 195, horizon 136\n", - "adding: mem time60, current time 195, horizon 135\n", - "adding: mem time61, current time 195, horizon 134\n", - "adding: mem time62, current time 195, horizon 133\n", - "adding: mem time63, current time 195, horizon 132\n", - "adding: mem time64, current time 195, horizon 131\n", - "adding: mem time65, current time 195, horizon 130\n", - "adding: mem time66, current time 195, horizon 129\n", - "adding: mem time67, current time 195, horizon 128\n", - "adding: mem time68, current time 195, horizon 127\n", - "adding: mem time69, current time 195, horizon 126\n", - "adding: mem time70, current time 195, horizon 125\n", - "adding: mem time71, current time 195, horizon 124\n", - "adding: mem time72, current time 195, horizon 123\n", - "adding: mem time73, current time 195, horizon 122\n", - "adding: mem time74, current time 195, horizon 121\n", - "adding: mem time75, current time 195, horizon 120\n", - "adding: mem time76, current time 195, horizon 119\n", - "adding: mem time77, current time 195, horizon 118\n", - "adding: mem time78, current time 195, horizon 117\n", - "adding: mem time79, current time 195, horizon 116\n", - "adding: mem time80, current time 195, horizon 115\n", - "adding: mem time81, current time 195, horizon 114\n", - "adding: mem time82, current time 195, horizon 113\n", - "adding: mem time83, current time 195, horizon 112\n", - "adding: mem time84, current time 195, horizon 111\n", - "adding: mem time85, current time 195, horizon 110\n", - "adding: mem time86, current time 195, horizon 109\n", - "adding: mem time87, current time 195, horizon 108\n", - "adding: mem time88, current time 195, horizon 107\n", - "adding: mem time89, current time 195, horizon 106\n", - "adding: mem time90, current time 195, horizon 105\n", - "adding: mem time91, current time 195, horizon 104\n", - "adding: mem time92, current time 195, horizon 103\n", - "adding: mem time93, current time 195, horizon 102\n", - "adding: mem time94, current time 195, horizon 101\n", - "adding: mem time95, current time 195, horizon 100\n", - "adding: mem time96, current time 195, horizon 99\n", - "adding: mem time97, current time 195, horizon 98\n", - "adding: mem time98, current time 195, horizon 97\n", - "adding: mem time99, current time 195, horizon 96\n", - "adding: mem time100, current time 195, horizon 95\n", - "adding: mem time101, current time 195, horizon 94\n", - "adding: mem time102, current time 195, horizon 93\n", - "adding: mem time103, current time 195, horizon 92\n", - "adding: mem time104, current time 195, horizon 91\n", - "adding: mem time105, current time 195, horizon 90\n", - "adding: mem time106, current time 195, horizon 89\n", - "adding: mem time107, current time 195, horizon 88\n", - "adding: mem time108, current time 195, horizon 87\n", - "adding: mem time109, current time 195, horizon 86\n", - "adding: mem time110, current time 195, horizon 85\n", - "adding: mem time111, current time 195, horizon 84\n", - "adding: mem time112, current time 195, horizon 83\n", - "adding: mem time113, current time 195, horizon 82\n", - "adding: mem time114, current time 195, horizon 81\n", - "adding: mem time115, current time 195, horizon 80\n", - "adding: mem time116, current time 195, horizon 79\n", - "adding: mem time117, current time 195, horizon 78\n", - "adding: mem time118, current time 195, horizon 77\n", - "adding: mem time119, current time 195, horizon 76\n", - "adding: mem time120, current time 195, horizon 75\n", - "adding: mem time121, current time 195, horizon 74\n", - "adding: mem time122, current time 195, horizon 73\n", - "adding: mem time123, current time 195, horizon 72\n", - "adding: mem time124, current time 195, horizon 71\n", - "adding: mem time125, current time 195, horizon 70\n", - "adding: mem time126, current time 195, horizon 69\n", - "adding: mem time127, current time 195, horizon 68\n", - "adding: mem time128, current time 195, horizon 67\n", - "adding: mem time129, current time 195, horizon 66\n", - "adding: mem time130, current time 195, horizon 65\n", - "adding: mem time131, current time 195, horizon 64\n", - "adding: mem time132, current time 195, horizon 63\n", - "adding: mem time133, current time 195, horizon 62\n", - "adding: mem time134, current time 195, horizon 61\n", - "adding: mem time135, current time 195, horizon 60\n", - "adding: mem time136, current time 195, horizon 59\n", - "adding: mem time137, current time 195, horizon 58\n", - "adding: mem time138, current time 195, horizon 57\n", - "adding: mem time139, current time 195, horizon 56\n", - "adding: mem time140, current time 195, horizon 55\n", - "adding: mem time141, current time 195, horizon 54\n", - "adding: mem time142, current time 195, horizon 53\n", - "adding: mem time143, current time 195, horizon 52\n", - "adding: mem time144, current time 195, horizon 51\n", - "adding: mem time145, current time 195, horizon 50\n", - "adding: mem time146, current time 195, horizon 49\n", - "adding: mem time147, current time 195, horizon 48\n", - "adding: mem time148, current time 195, horizon 47\n", - "adding: mem time149, current time 195, horizon 46\n", - "adding: mem time150, current time 195, horizon 45\n", - "adding: mem time151, current time 195, horizon 44\n", - "adding: mem time152, current time 195, horizon 43\n", - "adding: mem time153, current time 195, horizon 42\n", - "adding: mem time154, current time 195, horizon 41\n", - "adding: mem time155, current time 195, horizon 40\n", - "adding: mem time156, current time 195, horizon 39\n", - "adding: mem time157, current time 195, horizon 38\n", - "adding: mem time158, current time 195, horizon 37\n", - "adding: mem time159, current time 195, horizon 36\n", - "adding: mem time160, current time 195, horizon 35\n", - "adding: mem time161, current time 195, horizon 34\n", - "adding: mem time162, current time 195, horizon 33\n", - "adding: mem time163, current time 195, horizon 32\n", - "adding: mem time164, current time 195, horizon 31\n", - "adding: mem time165, current time 195, horizon 30\n", - "adding: mem time166, current time 195, horizon 29\n", - "adding: mem time167, current time 195, horizon 28\n", - "adding: mem time168, current time 195, horizon 27\n", - "adding: mem time169, current time 195, horizon 26\n", - "adding: mem time170, current time 195, horizon 25\n", - "adding: mem time171, current time 195, horizon 24\n", - "adding: mem time172, current time 195, horizon 23\n", - "adding: mem time173, current time 195, horizon 22\n", - "adding: mem time174, current time 195, horizon 21\n", - "adding: mem time175, current time 195, horizon 20\n", - "adding: mem time176, current time 195, horizon 19\n", - "adding: mem time177, current time 195, horizon 18\n", - "adding: mem time178, current time 195, horizon 17\n", - "adding: mem time179, current time 195, horizon 16\n", - "adding: mem time180, current time 195, horizon 15\n", - "adding: mem time181, current time 195, horizon 14\n", - "adding: mem time182, current time 195, horizon 13\n", - "adding: mem time183, current time 195, horizon 12\n", - "adding: mem time184, current time 195, horizon 11\n", - "adding: mem time185, current time 195, horizon 10\n", - "adding: mem time186, current time 195, horizon 9\n", - "adding: mem time187, current time 195, horizon 8\n", - "adding: mem time188, current time 195, horizon 7\n", - "adding: mem time189, current time 195, horizon 6\n", - "adding: mem time190, current time 195, horizon 5\n", - "adding: mem time191, current time 195, horizon 4\n", - "adding: mem time192, current time 195, horizon 3\n", - "adding: mem time193, current time 195, horizon 2\n", - "adding: mem time194, current time 195, horizon 1\n", - "adding: mem time0, current time 196, horizon 196\n", - "adding: mem time1, current time 196, horizon 195\n", - "adding: mem time2, current time 196, horizon 194\n", - "adding: mem time3, current time 196, horizon 193\n", - "adding: mem time4, current time 196, horizon 192\n", - "adding: mem time5, current time 196, horizon 191\n", - "adding: mem time6, current time 196, horizon 190\n", - "adding: mem time7, current time 196, horizon 189\n", - "adding: mem time8, current time 196, horizon 188\n", - "adding: mem time9, current time 196, horizon 187\n", - "adding: mem time10, current time 196, horizon 186\n", - "adding: mem time11, current time 196, horizon 185\n", - "adding: mem time12, current time 196, horizon 184\n", - "adding: mem time13, current time 196, horizon 183\n", - "adding: mem time14, current time 196, horizon 182\n", - "adding: mem time15, current time 196, horizon 181\n", - "adding: mem time16, current time 196, horizon 180\n", - "adding: mem time17, current time 196, horizon 179\n", - "adding: mem time18, current time 196, horizon 178\n", - "adding: mem time19, current time 196, horizon 177\n", - "adding: mem time20, current time 196, horizon 176\n", - "adding: mem time21, current time 196, horizon 175\n", - "adding: mem time22, current time 196, horizon 174\n", - "adding: mem time23, current time 196, horizon 173\n", - "adding: mem time24, current time 196, horizon 172\n", - "adding: mem time25, current time 196, horizon 171\n", - "adding: mem time26, current time 196, horizon 170\n", - "adding: mem time27, current time 196, horizon 169\n", - "adding: mem time28, current time 196, horizon 168\n", - "adding: mem time29, current time 196, horizon 167\n", - "adding: mem time30, current time 196, horizon 166\n", - "adding: mem time31, current time 196, horizon 165\n", - "adding: mem time32, current time 196, horizon 164\n", - "adding: mem time33, current time 196, horizon 163\n", - "adding: mem time34, current time 196, horizon 162\n", - "adding: mem time35, current time 196, horizon 161\n", - "adding: mem time36, current time 196, horizon 160\n", - "adding: mem time37, current time 196, horizon 159\n", - "adding: mem time38, current time 196, horizon 158\n", - "adding: mem time39, current time 196, horizon 157\n", - "adding: mem time40, current time 196, horizon 156\n", - "adding: mem time41, current time 196, horizon 155\n", - "adding: mem time42, current time 196, horizon 154\n", - "adding: mem time43, current time 196, horizon 153\n", - "adding: mem time44, current time 196, horizon 152\n", - "adding: mem time45, current time 196, horizon 151\n", - "adding: mem time46, current time 196, horizon 150\n", - "adding: mem time47, current time 196, horizon 149\n", - "adding: mem time48, current time 196, horizon 148\n", - "adding: mem time49, current time 196, horizon 147\n", - "adding: mem time50, current time 196, horizon 146\n", - "adding: mem time51, current time 196, horizon 145\n", - "adding: mem time52, current time 196, horizon 144\n", - "adding: mem time53, current time 196, horizon 143\n", - "adding: mem time54, current time 196, horizon 142\n", - "adding: mem time55, current time 196, horizon 141\n", - "adding: mem time56, current time 196, horizon 140\n", - "adding: mem time57, current time 196, horizon 139\n", - "adding: mem time58, current time 196, horizon 138\n", - "adding: mem time59, current time 196, horizon 137\n", - "adding: mem time60, current time 196, horizon 136\n", - "adding: mem time61, current time 196, horizon 135\n", - "adding: mem time62, current time 196, horizon 134\n", - "adding: mem time63, current time 196, horizon 133\n", - "adding: mem time64, current time 196, horizon 132\n", - "adding: mem time65, current time 196, horizon 131\n", - "adding: mem time66, current time 196, horizon 130\n", - "adding: mem time67, current time 196, horizon 129\n", - "adding: mem time68, current time 196, horizon 128\n", - "adding: mem time69, current time 196, horizon 127\n", - "adding: mem time70, current time 196, horizon 126\n", - "adding: mem time71, current time 196, horizon 125\n", - "adding: mem time72, current time 196, horizon 124\n", - "adding: mem time73, current time 196, horizon 123\n", - "adding: mem time74, current time 196, horizon 122\n", - "adding: mem time75, current time 196, horizon 121\n", - "adding: mem time76, current time 196, horizon 120\n", - "adding: mem time77, current time 196, horizon 119\n", - "adding: mem time78, current time 196, horizon 118\n", - "adding: mem time79, current time 196, horizon 117\n", - "adding: mem time80, current time 196, horizon 116\n", - "adding: mem time81, current time 196, horizon 115\n", - "adding: mem time82, current time 196, horizon 114\n", - "adding: mem time83, current time 196, horizon 113\n", - "adding: mem time84, current time 196, horizon 112\n", - "adding: mem time85, current time 196, horizon 111\n", - "adding: mem time86, current time 196, horizon 110\n", - "adding: mem time87, current time 196, horizon 109\n", - "adding: mem time88, current time 196, horizon 108\n", - "adding: mem time89, current time 196, horizon 107\n", - "adding: mem time90, current time 196, horizon 106\n", - "adding: mem time91, current time 196, horizon 105\n", - "adding: mem time92, current time 196, horizon 104\n", - "adding: mem time93, current time 196, horizon 103\n", - "adding: mem time94, current time 196, horizon 102\n", - "adding: mem time95, current time 196, horizon 101\n", - "adding: mem time96, current time 196, horizon 100\n", - "adding: mem time97, current time 196, horizon 99\n", - "adding: mem time98, current time 196, horizon 98\n", - "adding: mem time99, current time 196, horizon 97\n", - "adding: mem time100, current time 196, horizon 96\n", - "adding: mem time101, current time 196, horizon 95\n", - "adding: mem time102, current time 196, horizon 94\n", - "adding: mem time103, current time 196, horizon 93\n", - "adding: mem time104, current time 196, horizon 92\n", - "adding: mem time105, current time 196, horizon 91\n", - "adding: mem time106, current time 196, horizon 90\n", - "adding: mem time107, current time 196, horizon 89\n", - "adding: mem time108, current time 196, horizon 88\n", - "adding: mem time109, current time 196, horizon 87\n", - "adding: mem time110, current time 196, horizon 86\n", - "adding: mem time111, current time 196, horizon 85\n", - "adding: mem time112, current time 196, horizon 84\n", - "adding: mem time113, current time 196, horizon 83\n", - "adding: mem time114, current time 196, horizon 82\n", - "adding: mem time115, current time 196, horizon 81\n", - "adding: mem time116, current time 196, horizon 80\n", - "adding: mem time117, current time 196, horizon 79\n", - "adding: mem time118, current time 196, horizon 78\n", - "adding: mem time119, current time 196, horizon 77\n", - "adding: mem time120, current time 196, horizon 76\n", - "adding: mem time121, current time 196, horizon 75\n", - "adding: mem time122, current time 196, horizon 74\n", - "adding: mem time123, current time 196, horizon 73\n", - "adding: mem time124, current time 196, horizon 72\n", - "adding: mem time125, current time 196, horizon 71\n", - "adding: mem time126, current time 196, horizon 70\n", - "adding: mem time127, current time 196, horizon 69\n", - "adding: mem time128, current time 196, horizon 68\n", - "adding: mem time129, current time 196, horizon 67\n", - "adding: mem time130, current time 196, horizon 66\n", - "adding: mem time131, current time 196, horizon 65\n", - "adding: mem time132, current time 196, horizon 64\n", - "adding: mem time133, current time 196, horizon 63\n", - "adding: mem time134, current time 196, horizon 62\n", - "adding: mem time135, current time 196, horizon 61\n", - "adding: mem time136, current time 196, horizon 60\n", - "adding: mem time137, current time 196, horizon 59\n", - "adding: mem time138, current time 196, horizon 58\n", - "adding: mem time139, current time 196, horizon 57\n", - "adding: mem time140, current time 196, horizon 56\n", - "adding: mem time141, current time 196, horizon 55\n", - "adding: mem time142, current time 196, horizon 54\n", - "adding: mem time143, current time 196, horizon 53\n", - "adding: mem time144, current time 196, horizon 52\n", - "adding: mem time145, current time 196, horizon 51\n", - "adding: mem time146, current time 196, horizon 50\n", - "adding: mem time147, current time 196, horizon 49\n", - "adding: mem time148, current time 196, horizon 48\n", - "adding: mem time149, current time 196, horizon 47\n", - "adding: mem time150, current time 196, horizon 46\n", - "adding: mem time151, current time 196, horizon 45\n", - "adding: mem time152, current time 196, horizon 44\n", - "adding: mem time153, current time 196, horizon 43\n", - "adding: mem time154, current time 196, horizon 42\n", - "adding: mem time155, current time 196, horizon 41\n", - "adding: mem time156, current time 196, horizon 40\n", - "adding: mem time157, current time 196, horizon 39\n", - "adding: mem time158, current time 196, horizon 38\n", - "adding: mem time159, current time 196, horizon 37\n", - "adding: mem time160, current time 196, horizon 36\n", - "adding: mem time161, current time 196, horizon 35\n", - "adding: mem time162, current time 196, horizon 34\n", - "adding: mem time163, current time 196, horizon 33\n", - "adding: mem time164, current time 196, horizon 32\n", - "adding: mem time165, current time 196, horizon 31\n", - "adding: mem time166, current time 196, horizon 30\n", - "adding: mem time167, current time 196, horizon 29\n", - "adding: mem time168, current time 196, horizon 28\n", - "adding: mem time169, current time 196, horizon 27\n", - "adding: mem time170, current time 196, horizon 26\n", - "adding: mem time171, current time 196, horizon 25\n", - "adding: mem time172, current time 196, horizon 24\n", - "adding: mem time173, current time 196, horizon 23\n", - "adding: mem time174, current time 196, horizon 22\n", - "adding: mem time175, current time 196, horizon 21\n", - "adding: mem time176, current time 196, horizon 20\n", - "adding: mem time177, current time 196, horizon 19\n", - "adding: mem time178, current time 196, horizon 18\n", - "adding: mem time179, current time 196, horizon 17\n", - "adding: mem time180, current time 196, horizon 16\n", - "adding: mem time181, current time 196, horizon 15\n", - "adding: mem time182, current time 196, horizon 14\n", - "adding: mem time183, current time 196, horizon 13\n", - "adding: mem time184, current time 196, horizon 12\n", - "adding: mem time185, current time 196, horizon 11\n", - "adding: mem time186, current time 196, horizon 10\n", - "adding: mem time187, current time 196, horizon 9\n", - "adding: mem time188, current time 196, horizon 8\n", - "adding: mem time189, current time 196, horizon 7\n", - "adding: mem time190, current time 196, horizon 6\n", - "adding: mem time191, current time 196, horizon 5\n", - "adding: mem time192, current time 196, horizon 4\n", - "adding: mem time193, current time 196, horizon 3\n", - "adding: mem time194, current time 196, horizon 2\n", - "adding: mem time195, current time 196, horizon 1\n", - "adding: mem time0, current time 197, horizon 197\n", - "adding: mem time1, current time 197, horizon 196\n", - "adding: mem time2, current time 197, horizon 195\n", - "adding: mem time3, current time 197, horizon 194\n", - "adding: mem time4, current time 197, horizon 193\n", - "adding: mem time5, current time 197, horizon 192\n", - "adding: mem time6, current time 197, horizon 191\n", - "adding: mem time7, current time 197, horizon 190\n", - "adding: mem time8, current time 197, horizon 189\n", - "adding: mem time9, current time 197, horizon 188\n", - "adding: mem time10, current time 197, horizon 187\n", - "adding: mem time11, current time 197, horizon 186\n", - "adding: mem time12, current time 197, horizon 185\n", - "adding: mem time13, current time 197, horizon 184\n", - "adding: mem time14, current time 197, horizon 183\n", - "adding: mem time15, current time 197, horizon 182\n", - "adding: mem time16, current time 197, horizon 181\n", - "adding: mem time17, current time 197, horizon 180\n", - "adding: mem time18, current time 197, horizon 179\n", - "adding: mem time19, current time 197, horizon 178\n", - "adding: mem time20, current time 197, horizon 177\n", - "adding: mem time21, current time 197, horizon 176\n", - "adding: mem time22, current time 197, horizon 175\n", - "adding: mem time23, current time 197, horizon 174\n", - "adding: mem time24, current time 197, horizon 173\n", - "adding: mem time25, current time 197, horizon 172\n", - "adding: mem time26, current time 197, horizon 171\n", - "adding: mem time27, current time 197, horizon 170\n", - "adding: mem time28, current time 197, horizon 169\n", - "adding: mem time29, current time 197, horizon 168\n", - "adding: mem time30, current time 197, horizon 167\n", - "adding: mem time31, current time 197, horizon 166\n", - "adding: mem time32, current time 197, horizon 165\n", - "adding: mem time33, current time 197, horizon 164\n", - "adding: mem time34, current time 197, horizon 163\n", - "adding: mem time35, current time 197, horizon 162\n", - "adding: mem time36, current time 197, horizon 161\n", - "adding: mem time37, current time 197, horizon 160\n", - "adding: mem time38, current time 197, horizon 159\n", - "adding: mem time39, current time 197, horizon 158\n", - "adding: mem time40, current time 197, horizon 157\n", - "adding: mem time41, current time 197, horizon 156\n", - "adding: mem time42, current time 197, horizon 155\n", - "adding: mem time43, current time 197, horizon 154\n", - "adding: mem time44, current time 197, horizon 153\n", - "adding: mem time45, current time 197, horizon 152\n", - "adding: mem time46, current time 197, horizon 151\n", - "adding: mem time47, current time 197, horizon 150\n", - "adding: mem time48, current time 197, horizon 149\n", - "adding: mem time49, current time 197, horizon 148\n", - "adding: mem time50, current time 197, horizon 147\n", - "adding: mem time51, current time 197, horizon 146\n", - "adding: mem time52, current time 197, horizon 145\n", - "adding: mem time53, current time 197, horizon 144\n", - "adding: mem time54, current time 197, horizon 143\n", - "adding: mem time55, current time 197, horizon 142\n", - "adding: mem time56, current time 197, horizon 141\n", - "adding: mem time57, current time 197, horizon 140\n", - "adding: mem time58, current time 197, horizon 139\n", - "adding: mem time59, current time 197, horizon 138\n", - "adding: mem time60, current time 197, horizon 137\n", - "adding: mem time61, current time 197, horizon 136\n", - "adding: mem time62, current time 197, horizon 135\n", - "adding: mem time63, current time 197, horizon 134\n", - "adding: mem time64, current time 197, horizon 133\n", - "adding: mem time65, current time 197, horizon 132\n", - "adding: mem time66, current time 197, horizon 131\n", - "adding: mem time67, current time 197, horizon 130\n", - "adding: mem time68, current time 197, horizon 129\n", - "adding: mem time69, current time 197, horizon 128\n", - "adding: mem time70, current time 197, horizon 127\n", - "adding: mem time71, current time 197, horizon 126\n", - "adding: mem time72, current time 197, horizon 125\n", - "adding: mem time73, current time 197, horizon 124\n", - "adding: mem time74, current time 197, horizon 123\n", - "adding: mem time75, current time 197, horizon 122\n", - "adding: mem time76, current time 197, horizon 121\n", - "adding: mem time77, current time 197, horizon 120\n", - "adding: mem time78, current time 197, horizon 119\n", - "adding: mem time79, current time 197, horizon 118\n", - "adding: mem time80, current time 197, horizon 117\n", - "adding: mem time81, current time 197, horizon 116\n", - "adding: mem time82, current time 197, horizon 115\n", - "adding: mem time83, current time 197, horizon 114\n", - "adding: mem time84, current time 197, horizon 113\n", - "adding: mem time85, current time 197, horizon 112\n", - "adding: mem time86, current time 197, horizon 111\n", - "adding: mem time87, current time 197, horizon 110\n", - "adding: mem time88, current time 197, horizon 109\n", - "adding: mem time89, current time 197, horizon 108\n", - "adding: mem time90, current time 197, horizon 107\n", - "adding: mem time91, current time 197, horizon 106\n", - "adding: mem time92, current time 197, horizon 105\n", - "adding: mem time93, current time 197, horizon 104\n", - "adding: mem time94, current time 197, horizon 103\n", - "adding: mem time95, current time 197, horizon 102\n", - "adding: mem time96, current time 197, horizon 101\n", - "adding: mem time97, current time 197, horizon 100\n", - "adding: mem time98, current time 197, horizon 99\n", - "adding: mem time99, current time 197, horizon 98\n", - "adding: mem time100, current time 197, horizon 97\n", - "adding: mem time101, current time 197, horizon 96\n", - "adding: mem time102, current time 197, horizon 95\n", - "adding: mem time103, current time 197, horizon 94\n", - "adding: mem time104, current time 197, horizon 93\n", - "adding: mem time105, current time 197, horizon 92\n", - "adding: mem time106, current time 197, horizon 91\n", - "adding: mem time107, current time 197, horizon 90\n", - "adding: mem time108, current time 197, horizon 89\n", - "adding: mem time109, current time 197, horizon 88\n", - "adding: mem time110, current time 197, horizon 87\n", - "adding: mem time111, current time 197, horizon 86\n", - "adding: mem time112, current time 197, horizon 85\n", - "adding: mem time113, current time 197, horizon 84\n", - "adding: mem time114, current time 197, horizon 83\n", - "adding: mem time115, current time 197, horizon 82\n", - "adding: mem time116, current time 197, horizon 81\n", - "adding: mem time117, current time 197, horizon 80\n", - "adding: mem time118, current time 197, horizon 79\n", - "adding: mem time119, current time 197, horizon 78\n", - "adding: mem time120, current time 197, horizon 77\n", - "adding: mem time121, current time 197, horizon 76\n", - "adding: mem time122, current time 197, horizon 75\n", - "adding: mem time123, current time 197, horizon 74\n", - "adding: mem time124, current time 197, horizon 73\n", - "adding: mem time125, current time 197, horizon 72\n", - "adding: mem time126, current time 197, horizon 71\n", - "adding: mem time127, current time 197, horizon 70\n", - "adding: mem time128, current time 197, horizon 69\n", - "adding: mem time129, current time 197, horizon 68\n", - "adding: mem time130, current time 197, horizon 67\n", - "adding: mem time131, current time 197, horizon 66\n", - "adding: mem time132, current time 197, horizon 65\n", - "adding: mem time133, current time 197, horizon 64\n", - "adding: mem time134, current time 197, horizon 63\n", - "adding: mem time135, current time 197, horizon 62\n", - "adding: mem time136, current time 197, horizon 61\n", - "adding: mem time137, current time 197, horizon 60\n", - "adding: mem time138, current time 197, horizon 59\n", - "adding: mem time139, current time 197, horizon 58\n", - "adding: mem time140, current time 197, horizon 57\n", - "adding: mem time141, current time 197, horizon 56\n", - "adding: mem time142, current time 197, horizon 55\n", - "adding: mem time143, current time 197, horizon 54\n", - "adding: mem time144, current time 197, horizon 53\n", - "adding: mem time145, current time 197, horizon 52\n", - "adding: mem time146, current time 197, horizon 51\n", - "adding: mem time147, current time 197, horizon 50\n", - "adding: mem time148, current time 197, horizon 49\n", - "adding: mem time149, current time 197, horizon 48\n", - "adding: mem time150, current time 197, horizon 47\n", - "adding: mem time151, current time 197, horizon 46\n", - "adding: mem time152, current time 197, horizon 45\n", - "adding: mem time153, current time 197, horizon 44\n", - "adding: mem time154, current time 197, horizon 43\n", - "adding: mem time155, current time 197, horizon 42\n", - "adding: mem time156, current time 197, horizon 41\n", - "adding: mem time157, current time 197, horizon 40\n", - "adding: mem time158, current time 197, horizon 39\n", - "adding: mem time159, current time 197, horizon 38\n", - "adding: mem time160, current time 197, horizon 37\n", - "adding: mem time161, current time 197, horizon 36\n", - "adding: mem time162, current time 197, horizon 35\n", - "adding: mem time163, current time 197, horizon 34\n", - "adding: mem time164, current time 197, horizon 33\n", - "adding: mem time165, current time 197, horizon 32\n", - "adding: mem time166, current time 197, horizon 31\n", - "adding: mem time167, current time 197, horizon 30\n", - "adding: mem time168, current time 197, horizon 29\n", - "adding: mem time169, current time 197, horizon 28\n", - "adding: mem time170, current time 197, horizon 27\n", - "adding: mem time171, current time 197, horizon 26\n", - "adding: mem time172, current time 197, horizon 25\n", - "adding: mem time173, current time 197, horizon 24\n", - "adding: mem time174, current time 197, horizon 23\n", - "adding: mem time175, current time 197, horizon 22\n", - "adding: mem time176, current time 197, horizon 21\n", - "adding: mem time177, current time 197, horizon 20\n", - "adding: mem time178, current time 197, horizon 19\n", - "adding: mem time179, current time 197, horizon 18\n", - "adding: mem time180, current time 197, horizon 17\n", - "adding: mem time181, current time 197, horizon 16\n", - "adding: mem time182, current time 197, horizon 15\n", - "adding: mem time183, current time 197, horizon 14\n", - "adding: mem time184, current time 197, horizon 13\n", - "adding: mem time185, current time 197, horizon 12\n", - "adding: mem time186, current time 197, horizon 11\n", - "adding: mem time187, current time 197, horizon 10\n", - "adding: mem time188, current time 197, horizon 9\n", - "adding: mem time189, current time 197, horizon 8\n", - "adding: mem time190, current time 197, horizon 7\n", - "adding: mem time191, current time 197, horizon 6\n", - "adding: mem time192, current time 197, horizon 5\n", - "adding: mem time193, current time 197, horizon 4\n", - "adding: mem time194, current time 197, horizon 3\n", - "adding: mem time195, current time 197, horizon 2\n", - "adding: mem time196, current time 197, horizon 1\n", - "adding: mem time0, current time 198, horizon 198\n", - "adding: mem time1, current time 198, horizon 197\n", - "adding: mem time2, current time 198, horizon 196\n", - "adding: mem time3, current time 198, horizon 195\n", - "adding: mem time4, current time 198, horizon 194\n", - "adding: mem time5, current time 198, horizon 193\n", - "adding: mem time6, current time 198, horizon 192\n", - "adding: mem time7, current time 198, horizon 191\n", - "adding: mem time8, current time 198, horizon 190\n", - "adding: mem time9, current time 198, horizon 189\n", - "adding: mem time10, current time 198, horizon 188\n", - "adding: mem time11, current time 198, horizon 187\n", - "adding: mem time12, current time 198, horizon 186\n", - "adding: mem time13, current time 198, horizon 185\n", - "adding: mem time14, current time 198, horizon 184\n", - "adding: mem time15, current time 198, horizon 183\n", - "adding: mem time16, current time 198, horizon 182\n", - "adding: mem time17, current time 198, horizon 181\n", - "adding: mem time18, current time 198, horizon 180\n", - "adding: mem time19, current time 198, horizon 179\n", - "adding: mem time20, current time 198, horizon 178\n", - "adding: mem time21, current time 198, horizon 177\n", - "adding: mem time22, current time 198, horizon 176\n", - "adding: mem time23, current time 198, horizon 175\n", - "adding: mem time24, current time 198, horizon 174\n", - "adding: mem time25, current time 198, horizon 173\n", - "adding: mem time26, current time 198, horizon 172\n", - "adding: mem time27, current time 198, horizon 171\n", - "adding: mem time28, current time 198, horizon 170\n", - "adding: mem time29, current time 198, horizon 169\n", - "adding: mem time30, current time 198, horizon 168\n", - "adding: mem time31, current time 198, horizon 167\n", - "adding: mem time32, current time 198, horizon 166\n", - "adding: mem time33, current time 198, horizon 165\n", - "adding: mem time34, current time 198, horizon 164\n", - "adding: mem time35, current time 198, horizon 163\n", - "adding: mem time36, current time 198, horizon 162\n", - "adding: mem time37, current time 198, horizon 161\n", - "adding: mem time38, current time 198, horizon 160\n", - "adding: mem time39, current time 198, horizon 159\n", - "adding: mem time40, current time 198, horizon 158\n", - "adding: mem time41, current time 198, horizon 157\n", - "adding: mem time42, current time 198, horizon 156\n", - "adding: mem time43, current time 198, horizon 155\n", - "adding: mem time44, current time 198, horizon 154\n", - "adding: mem time45, current time 198, horizon 153\n", - "adding: mem time46, current time 198, horizon 152\n", - "adding: mem time47, current time 198, horizon 151\n", - "adding: mem time48, current time 198, horizon 150\n", - "adding: mem time49, current time 198, horizon 149\n", - "adding: mem time50, current time 198, horizon 148\n", - "adding: mem time51, current time 198, horizon 147\n", - "adding: mem time52, current time 198, horizon 146\n", - "adding: mem time53, current time 198, horizon 145\n", - "adding: mem time54, current time 198, horizon 144\n", - "adding: mem time55, current time 198, horizon 143\n", - "adding: mem time56, current time 198, horizon 142\n", - "adding: mem time57, current time 198, horizon 141\n", - "adding: mem time58, current time 198, horizon 140\n", - "adding: mem time59, current time 198, horizon 139\n", - "adding: mem time60, current time 198, horizon 138\n", - "adding: mem time61, current time 198, horizon 137\n", - "adding: mem time62, current time 198, horizon 136\n", - "adding: mem time63, current time 198, horizon 135\n", - "adding: mem time64, current time 198, horizon 134\n", - "adding: mem time65, current time 198, horizon 133\n", - "adding: mem time66, current time 198, horizon 132\n", - "adding: mem time67, current time 198, horizon 131\n", - "adding: mem time68, current time 198, horizon 130\n", - "adding: mem time69, current time 198, horizon 129\n", - "adding: mem time70, current time 198, horizon 128\n", - "adding: mem time71, current time 198, horizon 127\n", - "adding: mem time72, current time 198, horizon 126\n", - "adding: mem time73, current time 198, horizon 125\n", - "adding: mem time74, current time 198, horizon 124\n", - "adding: mem time75, current time 198, horizon 123\n", - "adding: mem time76, current time 198, horizon 122\n", - "adding: mem time77, current time 198, horizon 121\n", - "adding: mem time78, current time 198, horizon 120\n", - "adding: mem time79, current time 198, horizon 119\n", - "adding: mem time80, current time 198, horizon 118\n", - "adding: mem time81, current time 198, horizon 117\n", - "adding: mem time82, current time 198, horizon 116\n", - "adding: mem time83, current time 198, horizon 115\n", - "adding: mem time84, current time 198, horizon 114\n", - "adding: mem time85, current time 198, horizon 113\n", - "adding: mem time86, current time 198, horizon 112\n", - "adding: mem time87, current time 198, horizon 111\n", - "adding: mem time88, current time 198, horizon 110\n", - "adding: mem time89, current time 198, horizon 109\n", - "adding: mem time90, current time 198, horizon 108\n", - "adding: mem time91, current time 198, horizon 107\n", - "adding: mem time92, current time 198, horizon 106\n", - "adding: mem time93, current time 198, horizon 105\n", - "adding: mem time94, current time 198, horizon 104\n", - "adding: mem time95, current time 198, horizon 103\n", - "adding: mem time96, current time 198, horizon 102\n", - "adding: mem time97, current time 198, horizon 101\n", - "adding: mem time98, current time 198, horizon 100\n", - "adding: mem time99, current time 198, horizon 99\n", - "adding: mem time100, current time 198, horizon 98\n", - "adding: mem time101, current time 198, horizon 97\n", - "adding: mem time102, current time 198, horizon 96\n", - "adding: mem time103, current time 198, horizon 95\n", - "adding: mem time104, current time 198, horizon 94\n", - "adding: mem time105, current time 198, horizon 93\n", - "adding: mem time106, current time 198, horizon 92\n", - "adding: mem time107, current time 198, horizon 91\n", - "adding: mem time108, current time 198, horizon 90\n", - "adding: mem time109, current time 198, horizon 89\n", - "adding: mem time110, current time 198, horizon 88\n", - "adding: mem time111, current time 198, horizon 87\n", - "adding: mem time112, current time 198, horizon 86\n", - "adding: mem time113, current time 198, horizon 85\n", - "adding: mem time114, current time 198, horizon 84\n", - "adding: mem time115, current time 198, horizon 83\n", - "adding: mem time116, current time 198, horizon 82\n", - "adding: mem time117, current time 198, horizon 81\n", - "adding: mem time118, current time 198, horizon 80\n", - "adding: mem time119, current time 198, horizon 79\n", - "adding: mem time120, current time 198, horizon 78\n", - "adding: mem time121, current time 198, horizon 77\n", - "adding: mem time122, current time 198, horizon 76\n", - "adding: mem time123, current time 198, horizon 75\n", - "adding: mem time124, current time 198, horizon 74\n", - "adding: mem time125, current time 198, horizon 73\n", - "adding: mem time126, current time 198, horizon 72\n", - "adding: mem time127, current time 198, horizon 71\n", - "adding: mem time128, current time 198, horizon 70\n", - "adding: mem time129, current time 198, horizon 69\n", - "adding: mem time130, current time 198, horizon 68\n", - "adding: mem time131, current time 198, horizon 67\n", - "adding: mem time132, current time 198, horizon 66\n", - "adding: mem time133, current time 198, horizon 65\n", - "adding: mem time134, current time 198, horizon 64\n", - "adding: mem time135, current time 198, horizon 63\n", - "adding: mem time136, current time 198, horizon 62\n", - "adding: mem time137, current time 198, horizon 61\n", - "adding: mem time138, current time 198, horizon 60\n", - "adding: mem time139, current time 198, horizon 59\n", - "adding: mem time140, current time 198, horizon 58\n", - "adding: mem time141, current time 198, horizon 57\n", - "adding: mem time142, current time 198, horizon 56\n", - "adding: mem time143, current time 198, horizon 55\n", - "adding: mem time144, current time 198, horizon 54\n", - "adding: mem time145, current time 198, horizon 53\n", - "adding: mem time146, current time 198, horizon 52\n", - "adding: mem time147, current time 198, horizon 51\n", - "adding: mem time148, current time 198, horizon 50\n", - "adding: mem time149, current time 198, horizon 49\n", - "adding: mem time150, current time 198, horizon 48\n", - "adding: mem time151, current time 198, horizon 47\n", - "adding: mem time152, current time 198, horizon 46\n", - "adding: mem time153, current time 198, horizon 45\n", - "adding: mem time154, current time 198, horizon 44\n", - "adding: mem time155, current time 198, horizon 43\n", - "adding: mem time156, current time 198, horizon 42\n", - "adding: mem time157, current time 198, horizon 41\n", - "adding: mem time158, current time 198, horizon 40\n", - "adding: mem time159, current time 198, horizon 39\n", - "adding: mem time160, current time 198, horizon 38\n", - "adding: mem time161, current time 198, horizon 37\n", - "adding: mem time162, current time 198, horizon 36\n", - "adding: mem time163, current time 198, horizon 35\n", - "adding: mem time164, current time 198, horizon 34\n", - "adding: mem time165, current time 198, horizon 33\n", - "adding: mem time166, current time 198, horizon 32\n", - "adding: mem time167, current time 198, horizon 31\n", - "adding: mem time168, current time 198, horizon 30\n", - "adding: mem time169, current time 198, horizon 29\n", - "adding: mem time170, current time 198, horizon 28\n", - "adding: mem time171, current time 198, horizon 27\n", - "adding: mem time172, current time 198, horizon 26\n", - "adding: mem time173, current time 198, horizon 25\n", - "adding: mem time174, current time 198, horizon 24\n", - "adding: mem time175, current time 198, horizon 23\n", - "adding: mem time176, current time 198, horizon 22\n", - "adding: mem time177, current time 198, horizon 21\n", - "adding: mem time178, current time 198, horizon 20\n", - "adding: mem time179, current time 198, horizon 19\n", - "adding: mem time180, current time 198, horizon 18\n", - "adding: mem time181, current time 198, horizon 17\n", - "adding: mem time182, current time 198, horizon 16\n", - "adding: mem time183, current time 198, horizon 15\n", - "adding: mem time184, current time 198, horizon 14\n", - "adding: mem time185, current time 198, horizon 13\n", - "adding: mem time186, current time 198, horizon 12\n", - "adding: mem time187, current time 198, horizon 11\n", - "adding: mem time188, current time 198, horizon 10\n", - "adding: mem time189, current time 198, horizon 9\n", - "adding: mem time190, current time 198, horizon 8\n", - "adding: mem time191, current time 198, horizon 7\n", - "adding: mem time192, current time 198, horizon 6\n", - "adding: mem time193, current time 198, horizon 5\n", - "adding: mem time194, current time 198, horizon 4\n", - "adding: mem time195, current time 198, horizon 3\n", - "adding: mem time196, current time 198, horizon 2\n", - "adding: mem time197, current time 198, horizon 1\n", - "adding: mem time0, current time 199, horizon 199\n", - "adding: mem time1, current time 199, horizon 198\n", - "adding: mem time2, current time 199, horizon 197\n", - "adding: mem time3, current time 199, horizon 196\n", - "adding: mem time4, current time 199, horizon 195\n", - "adding: mem time5, current time 199, horizon 194\n", - "adding: mem time6, current time 199, horizon 193\n", - "adding: mem time7, current time 199, horizon 192\n", - "adding: mem time8, current time 199, horizon 191\n", - "adding: mem time9, current time 199, horizon 190\n", - "adding: mem time10, current time 199, horizon 189\n", - "adding: mem time11, current time 199, horizon 188\n", - "adding: mem time12, current time 199, horizon 187\n", - "adding: mem time13, current time 199, horizon 186\n", - "adding: mem time14, current time 199, horizon 185\n", - "adding: mem time15, current time 199, horizon 184\n", - "adding: mem time16, current time 199, horizon 183\n", - "adding: mem time17, current time 199, horizon 182\n", - "adding: mem time18, current time 199, horizon 181\n", - "adding: mem time19, current time 199, horizon 180\n", - "adding: mem time20, current time 199, horizon 179\n", - "adding: mem time21, current time 199, horizon 178\n", - "adding: mem time22, current time 199, horizon 177\n", - "adding: mem time23, current time 199, horizon 176\n", - "adding: mem time24, current time 199, horizon 175\n", - "adding: mem time25, current time 199, horizon 174\n", - "adding: mem time26, current time 199, horizon 173\n", - "adding: mem time27, current time 199, horizon 172\n", - "adding: mem time28, current time 199, horizon 171\n", - "adding: mem time29, current time 199, horizon 170\n", - "adding: mem time30, current time 199, horizon 169\n", - "adding: mem time31, current time 199, horizon 168\n", - "adding: mem time32, current time 199, horizon 167\n", - "adding: mem time33, current time 199, horizon 166\n", - "adding: mem time34, current time 199, horizon 165\n", - "adding: mem time35, current time 199, horizon 164\n", - "adding: mem time36, current time 199, horizon 163\n", - "adding: mem time37, current time 199, horizon 162\n", - "adding: mem time38, current time 199, horizon 161\n", - "adding: mem time39, current time 199, horizon 160\n", - "adding: mem time40, current time 199, horizon 159\n", - "adding: mem time41, current time 199, horizon 158\n", - "adding: mem time42, current time 199, horizon 157\n", - "adding: mem time43, current time 199, horizon 156\n", - "adding: mem time44, current time 199, horizon 155\n", - "adding: mem time45, current time 199, horizon 154\n", - "adding: mem time46, current time 199, horizon 153\n", - "adding: mem time47, current time 199, horizon 152\n", - "adding: mem time48, current time 199, horizon 151\n", - "adding: mem time49, current time 199, horizon 150\n", - "adding: mem time50, current time 199, horizon 149\n", - "adding: mem time51, current time 199, horizon 148\n", - "adding: mem time52, current time 199, horizon 147\n", - "adding: mem time53, current time 199, horizon 146\n", - "adding: mem time54, current time 199, horizon 145\n", - "adding: mem time55, current time 199, horizon 144\n", - "adding: mem time56, current time 199, horizon 143\n", - "adding: mem time57, current time 199, horizon 142\n", - "adding: mem time58, current time 199, horizon 141\n", - "adding: mem time59, current time 199, horizon 140\n", - "adding: mem time60, current time 199, horizon 139\n", - "adding: mem time61, current time 199, horizon 138\n", - "adding: mem time62, current time 199, horizon 137\n", - "adding: mem time63, current time 199, horizon 136\n", - "adding: mem time64, current time 199, horizon 135\n", - "adding: mem time65, current time 199, horizon 134\n", - "adding: mem time66, current time 199, horizon 133\n", - "adding: mem time67, current time 199, horizon 132\n", - "adding: mem time68, current time 199, horizon 131\n", - "adding: mem time69, current time 199, horizon 130\n", - "adding: mem time70, current time 199, horizon 129\n", - "adding: mem time71, current time 199, horizon 128\n", - "adding: mem time72, current time 199, horizon 127\n", - "adding: mem time73, current time 199, horizon 126\n", - "adding: mem time74, current time 199, horizon 125\n", - "adding: mem time75, current time 199, horizon 124\n", - "adding: mem time76, current time 199, horizon 123\n", - "adding: mem time77, current time 199, horizon 122\n", - "adding: mem time78, current time 199, horizon 121\n", - "adding: mem time79, current time 199, horizon 120\n", - "adding: mem time80, current time 199, horizon 119\n", - "adding: mem time81, current time 199, horizon 118\n", - "adding: mem time82, current time 199, horizon 117\n", - "adding: mem time83, current time 199, horizon 116\n", - "adding: mem time84, current time 199, horizon 115\n", - "adding: mem time85, current time 199, horizon 114\n", - "adding: mem time86, current time 199, horizon 113\n", - "adding: mem time87, current time 199, horizon 112\n", - "adding: mem time88, current time 199, horizon 111\n", - "adding: mem time89, current time 199, horizon 110\n", - "adding: mem time90, current time 199, horizon 109\n", - "adding: mem time91, current time 199, horizon 108\n", - "adding: mem time92, current time 199, horizon 107\n", - "adding: mem time93, current time 199, horizon 106\n", - "adding: mem time94, current time 199, horizon 105\n", - "adding: mem time95, current time 199, horizon 104\n", - "adding: mem time96, current time 199, horizon 103\n", - "adding: mem time97, current time 199, horizon 102\n", - "adding: mem time98, current time 199, horizon 101\n", - "adding: mem time99, current time 199, horizon 100\n", - "adding: mem time100, current time 199, horizon 99\n", - "adding: mem time101, current time 199, horizon 98\n", - "adding: mem time102, current time 199, horizon 97\n", - "adding: mem time103, current time 199, horizon 96\n", - "adding: mem time104, current time 199, horizon 95\n", - "adding: mem time105, current time 199, horizon 94\n", - "adding: mem time106, current time 199, horizon 93\n", - "adding: mem time107, current time 199, horizon 92\n", - "adding: mem time108, current time 199, horizon 91\n", - "adding: mem time109, current time 199, horizon 90\n", - "adding: mem time110, current time 199, horizon 89\n", - "adding: mem time111, current time 199, horizon 88\n", - "adding: mem time112, current time 199, horizon 87\n", - "adding: mem time113, current time 199, horizon 86\n", - "adding: mem time114, current time 199, horizon 85\n", - "adding: mem time115, current time 199, horizon 84\n", - "adding: mem time116, current time 199, horizon 83\n", - "adding: mem time117, current time 199, horizon 82\n", - "adding: mem time118, current time 199, horizon 81\n", - "adding: mem time119, current time 199, horizon 80\n", - "adding: mem time120, current time 199, horizon 79\n", - "adding: mem time121, current time 199, horizon 78\n", - "adding: mem time122, current time 199, horizon 77\n", - "adding: mem time123, current time 199, horizon 76\n", - "adding: mem time124, current time 199, horizon 75\n", - "adding: mem time125, current time 199, horizon 74\n", - "adding: mem time126, current time 199, horizon 73\n", - "adding: mem time127, current time 199, horizon 72\n", - "adding: mem time128, current time 199, horizon 71\n", - "adding: mem time129, current time 199, horizon 70\n", - "adding: mem time130, current time 199, horizon 69\n", - "adding: mem time131, current time 199, horizon 68\n", - "adding: mem time132, current time 199, horizon 67\n", - "adding: mem time133, current time 199, horizon 66\n", - "adding: mem time134, current time 199, horizon 65\n", - "adding: mem time135, current time 199, horizon 64\n", - "adding: mem time136, current time 199, horizon 63\n", - "adding: mem time137, current time 199, horizon 62\n", - "adding: mem time138, current time 199, horizon 61\n", - "adding: mem time139, current time 199, horizon 60\n", - "adding: mem time140, current time 199, horizon 59\n", - "adding: mem time141, current time 199, horizon 58\n", - "adding: mem time142, current time 199, horizon 57\n", - "adding: mem time143, current time 199, horizon 56\n", - "adding: mem time144, current time 199, horizon 55\n", - "adding: mem time145, current time 199, horizon 54\n", - "adding: mem time146, current time 199, horizon 53\n", - "adding: mem time147, current time 199, horizon 52\n", - "adding: mem time148, current time 199, horizon 51\n", - "adding: mem time149, current time 199, horizon 50\n", - "adding: mem time150, current time 199, horizon 49\n", - "adding: mem time151, current time 199, horizon 48\n", - "adding: mem time152, current time 199, horizon 47\n", - "adding: mem time153, current time 199, horizon 46\n", - "adding: mem time154, current time 199, horizon 45\n", - "adding: mem time155, current time 199, horizon 44\n", - "adding: mem time156, current time 199, horizon 43\n", - "adding: mem time157, current time 199, horizon 42\n", - "adding: mem time158, current time 199, horizon 41\n", - "adding: mem time159, current time 199, horizon 40\n", - "adding: mem time160, current time 199, horizon 39\n", - "adding: mem time161, current time 199, horizon 38\n", - "adding: mem time162, current time 199, horizon 37\n", - "adding: mem time163, current time 199, horizon 36\n", - "adding: mem time164, current time 199, horizon 35\n", - "adding: mem time165, current time 199, horizon 34\n", - "adding: mem time166, current time 199, horizon 33\n", - "adding: mem time167, current time 199, horizon 32\n", - "adding: mem time168, current time 199, horizon 31\n", - "adding: mem time169, current time 199, horizon 30\n", - "adding: mem time170, current time 199, horizon 29\n", - "adding: mem time171, current time 199, horizon 28\n", - "adding: mem time172, current time 199, horizon 27\n", - "adding: mem time173, current time 199, horizon 26\n", - "adding: mem time174, current time 199, horizon 25\n", - "adding: mem time175, current time 199, horizon 24\n", - "adding: mem time176, current time 199, horizon 23\n", - "adding: mem time177, current time 199, horizon 22\n", - "adding: mem time178, current time 199, horizon 21\n", - "adding: mem time179, current time 199, horizon 20\n", - "adding: mem time180, current time 199, horizon 19\n", - "adding: mem time181, current time 199, horizon 18\n", - "adding: mem time182, current time 199, horizon 17\n", - "adding: mem time183, current time 199, horizon 16\n", - "adding: mem time184, current time 199, horizon 15\n", - "adding: mem time185, current time 199, horizon 14\n", - "adding: mem time186, current time 199, horizon 13\n", - "adding: mem time187, current time 199, horizon 12\n", - "adding: mem time188, current time 199, horizon 11\n", - "adding: mem time189, current time 199, horizon 10\n", - "adding: mem time190, current time 199, horizon 9\n", - "adding: mem time191, current time 199, horizon 8\n", - "adding: mem time192, current time 199, horizon 7\n", - "adding: mem time193, current time 199, horizon 6\n", - "adding: mem time194, current time 199, horizon 5\n", - "adding: mem time195, current time 199, horizon 4\n", - "adding: mem time196, current time 199, horizon 3\n", - "adding: mem time197, current time 199, horizon 2\n", - "adding: mem time198, current time 199, horizon 1\n", - "adding: mem time200, current time 201, horizon 1\n", - "adding: mem time200, current time 202, horizon 2\n", - "adding: mem time201, current time 202, horizon 1\n", - "adding: mem time200, current time 203, horizon 3\n", - "adding: mem time201, current time 203, horizon 2\n", - "adding: mem time202, current time 203, horizon 1\n", - "adding: mem time200, current time 204, horizon 4\n", - "adding: mem time201, current time 204, horizon 3\n", - "adding: mem time202, current time 204, horizon 2\n", - "adding: mem time203, current time 204, horizon 1\n", - "adding: mem time200, current time 205, horizon 5\n", - "adding: mem time201, current time 205, horizon 4\n", - "adding: mem time202, current time 205, horizon 3\n", - "adding: mem time203, current time 205, horizon 2\n", - "adding: mem time204, current time 205, horizon 1\n", - "adding: mem time200, current time 206, horizon 6\n", - "adding: mem time201, current time 206, horizon 5\n", - "adding: mem time202, current time 206, horizon 4\n", - "adding: mem time203, current time 206, horizon 3\n", - "adding: mem time204, current time 206, horizon 2\n", - "adding: mem time205, current time 206, horizon 1\n", - "adding: mem time200, current time 207, horizon 7\n", - "adding: mem time201, current time 207, horizon 6\n", - "adding: mem time202, current time 207, horizon 5\n", - "adding: mem time203, current time 207, horizon 4\n", - "adding: mem time204, current time 207, horizon 3\n", - "adding: mem time205, current time 207, horizon 2\n", - "adding: mem time206, current time 207, horizon 1\n", - "adding: mem time200, current time 208, horizon 8\n", - "adding: mem time201, current time 208, horizon 7\n", - "adding: mem time202, current time 208, horizon 6\n", - "adding: mem time203, current time 208, horizon 5\n", - "adding: mem time204, current time 208, horizon 4\n", - "adding: mem time205, current time 208, horizon 3\n", - "adding: mem time206, current time 208, horizon 2\n", - "adding: mem time207, current time 208, horizon 1\n", - "adding: mem time200, current time 209, horizon 9\n", - "adding: mem time201, current time 209, horizon 8\n", - "adding: mem time202, current time 209, horizon 7\n", - "adding: mem time203, current time 209, horizon 6\n", - "adding: mem time204, current time 209, horizon 5\n", - "adding: mem time205, current time 209, horizon 4\n", - "adding: mem time206, current time 209, horizon 3\n", - "adding: mem time207, current time 209, horizon 2\n", - "adding: mem time208, current time 209, horizon 1\n", - "adding: mem time200, current time 210, horizon 10\n", - "adding: mem time201, current time 210, horizon 9\n", - "adding: mem time202, current time 210, horizon 8\n", - "adding: mem time203, current time 210, horizon 7\n", - "adding: mem time204, current time 210, horizon 6\n", - "adding: mem time205, current time 210, horizon 5\n", - "adding: mem time206, current time 210, horizon 4\n", - "adding: mem time207, current time 210, horizon 3\n", - "adding: mem time208, current time 210, horizon 2\n", - "adding: mem time209, current time 210, horizon 1\n", - "adding: mem time200, current time 211, horizon 11\n", - "adding: mem time201, current time 211, horizon 10\n", - "adding: mem time202, current time 211, horizon 9\n", - "adding: mem time203, current time 211, horizon 8\n", - "adding: mem time204, current time 211, horizon 7\n", - "adding: mem time205, current time 211, horizon 6\n", - "adding: mem time206, current time 211, horizon 5\n", - "adding: mem time207, current time 211, horizon 4\n", - "adding: mem time208, current time 211, horizon 3\n", - "adding: mem time209, current time 211, horizon 2\n", - "adding: mem time210, current time 211, horizon 1\n", - "adding: mem time200, current time 212, horizon 12\n", - "adding: mem time201, current time 212, horizon 11\n", - "adding: mem time202, current time 212, horizon 10\n", - "adding: mem time203, current time 212, horizon 9\n", - "adding: mem time204, current time 212, horizon 8\n", - "adding: mem time205, current time 212, horizon 7\n", - "adding: mem time206, current time 212, horizon 6\n", - "adding: mem time207, current time 212, horizon 5\n", - "adding: mem time208, current time 212, horizon 4\n", - "adding: mem time209, current time 212, horizon 3\n", - "adding: mem time210, current time 212, horizon 2\n", - "adding: mem time211, current time 212, horizon 1\n", - "adding: mem time200, current time 213, horizon 13\n", - "adding: mem time201, current time 213, horizon 12\n", - "adding: mem time202, current time 213, horizon 11\n", - "adding: mem time203, current time 213, horizon 10\n", - "adding: mem time204, current time 213, horizon 9\n", - "adding: mem time205, current time 213, horizon 8\n", - "adding: mem time206, current time 213, horizon 7\n", - "adding: mem time207, current time 213, horizon 6\n", - "adding: mem time208, current time 213, horizon 5\n", - "adding: mem time209, current time 213, horizon 4\n", - "adding: mem time210, current time 213, horizon 3\n", - "adding: mem time211, current time 213, horizon 2\n", - "adding: mem time212, current time 213, horizon 1\n", - "adding: mem time200, current time 214, horizon 14\n", - "adding: mem time201, current time 214, horizon 13\n", - "adding: mem time202, current time 214, horizon 12\n", - "adding: mem time203, current time 214, horizon 11\n", - "adding: mem time204, current time 214, horizon 10\n", - "adding: mem time205, current time 214, horizon 9\n", - "adding: mem time206, current time 214, horizon 8\n", - "adding: mem time207, current time 214, horizon 7\n", - "adding: mem time208, current time 214, horizon 6\n", - "adding: mem time209, current time 214, horizon 5\n", - "adding: mem time210, current time 214, horizon 4\n", - "adding: mem time211, current time 214, horizon 3\n", - "adding: mem time212, current time 214, horizon 2\n", - "adding: mem time213, current time 214, horizon 1\n", - "adding: mem time200, current time 215, horizon 15\n", - "adding: mem time201, current time 215, horizon 14\n", - "adding: mem time202, current time 215, horizon 13\n", - "adding: mem time203, current time 215, horizon 12\n", - "adding: mem time204, current time 215, horizon 11\n", - "adding: mem time205, current time 215, horizon 10\n", - "adding: mem time206, current time 215, horizon 9\n", - "adding: mem time207, current time 215, horizon 8\n", - "adding: mem time208, current time 215, horizon 7\n", - "adding: mem time209, current time 215, horizon 6\n", - "adding: mem time210, current time 215, horizon 5\n", - "adding: mem time211, current time 215, horizon 4\n", - "adding: mem time212, current time 215, horizon 3\n", - "adding: mem time213, current time 215, horizon 2\n", - "adding: mem time214, current time 215, horizon 1\n", - "adding: mem time200, current time 216, horizon 16\n", - "adding: mem time201, current time 216, horizon 15\n", - "adding: mem time202, current time 216, horizon 14\n", - "adding: mem time203, current time 216, horizon 13\n", - "adding: mem time204, current time 216, horizon 12\n", - "adding: mem time205, current time 216, horizon 11\n", - "adding: mem time206, current time 216, horizon 10\n", - "adding: mem time207, current time 216, horizon 9\n", - "adding: mem time208, current time 216, horizon 8\n", - "adding: mem time209, current time 216, horizon 7\n", - "adding: mem time210, current time 216, horizon 6\n", - "adding: mem time211, current time 216, horizon 5\n", - "adding: mem time212, current time 216, horizon 4\n", - "adding: mem time213, current time 216, horizon 3\n", - "adding: mem time214, current time 216, horizon 2\n", - "adding: mem time215, current time 216, horizon 1\n", - "adding: mem time200, current time 217, horizon 17\n", - "adding: mem time201, current time 217, horizon 16\n", - "adding: mem time202, current time 217, horizon 15\n", - "adding: mem time203, current time 217, horizon 14\n", - "adding: mem time204, current time 217, horizon 13\n", - "adding: mem time205, current time 217, horizon 12\n", - "adding: mem time206, current time 217, horizon 11\n", - "adding: mem time207, current time 217, horizon 10\n", - "adding: mem time208, current time 217, horizon 9\n", - "adding: mem time209, current time 217, horizon 8\n", - "adding: mem time210, current time 217, horizon 7\n", - "adding: mem time211, current time 217, horizon 6\n", - "adding: mem time212, current time 217, horizon 5\n", - "adding: mem time213, current time 217, horizon 4\n", - "adding: mem time214, current time 217, horizon 3\n", - "adding: mem time215, current time 217, horizon 2\n", - "adding: mem time216, current time 217, horizon 1\n", - "adding: mem time200, current time 218, horizon 18\n", - "adding: mem time201, current time 218, horizon 17\n", - "adding: mem time202, current time 218, horizon 16\n", - "adding: mem time203, current time 218, horizon 15\n", - "adding: mem time204, current time 218, horizon 14\n", - "adding: mem time205, current time 218, horizon 13\n", - "adding: mem time206, current time 218, horizon 12\n", - "adding: mem time207, current time 218, horizon 11\n", - "adding: mem time208, current time 218, horizon 10\n", - "adding: mem time209, current time 218, horizon 9\n", - "adding: mem time210, current time 218, horizon 8\n", - "adding: mem time211, current time 218, horizon 7\n", - "adding: mem time212, current time 218, horizon 6\n", - "adding: mem time213, current time 218, horizon 5\n", - "adding: mem time214, current time 218, horizon 4\n", - "adding: mem time215, current time 218, horizon 3\n", - "adding: mem time216, current time 218, horizon 2\n", - "adding: mem time217, current time 218, horizon 1\n", - "adding: mem time200, current time 219, horizon 19\n", - "adding: mem time201, current time 219, horizon 18\n", - "adding: mem time202, current time 219, horizon 17\n", - "adding: mem time203, current time 219, horizon 16\n", - "adding: mem time204, current time 219, horizon 15\n", - "adding: mem time205, current time 219, horizon 14\n", - "adding: mem time206, current time 219, horizon 13\n", - "adding: mem time207, current time 219, horizon 12\n", - "adding: mem time208, current time 219, horizon 11\n", - "adding: mem time209, current time 219, horizon 10\n", - "adding: mem time210, current time 219, horizon 9\n", - "adding: mem time211, current time 219, horizon 8\n", - "adding: mem time212, current time 219, horizon 7\n", - "adding: mem time213, current time 219, horizon 6\n", - "adding: mem time214, current time 219, horizon 5\n", - "adding: mem time215, current time 219, horizon 4\n", - "adding: mem time216, current time 219, horizon 3\n", - "adding: mem time217, current time 219, horizon 2\n", - "adding: mem time218, current time 219, horizon 1\n", - "adding: mem time200, current time 220, horizon 20\n", - "adding: mem time201, current time 220, horizon 19\n", - "adding: mem time202, current time 220, horizon 18\n", - "adding: mem time203, current time 220, horizon 17\n", - "adding: mem time204, current time 220, horizon 16\n", - "adding: mem time205, current time 220, horizon 15\n", - "adding: mem time206, current time 220, horizon 14\n", - "adding: mem time207, current time 220, horizon 13\n", - "adding: mem time208, current time 220, horizon 12\n", - "adding: mem time209, current time 220, horizon 11\n", - "adding: mem time210, current time 220, horizon 10\n", - "adding: mem time211, current time 220, horizon 9\n", - "adding: mem time212, current time 220, horizon 8\n", - "adding: mem time213, current time 220, horizon 7\n", - "adding: mem time214, current time 220, horizon 6\n", - "adding: mem time215, current time 220, horizon 5\n", - "adding: mem time216, current time 220, horizon 4\n", - "adding: mem time217, current time 220, horizon 3\n", - "adding: mem time218, current time 220, horizon 2\n", - "adding: mem time219, current time 220, horizon 1\n", - "adding: mem time200, current time 221, horizon 21\n", - "adding: mem time201, current time 221, horizon 20\n", - "adding: mem time202, current time 221, horizon 19\n", - "adding: mem time203, current time 221, horizon 18\n", - "adding: mem time204, current time 221, horizon 17\n", - "adding: mem time205, current time 221, horizon 16\n", - "adding: mem time206, current time 221, horizon 15\n", - "adding: mem time207, current time 221, horizon 14\n", - "adding: mem time208, current time 221, horizon 13\n", - "adding: mem time209, current time 221, horizon 12\n", - "adding: mem time210, current time 221, horizon 11\n", - "adding: mem time211, current time 221, horizon 10\n", - "adding: mem time212, current time 221, horizon 9\n", - "adding: mem time213, current time 221, horizon 8\n", - "adding: mem time214, current time 221, horizon 7\n", - "adding: mem time215, current time 221, horizon 6\n", - "adding: mem time216, current time 221, horizon 5\n", - "adding: mem time217, current time 221, horizon 4\n", - "adding: mem time218, current time 221, horizon 3\n", - "adding: mem time219, current time 221, horizon 2\n", - "adding: mem time220, current time 221, horizon 1\n", - "adding: mem time200, current time 222, horizon 22\n", - "adding: mem time201, current time 222, horizon 21\n", - "adding: mem time202, current time 222, horizon 20\n", - "adding: mem time203, current time 222, horizon 19\n", - "adding: mem time204, current time 222, horizon 18\n", - "adding: mem time205, current time 222, horizon 17\n", - "adding: mem time206, current time 222, horizon 16\n", - "adding: mem time207, current time 222, horizon 15\n", - "adding: mem time208, current time 222, horizon 14\n", - "adding: mem time209, current time 222, horizon 13\n", - "adding: mem time210, current time 222, horizon 12\n", - "adding: mem time211, current time 222, horizon 11\n", - "adding: mem time212, current time 222, horizon 10\n", - "adding: mem time213, current time 222, horizon 9\n", - "adding: mem time214, current time 222, horizon 8\n", - "adding: mem time215, current time 222, horizon 7\n", - "adding: mem time216, current time 222, horizon 6\n", - "adding: mem time217, current time 222, horizon 5\n", - "adding: mem time218, current time 222, horizon 4\n", - "adding: mem time219, current time 222, horizon 3\n", - "adding: mem time220, current time 222, horizon 2\n", - "adding: mem time221, current time 222, horizon 1\n", - "adding: mem time200, current time 223, horizon 23\n", - "adding: mem time201, current time 223, horizon 22\n", - "adding: mem time202, current time 223, horizon 21\n", - "adding: mem time203, current time 223, horizon 20\n", - "adding: mem time204, current time 223, horizon 19\n", - "adding: mem time205, current time 223, horizon 18\n", - "adding: mem time206, current time 223, horizon 17\n", - "adding: mem time207, current time 223, horizon 16\n", - "adding: mem time208, current time 223, horizon 15\n", - "adding: mem time209, current time 223, horizon 14\n", - "adding: mem time210, current time 223, horizon 13\n", - "adding: mem time211, current time 223, horizon 12\n", - "adding: mem time212, current time 223, horizon 11\n", - "adding: mem time213, current time 223, horizon 10\n", - "adding: mem time214, current time 223, horizon 9\n", - "adding: mem time215, current time 223, horizon 8\n", - "adding: mem time216, current time 223, horizon 7\n", - "adding: mem time217, current time 223, horizon 6\n", - "adding: mem time218, current time 223, horizon 5\n", - "adding: mem time219, current time 223, horizon 4\n", - "adding: mem time220, current time 223, horizon 3\n", - "adding: mem time221, current time 223, horizon 2\n", - "adding: mem time222, current time 223, horizon 1\n", - "adding: mem time200, current time 224, horizon 24\n", - "adding: mem time201, current time 224, horizon 23\n", - "adding: mem time202, current time 224, horizon 22\n", - "adding: mem time203, current time 224, horizon 21\n", - "adding: mem time204, current time 224, horizon 20\n", - "adding: mem time205, current time 224, horizon 19\n", - "adding: mem time206, current time 224, horizon 18\n", - "adding: mem time207, current time 224, horizon 17\n", - "adding: mem time208, current time 224, horizon 16\n", - "adding: mem time209, current time 224, horizon 15\n", - "adding: mem time210, current time 224, horizon 14\n", - "adding: mem time211, current time 224, horizon 13\n", - "adding: mem time212, current time 224, horizon 12\n", - "adding: mem time213, current time 224, horizon 11\n", - "adding: mem time214, current time 224, horizon 10\n", - "adding: mem time215, current time 224, horizon 9\n", - "adding: mem time216, current time 224, horizon 8\n", - "adding: mem time217, current time 224, horizon 7\n", - "adding: mem time218, current time 224, horizon 6\n", - "adding: mem time219, current time 224, horizon 5\n", - "adding: mem time220, current time 224, horizon 4\n", - "adding: mem time221, current time 224, horizon 3\n", - "adding: mem time222, current time 224, horizon 2\n", - "adding: mem time223, current time 224, horizon 1\n", - "adding: mem time200, current time 225, horizon 25\n", - "adding: mem time201, current time 225, horizon 24\n", - "adding: mem time202, current time 225, horizon 23\n", - "adding: mem time203, current time 225, horizon 22\n", - "adding: mem time204, current time 225, horizon 21\n", - "adding: mem time205, current time 225, horizon 20\n", - "adding: mem time206, current time 225, horizon 19\n", - "adding: mem time207, current time 225, horizon 18\n", - "adding: mem time208, current time 225, horizon 17\n", - "adding: mem time209, current time 225, horizon 16\n", - "adding: mem time210, current time 225, horizon 15\n", - "adding: mem time211, current time 225, horizon 14\n", - "adding: mem time212, current time 225, horizon 13\n", - "adding: mem time213, current time 225, horizon 12\n", - "adding: mem time214, current time 225, horizon 11\n", - "adding: mem time215, current time 225, horizon 10\n", - "adding: mem time216, current time 225, horizon 9\n", - "adding: mem time217, current time 225, horizon 8\n", - "adding: mem time218, current time 225, horizon 7\n", - "adding: mem time219, current time 225, horizon 6\n", - "adding: mem time220, current time 225, horizon 5\n", - "adding: mem time221, current time 225, horizon 4\n", - "adding: mem time222, current time 225, horizon 3\n", - "adding: mem time223, current time 225, horizon 2\n", - "adding: mem time224, current time 225, horizon 1\n", - "adding: mem time200, current time 226, horizon 26\n", - "adding: mem time201, current time 226, horizon 25\n", - "adding: mem time202, current time 226, horizon 24\n", - "adding: mem time203, current time 226, horizon 23\n", - "adding: mem time204, current time 226, horizon 22\n", - "adding: mem time205, current time 226, horizon 21\n", - "adding: mem time206, current time 226, horizon 20\n", - "adding: mem time207, current time 226, horizon 19\n", - "adding: mem time208, current time 226, horizon 18\n", - "adding: mem time209, current time 226, horizon 17\n", - "adding: mem time210, current time 226, horizon 16\n", - "adding: mem time211, current time 226, horizon 15\n", - "adding: mem time212, current time 226, horizon 14\n", - "adding: mem time213, current time 226, horizon 13\n", - "adding: mem time214, current time 226, horizon 12\n", - "adding: mem time215, current time 226, horizon 11\n", - "adding: mem time216, current time 226, horizon 10\n", - "adding: mem time217, current time 226, horizon 9\n", - "adding: mem time218, current time 226, horizon 8\n", - "adding: mem time219, current time 226, horizon 7\n", - "adding: mem time220, current time 226, horizon 6\n", - "adding: mem time221, current time 226, horizon 5\n", - "adding: mem time222, current time 226, horizon 4\n", - "adding: mem time223, current time 226, horizon 3\n", - "adding: mem time224, current time 226, horizon 2\n", - "adding: mem time225, current time 226, horizon 1\n", - "adding: mem time200, current time 227, horizon 27\n", - "adding: mem time201, current time 227, horizon 26\n", - "adding: mem time202, current time 227, horizon 25\n", - "adding: mem time203, current time 227, horizon 24\n", - "adding: mem time204, current time 227, horizon 23\n", - "adding: mem time205, current time 227, horizon 22\n", - "adding: mem time206, current time 227, horizon 21\n", - "adding: mem time207, current time 227, horizon 20\n", - "adding: mem time208, current time 227, horizon 19\n", - "adding: mem time209, current time 227, horizon 18\n", - "adding: mem time210, current time 227, horizon 17\n", - "adding: mem time211, current time 227, horizon 16\n", - "adding: mem time212, current time 227, horizon 15\n", - "adding: mem time213, current time 227, horizon 14\n", - "adding: mem time214, current time 227, horizon 13\n", - "adding: mem time215, current time 227, horizon 12\n", - "adding: mem time216, current time 227, horizon 11\n", - "adding: mem time217, current time 227, horizon 10\n", - "adding: mem time218, current time 227, horizon 9\n", - "adding: mem time219, current time 227, horizon 8\n", - "adding: mem time220, current time 227, horizon 7\n", - "adding: mem time221, current time 227, horizon 6\n", - "adding: mem time222, current time 227, horizon 5\n", - "adding: mem time223, current time 227, horizon 4\n", - "adding: mem time224, current time 227, horizon 3\n", - "adding: mem time225, current time 227, horizon 2\n", - "adding: mem time226, current time 227, horizon 1\n", - "adding: mem time200, current time 228, horizon 28\n", - "adding: mem time201, current time 228, horizon 27\n", - "adding: mem time202, current time 228, horizon 26\n", - "adding: mem time203, current time 228, horizon 25\n", - "adding: mem time204, current time 228, horizon 24\n", - "adding: mem time205, current time 228, horizon 23\n", - "adding: mem time206, current time 228, horizon 22\n", - "adding: mem time207, current time 228, horizon 21\n", - "adding: mem time208, current time 228, horizon 20\n", - "adding: mem time209, current time 228, horizon 19\n", - "adding: mem time210, current time 228, horizon 18\n", - "adding: mem time211, current time 228, horizon 17\n", - "adding: mem time212, current time 228, horizon 16\n", - "adding: mem time213, current time 228, horizon 15\n", - "adding: mem time214, current time 228, horizon 14\n", - "adding: mem time215, current time 228, horizon 13\n", - "adding: mem time216, current time 228, horizon 12\n", - "adding: mem time217, current time 228, horizon 11\n", - "adding: mem time218, current time 228, horizon 10\n", - "adding: mem time219, current time 228, horizon 9\n", - "adding: mem time220, current time 228, horizon 8\n", - "adding: mem time221, current time 228, horizon 7\n", - "adding: mem time222, current time 228, horizon 6\n", - "adding: mem time223, current time 228, horizon 5\n", - "adding: mem time224, current time 228, horizon 4\n", - "adding: mem time225, current time 228, horizon 3\n", - "adding: mem time226, current time 228, horizon 2\n", - "adding: mem time227, current time 228, horizon 1\n", - "adding: mem time200, current time 229, horizon 29\n", - "adding: mem time201, current time 229, horizon 28\n", - "adding: mem time202, current time 229, horizon 27\n", - "adding: mem time203, current time 229, horizon 26\n", - "adding: mem time204, current time 229, horizon 25\n", - "adding: mem time205, current time 229, horizon 24\n", - "adding: mem time206, current time 229, horizon 23\n", - "adding: mem time207, current time 229, horizon 22\n", - "adding: mem time208, current time 229, horizon 21\n", - "adding: mem time209, current time 229, horizon 20\n", - "adding: mem time210, current time 229, horizon 19\n", - "adding: mem time211, current time 229, horizon 18\n", - "adding: mem time212, current time 229, horizon 17\n", - "adding: mem time213, current time 229, horizon 16\n", - "adding: mem time214, current time 229, horizon 15\n", - "adding: mem time215, current time 229, horizon 14\n", - "adding: mem time216, current time 229, horizon 13\n", - "adding: mem time217, current time 229, horizon 12\n", - "adding: mem time218, current time 229, horizon 11\n", - "adding: mem time219, current time 229, horizon 10\n", - "adding: mem time220, current time 229, horizon 9\n", - "adding: mem time221, current time 229, horizon 8\n", - "adding: mem time222, current time 229, horizon 7\n", - "adding: mem time223, current time 229, horizon 6\n", - "adding: mem time224, current time 229, horizon 5\n", - "adding: mem time225, current time 229, horizon 4\n", - "adding: mem time226, current time 229, horizon 3\n", - "adding: mem time227, current time 229, horizon 2\n", - "adding: mem time228, current time 229, horizon 1\n", - "adding: mem time200, current time 230, horizon 30\n", - "adding: mem time201, current time 230, horizon 29\n", - "adding: mem time202, current time 230, horizon 28\n", - "adding: mem time203, current time 230, horizon 27\n", - "adding: mem time204, current time 230, horizon 26\n", - "adding: mem time205, current time 230, horizon 25\n", - "adding: mem time206, current time 230, horizon 24\n", - "adding: mem time207, current time 230, horizon 23\n", - "adding: mem time208, current time 230, horizon 22\n", - "adding: mem time209, current time 230, horizon 21\n", - "adding: mem time210, current time 230, horizon 20\n", - "adding: mem time211, current time 230, horizon 19\n", - "adding: mem time212, current time 230, horizon 18\n", - "adding: mem time213, current time 230, horizon 17\n", - "adding: mem time214, current time 230, horizon 16\n", - "adding: mem time215, current time 230, horizon 15\n", - "adding: mem time216, current time 230, horizon 14\n", - "adding: mem time217, current time 230, horizon 13\n", - "adding: mem time218, current time 230, horizon 12\n", - "adding: mem time219, current time 230, horizon 11\n", - "adding: mem time220, current time 230, horizon 10\n", - "adding: mem time221, current time 230, horizon 9\n", - "adding: mem time222, current time 230, horizon 8\n", - "adding: mem time223, current time 230, horizon 7\n", - "adding: mem time224, current time 230, horizon 6\n", - "adding: mem time225, current time 230, horizon 5\n", - "adding: mem time226, current time 230, horizon 4\n", - "adding: mem time227, current time 230, horizon 3\n", - "adding: mem time228, current time 230, horizon 2\n", - "adding: mem time229, current time 230, horizon 1\n", - "adding: mem time200, current time 231, horizon 31\n", - "adding: mem time201, current time 231, horizon 30\n", - "adding: mem time202, current time 231, horizon 29\n", - "adding: mem time203, current time 231, horizon 28\n", - "adding: mem time204, current time 231, horizon 27\n", - "adding: mem time205, current time 231, horizon 26\n", - "adding: mem time206, current time 231, horizon 25\n", - "adding: mem time207, current time 231, horizon 24\n", - "adding: mem time208, current time 231, horizon 23\n", - "adding: mem time209, current time 231, horizon 22\n", - "adding: mem time210, current time 231, horizon 21\n", - "adding: mem time211, current time 231, horizon 20\n", - "adding: mem time212, current time 231, horizon 19\n", - "adding: mem time213, current time 231, horizon 18\n", - "adding: mem time214, current time 231, horizon 17\n", - "adding: mem time215, current time 231, horizon 16\n", - "adding: mem time216, current time 231, horizon 15\n", - "adding: mem time217, current time 231, horizon 14\n", - "adding: mem time218, current time 231, horizon 13\n", - "adding: mem time219, current time 231, horizon 12\n", - "adding: mem time220, current time 231, horizon 11\n", - "adding: mem time221, current time 231, horizon 10\n", - "adding: mem time222, current time 231, horizon 9\n", - "adding: mem time223, current time 231, horizon 8\n", - "adding: mem time224, current time 231, horizon 7\n", - "adding: mem time225, current time 231, horizon 6\n", - "adding: mem time226, current time 231, horizon 5\n", - "adding: mem time227, current time 231, horizon 4\n", - "adding: mem time228, current time 231, horizon 3\n", - "adding: mem time229, current time 231, horizon 2\n", - "adding: mem time230, current time 231, horizon 1\n", - "adding: mem time200, current time 232, horizon 32\n", - "adding: mem time201, current time 232, horizon 31\n", - "adding: mem time202, current time 232, horizon 30\n", - "adding: mem time203, current time 232, horizon 29\n", - "adding: mem time204, current time 232, horizon 28\n", - "adding: mem time205, current time 232, horizon 27\n", - "adding: mem time206, current time 232, horizon 26\n", - "adding: mem time207, current time 232, horizon 25\n", - "adding: mem time208, current time 232, horizon 24\n", - "adding: mem time209, current time 232, horizon 23\n", - "adding: mem time210, current time 232, horizon 22\n", - "adding: mem time211, current time 232, horizon 21\n", - "adding: mem time212, current time 232, horizon 20\n", - "adding: mem time213, current time 232, horizon 19\n", - "adding: mem time214, current time 232, horizon 18\n", - "adding: mem time215, current time 232, horizon 17\n", - "adding: mem time216, current time 232, horizon 16\n", - "adding: mem time217, current time 232, horizon 15\n", - "adding: mem time218, current time 232, horizon 14\n", - "adding: mem time219, current time 232, horizon 13\n", - "adding: mem time220, current time 232, horizon 12\n", - "adding: mem time221, current time 232, horizon 11\n", - "adding: mem time222, current time 232, horizon 10\n", - "adding: mem time223, current time 232, horizon 9\n", - "adding: mem time224, current time 232, horizon 8\n", - "adding: mem time225, current time 232, horizon 7\n", - "adding: mem time226, current time 232, horizon 6\n", - "adding: mem time227, current time 232, horizon 5\n", - "adding: mem time228, current time 232, horizon 4\n", - "adding: mem time229, current time 232, horizon 3\n", - "adding: mem time230, current time 232, horizon 2\n", - "adding: mem time231, current time 232, horizon 1\n", - "adding: mem time200, current time 233, horizon 33\n", - "adding: mem time201, current time 233, horizon 32\n", - "adding: mem time202, current time 233, horizon 31\n", - "adding: mem time203, current time 233, horizon 30\n", - "adding: mem time204, current time 233, horizon 29\n", - "adding: mem time205, current time 233, horizon 28\n", - "adding: mem time206, current time 233, horizon 27\n", - "adding: mem time207, current time 233, horizon 26\n", - "adding: mem time208, current time 233, horizon 25\n", - "adding: mem time209, current time 233, horizon 24\n", - "adding: mem time210, current time 233, horizon 23\n", - "adding: mem time211, current time 233, horizon 22\n", - "adding: mem time212, current time 233, horizon 21\n", - "adding: mem time213, current time 233, horizon 20\n", - "adding: mem time214, current time 233, horizon 19\n", - "adding: mem time215, current time 233, horizon 18\n", - "adding: mem time216, current time 233, horizon 17\n", - "adding: mem time217, current time 233, horizon 16\n", - "adding: mem time218, current time 233, horizon 15\n", - "adding: mem time219, current time 233, horizon 14\n", - "adding: mem time220, current time 233, horizon 13\n", - "adding: mem time221, current time 233, horizon 12\n", - "adding: mem time222, current time 233, horizon 11\n", - "adding: mem time223, current time 233, horizon 10\n", - "adding: mem time224, current time 233, horizon 9\n", - "adding: mem time225, current time 233, horizon 8\n", - "adding: mem time226, current time 233, horizon 7\n", - "adding: mem time227, current time 233, horizon 6\n", - "adding: mem time228, current time 233, horizon 5\n", - "adding: mem time229, current time 233, horizon 4\n", - "adding: mem time230, current time 233, horizon 3\n", - "adding: mem time231, current time 233, horizon 2\n", - "adding: mem time232, current time 233, horizon 1\n", - "adding: mem time200, current time 234, horizon 34\n", - "adding: mem time201, current time 234, horizon 33\n", - "adding: mem time202, current time 234, horizon 32\n", - "adding: mem time203, current time 234, horizon 31\n", - "adding: mem time204, current time 234, horizon 30\n", - "adding: mem time205, current time 234, horizon 29\n", - "adding: mem time206, current time 234, horizon 28\n", - "adding: mem time207, current time 234, horizon 27\n", - "adding: mem time208, current time 234, horizon 26\n", - "adding: mem time209, current time 234, horizon 25\n", - "adding: mem time210, current time 234, horizon 24\n", - "adding: mem time211, current time 234, horizon 23\n", - "adding: mem time212, current time 234, horizon 22\n", - "adding: mem time213, current time 234, horizon 21\n", - "adding: mem time214, current time 234, horizon 20\n", - "adding: mem time215, current time 234, horizon 19\n", - "adding: mem time216, current time 234, horizon 18\n", - "adding: mem time217, current time 234, horizon 17\n", - "adding: mem time218, current time 234, horizon 16\n", - "adding: mem time219, current time 234, horizon 15\n", - "adding: mem time220, current time 234, horizon 14\n", - "adding: mem time221, current time 234, horizon 13\n", - "adding: mem time222, current time 234, horizon 12\n", - "adding: mem time223, current time 234, horizon 11\n", - "adding: mem time224, current time 234, horizon 10\n", - "adding: mem time225, current time 234, horizon 9\n", - "adding: mem time226, current time 234, horizon 8\n", - "adding: mem time227, current time 234, horizon 7\n", - "adding: mem time228, current time 234, horizon 6\n", - "adding: mem time229, current time 234, horizon 5\n", - "adding: mem time230, current time 234, horizon 4\n", - "adding: mem time231, current time 234, horizon 3\n", - "adding: mem time232, current time 234, horizon 2\n", - "adding: mem time233, current time 234, horizon 1\n", - "adding: mem time200, current time 235, horizon 35\n", - "adding: mem time201, current time 235, horizon 34\n", - "adding: mem time202, current time 235, horizon 33\n", - "adding: mem time203, current time 235, horizon 32\n", - "adding: mem time204, current time 235, horizon 31\n", - "adding: mem time205, current time 235, horizon 30\n", - "adding: mem time206, current time 235, horizon 29\n", - "adding: mem time207, current time 235, horizon 28\n", - "adding: mem time208, current time 235, horizon 27\n", - "adding: mem time209, current time 235, horizon 26\n", - "adding: mem time210, current time 235, horizon 25\n", - "adding: mem time211, current time 235, horizon 24\n", - "adding: mem time212, current time 235, horizon 23\n", - "adding: mem time213, current time 235, horizon 22\n", - "adding: mem time214, current time 235, horizon 21\n", - "adding: mem time215, current time 235, horizon 20\n", - "adding: mem time216, current time 235, horizon 19\n", - "adding: mem time217, current time 235, horizon 18\n", - "adding: mem time218, current time 235, horizon 17\n", - "adding: mem time219, current time 235, horizon 16\n", - "adding: mem time220, current time 235, horizon 15\n", - "adding: mem time221, current time 235, horizon 14\n", - "adding: mem time222, current time 235, horizon 13\n", - "adding: mem time223, current time 235, horizon 12\n", - "adding: mem time224, current time 235, horizon 11\n", - "adding: mem time225, current time 235, horizon 10\n", - "adding: mem time226, current time 235, horizon 9\n", - "adding: mem time227, current time 235, horizon 8\n", - "adding: mem time228, current time 235, horizon 7\n", - "adding: mem time229, current time 235, horizon 6\n", - "adding: mem time230, current time 235, horizon 5\n", - "adding: mem time231, current time 235, horizon 4\n", - "adding: mem time232, current time 235, horizon 3\n", - "adding: mem time233, current time 235, horizon 2\n", - "adding: mem time234, current time 235, horizon 1\n", - "adding: mem time200, current time 236, horizon 36\n", - "adding: mem time201, current time 236, horizon 35\n", - "adding: mem time202, current time 236, horizon 34\n", - "adding: mem time203, current time 236, horizon 33\n", - "adding: mem time204, current time 236, horizon 32\n", - "adding: mem time205, current time 236, horizon 31\n", - "adding: mem time206, current time 236, horizon 30\n", - "adding: mem time207, current time 236, horizon 29\n", - "adding: mem time208, current time 236, horizon 28\n", - "adding: mem time209, current time 236, horizon 27\n", - "adding: mem time210, current time 236, horizon 26\n", - "adding: mem time211, current time 236, horizon 25\n", - "adding: mem time212, current time 236, horizon 24\n", - "adding: mem time213, current time 236, horizon 23\n", - "adding: mem time214, current time 236, horizon 22\n", - "adding: mem time215, current time 236, horizon 21\n", - "adding: mem time216, current time 236, horizon 20\n", - "adding: mem time217, current time 236, horizon 19\n", - "adding: mem time218, current time 236, horizon 18\n", - "adding: mem time219, current time 236, horizon 17\n", - "adding: mem time220, current time 236, horizon 16\n", - "adding: mem time221, current time 236, horizon 15\n", - "adding: mem time222, current time 236, horizon 14\n", - "adding: mem time223, current time 236, horizon 13\n", - "adding: mem time224, current time 236, horizon 12\n", - "adding: mem time225, current time 236, horizon 11\n", - "adding: mem time226, current time 236, horizon 10\n", - "adding: mem time227, current time 236, horizon 9\n", - "adding: mem time228, current time 236, horizon 8\n", - "adding: mem time229, current time 236, horizon 7\n", - "adding: mem time230, current time 236, horizon 6\n", - "adding: mem time231, current time 236, horizon 5\n", - "adding: mem time232, current time 236, horizon 4\n", - "adding: mem time233, current time 236, horizon 3\n", - "adding: mem time234, current time 236, horizon 2\n", - "adding: mem time235, current time 236, horizon 1\n", - "adding: mem time200, current time 237, horizon 37\n", - "adding: mem time201, current time 237, horizon 36\n", - "adding: mem time202, current time 237, horizon 35\n", - "adding: mem time203, current time 237, horizon 34\n", - "adding: mem time204, current time 237, horizon 33\n", - "adding: mem time205, current time 237, horizon 32\n", - "adding: mem time206, current time 237, horizon 31\n", - "adding: mem time207, current time 237, horizon 30\n", - "adding: mem time208, current time 237, horizon 29\n", - "adding: mem time209, current time 237, horizon 28\n", - "adding: mem time210, current time 237, horizon 27\n", - "adding: mem time211, current time 237, horizon 26\n", - "adding: mem time212, current time 237, horizon 25\n", - "adding: mem time213, current time 237, horizon 24\n", - "adding: mem time214, current time 237, horizon 23\n", - "adding: mem time215, current time 237, horizon 22\n", - "adding: mem time216, current time 237, horizon 21\n", - "adding: mem time217, current time 237, horizon 20\n", - "adding: mem time218, current time 237, horizon 19\n", - "adding: mem time219, current time 237, horizon 18\n", - "adding: mem time220, current time 237, horizon 17\n", - "adding: mem time221, current time 237, horizon 16\n", - "adding: mem time222, current time 237, horizon 15\n", - "adding: mem time223, current time 237, horizon 14\n", - "adding: mem time224, current time 237, horizon 13\n", - "adding: mem time225, current time 237, horizon 12\n", - "adding: mem time226, current time 237, horizon 11\n", - "adding: mem time227, current time 237, horizon 10\n", - "adding: mem time228, current time 237, horizon 9\n", - "adding: mem time229, current time 237, horizon 8\n", - "adding: mem time230, current time 237, horizon 7\n", - "adding: mem time231, current time 237, horizon 6\n", - "adding: mem time232, current time 237, horizon 5\n", - "adding: mem time233, current time 237, horizon 4\n", - "adding: mem time234, current time 237, horizon 3\n", - "adding: mem time235, current time 237, horizon 2\n", - "adding: mem time236, current time 237, horizon 1\n", - "adding: mem time200, current time 238, horizon 38\n", - "adding: mem time201, current time 238, horizon 37\n", - "adding: mem time202, current time 238, horizon 36\n", - "adding: mem time203, current time 238, horizon 35\n", - "adding: mem time204, current time 238, horizon 34\n", - "adding: mem time205, current time 238, horizon 33\n", - "adding: mem time206, current time 238, horizon 32\n", - "adding: mem time207, current time 238, horizon 31\n", - "adding: mem time208, current time 238, horizon 30\n", - "adding: mem time209, current time 238, horizon 29\n", - "adding: mem time210, current time 238, horizon 28\n", - "adding: mem time211, current time 238, horizon 27\n", - "adding: mem time212, current time 238, horizon 26\n", - "adding: mem time213, current time 238, horizon 25\n", - "adding: mem time214, current time 238, horizon 24\n", - "adding: mem time215, current time 238, horizon 23\n", - "adding: mem time216, current time 238, horizon 22\n", - "adding: mem time217, current time 238, horizon 21\n", - "adding: mem time218, current time 238, horizon 20\n", - "adding: mem time219, current time 238, horizon 19\n", - "adding: mem time220, current time 238, horizon 18\n", - "adding: mem time221, current time 238, horizon 17\n", - "adding: mem time222, current time 238, horizon 16\n", - "adding: mem time223, current time 238, horizon 15\n", - "adding: mem time224, current time 238, horizon 14\n", - "adding: mem time225, current time 238, horizon 13\n", - "adding: mem time226, current time 238, horizon 12\n", - "adding: mem time227, current time 238, horizon 11\n", - "adding: mem time228, current time 238, horizon 10\n", - "adding: mem time229, current time 238, horizon 9\n", - "adding: mem time230, current time 238, horizon 8\n", - "adding: mem time231, current time 238, horizon 7\n", - "adding: mem time232, current time 238, horizon 6\n", - "adding: mem time233, current time 238, horizon 5\n", - "adding: mem time234, current time 238, horizon 4\n", - "adding: mem time235, current time 238, horizon 3\n", - "adding: mem time236, current time 238, horizon 2\n", - "adding: mem time237, current time 238, horizon 1\n", - "adding: mem time200, current time 239, horizon 39\n", - "adding: mem time201, current time 239, horizon 38\n", - "adding: mem time202, current time 239, horizon 37\n", - "adding: mem time203, current time 239, horizon 36\n", - "adding: mem time204, current time 239, horizon 35\n", - "adding: mem time205, current time 239, horizon 34\n", - "adding: mem time206, current time 239, horizon 33\n", - "adding: mem time207, current time 239, horizon 32\n", - "adding: mem time208, current time 239, horizon 31\n", - "adding: mem time209, current time 239, horizon 30\n", - "adding: mem time210, current time 239, horizon 29\n", - "adding: mem time211, current time 239, horizon 28\n", - "adding: mem time212, current time 239, horizon 27\n", - "adding: mem time213, current time 239, horizon 26\n", - "adding: mem time214, current time 239, horizon 25\n", - "adding: mem time215, current time 239, horizon 24\n", - "adding: mem time216, current time 239, horizon 23\n", - "adding: mem time217, current time 239, horizon 22\n", - "adding: mem time218, current time 239, horizon 21\n", - "adding: mem time219, current time 239, horizon 20\n", - "adding: mem time220, current time 239, horizon 19\n", - "adding: mem time221, current time 239, horizon 18\n", - "adding: mem time222, current time 239, horizon 17\n", - "adding: mem time223, current time 239, horizon 16\n", - "adding: mem time224, current time 239, horizon 15\n", - "adding: mem time225, current time 239, horizon 14\n", - "adding: mem time226, current time 239, horizon 13\n", - "adding: mem time227, current time 239, horizon 12\n", - "adding: mem time228, current time 239, horizon 11\n", - "adding: mem time229, current time 239, horizon 10\n", - "adding: mem time230, current time 239, horizon 9\n", - "adding: mem time231, current time 239, horizon 8\n", - "adding: mem time232, current time 239, horizon 7\n", - "adding: mem time233, current time 239, horizon 6\n", - "adding: mem time234, current time 239, horizon 5\n", - "adding: mem time235, current time 239, horizon 4\n", - "adding: mem time236, current time 239, horizon 3\n", - "adding: mem time237, current time 239, horizon 2\n", - "adding: mem time238, current time 239, horizon 1\n", - "adding: mem time200, current time 240, horizon 40\n", - "adding: mem time201, current time 240, horizon 39\n", - "adding: mem time202, current time 240, horizon 38\n", - "adding: mem time203, current time 240, horizon 37\n", - "adding: mem time204, current time 240, horizon 36\n", - "adding: mem time205, current time 240, horizon 35\n", - "adding: mem time206, current time 240, horizon 34\n", - "adding: mem time207, current time 240, horizon 33\n", - "adding: mem time208, current time 240, horizon 32\n", - "adding: mem time209, current time 240, horizon 31\n", - "adding: mem time210, current time 240, horizon 30\n", - "adding: mem time211, current time 240, horizon 29\n", - "adding: mem time212, current time 240, horizon 28\n", - "adding: mem time213, current time 240, horizon 27\n", - "adding: mem time214, current time 240, horizon 26\n", - "adding: mem time215, current time 240, horizon 25\n", - "adding: mem time216, current time 240, horizon 24\n", - "adding: mem time217, current time 240, horizon 23\n", - "adding: mem time218, current time 240, horizon 22\n", - "adding: mem time219, current time 240, horizon 21\n", - "adding: mem time220, current time 240, horizon 20\n", - "adding: mem time221, current time 240, horizon 19\n", - "adding: mem time222, current time 240, horizon 18\n", - "adding: mem time223, current time 240, horizon 17\n", - "adding: mem time224, current time 240, horizon 16\n", - "adding: mem time225, current time 240, horizon 15\n", - "adding: mem time226, current time 240, horizon 14\n", - "adding: mem time227, current time 240, horizon 13\n", - "adding: mem time228, current time 240, horizon 12\n", - "adding: mem time229, current time 240, horizon 11\n", - "adding: mem time230, current time 240, horizon 10\n", - "adding: mem time231, current time 240, horizon 9\n", - "adding: mem time232, current time 240, horizon 8\n", - "adding: mem time233, current time 240, horizon 7\n", - "adding: mem time234, current time 240, horizon 6\n", - "adding: mem time235, current time 240, horizon 5\n", - "adding: mem time236, current time 240, horizon 4\n", - "adding: mem time237, current time 240, horizon 3\n", - "adding: mem time238, current time 240, horizon 2\n", - "adding: mem time239, current time 240, horizon 1\n", - "adding: mem time200, current time 241, horizon 41\n", - "adding: mem time201, current time 241, horizon 40\n", - "adding: mem time202, current time 241, horizon 39\n", - "adding: mem time203, current time 241, horizon 38\n", - "adding: mem time204, current time 241, horizon 37\n", - "adding: mem time205, current time 241, horizon 36\n", - "adding: mem time206, current time 241, horizon 35\n", - "adding: mem time207, current time 241, horizon 34\n", - "adding: mem time208, current time 241, horizon 33\n", - "adding: mem time209, current time 241, horizon 32\n", - "adding: mem time210, current time 241, horizon 31\n", - "adding: mem time211, current time 241, horizon 30\n", - "adding: mem time212, current time 241, horizon 29\n", - "adding: mem time213, current time 241, horizon 28\n", - "adding: mem time214, current time 241, horizon 27\n", - "adding: mem time215, current time 241, horizon 26\n", - "adding: mem time216, current time 241, horizon 25\n", - "adding: mem time217, current time 241, horizon 24\n", - "adding: mem time218, current time 241, horizon 23\n", - "adding: mem time219, current time 241, horizon 22\n", - "adding: mem time220, current time 241, horizon 21\n", - "adding: mem time221, current time 241, horizon 20\n", - "adding: mem time222, current time 241, horizon 19\n", - "adding: mem time223, current time 241, horizon 18\n", - "adding: mem time224, current time 241, horizon 17\n", - "adding: mem time225, current time 241, horizon 16\n", - "adding: mem time226, current time 241, horizon 15\n", - "adding: mem time227, current time 241, horizon 14\n", - "adding: mem time228, current time 241, horizon 13\n", - "adding: mem time229, current time 241, horizon 12\n", - "adding: mem time230, current time 241, horizon 11\n", - "adding: mem time231, current time 241, horizon 10\n", - "adding: mem time232, current time 241, horizon 9\n", - "adding: mem time233, current time 241, horizon 8\n", - "adding: mem time234, current time 241, horizon 7\n", - "adding: mem time235, current time 241, horizon 6\n", - "adding: mem time236, current time 241, horizon 5\n", - "adding: mem time237, current time 241, horizon 4\n", - "adding: mem time238, current time 241, horizon 3\n", - "adding: mem time239, current time 241, horizon 2\n", - "adding: mem time240, current time 241, horizon 1\n", - "adding: mem time200, current time 242, horizon 42\n", - "adding: mem time201, current time 242, horizon 41\n", - "adding: mem time202, current time 242, horizon 40\n", - "adding: mem time203, current time 242, horizon 39\n", - "adding: mem time204, current time 242, horizon 38\n", - "adding: mem time205, current time 242, horizon 37\n", - "adding: mem time206, current time 242, horizon 36\n", - "adding: mem time207, current time 242, horizon 35\n", - "adding: mem time208, current time 242, horizon 34\n", - "adding: mem time209, current time 242, horizon 33\n", - "adding: mem time210, current time 242, horizon 32\n", - "adding: mem time211, current time 242, horizon 31\n", - "adding: mem time212, current time 242, horizon 30\n", - "adding: mem time213, current time 242, horizon 29\n", - "adding: mem time214, current time 242, horizon 28\n", - "adding: mem time215, current time 242, horizon 27\n", - "adding: mem time216, current time 242, horizon 26\n", - "adding: mem time217, current time 242, horizon 25\n", - "adding: mem time218, current time 242, horizon 24\n", - "adding: mem time219, current time 242, horizon 23\n", - "adding: mem time220, current time 242, horizon 22\n", - "adding: mem time221, current time 242, horizon 21\n", - "adding: mem time222, current time 242, horizon 20\n", - "adding: mem time223, current time 242, horizon 19\n", - "adding: mem time224, current time 242, horizon 18\n", - "adding: mem time225, current time 242, horizon 17\n", - "adding: mem time226, current time 242, horizon 16\n", - "adding: mem time227, current time 242, horizon 15\n", - "adding: mem time228, current time 242, horizon 14\n", - "adding: mem time229, current time 242, horizon 13\n", - "adding: mem time230, current time 242, horizon 12\n", - "adding: mem time231, current time 242, horizon 11\n", - "adding: mem time232, current time 242, horizon 10\n", - "adding: mem time233, current time 242, horizon 9\n", - "adding: mem time234, current time 242, horizon 8\n", - "adding: mem time235, current time 242, horizon 7\n", - "adding: mem time236, current time 242, horizon 6\n", - "adding: mem time237, current time 242, horizon 5\n", - "adding: mem time238, current time 242, horizon 4\n", - "adding: mem time239, current time 242, horizon 3\n", - "adding: mem time240, current time 242, horizon 2\n", - "adding: mem time241, current time 242, horizon 1\n", - "adding: mem time200, current time 243, horizon 43\n", - "adding: mem time201, current time 243, horizon 42\n", - "adding: mem time202, current time 243, horizon 41\n", - "adding: mem time203, current time 243, horizon 40\n", - "adding: mem time204, current time 243, horizon 39\n", - "adding: mem time205, current time 243, horizon 38\n", - "adding: mem time206, current time 243, horizon 37\n", - "adding: mem time207, current time 243, horizon 36\n", - "adding: mem time208, current time 243, horizon 35\n", - "adding: mem time209, current time 243, horizon 34\n", - "adding: mem time210, current time 243, horizon 33\n", - "adding: mem time211, current time 243, horizon 32\n", - "adding: mem time212, current time 243, horizon 31\n", - "adding: mem time213, current time 243, horizon 30\n", - "adding: mem time214, current time 243, horizon 29\n", - "adding: mem time215, current time 243, horizon 28\n", - "adding: mem time216, current time 243, horizon 27\n", - "adding: mem time217, current time 243, horizon 26\n", - "adding: mem time218, current time 243, horizon 25\n", - "adding: mem time219, current time 243, horizon 24\n", - "adding: mem time220, current time 243, horizon 23\n", - "adding: mem time221, current time 243, horizon 22\n", - "adding: mem time222, current time 243, horizon 21\n", - "adding: mem time223, current time 243, horizon 20\n", - "adding: mem time224, current time 243, horizon 19\n", - "adding: mem time225, current time 243, horizon 18\n", - "adding: mem time226, current time 243, horizon 17\n", - "adding: mem time227, current time 243, horizon 16\n", - "adding: mem time228, current time 243, horizon 15\n", - "adding: mem time229, current time 243, horizon 14\n", - "adding: mem time230, current time 243, horizon 13\n", - "adding: mem time231, current time 243, horizon 12\n", - "adding: mem time232, current time 243, horizon 11\n", - "adding: mem time233, current time 243, horizon 10\n", - "adding: mem time234, current time 243, horizon 9\n", - "adding: mem time235, current time 243, horizon 8\n", - "adding: mem time236, current time 243, horizon 7\n", - "adding: mem time237, current time 243, horizon 6\n", - "adding: mem time238, current time 243, horizon 5\n", - "adding: mem time239, current time 243, horizon 4\n", - "adding: mem time240, current time 243, horizon 3\n", - "adding: mem time241, current time 243, horizon 2\n", - "adding: mem time242, current time 243, horizon 1\n", - "adding: mem time200, current time 244, horizon 44\n", - "adding: mem time201, current time 244, horizon 43\n", - "adding: mem time202, current time 244, horizon 42\n", - "adding: mem time203, current time 244, horizon 41\n", - "adding: mem time204, current time 244, horizon 40\n", - "adding: mem time205, current time 244, horizon 39\n", - "adding: mem time206, current time 244, horizon 38\n", - "adding: mem time207, current time 244, horizon 37\n", - "adding: mem time208, current time 244, horizon 36\n", - "adding: mem time209, current time 244, horizon 35\n", - "adding: mem time210, current time 244, horizon 34\n", - "adding: mem time211, current time 244, horizon 33\n", - "adding: mem time212, current time 244, horizon 32\n", - "adding: mem time213, current time 244, horizon 31\n", - "adding: mem time214, current time 244, horizon 30\n", - "adding: mem time215, current time 244, horizon 29\n", - "adding: mem time216, current time 244, horizon 28\n", - "adding: mem time217, current time 244, horizon 27\n", - "adding: mem time218, current time 244, horizon 26\n", - "adding: mem time219, current time 244, horizon 25\n", - "adding: mem time220, current time 244, horizon 24\n", - "adding: mem time221, current time 244, horizon 23\n", - "adding: mem time222, current time 244, horizon 22\n", - "adding: mem time223, current time 244, horizon 21\n", - "adding: mem time224, current time 244, horizon 20\n", - "adding: mem time225, current time 244, horizon 19\n", - "adding: mem time226, current time 244, horizon 18\n", - "adding: mem time227, current time 244, horizon 17\n", - "adding: mem time228, current time 244, horizon 16\n", - "adding: mem time229, current time 244, horizon 15\n", - "adding: mem time230, current time 244, horizon 14\n", - "adding: mem time231, current time 244, horizon 13\n", - "adding: mem time232, current time 244, horizon 12\n", - "adding: mem time233, current time 244, horizon 11\n", - "adding: mem time234, current time 244, horizon 10\n", - "adding: mem time235, current time 244, horizon 9\n", - "adding: mem time236, current time 244, horizon 8\n", - "adding: mem time237, current time 244, horizon 7\n", - "adding: mem time238, current time 244, horizon 6\n", - "adding: mem time239, current time 244, horizon 5\n", - "adding: mem time240, current time 244, horizon 4\n", - "adding: mem time241, current time 244, horizon 3\n", - "adding: mem time242, current time 244, horizon 2\n", - "adding: mem time243, current time 244, horizon 1\n", - "adding: mem time200, current time 245, horizon 45\n", - "adding: mem time201, current time 245, horizon 44\n", - "adding: mem time202, current time 245, horizon 43\n", - "adding: mem time203, current time 245, horizon 42\n", - "adding: mem time204, current time 245, horizon 41\n", - "adding: mem time205, current time 245, horizon 40\n", - "adding: mem time206, current time 245, horizon 39\n", - "adding: mem time207, current time 245, horizon 38\n", - "adding: mem time208, current time 245, horizon 37\n", - "adding: mem time209, current time 245, horizon 36\n", - "adding: mem time210, current time 245, horizon 35\n", - "adding: mem time211, current time 245, horizon 34\n", - "adding: mem time212, current time 245, horizon 33\n", - "adding: mem time213, current time 245, horizon 32\n", - "adding: mem time214, current time 245, horizon 31\n", - "adding: mem time215, current time 245, horizon 30\n", - "adding: mem time216, current time 245, horizon 29\n", - "adding: mem time217, current time 245, horizon 28\n", - "adding: mem time218, current time 245, horizon 27\n", - "adding: mem time219, current time 245, horizon 26\n", - "adding: mem time220, current time 245, horizon 25\n", - "adding: mem time221, current time 245, horizon 24\n", - "adding: mem time222, current time 245, horizon 23\n", - "adding: mem time223, current time 245, horizon 22\n", - "adding: mem time224, current time 245, horizon 21\n", - "adding: mem time225, current time 245, horizon 20\n", - "adding: mem time226, current time 245, horizon 19\n", - "adding: mem time227, current time 245, horizon 18\n", - "adding: mem time228, current time 245, horizon 17\n", - "adding: mem time229, current time 245, horizon 16\n", - "adding: mem time230, current time 245, horizon 15\n", - "adding: mem time231, current time 245, horizon 14\n", - "adding: mem time232, current time 245, horizon 13\n", - "adding: mem time233, current time 245, horizon 12\n", - "adding: mem time234, current time 245, horizon 11\n", - "adding: mem time235, current time 245, horizon 10\n", - "adding: mem time236, current time 245, horizon 9\n", - "adding: mem time237, current time 245, horizon 8\n", - "adding: mem time238, current time 245, horizon 7\n", - "adding: mem time239, current time 245, horizon 6\n", - "adding: mem time240, current time 245, horizon 5\n", - "adding: mem time241, current time 245, horizon 4\n", - "adding: mem time242, current time 245, horizon 3\n", - "adding: mem time243, current time 245, horizon 2\n", - "adding: mem time244, current time 245, horizon 1\n", - "adding: mem time200, current time 246, horizon 46\n", - "adding: mem time201, current time 246, horizon 45\n", - "adding: mem time202, current time 246, horizon 44\n", - "adding: mem time203, current time 246, horizon 43\n", - "adding: mem time204, current time 246, horizon 42\n", - "adding: mem time205, current time 246, horizon 41\n", - "adding: mem time206, current time 246, horizon 40\n", - "adding: mem time207, current time 246, horizon 39\n", - "adding: mem time208, current time 246, horizon 38\n", - "adding: mem time209, current time 246, horizon 37\n", - "adding: mem time210, current time 246, horizon 36\n", - "adding: mem time211, current time 246, horizon 35\n", - "adding: mem time212, current time 246, horizon 34\n", - "adding: mem time213, current time 246, horizon 33\n", - "adding: mem time214, current time 246, horizon 32\n", - "adding: mem time215, current time 246, horizon 31\n", - "adding: mem time216, current time 246, horizon 30\n", - "adding: mem time217, current time 246, horizon 29\n", - "adding: mem time218, current time 246, horizon 28\n", - "adding: mem time219, current time 246, horizon 27\n", - "adding: mem time220, current time 246, horizon 26\n", - "adding: mem time221, current time 246, horizon 25\n", - "adding: mem time222, current time 246, horizon 24\n", - "adding: mem time223, current time 246, horizon 23\n", - "adding: mem time224, current time 246, horizon 22\n", - "adding: mem time225, current time 246, horizon 21\n", - "adding: mem time226, current time 246, horizon 20\n", - "adding: mem time227, current time 246, horizon 19\n", - "adding: mem time228, current time 246, horizon 18\n", - "adding: mem time229, current time 246, horizon 17\n", - "adding: mem time230, current time 246, horizon 16\n", - "adding: mem time231, current time 246, horizon 15\n", - "adding: mem time232, current time 246, horizon 14\n", - "adding: mem time233, current time 246, horizon 13\n", - "adding: mem time234, current time 246, horizon 12\n", - "adding: mem time235, current time 246, horizon 11\n", - "adding: mem time236, current time 246, horizon 10\n", - "adding: mem time237, current time 246, horizon 9\n", - "adding: mem time238, current time 246, horizon 8\n", - "adding: mem time239, current time 246, horizon 7\n", - "adding: mem time240, current time 246, horizon 6\n", - "adding: mem time241, current time 246, horizon 5\n", - "adding: mem time242, current time 246, horizon 4\n", - "adding: mem time243, current time 246, horizon 3\n", - "adding: mem time244, current time 246, horizon 2\n", - "adding: mem time245, current time 246, horizon 1\n", - "adding: mem time200, current time 247, horizon 47\n", - "adding: mem time201, current time 247, horizon 46\n", - "adding: mem time202, current time 247, horizon 45\n", - "adding: mem time203, current time 247, horizon 44\n", - "adding: mem time204, current time 247, horizon 43\n", - "adding: mem time205, current time 247, horizon 42\n", - "adding: mem time206, current time 247, horizon 41\n", - "adding: mem time207, current time 247, horizon 40\n", - "adding: mem time208, current time 247, horizon 39\n", - "adding: mem time209, current time 247, horizon 38\n", - "adding: mem time210, current time 247, horizon 37\n", - "adding: mem time211, current time 247, horizon 36\n", - "adding: mem time212, current time 247, horizon 35\n", - "adding: mem time213, current time 247, horizon 34\n", - "adding: mem time214, current time 247, horizon 33\n", - "adding: mem time215, current time 247, horizon 32\n", - "adding: mem time216, current time 247, horizon 31\n", - "adding: mem time217, current time 247, horizon 30\n", - "adding: mem time218, current time 247, horizon 29\n", - "adding: mem time219, current time 247, horizon 28\n", - "adding: mem time220, current time 247, horizon 27\n", - "adding: mem time221, current time 247, horizon 26\n", - "adding: mem time222, current time 247, horizon 25\n", - "adding: mem time223, current time 247, horizon 24\n", - "adding: mem time224, current time 247, horizon 23\n", - "adding: mem time225, current time 247, horizon 22\n", - "adding: mem time226, current time 247, horizon 21\n", - "adding: mem time227, current time 247, horizon 20\n", - "adding: mem time228, current time 247, horizon 19\n", - "adding: mem time229, current time 247, horizon 18\n", - "adding: mem time230, current time 247, horizon 17\n", - "adding: mem time231, current time 247, horizon 16\n", - "adding: mem time232, current time 247, horizon 15\n", - "adding: mem time233, current time 247, horizon 14\n", - "adding: mem time234, current time 247, horizon 13\n", - "adding: mem time235, current time 247, horizon 12\n", - "adding: mem time236, current time 247, horizon 11\n", - "adding: mem time237, current time 247, horizon 10\n", - "adding: mem time238, current time 247, horizon 9\n", - "adding: mem time239, current time 247, horizon 8\n", - "adding: mem time240, current time 247, horizon 7\n", - "adding: mem time241, current time 247, horizon 6\n", - "adding: mem time242, current time 247, horizon 5\n", - "adding: mem time243, current time 247, horizon 4\n", - "adding: mem time244, current time 247, horizon 3\n", - "adding: mem time245, current time 247, horizon 2\n", - "adding: mem time246, current time 247, horizon 1\n", - "adding: mem time200, current time 248, horizon 48\n", - "adding: mem time201, current time 248, horizon 47\n", - "adding: mem time202, current time 248, horizon 46\n", - "adding: mem time203, current time 248, horizon 45\n", - "adding: mem time204, current time 248, horizon 44\n", - "adding: mem time205, current time 248, horizon 43\n", - "adding: mem time206, current time 248, horizon 42\n", - "adding: mem time207, current time 248, horizon 41\n", - "adding: mem time208, current time 248, horizon 40\n", - "adding: mem time209, current time 248, horizon 39\n", - "adding: mem time210, current time 248, horizon 38\n", - "adding: mem time211, current time 248, horizon 37\n", - "adding: mem time212, current time 248, horizon 36\n", - "adding: mem time213, current time 248, horizon 35\n", - "adding: mem time214, current time 248, horizon 34\n", - "adding: mem time215, current time 248, horizon 33\n", - "adding: mem time216, current time 248, horizon 32\n", - "adding: mem time217, current time 248, horizon 31\n", - "adding: mem time218, current time 248, horizon 30\n", - "adding: mem time219, current time 248, horizon 29\n", - "adding: mem time220, current time 248, horizon 28\n", - "adding: mem time221, current time 248, horizon 27\n", - "adding: mem time222, current time 248, horizon 26\n", - "adding: mem time223, current time 248, horizon 25\n", - "adding: mem time224, current time 248, horizon 24\n", - "adding: mem time225, current time 248, horizon 23\n", - "adding: mem time226, current time 248, horizon 22\n", - "adding: mem time227, current time 248, horizon 21\n", - "adding: mem time228, current time 248, horizon 20\n", - "adding: mem time229, current time 248, horizon 19\n", - "adding: mem time230, current time 248, horizon 18\n", - "adding: mem time231, current time 248, horizon 17\n", - "adding: mem time232, current time 248, horizon 16\n", - "adding: mem time233, current time 248, horizon 15\n", - "adding: mem time234, current time 248, horizon 14\n", - "adding: mem time235, current time 248, horizon 13\n", - "adding: mem time236, current time 248, horizon 12\n", - "adding: mem time237, current time 248, horizon 11\n", - "adding: mem time238, current time 248, horizon 10\n", - "adding: mem time239, current time 248, horizon 9\n", - "adding: mem time240, current time 248, horizon 8\n", - "adding: mem time241, current time 248, horizon 7\n", - "adding: mem time242, current time 248, horizon 6\n", - "adding: mem time243, current time 248, horizon 5\n", - "adding: mem time244, current time 248, horizon 4\n", - "adding: mem time245, current time 248, horizon 3\n", - "adding: mem time246, current time 248, horizon 2\n", - "adding: mem time247, current time 248, horizon 1\n", - "adding: mem time200, current time 249, horizon 49\n", - "adding: mem time201, current time 249, horizon 48\n", - "adding: mem time202, current time 249, horizon 47\n", - "adding: mem time203, current time 249, horizon 46\n", - "adding: mem time204, current time 249, horizon 45\n", - "adding: mem time205, current time 249, horizon 44\n", - "adding: mem time206, current time 249, horizon 43\n", - "adding: mem time207, current time 249, horizon 42\n", - "adding: mem time208, current time 249, horizon 41\n", - "adding: mem time209, current time 249, horizon 40\n", - "adding: mem time210, current time 249, horizon 39\n", - "adding: mem time211, current time 249, horizon 38\n", - "adding: mem time212, current time 249, horizon 37\n", - "adding: mem time213, current time 249, horizon 36\n", - "adding: mem time214, current time 249, horizon 35\n", - "adding: mem time215, current time 249, horizon 34\n", - "adding: mem time216, current time 249, horizon 33\n", - "adding: mem time217, current time 249, horizon 32\n", - "adding: mem time218, current time 249, horizon 31\n", - "adding: mem time219, current time 249, horizon 30\n", - "adding: mem time220, current time 249, horizon 29\n", - "adding: mem time221, current time 249, horizon 28\n", - "adding: mem time222, current time 249, horizon 27\n", - "adding: mem time223, current time 249, horizon 26\n", - "adding: mem time224, current time 249, horizon 25\n", - "adding: mem time225, current time 249, horizon 24\n", - "adding: mem time226, current time 249, horizon 23\n", - "adding: mem time227, current time 249, horizon 22\n", - "adding: mem time228, current time 249, horizon 21\n", - "adding: mem time229, current time 249, horizon 20\n", - "adding: mem time230, current time 249, horizon 19\n", - "adding: mem time231, current time 249, horizon 18\n", - "adding: mem time232, current time 249, horizon 17\n", - "adding: mem time233, current time 249, horizon 16\n", - "adding: mem time234, current time 249, horizon 15\n", - "adding: mem time235, current time 249, horizon 14\n", - "adding: mem time236, current time 249, horizon 13\n", - "adding: mem time237, current time 249, horizon 12\n", - "adding: mem time238, current time 249, horizon 11\n", - "adding: mem time239, current time 249, horizon 10\n", - "adding: mem time240, current time 249, horizon 9\n", - "adding: mem time241, current time 249, horizon 8\n", - "adding: mem time242, current time 249, horizon 7\n", - "adding: mem time243, current time 249, horizon 6\n", - "adding: mem time244, current time 249, horizon 5\n", - "adding: mem time245, current time 249, horizon 4\n", - "adding: mem time246, current time 249, horizon 3\n", - "adding: mem time247, current time 249, horizon 2\n", - "adding: mem time248, current time 249, horizon 1\n", - "adding: mem time200, current time 250, horizon 50\n", - "adding: mem time201, current time 250, horizon 49\n", - "adding: mem time202, current time 250, horizon 48\n", - "adding: mem time203, current time 250, horizon 47\n", - "adding: mem time204, current time 250, horizon 46\n", - "adding: mem time205, current time 250, horizon 45\n", - "adding: mem time206, current time 250, horizon 44\n", - "adding: mem time207, current time 250, horizon 43\n", - "adding: mem time208, current time 250, horizon 42\n", - "adding: mem time209, current time 250, horizon 41\n", - "adding: mem time210, current time 250, horizon 40\n", - "adding: mem time211, current time 250, horizon 39\n", - "adding: mem time212, current time 250, horizon 38\n", - "adding: mem time213, current time 250, horizon 37\n", - "adding: mem time214, current time 250, horizon 36\n", - "adding: mem time215, current time 250, horizon 35\n", - "adding: mem time216, current time 250, horizon 34\n", - "adding: mem time217, current time 250, horizon 33\n", - "adding: mem time218, current time 250, horizon 32\n", - "adding: mem time219, current time 250, horizon 31\n", - "adding: mem time220, current time 250, horizon 30\n", - "adding: mem time221, current time 250, horizon 29\n", - "adding: mem time222, current time 250, horizon 28\n", - "adding: mem time223, current time 250, horizon 27\n", - "adding: mem time224, current time 250, horizon 26\n", - "adding: mem time225, current time 250, horizon 25\n", - "adding: mem time226, current time 250, horizon 24\n", - "adding: mem time227, current time 250, horizon 23\n", - "adding: mem time228, current time 250, horizon 22\n", - "adding: mem time229, current time 250, horizon 21\n", - "adding: mem time230, current time 250, horizon 20\n", - "adding: mem time231, current time 250, horizon 19\n", - "adding: mem time232, current time 250, horizon 18\n", - "adding: mem time233, current time 250, horizon 17\n", - "adding: mem time234, current time 250, horizon 16\n", - "adding: mem time235, current time 250, horizon 15\n", - "adding: mem time236, current time 250, horizon 14\n", - "adding: mem time237, current time 250, horizon 13\n", - "adding: mem time238, current time 250, horizon 12\n", - "adding: mem time239, current time 250, horizon 11\n", - "adding: mem time240, current time 250, horizon 10\n", - "adding: mem time241, current time 250, horizon 9\n", - "adding: mem time242, current time 250, horizon 8\n", - "adding: mem time243, current time 250, horizon 7\n", - "adding: mem time244, current time 250, horizon 6\n", - "adding: mem time245, current time 250, horizon 5\n", - "adding: mem time246, current time 250, horizon 4\n", - "adding: mem time247, current time 250, horizon 3\n", - "adding: mem time248, current time 250, horizon 2\n", - "adding: mem time249, current time 250, horizon 1\n", - "adding: mem time200, current time 251, horizon 51\n", - "adding: mem time201, current time 251, horizon 50\n", - "adding: mem time202, current time 251, horizon 49\n", - "adding: mem time203, current time 251, horizon 48\n", - "adding: mem time204, current time 251, horizon 47\n", - "adding: mem time205, current time 251, horizon 46\n", - "adding: mem time206, current time 251, horizon 45\n", - "adding: mem time207, current time 251, horizon 44\n", - "adding: mem time208, current time 251, horizon 43\n", - "adding: mem time209, current time 251, horizon 42\n", - "adding: mem time210, current time 251, horizon 41\n", - "adding: mem time211, current time 251, horizon 40\n", - "adding: mem time212, current time 251, horizon 39\n", - "adding: mem time213, current time 251, horizon 38\n", - "adding: mem time214, current time 251, horizon 37\n", - "adding: mem time215, current time 251, horizon 36\n", - "adding: mem time216, current time 251, horizon 35\n", - "adding: mem time217, current time 251, horizon 34\n", - "adding: mem time218, current time 251, horizon 33\n", - "adding: mem time219, current time 251, horizon 32\n", - "adding: mem time220, current time 251, horizon 31\n", - "adding: mem time221, current time 251, horizon 30\n", - "adding: mem time222, current time 251, horizon 29\n", - "adding: mem time223, current time 251, horizon 28\n", - "adding: mem time224, current time 251, horizon 27\n", - "adding: mem time225, current time 251, horizon 26\n", - "adding: mem time226, current time 251, horizon 25\n", - "adding: mem time227, current time 251, horizon 24\n", - "adding: mem time228, current time 251, horizon 23\n", - "adding: mem time229, current time 251, horizon 22\n", - "adding: mem time230, current time 251, horizon 21\n", - "adding: mem time231, current time 251, horizon 20\n", - "adding: mem time232, current time 251, horizon 19\n", - "adding: mem time233, current time 251, horizon 18\n", - "adding: mem time234, current time 251, horizon 17\n", - "adding: mem time235, current time 251, horizon 16\n", - "adding: mem time236, current time 251, horizon 15\n", - "adding: mem time237, current time 251, horizon 14\n", - "adding: mem time238, current time 251, horizon 13\n", - "adding: mem time239, current time 251, horizon 12\n", - "adding: mem time240, current time 251, horizon 11\n", - "adding: mem time241, current time 251, horizon 10\n", - "adding: mem time242, current time 251, horizon 9\n", - "adding: mem time243, current time 251, horizon 8\n", - "adding: mem time244, current time 251, horizon 7\n", - "adding: mem time245, current time 251, horizon 6\n", - "adding: mem time246, current time 251, horizon 5\n", - "adding: mem time247, current time 251, horizon 4\n", - "adding: mem time248, current time 251, horizon 3\n", - "adding: mem time249, current time 251, horizon 2\n", - "adding: mem time250, current time 251, horizon 1\n", - "adding: mem time200, current time 252, horizon 52\n", - "adding: mem time201, current time 252, horizon 51\n", - "adding: mem time202, current time 252, horizon 50\n", - "adding: mem time203, current time 252, horizon 49\n", - "adding: mem time204, current time 252, horizon 48\n", - "adding: mem time205, current time 252, horizon 47\n", - "adding: mem time206, current time 252, horizon 46\n", - "adding: mem time207, current time 252, horizon 45\n", - "adding: mem time208, current time 252, horizon 44\n", - "adding: mem time209, current time 252, horizon 43\n", - "adding: mem time210, current time 252, horizon 42\n", - "adding: mem time211, current time 252, horizon 41\n", - "adding: mem time212, current time 252, horizon 40\n", - "adding: mem time213, current time 252, horizon 39\n", - "adding: mem time214, current time 252, horizon 38\n", - "adding: mem time215, current time 252, horizon 37\n", - "adding: mem time216, current time 252, horizon 36\n", - "adding: mem time217, current time 252, horizon 35\n", - "adding: mem time218, current time 252, horizon 34\n", - "adding: mem time219, current time 252, horizon 33\n", - "adding: mem time220, current time 252, horizon 32\n", - "adding: mem time221, current time 252, horizon 31\n", - "adding: mem time222, current time 252, horizon 30\n", - "adding: mem time223, current time 252, horizon 29\n", - "adding: mem time224, current time 252, horizon 28\n", - "adding: mem time225, current time 252, horizon 27\n", - "adding: mem time226, current time 252, horizon 26\n", - "adding: mem time227, current time 252, horizon 25\n", - "adding: mem time228, current time 252, horizon 24\n", - "adding: mem time229, current time 252, horizon 23\n", - "adding: mem time230, current time 252, horizon 22\n", - "adding: mem time231, current time 252, horizon 21\n", - "adding: mem time232, current time 252, horizon 20\n", - "adding: mem time233, current time 252, horizon 19\n", - "adding: mem time234, current time 252, horizon 18\n", - "adding: mem time235, current time 252, horizon 17\n", - "adding: mem time236, current time 252, horizon 16\n", - "adding: mem time237, current time 252, horizon 15\n", - "adding: mem time238, current time 252, horizon 14\n", - "adding: mem time239, current time 252, horizon 13\n", - "adding: mem time240, current time 252, horizon 12\n", - "adding: mem time241, current time 252, horizon 11\n", - "adding: mem time242, current time 252, horizon 10\n", - "adding: mem time243, current time 252, horizon 9\n", - "adding: mem time244, current time 252, horizon 8\n", - "adding: mem time245, current time 252, horizon 7\n", - "adding: mem time246, current time 252, horizon 6\n", - "adding: mem time247, current time 252, horizon 5\n", - "adding: mem time248, current time 252, horizon 4\n", - "adding: mem time249, current time 252, horizon 3\n", - "adding: mem time250, current time 252, horizon 2\n", - "adding: mem time251, current time 252, horizon 1\n", - "adding: mem time200, current time 253, horizon 53\n", - "adding: mem time201, current time 253, horizon 52\n", - "adding: mem time202, current time 253, horizon 51\n", - "adding: mem time203, current time 253, horizon 50\n", - "adding: mem time204, current time 253, horizon 49\n", - "adding: mem time205, current time 253, horizon 48\n", - "adding: mem time206, current time 253, horizon 47\n", - "adding: mem time207, current time 253, horizon 46\n", - "adding: mem time208, current time 253, horizon 45\n", - "adding: mem time209, current time 253, horizon 44\n", - "adding: mem time210, current time 253, horizon 43\n", - "adding: mem time211, current time 253, horizon 42\n", - "adding: mem time212, current time 253, horizon 41\n", - "adding: mem time213, current time 253, horizon 40\n", - "adding: mem time214, current time 253, horizon 39\n", - "adding: mem time215, current time 253, horizon 38\n", - "adding: mem time216, current time 253, horizon 37\n", - "adding: mem time217, current time 253, horizon 36\n", - "adding: mem time218, current time 253, horizon 35\n", - "adding: mem time219, current time 253, horizon 34\n", - "adding: mem time220, current time 253, horizon 33\n", - "adding: mem time221, current time 253, horizon 32\n", - "adding: mem time222, current time 253, horizon 31\n", - "adding: mem time223, current time 253, horizon 30\n", - "adding: mem time224, current time 253, horizon 29\n", - "adding: mem time225, current time 253, horizon 28\n", - "adding: mem time226, current time 253, horizon 27\n", - "adding: mem time227, current time 253, horizon 26\n", - "adding: mem time228, current time 253, horizon 25\n", - "adding: mem time229, current time 253, horizon 24\n", - "adding: mem time230, current time 253, horizon 23\n", - "adding: mem time231, current time 253, horizon 22\n", - "adding: mem time232, current time 253, horizon 21\n", - "adding: mem time233, current time 253, horizon 20\n", - "adding: mem time234, current time 253, horizon 19\n", - "adding: mem time235, current time 253, horizon 18\n", - "adding: mem time236, current time 253, horizon 17\n", - "adding: mem time237, current time 253, horizon 16\n", - "adding: mem time238, current time 253, horizon 15\n", - "adding: mem time239, current time 253, horizon 14\n", - "adding: mem time240, current time 253, horizon 13\n", - "adding: mem time241, current time 253, horizon 12\n", - "adding: mem time242, current time 253, horizon 11\n", - "adding: mem time243, current time 253, horizon 10\n", - "adding: mem time244, current time 253, horizon 9\n", - "adding: mem time245, current time 253, horizon 8\n", - "adding: mem time246, current time 253, horizon 7\n", - "adding: mem time247, current time 253, horizon 6\n", - "adding: mem time248, current time 253, horizon 5\n", - "adding: mem time249, current time 253, horizon 4\n", - "adding: mem time250, current time 253, horizon 3\n", - "adding: mem time251, current time 253, horizon 2\n", - "adding: mem time252, current time 253, horizon 1\n", - "adding: mem time200, current time 254, horizon 54\n", - "adding: mem time201, current time 254, horizon 53\n", - "adding: mem time202, current time 254, horizon 52\n", - "adding: mem time203, current time 254, horizon 51\n", - "adding: mem time204, current time 254, horizon 50\n", - "adding: mem time205, current time 254, horizon 49\n", - "adding: mem time206, current time 254, horizon 48\n", - "adding: mem time207, current time 254, horizon 47\n", - "adding: mem time208, current time 254, horizon 46\n", - "adding: mem time209, current time 254, horizon 45\n", - "adding: mem time210, current time 254, horizon 44\n", - "adding: mem time211, current time 254, horizon 43\n", - "adding: mem time212, current time 254, horizon 42\n", - "adding: mem time213, current time 254, horizon 41\n", - "adding: mem time214, current time 254, horizon 40\n", - "adding: mem time215, current time 254, horizon 39\n", - "adding: mem time216, current time 254, horizon 38\n", - "adding: mem time217, current time 254, horizon 37\n", - "adding: mem time218, current time 254, horizon 36\n", - "adding: mem time219, current time 254, horizon 35\n", - "adding: mem time220, current time 254, horizon 34\n", - "adding: mem time221, current time 254, horizon 33\n", - "adding: mem time222, current time 254, horizon 32\n", - "adding: mem time223, current time 254, horizon 31\n", - "adding: mem time224, current time 254, horizon 30\n", - "adding: mem time225, current time 254, horizon 29\n", - "adding: mem time226, current time 254, horizon 28\n", - "adding: mem time227, current time 254, horizon 27\n", - "adding: mem time228, current time 254, horizon 26\n", - "adding: mem time229, current time 254, horizon 25\n", - "adding: mem time230, current time 254, horizon 24\n", - "adding: mem time231, current time 254, horizon 23\n", - "adding: mem time232, current time 254, horizon 22\n", - "adding: mem time233, current time 254, horizon 21\n", - "adding: mem time234, current time 254, horizon 20\n", - "adding: mem time235, current time 254, horizon 19\n", - "adding: mem time236, current time 254, horizon 18\n", - "adding: mem time237, current time 254, horizon 17\n", - "adding: mem time238, current time 254, horizon 16\n", - "adding: mem time239, current time 254, horizon 15\n", - "adding: mem time240, current time 254, horizon 14\n", - "adding: mem time241, current time 254, horizon 13\n", - "adding: mem time242, current time 254, horizon 12\n", - "adding: mem time243, current time 254, horizon 11\n", - "adding: mem time244, current time 254, horizon 10\n", - "adding: mem time245, current time 254, horizon 9\n", - "adding: mem time246, current time 254, horizon 8\n", - "adding: mem time247, current time 254, horizon 7\n", - "adding: mem time248, current time 254, horizon 6\n", - "adding: mem time249, current time 254, horizon 5\n", - "adding: mem time250, current time 254, horizon 4\n", - "adding: mem time251, current time 254, horizon 3\n", - "adding: mem time252, current time 254, horizon 2\n", - "adding: mem time253, current time 254, horizon 1\n", - "adding: mem time200, current time 255, horizon 55\n", - "adding: mem time201, current time 255, horizon 54\n", - "adding: mem time202, current time 255, horizon 53\n", - "adding: mem time203, current time 255, horizon 52\n", - "adding: mem time204, current time 255, horizon 51\n", - "adding: mem time205, current time 255, horizon 50\n", - "adding: mem time206, current time 255, horizon 49\n", - "adding: mem time207, current time 255, horizon 48\n", - "adding: mem time208, current time 255, horizon 47\n", - "adding: mem time209, current time 255, horizon 46\n", - "adding: mem time210, current time 255, horizon 45\n", - "adding: mem time211, current time 255, horizon 44\n", - "adding: mem time212, current time 255, horizon 43\n", - "adding: mem time213, current time 255, horizon 42\n", - "adding: mem time214, current time 255, horizon 41\n", - "adding: mem time215, current time 255, horizon 40\n", - "adding: mem time216, current time 255, horizon 39\n", - "adding: mem time217, current time 255, horizon 38\n", - "adding: mem time218, current time 255, horizon 37\n", - "adding: mem time219, current time 255, horizon 36\n", - "adding: mem time220, current time 255, horizon 35\n", - "adding: mem time221, current time 255, horizon 34\n", - "adding: mem time222, current time 255, horizon 33\n", - "adding: mem time223, current time 255, horizon 32\n", - "adding: mem time224, current time 255, horizon 31\n", - "adding: mem time225, current time 255, horizon 30\n", - "adding: mem time226, current time 255, horizon 29\n", - "adding: mem time227, current time 255, horizon 28\n", - "adding: mem time228, current time 255, horizon 27\n", - "adding: mem time229, current time 255, horizon 26\n", - "adding: mem time230, current time 255, horizon 25\n", - "adding: mem time231, current time 255, horizon 24\n", - "adding: mem time232, current time 255, horizon 23\n", - "adding: mem time233, current time 255, horizon 22\n", - "adding: mem time234, current time 255, horizon 21\n", - "adding: mem time235, current time 255, horizon 20\n", - "adding: mem time236, current time 255, horizon 19\n", - "adding: mem time237, current time 255, horizon 18\n", - "adding: mem time238, current time 255, horizon 17\n", - "adding: mem time239, current time 255, horizon 16\n", - "adding: mem time240, current time 255, horizon 15\n", - "adding: mem time241, current time 255, horizon 14\n", - "adding: mem time242, current time 255, horizon 13\n", - "adding: mem time243, current time 255, horizon 12\n", - "adding: mem time244, current time 255, horizon 11\n", - "adding: mem time245, current time 255, horizon 10\n", - "adding: mem time246, current time 255, horizon 9\n", - "adding: mem time247, current time 255, horizon 8\n", - "adding: mem time248, current time 255, horizon 7\n", - "adding: mem time249, current time 255, horizon 6\n", - "adding: mem time250, current time 255, horizon 5\n", - "adding: mem time251, current time 255, horizon 4\n", - "adding: mem time252, current time 255, horizon 3\n", - "adding: mem time253, current time 255, horizon 2\n", - "adding: mem time254, current time 255, horizon 1\n", - "adding: mem time200, current time 256, horizon 56\n", - "adding: mem time201, current time 256, horizon 55\n", - "adding: mem time202, current time 256, horizon 54\n", - "adding: mem time203, current time 256, horizon 53\n", - "adding: mem time204, current time 256, horizon 52\n", - "adding: mem time205, current time 256, horizon 51\n", - "adding: mem time206, current time 256, horizon 50\n", - "adding: mem time207, current time 256, horizon 49\n", - "adding: mem time208, current time 256, horizon 48\n", - "adding: mem time209, current time 256, horizon 47\n", - "adding: mem time210, current time 256, horizon 46\n", - "adding: mem time211, current time 256, horizon 45\n", - "adding: mem time212, current time 256, horizon 44\n", - "adding: mem time213, current time 256, horizon 43\n", - "adding: mem time214, current time 256, horizon 42\n", - "adding: mem time215, current time 256, horizon 41\n", - "adding: mem time216, current time 256, horizon 40\n", - "adding: mem time217, current time 256, horizon 39\n", - "adding: mem time218, current time 256, horizon 38\n", - "adding: mem time219, current time 256, horizon 37\n", - "adding: mem time220, current time 256, horizon 36\n", - "adding: mem time221, current time 256, horizon 35\n", - "adding: mem time222, current time 256, horizon 34\n", - "adding: mem time223, current time 256, horizon 33\n", - "adding: mem time224, current time 256, horizon 32\n", - "adding: mem time225, current time 256, horizon 31\n", - "adding: mem time226, current time 256, horizon 30\n", - "adding: mem time227, current time 256, horizon 29\n", - "adding: mem time228, current time 256, horizon 28\n", - "adding: mem time229, current time 256, horizon 27\n", - "adding: mem time230, current time 256, horizon 26\n", - "adding: mem time231, current time 256, horizon 25\n", - "adding: mem time232, current time 256, horizon 24\n", - "adding: mem time233, current time 256, horizon 23\n", - "adding: mem time234, current time 256, horizon 22\n", - "adding: mem time235, current time 256, horizon 21\n", - "adding: mem time236, current time 256, horizon 20\n", - "adding: mem time237, current time 256, horizon 19\n", - "adding: mem time238, current time 256, horizon 18\n", - "adding: mem time239, current time 256, horizon 17\n", - "adding: mem time240, current time 256, horizon 16\n", - "adding: mem time241, current time 256, horizon 15\n", - "adding: mem time242, current time 256, horizon 14\n", - "adding: mem time243, current time 256, horizon 13\n", - "adding: mem time244, current time 256, horizon 12\n", - "adding: mem time245, current time 256, horizon 11\n", - "adding: mem time246, current time 256, horizon 10\n", - "adding: mem time247, current time 256, horizon 9\n", - "adding: mem time248, current time 256, horizon 8\n", - "adding: mem time249, current time 256, horizon 7\n", - "adding: mem time250, current time 256, horizon 6\n", - "adding: mem time251, current time 256, horizon 5\n", - "adding: mem time252, current time 256, horizon 4\n", - "adding: mem time253, current time 256, horizon 3\n", - "adding: mem time254, current time 256, horizon 2\n", - "adding: mem time255, current time 256, horizon 1\n", - "adding: mem time200, current time 257, horizon 57\n", - "adding: mem time201, current time 257, horizon 56\n", - "adding: mem time202, current time 257, horizon 55\n", - "adding: mem time203, current time 257, horizon 54\n", - "adding: mem time204, current time 257, horizon 53\n", - "adding: mem time205, current time 257, horizon 52\n", - "adding: mem time206, current time 257, horizon 51\n", - "adding: mem time207, current time 257, horizon 50\n", - "adding: mem time208, current time 257, horizon 49\n", - "adding: mem time209, current time 257, horizon 48\n", - "adding: mem time210, current time 257, horizon 47\n", - "adding: mem time211, current time 257, horizon 46\n", - "adding: mem time212, current time 257, horizon 45\n", - "adding: mem time213, current time 257, horizon 44\n", - "adding: mem time214, current time 257, horizon 43\n", - "adding: mem time215, current time 257, horizon 42\n", - "adding: mem time216, current time 257, horizon 41\n", - "adding: mem time217, current time 257, horizon 40\n", - "adding: mem time218, current time 257, horizon 39\n", - "adding: mem time219, current time 257, horizon 38\n", - "adding: mem time220, current time 257, horizon 37\n", - "adding: mem time221, current time 257, horizon 36\n", - "adding: mem time222, current time 257, horizon 35\n", - "adding: mem time223, current time 257, horizon 34\n", - "adding: mem time224, current time 257, horizon 33\n", - "adding: mem time225, current time 257, horizon 32\n", - "adding: mem time226, current time 257, horizon 31\n", - "adding: mem time227, current time 257, horizon 30\n", - "adding: mem time228, current time 257, horizon 29\n", - "adding: mem time229, current time 257, horizon 28\n", - "adding: mem time230, current time 257, horizon 27\n", - "adding: mem time231, current time 257, horizon 26\n", - "adding: mem time232, current time 257, horizon 25\n", - "adding: mem time233, current time 257, horizon 24\n", - "adding: mem time234, current time 257, horizon 23\n", - "adding: mem time235, current time 257, horizon 22\n", - "adding: mem time236, current time 257, horizon 21\n", - "adding: mem time237, current time 257, horizon 20\n", - "adding: mem time238, current time 257, horizon 19\n", - "adding: mem time239, current time 257, horizon 18\n", - "adding: mem time240, current time 257, horizon 17\n", - "adding: mem time241, current time 257, horizon 16\n", - "adding: mem time242, current time 257, horizon 15\n", - "adding: mem time243, current time 257, horizon 14\n", - "adding: mem time244, current time 257, horizon 13\n", - "adding: mem time245, current time 257, horizon 12\n", - "adding: mem time246, current time 257, horizon 11\n", - "adding: mem time247, current time 257, horizon 10\n", - "adding: mem time248, current time 257, horizon 9\n", - "adding: mem time249, current time 257, horizon 8\n", - "adding: mem time250, current time 257, horizon 7\n", - "adding: mem time251, current time 257, horizon 6\n", - "adding: mem time252, current time 257, horizon 5\n", - "adding: mem time253, current time 257, horizon 4\n", - "adding: mem time254, current time 257, horizon 3\n", - "adding: mem time255, current time 257, horizon 2\n", - "adding: mem time256, current time 257, horizon 1\n", - "adding: mem time200, current time 258, horizon 58\n", - "adding: mem time201, current time 258, horizon 57\n", - "adding: mem time202, current time 258, horizon 56\n", - "adding: mem time203, current time 258, horizon 55\n", - "adding: mem time204, current time 258, horizon 54\n", - "adding: mem time205, current time 258, horizon 53\n", - "adding: mem time206, current time 258, horizon 52\n", - "adding: mem time207, current time 258, horizon 51\n", - "adding: mem time208, current time 258, horizon 50\n", - "adding: mem time209, current time 258, horizon 49\n", - "adding: mem time210, current time 258, horizon 48\n", - "adding: mem time211, current time 258, horizon 47\n", - "adding: mem time212, current time 258, horizon 46\n", - "adding: mem time213, current time 258, horizon 45\n", - "adding: mem time214, current time 258, horizon 44\n", - "adding: mem time215, current time 258, horizon 43\n", - "adding: mem time216, current time 258, horizon 42\n", - "adding: mem time217, current time 258, horizon 41\n", - "adding: mem time218, current time 258, horizon 40\n", - "adding: mem time219, current time 258, horizon 39\n", - "adding: mem time220, current time 258, horizon 38\n", - "adding: mem time221, current time 258, horizon 37\n", - "adding: mem time222, current time 258, horizon 36\n", - "adding: mem time223, current time 258, horizon 35\n", - "adding: mem time224, current time 258, horizon 34\n", - "adding: mem time225, current time 258, horizon 33\n", - "adding: mem time226, current time 258, horizon 32\n", - "adding: mem time227, current time 258, horizon 31\n", - "adding: mem time228, current time 258, horizon 30\n", - "adding: mem time229, current time 258, horizon 29\n", - "adding: mem time230, current time 258, horizon 28\n", - "adding: mem time231, current time 258, horizon 27\n", - "adding: mem time232, current time 258, horizon 26\n", - "adding: mem time233, current time 258, horizon 25\n", - "adding: mem time234, current time 258, horizon 24\n", - "adding: mem time235, current time 258, horizon 23\n", - "adding: mem time236, current time 258, horizon 22\n", - "adding: mem time237, current time 258, horizon 21\n", - "adding: mem time238, current time 258, horizon 20\n", - "adding: mem time239, current time 258, horizon 19\n", - "adding: mem time240, current time 258, horizon 18\n", - "adding: mem time241, current time 258, horizon 17\n", - "adding: mem time242, current time 258, horizon 16\n", - "adding: mem time243, current time 258, horizon 15\n", - "adding: mem time244, current time 258, horizon 14\n", - "adding: mem time245, current time 258, horizon 13\n", - "adding: mem time246, current time 258, horizon 12\n", - "adding: mem time247, current time 258, horizon 11\n", - "adding: mem time248, current time 258, horizon 10\n", - "adding: mem time249, current time 258, horizon 9\n", - "adding: mem time250, current time 258, horizon 8\n", - "adding: mem time251, current time 258, horizon 7\n", - "adding: mem time252, current time 258, horizon 6\n", - "adding: mem time253, current time 258, horizon 5\n", - "adding: mem time254, current time 258, horizon 4\n", - "adding: mem time255, current time 258, horizon 3\n", - "adding: mem time256, current time 258, horizon 2\n", - "adding: mem time257, current time 258, horizon 1\n", - "adding: mem time200, current time 259, horizon 59\n", - "adding: mem time201, current time 259, horizon 58\n", - "adding: mem time202, current time 259, horizon 57\n", - "adding: mem time203, current time 259, horizon 56\n", - "adding: mem time204, current time 259, horizon 55\n", - "adding: mem time205, current time 259, horizon 54\n", - "adding: mem time206, current time 259, horizon 53\n", - "adding: mem time207, current time 259, horizon 52\n", - "adding: mem time208, current time 259, horizon 51\n", - "adding: mem time209, current time 259, horizon 50\n", - "adding: mem time210, current time 259, horizon 49\n", - "adding: mem time211, current time 259, horizon 48\n", - "adding: mem time212, current time 259, horizon 47\n", - "adding: mem time213, current time 259, horizon 46\n", - "adding: mem time214, current time 259, horizon 45\n", - "adding: mem time215, current time 259, horizon 44\n", - "adding: mem time216, current time 259, horizon 43\n", - "adding: mem time217, current time 259, horizon 42\n", - "adding: mem time218, current time 259, horizon 41\n", - "adding: mem time219, current time 259, horizon 40\n", - "adding: mem time220, current time 259, horizon 39\n", - "adding: mem time221, current time 259, horizon 38\n", - "adding: mem time222, current time 259, horizon 37\n", - "adding: mem time223, current time 259, horizon 36\n", - "adding: mem time224, current time 259, horizon 35\n", - "adding: mem time225, current time 259, horizon 34\n", - "adding: mem time226, current time 259, horizon 33\n", - "adding: mem time227, current time 259, horizon 32\n", - "adding: mem time228, current time 259, horizon 31\n", - "adding: mem time229, current time 259, horizon 30\n", - "adding: mem time230, current time 259, horizon 29\n", - "adding: mem time231, current time 259, horizon 28\n", - "adding: mem time232, current time 259, horizon 27\n", - "adding: mem time233, current time 259, horizon 26\n", - "adding: mem time234, current time 259, horizon 25\n", - "adding: mem time235, current time 259, horizon 24\n", - "adding: mem time236, current time 259, horizon 23\n", - "adding: mem time237, current time 259, horizon 22\n", - "adding: mem time238, current time 259, horizon 21\n", - "adding: mem time239, current time 259, horizon 20\n", - "adding: mem time240, current time 259, horizon 19\n", - "adding: mem time241, current time 259, horizon 18\n", - "adding: mem time242, current time 259, horizon 17\n", - "adding: mem time243, current time 259, horizon 16\n", - "adding: mem time244, current time 259, horizon 15\n", - "adding: mem time245, current time 259, horizon 14\n", - "adding: mem time246, current time 259, horizon 13\n", - "adding: mem time247, current time 259, horizon 12\n", - "adding: mem time248, current time 259, horizon 11\n", - "adding: mem time249, current time 259, horizon 10\n", - "adding: mem time250, current time 259, horizon 9\n", - "adding: mem time251, current time 259, horizon 8\n", - "adding: mem time252, current time 259, horizon 7\n", - "adding: mem time253, current time 259, horizon 6\n", - "adding: mem time254, current time 259, horizon 5\n", - "adding: mem time255, current time 259, horizon 4\n", - "adding: mem time256, current time 259, horizon 3\n", - "adding: mem time257, current time 259, horizon 2\n", - "adding: mem time258, current time 259, horizon 1\n", - "adding: mem time200, current time 260, horizon 60\n", - "adding: mem time201, current time 260, horizon 59\n", - "adding: mem time202, current time 260, horizon 58\n", - "adding: mem time203, current time 260, horizon 57\n", - "adding: mem time204, current time 260, horizon 56\n", - "adding: mem time205, current time 260, horizon 55\n", - "adding: mem time206, current time 260, horizon 54\n", - "adding: mem time207, current time 260, horizon 53\n", - "adding: mem time208, current time 260, horizon 52\n", - "adding: mem time209, current time 260, horizon 51\n", - "adding: mem time210, current time 260, horizon 50\n", - "adding: mem time211, current time 260, horizon 49\n", - "adding: mem time212, current time 260, horizon 48\n", - "adding: mem time213, current time 260, horizon 47\n", - "adding: mem time214, current time 260, horizon 46\n", - "adding: mem time215, current time 260, horizon 45\n", - "adding: mem time216, current time 260, horizon 44\n", - "adding: mem time217, current time 260, horizon 43\n", - "adding: mem time218, current time 260, horizon 42\n", - "adding: mem time219, current time 260, horizon 41\n", - "adding: mem time220, current time 260, horizon 40\n", - "adding: mem time221, current time 260, horizon 39\n", - "adding: mem time222, current time 260, horizon 38\n", - "adding: mem time223, current time 260, horizon 37\n", - "adding: mem time224, current time 260, horizon 36\n", - "adding: mem time225, current time 260, horizon 35\n", - "adding: mem time226, current time 260, horizon 34\n", - "adding: mem time227, current time 260, horizon 33\n", - "adding: mem time228, current time 260, horizon 32\n", - "adding: mem time229, current time 260, horizon 31\n", - "adding: mem time230, current time 260, horizon 30\n", - "adding: mem time231, current time 260, horizon 29\n", - "adding: mem time232, current time 260, horizon 28\n", - "adding: mem time233, current time 260, horizon 27\n", - "adding: mem time234, current time 260, horizon 26\n", - "adding: mem time235, current time 260, horizon 25\n", - "adding: mem time236, current time 260, horizon 24\n", - "adding: mem time237, current time 260, horizon 23\n", - "adding: mem time238, current time 260, horizon 22\n", - "adding: mem time239, current time 260, horizon 21\n", - "adding: mem time240, current time 260, horizon 20\n", - "adding: mem time241, current time 260, horizon 19\n", - "adding: mem time242, current time 260, horizon 18\n", - "adding: mem time243, current time 260, horizon 17\n", - "adding: mem time244, current time 260, horizon 16\n", - "adding: mem time245, current time 260, horizon 15\n", - "adding: mem time246, current time 260, horizon 14\n", - "adding: mem time247, current time 260, horizon 13\n", - "adding: mem time248, current time 260, horizon 12\n", - "adding: mem time249, current time 260, horizon 11\n", - "adding: mem time250, current time 260, horizon 10\n", - "adding: mem time251, current time 260, horizon 9\n", - "adding: mem time252, current time 260, horizon 8\n", - "adding: mem time253, current time 260, horizon 7\n", - "adding: mem time254, current time 260, horizon 6\n", - "adding: mem time255, current time 260, horizon 5\n", - "adding: mem time256, current time 260, horizon 4\n", - "adding: mem time257, current time 260, horizon 3\n", - "adding: mem time258, current time 260, horizon 2\n", - "adding: mem time259, current time 260, horizon 1\n", - "adding: mem time200, current time 261, horizon 61\n", - "adding: mem time201, current time 261, horizon 60\n", - "adding: mem time202, current time 261, horizon 59\n", - "adding: mem time203, current time 261, horizon 58\n", - "adding: mem time204, current time 261, horizon 57\n", - "adding: mem time205, current time 261, horizon 56\n", - "adding: mem time206, current time 261, horizon 55\n", - "adding: mem time207, current time 261, horizon 54\n", - "adding: mem time208, current time 261, horizon 53\n", - "adding: mem time209, current time 261, horizon 52\n", - "adding: mem time210, current time 261, horizon 51\n", - "adding: mem time211, current time 261, horizon 50\n", - "adding: mem time212, current time 261, horizon 49\n", - "adding: mem time213, current time 261, horizon 48\n", - "adding: mem time214, current time 261, horizon 47\n", - "adding: mem time215, current time 261, horizon 46\n", - "adding: mem time216, current time 261, horizon 45\n", - "adding: mem time217, current time 261, horizon 44\n", - "adding: mem time218, current time 261, horizon 43\n", - "adding: mem time219, current time 261, horizon 42\n", - "adding: mem time220, current time 261, horizon 41\n", - "adding: mem time221, current time 261, horizon 40\n", - "adding: mem time222, current time 261, horizon 39\n", - "adding: mem time223, current time 261, horizon 38\n", - "adding: mem time224, current time 261, horizon 37\n", - "adding: mem time225, current time 261, horizon 36\n", - "adding: mem time226, current time 261, horizon 35\n", - "adding: mem time227, current time 261, horizon 34\n", - "adding: mem time228, current time 261, horizon 33\n", - "adding: mem time229, current time 261, horizon 32\n", - "adding: mem time230, current time 261, horizon 31\n", - "adding: mem time231, current time 261, horizon 30\n", - "adding: mem time232, current time 261, horizon 29\n", - "adding: mem time233, current time 261, horizon 28\n", - "adding: mem time234, current time 261, horizon 27\n", - "adding: mem time235, current time 261, horizon 26\n", - "adding: mem time236, current time 261, horizon 25\n", - "adding: mem time237, current time 261, horizon 24\n", - "adding: mem time238, current time 261, horizon 23\n", - "adding: mem time239, current time 261, horizon 22\n", - "adding: mem time240, current time 261, horizon 21\n", - "adding: mem time241, current time 261, horizon 20\n", - "adding: mem time242, current time 261, horizon 19\n", - "adding: mem time243, current time 261, horizon 18\n", - "adding: mem time244, current time 261, horizon 17\n", - "adding: mem time245, current time 261, horizon 16\n", - "adding: mem time246, current time 261, horizon 15\n", - "adding: mem time247, current time 261, horizon 14\n", - "adding: mem time248, current time 261, horizon 13\n", - "adding: mem time249, current time 261, horizon 12\n", - "adding: mem time250, current time 261, horizon 11\n", - "adding: mem time251, current time 261, horizon 10\n", - "adding: mem time252, current time 261, horizon 9\n", - "adding: mem time253, current time 261, horizon 8\n", - "adding: mem time254, current time 261, horizon 7\n", - "adding: mem time255, current time 261, horizon 6\n", - "adding: mem time256, current time 261, horizon 5\n", - "adding: mem time257, current time 261, horizon 4\n", - "adding: mem time258, current time 261, horizon 3\n", - "adding: mem time259, current time 261, horizon 2\n", - "adding: mem time260, current time 261, horizon 1\n", - "adding: mem time200, current time 262, horizon 62\n", - "adding: mem time201, current time 262, horizon 61\n", - "adding: mem time202, current time 262, horizon 60\n", - "adding: mem time203, current time 262, horizon 59\n", - "adding: mem time204, current time 262, horizon 58\n", - "adding: mem time205, current time 262, horizon 57\n", - "adding: mem time206, current time 262, horizon 56\n", - "adding: mem time207, current time 262, horizon 55\n", - "adding: mem time208, current time 262, horizon 54\n", - "adding: mem time209, current time 262, horizon 53\n", - "adding: mem time210, current time 262, horizon 52\n", - "adding: mem time211, current time 262, horizon 51\n", - "adding: mem time212, current time 262, horizon 50\n", - "adding: mem time213, current time 262, horizon 49\n", - "adding: mem time214, current time 262, horizon 48\n", - "adding: mem time215, current time 262, horizon 47\n", - "adding: mem time216, current time 262, horizon 46\n", - "adding: mem time217, current time 262, horizon 45\n", - "adding: mem time218, current time 262, horizon 44\n", - "adding: mem time219, current time 262, horizon 43\n", - "adding: mem time220, current time 262, horizon 42\n", - "adding: mem time221, current time 262, horizon 41\n", - "adding: mem time222, current time 262, horizon 40\n", - "adding: mem time223, current time 262, horizon 39\n", - "adding: mem time224, current time 262, horizon 38\n", - "adding: mem time225, current time 262, horizon 37\n", - "adding: mem time226, current time 262, horizon 36\n", - "adding: mem time227, current time 262, horizon 35\n", - "adding: mem time228, current time 262, horizon 34\n", - "adding: mem time229, current time 262, horizon 33\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "adding: mem time230, current time 262, horizon 32\n", - "adding: mem time231, current time 262, horizon 31\n", - "adding: mem time232, current time 262, horizon 30\n", - "adding: mem time233, current time 262, horizon 29\n", - "adding: mem time234, current time 262, horizon 28\n", - "adding: mem time235, current time 262, horizon 27\n", - "adding: mem time236, current time 262, horizon 26\n", - "adding: mem time237, current time 262, horizon 25\n", - "adding: mem time238, current time 262, horizon 24\n", - "adding: mem time239, current time 262, horizon 23\n", - "adding: mem time240, current time 262, horizon 22\n", - "adding: mem time241, current time 262, horizon 21\n", - "adding: mem time242, current time 262, horizon 20\n", - "adding: mem time243, current time 262, horizon 19\n", - "adding: mem time244, current time 262, horizon 18\n", - "adding: mem time245, current time 262, horizon 17\n", - "adding: mem time246, current time 262, horizon 16\n", - "adding: mem time247, current time 262, horizon 15\n", - "adding: mem time248, current time 262, horizon 14\n", - "adding: mem time249, current time 262, horizon 13\n", - "adding: mem time250, current time 262, horizon 12\n", - "adding: mem time251, current time 262, horizon 11\n", - "adding: mem time252, current time 262, horizon 10\n", - "adding: mem time253, current time 262, horizon 9\n", - "adding: mem time254, current time 262, horizon 8\n", - "adding: mem time255, current time 262, horizon 7\n", - "adding: mem time256, current time 262, horizon 6\n", - "adding: mem time257, current time 262, horizon 5\n", - "adding: mem time258, current time 262, horizon 4\n", - "adding: mem time259, current time 262, horizon 3\n", - "adding: mem time260, current time 262, horizon 2\n", - "adding: mem time261, current time 262, horizon 1\n", - "adding: mem time200, current time 263, horizon 63\n", - "adding: mem time201, current time 263, horizon 62\n", - "adding: mem time202, current time 263, horizon 61\n", - "adding: mem time203, current time 263, horizon 60\n", - "adding: mem time204, current time 263, horizon 59\n", - "adding: mem time205, current time 263, horizon 58\n", - "adding: mem time206, current time 263, horizon 57\n", - "adding: mem time207, current time 263, horizon 56\n", - "adding: mem time208, current time 263, horizon 55\n", - "adding: mem time209, current time 263, horizon 54\n", - "adding: mem time210, current time 263, horizon 53\n", - "adding: mem time211, current time 263, horizon 52\n", - "adding: mem time212, current time 263, horizon 51\n", - "adding: mem time213, current time 263, horizon 50\n", - "adding: mem time214, current time 263, horizon 49\n", - "adding: mem time215, current time 263, horizon 48\n", - "adding: mem time216, current time 263, horizon 47\n", - "adding: mem time217, current time 263, horizon 46\n", - "adding: mem time218, current time 263, horizon 45\n", - "adding: mem time219, current time 263, horizon 44\n", - "adding: mem time220, current time 263, horizon 43\n", - "adding: mem time221, current time 263, horizon 42\n", - "adding: mem time222, current time 263, horizon 41\n", - "adding: mem time223, current time 263, horizon 40\n", - "adding: mem time224, current time 263, horizon 39\n", - "adding: mem time225, current time 263, horizon 38\n", - "adding: mem time226, current time 263, horizon 37\n", - "adding: mem time227, current time 263, horizon 36\n", - "adding: mem time228, current time 263, horizon 35\n", - "adding: mem time229, current time 263, horizon 34\n", - "adding: mem time230, current time 263, horizon 33\n", - "adding: mem time231, current time 263, horizon 32\n", - "adding: mem time232, current time 263, horizon 31\n", - "adding: mem time233, current time 263, horizon 30\n", - "adding: mem time234, current time 263, horizon 29\n", - "adding: mem time235, current time 263, horizon 28\n", - "adding: mem time236, current time 263, horizon 27\n", - "adding: mem time237, current time 263, horizon 26\n", - "adding: mem time238, current time 263, horizon 25\n", - "adding: mem time239, current time 263, horizon 24\n", - "adding: mem time240, current time 263, horizon 23\n", - "adding: mem time241, current time 263, horizon 22\n", - "adding: mem time242, current time 263, horizon 21\n", - "adding: mem time243, current time 263, horizon 20\n", - "adding: mem time244, current time 263, horizon 19\n", - "adding: mem time245, current time 263, horizon 18\n", - "adding: mem time246, current time 263, horizon 17\n", - "adding: mem time247, current time 263, horizon 16\n", - "adding: mem time248, current time 263, horizon 15\n", - "adding: mem time249, current time 263, horizon 14\n", - "adding: mem time250, current time 263, horizon 13\n", - "adding: mem time251, current time 263, horizon 12\n", - "adding: mem time252, current time 263, horizon 11\n", - "adding: mem time253, current time 263, horizon 10\n", - "adding: mem time254, current time 263, horizon 9\n", - "adding: mem time255, current time 263, horizon 8\n", - "adding: mem time256, current time 263, horizon 7\n", - "adding: mem time257, current time 263, horizon 6\n", - "adding: mem time258, current time 263, horizon 5\n", - "adding: mem time259, current time 263, horizon 4\n", - "adding: mem time260, current time 263, horizon 3\n", - "adding: mem time261, current time 263, horizon 2\n", - "adding: mem time262, current time 263, horizon 1\n", - "adding: mem time200, current time 264, horizon 64\n", - "adding: mem time201, current time 264, horizon 63\n", - "adding: mem time202, current time 264, horizon 62\n", - "adding: mem time203, current time 264, horizon 61\n", - "adding: mem time204, current time 264, horizon 60\n", - "adding: mem time205, current time 264, horizon 59\n", - "adding: mem time206, current time 264, horizon 58\n", - "adding: mem time207, current time 264, horizon 57\n", - "adding: mem time208, current time 264, horizon 56\n", - "adding: mem time209, current time 264, horizon 55\n", - "adding: mem time210, current time 264, horizon 54\n", - "adding: mem time211, current time 264, horizon 53\n", - "adding: mem time212, current time 264, horizon 52\n", - "adding: mem time213, current time 264, horizon 51\n", - "adding: mem time214, current time 264, horizon 50\n", - "adding: mem time215, current time 264, horizon 49\n", - "adding: mem time216, current time 264, horizon 48\n", - "adding: mem time217, current time 264, horizon 47\n", - "adding: mem time218, current time 264, horizon 46\n", - "adding: mem time219, current time 264, horizon 45\n", - "adding: mem time220, current time 264, horizon 44\n", - "adding: mem time221, current time 264, horizon 43\n", - "adding: mem time222, current time 264, horizon 42\n", - "adding: mem time223, current time 264, horizon 41\n", - "adding: mem time224, current time 264, horizon 40\n", - "adding: mem time225, current time 264, horizon 39\n", - "adding: mem time226, current time 264, horizon 38\n", - "adding: mem time227, current time 264, horizon 37\n", - "adding: mem time228, current time 264, horizon 36\n", - "adding: mem time229, current time 264, horizon 35\n", - "adding: mem time230, current time 264, horizon 34\n", - "adding: mem time231, current time 264, horizon 33\n", - "adding: mem time232, current time 264, horizon 32\n", - "adding: mem time233, current time 264, horizon 31\n", - "adding: mem time234, current time 264, horizon 30\n", - "adding: mem time235, current time 264, horizon 29\n", - "adding: mem time236, current time 264, horizon 28\n", - "adding: mem time237, current time 264, horizon 27\n", - "adding: mem time238, current time 264, horizon 26\n", - "adding: mem time239, current time 264, horizon 25\n", - "adding: mem time240, current time 264, horizon 24\n", - "adding: mem time241, current time 264, horizon 23\n", - "adding: mem time242, current time 264, horizon 22\n", - "adding: mem time243, current time 264, horizon 21\n", - "adding: mem time244, current time 264, horizon 20\n", - "adding: mem time245, current time 264, horizon 19\n", - "adding: mem time246, current time 264, horizon 18\n", - "adding: mem time247, current time 264, horizon 17\n", - "adding: mem time248, current time 264, horizon 16\n", - "adding: mem time249, current time 264, horizon 15\n", - "adding: mem time250, current time 264, horizon 14\n", - "adding: mem time251, current time 264, horizon 13\n", - "adding: mem time252, current time 264, horizon 12\n", - "adding: mem time253, current time 264, horizon 11\n", - "adding: mem time254, current time 264, horizon 10\n", - "adding: mem time255, current time 264, horizon 9\n", - "adding: mem time256, current time 264, horizon 8\n", - "adding: mem time257, current time 264, horizon 7\n", - "adding: mem time258, current time 264, horizon 6\n", - "adding: mem time259, current time 264, horizon 5\n", - "adding: mem time260, current time 264, horizon 4\n", - "adding: mem time261, current time 264, horizon 3\n", - "adding: mem time262, current time 264, horizon 2\n", - "adding: mem time263, current time 264, horizon 1\n", - "adding: mem time200, current time 265, horizon 65\n", - "adding: mem time201, current time 265, horizon 64\n", - "adding: mem time202, current time 265, horizon 63\n", - "adding: mem time203, current time 265, horizon 62\n", - "adding: mem time204, current time 265, horizon 61\n", - "adding: mem time205, current time 265, horizon 60\n", - "adding: mem time206, current time 265, horizon 59\n", - "adding: mem time207, current time 265, horizon 58\n", - "adding: mem time208, current time 265, horizon 57\n", - "adding: mem time209, current time 265, horizon 56\n", - "adding: mem time210, current time 265, horizon 55\n", - "adding: mem time211, current time 265, horizon 54\n", - "adding: mem time212, current time 265, horizon 53\n", - "adding: mem time213, current time 265, horizon 52\n", - "adding: mem time214, current time 265, horizon 51\n", - "adding: mem time215, current time 265, horizon 50\n", - "adding: mem time216, current time 265, horizon 49\n", - "adding: mem time217, current time 265, horizon 48\n", - "adding: mem time218, current time 265, horizon 47\n", - "adding: mem time219, current time 265, horizon 46\n", - "adding: mem time220, current time 265, horizon 45\n", - "adding: mem time221, current time 265, horizon 44\n", - "adding: mem time222, current time 265, horizon 43\n", - "adding: mem time223, current time 265, horizon 42\n", - "adding: mem time224, current time 265, horizon 41\n", - "adding: mem time225, current time 265, horizon 40\n", - "adding: mem time226, current time 265, horizon 39\n", - "adding: mem time227, current time 265, horizon 38\n", - "adding: mem time228, current time 265, horizon 37\n", - "adding: mem time229, current time 265, horizon 36\n", - "adding: mem time230, current time 265, horizon 35\n", - "adding: mem time231, current time 265, horizon 34\n", - "adding: mem time232, current time 265, horizon 33\n", - "adding: mem time233, current time 265, horizon 32\n", - "adding: mem time234, current time 265, horizon 31\n", - "adding: mem time235, current time 265, horizon 30\n", - "adding: mem time236, current time 265, horizon 29\n", - "adding: mem time237, current time 265, horizon 28\n", - "adding: mem time238, current time 265, horizon 27\n", - "adding: mem time239, current time 265, horizon 26\n", - "adding: mem time240, current time 265, horizon 25\n", - "adding: mem time241, current time 265, horizon 24\n", - "adding: mem time242, current time 265, horizon 23\n", - "adding: mem time243, current time 265, horizon 22\n", - "adding: mem time244, current time 265, horizon 21\n", - "adding: mem time245, current time 265, horizon 20\n", - "adding: mem time246, current time 265, horizon 19\n", - "adding: mem time247, current time 265, horizon 18\n", - "adding: mem time248, current time 265, horizon 17\n", - "adding: mem time249, current time 265, horizon 16\n", - "adding: mem time250, current time 265, horizon 15\n", - "adding: mem time251, current time 265, horizon 14\n", - "adding: mem time252, current time 265, horizon 13\n", - "adding: mem time253, current time 265, horizon 12\n", - "adding: mem time254, current time 265, horizon 11\n", - "adding: mem time255, current time 265, horizon 10\n", - "adding: mem time256, current time 265, horizon 9\n", - "adding: mem time257, current time 265, horizon 8\n", - "adding: mem time258, current time 265, horizon 7\n", - "adding: mem time259, current time 265, horizon 6\n", - "adding: mem time260, current time 265, horizon 5\n", - "adding: mem time261, current time 265, horizon 4\n", - "adding: mem time262, current time 265, horizon 3\n", - "adding: mem time263, current time 265, horizon 2\n", - "adding: mem time264, current time 265, horizon 1\n", - "adding: mem time200, current time 266, horizon 66\n", - "adding: mem time201, current time 266, horizon 65\n", - "adding: mem time202, current time 266, horizon 64\n", - "adding: mem time203, current time 266, horizon 63\n", - "adding: mem time204, current time 266, horizon 62\n", - "adding: mem time205, current time 266, horizon 61\n", - "adding: mem time206, current time 266, horizon 60\n", - "adding: mem time207, current time 266, horizon 59\n", - "adding: mem time208, current time 266, horizon 58\n", - "adding: mem time209, current time 266, horizon 57\n", - "adding: mem time210, current time 266, horizon 56\n", - "adding: mem time211, current time 266, horizon 55\n", - "adding: mem time212, current time 266, horizon 54\n", - "adding: mem time213, current time 266, horizon 53\n", - "adding: mem time214, current time 266, horizon 52\n", - "adding: mem time215, current time 266, horizon 51\n", - "adding: mem time216, current time 266, horizon 50\n", - "adding: mem time217, current time 266, horizon 49\n", - "adding: mem time218, current time 266, horizon 48\n", - "adding: mem time219, current time 266, horizon 47\n", - "adding: mem time220, current time 266, horizon 46\n", - "adding: mem time221, current time 266, horizon 45\n", - "adding: mem time222, current time 266, horizon 44\n", - "adding: mem time223, current time 266, horizon 43\n", - "adding: mem time224, current time 266, horizon 42\n", - "adding: mem time225, current time 266, horizon 41\n", - "adding: mem time226, current time 266, horizon 40\n", - "adding: mem time227, current time 266, horizon 39\n", - "adding: mem time228, current time 266, horizon 38\n", - "adding: mem time229, current time 266, horizon 37\n", - "adding: mem time230, current time 266, horizon 36\n", - "adding: mem time231, current time 266, horizon 35\n", - "adding: mem time232, current time 266, horizon 34\n", - "adding: mem time233, current time 266, horizon 33\n", - "adding: mem time234, current time 266, horizon 32\n", - "adding: mem time235, current time 266, horizon 31\n", - "adding: mem time236, current time 266, horizon 30\n", - "adding: mem time237, current time 266, horizon 29\n", - "adding: mem time238, current time 266, horizon 28\n", - "adding: mem time239, current time 266, horizon 27\n", - "adding: mem time240, current time 266, horizon 26\n", - "adding: mem time241, current time 266, horizon 25\n", - "adding: mem time242, current time 266, horizon 24\n", - "adding: mem time243, current time 266, horizon 23\n", - "adding: mem time244, current time 266, horizon 22\n", - "adding: mem time245, current time 266, horizon 21\n", - "adding: mem time246, current time 266, horizon 20\n", - "adding: mem time247, current time 266, horizon 19\n", - "adding: mem time248, current time 266, horizon 18\n", - "adding: mem time249, current time 266, horizon 17\n", - "adding: mem time250, current time 266, horizon 16\n", - "adding: mem time251, current time 266, horizon 15\n", - "adding: mem time252, current time 266, horizon 14\n", - "adding: mem time253, current time 266, horizon 13\n", - "adding: mem time254, current time 266, horizon 12\n", - "adding: mem time255, current time 266, horizon 11\n", - "adding: mem time256, current time 266, horizon 10\n", - "adding: mem time257, current time 266, horizon 9\n", - "adding: mem time258, current time 266, horizon 8\n", - "adding: mem time259, current time 266, horizon 7\n", - "adding: mem time260, current time 266, horizon 6\n", - "adding: mem time261, current time 266, horizon 5\n", - "adding: mem time262, current time 266, horizon 4\n", - "adding: mem time263, current time 266, horizon 3\n", - "adding: mem time264, current time 266, horizon 2\n", - "adding: mem time265, current time 266, horizon 1\n", - "adding: mem time200, current time 267, horizon 67\n", - "adding: mem time201, current time 267, horizon 66\n", - "adding: mem time202, current time 267, horizon 65\n", - "adding: mem time203, current time 267, horizon 64\n", - "adding: mem time204, current time 267, horizon 63\n", - "adding: mem time205, current time 267, horizon 62\n", - "adding: mem time206, current time 267, horizon 61\n", - "adding: mem time207, current time 267, horizon 60\n", - "adding: mem time208, current time 267, horizon 59\n", - "adding: mem time209, current time 267, horizon 58\n", - "adding: mem time210, current time 267, horizon 57\n", - "adding: mem time211, current time 267, horizon 56\n", - "adding: mem time212, current time 267, horizon 55\n", - "adding: mem time213, current time 267, horizon 54\n", - "adding: mem time214, current time 267, horizon 53\n", - "adding: mem time215, current time 267, horizon 52\n", - "adding: mem time216, current time 267, horizon 51\n", - "adding: mem time217, current time 267, horizon 50\n", - "adding: mem time218, current time 267, horizon 49\n", - "adding: mem time219, current time 267, horizon 48\n", - "adding: mem time220, current time 267, horizon 47\n", - "adding: mem time221, current time 267, horizon 46\n", - "adding: mem time222, current time 267, horizon 45\n", - "adding: mem time223, current time 267, horizon 44\n", - "adding: mem time224, current time 267, horizon 43\n", - "adding: mem time225, current time 267, horizon 42\n", - "adding: mem time226, current time 267, horizon 41\n", - "adding: mem time227, current time 267, horizon 40\n", - "adding: mem time228, current time 267, horizon 39\n", - "adding: mem time229, current time 267, horizon 38\n", - "adding: mem time230, current time 267, horizon 37\n", - "adding: mem time231, current time 267, horizon 36\n", - "adding: mem time232, current time 267, horizon 35\n", - "adding: mem time233, current time 267, horizon 34\n", - "adding: mem time234, current time 267, horizon 33\n", - "adding: mem time235, current time 267, horizon 32\n", - "adding: mem time236, current time 267, horizon 31\n", - "adding: mem time237, current time 267, horizon 30\n", - "adding: mem time238, current time 267, horizon 29\n", - "adding: mem time239, current time 267, horizon 28\n", - "adding: mem time240, current time 267, horizon 27\n", - "adding: mem time241, current time 267, horizon 26\n", - "adding: mem time242, current time 267, horizon 25\n", - "adding: mem time243, current time 267, horizon 24\n", - "adding: mem time244, current time 267, horizon 23\n", - "adding: mem time245, current time 267, horizon 22\n", - "adding: mem time246, current time 267, horizon 21\n", - "adding: mem time247, current time 267, horizon 20\n", - "adding: mem time248, current time 267, horizon 19\n", - "adding: mem time249, current time 267, horizon 18\n", - "adding: mem time250, current time 267, horizon 17\n", - "adding: mem time251, current time 267, horizon 16\n", - "adding: mem time252, current time 267, horizon 15\n", - "adding: mem time253, current time 267, horizon 14\n", - "adding: mem time254, current time 267, horizon 13\n", - "adding: mem time255, current time 267, horizon 12\n", - "adding: mem time256, current time 267, horizon 11\n", - "adding: mem time257, current time 267, horizon 10\n", - "adding: mem time258, current time 267, horizon 9\n", - "adding: mem time259, current time 267, horizon 8\n", - "adding: mem time260, current time 267, horizon 7\n", - "adding: mem time261, current time 267, horizon 6\n", - "adding: mem time262, current time 267, horizon 5\n", - "adding: mem time263, current time 267, horizon 4\n", - "adding: mem time264, current time 267, horizon 3\n", - "adding: mem time265, current time 267, horizon 2\n", - "adding: mem time266, current time 267, horizon 1\n", - "adding: mem time200, current time 268, horizon 68\n", - "adding: mem time201, current time 268, horizon 67\n", - "adding: mem time202, current time 268, horizon 66\n", - "adding: mem time203, current time 268, horizon 65\n", - "adding: mem time204, current time 268, horizon 64\n", - "adding: mem time205, current time 268, horizon 63\n", - "adding: mem time206, current time 268, horizon 62\n", - "adding: mem time207, current time 268, horizon 61\n", - "adding: mem time208, current time 268, horizon 60\n", - "adding: mem time209, current time 268, horizon 59\n", - "adding: mem time210, current time 268, horizon 58\n", - "adding: mem time211, current time 268, horizon 57\n", - "adding: mem time212, current time 268, horizon 56\n", - "adding: mem time213, current time 268, horizon 55\n", - "adding: mem time214, current time 268, horizon 54\n", - "adding: mem time215, current time 268, horizon 53\n", - "adding: mem time216, current time 268, horizon 52\n", - "adding: mem time217, current time 268, horizon 51\n", - "adding: mem time218, current time 268, horizon 50\n", - "adding: mem time219, current time 268, horizon 49\n", - "adding: mem time220, current time 268, horizon 48\n", - "adding: mem time221, current time 268, horizon 47\n", - "adding: mem time222, current time 268, horizon 46\n", - "adding: mem time223, current time 268, horizon 45\n", - "adding: mem time224, current time 268, horizon 44\n", - "adding: mem time225, current time 268, horizon 43\n", - "adding: mem time226, current time 268, horizon 42\n", - "adding: mem time227, current time 268, horizon 41\n", - "adding: mem time228, current time 268, horizon 40\n", - "adding: mem time229, current time 268, horizon 39\n", - "adding: mem time230, current time 268, horizon 38\n", - "adding: mem time231, current time 268, horizon 37\n", - "adding: mem time232, current time 268, horizon 36\n", - "adding: mem time233, current time 268, horizon 35\n", - "adding: mem time234, current time 268, horizon 34\n", - "adding: mem time235, current time 268, horizon 33\n", - "adding: mem time236, current time 268, horizon 32\n", - "adding: mem time237, current time 268, horizon 31\n", - "adding: mem time238, current time 268, horizon 30\n", - "adding: mem time239, current time 268, horizon 29\n", - "adding: mem time240, current time 268, horizon 28\n", - "adding: mem time241, current time 268, horizon 27\n", - "adding: mem time242, current time 268, horizon 26\n", - "adding: mem time243, current time 268, horizon 25\n", - "adding: mem time244, current time 268, horizon 24\n", - "adding: mem time245, current time 268, horizon 23\n", - "adding: mem time246, current time 268, horizon 22\n", - "adding: mem time247, current time 268, horizon 21\n", - "adding: mem time248, current time 268, horizon 20\n", - "adding: mem time249, current time 268, horizon 19\n", - "adding: mem time250, current time 268, horizon 18\n", - "adding: mem time251, current time 268, horizon 17\n", - "adding: mem time252, current time 268, horizon 16\n", - "adding: mem time253, current time 268, horizon 15\n", - "adding: mem time254, current time 268, horizon 14\n", - "adding: mem time255, current time 268, horizon 13\n", - "adding: mem time256, current time 268, horizon 12\n", - "adding: mem time257, current time 268, horizon 11\n", - "adding: mem time258, current time 268, horizon 10\n", - "adding: mem time259, current time 268, horizon 9\n", - "adding: mem time260, current time 268, horizon 8\n", - "adding: mem time261, current time 268, horizon 7\n", - "adding: mem time262, current time 268, horizon 6\n", - "adding: mem time263, current time 268, horizon 5\n", - "adding: mem time264, current time 268, horizon 4\n", - "adding: mem time265, current time 268, horizon 3\n", - "adding: mem time266, current time 268, horizon 2\n", - "adding: mem time267, current time 268, horizon 1\n", - "adding: mem time200, current time 269, horizon 69\n", - "adding: mem time201, current time 269, horizon 68\n", - "adding: mem time202, current time 269, horizon 67\n", - "adding: mem time203, current time 269, horizon 66\n", - "adding: mem time204, current time 269, horizon 65\n", - "adding: mem time205, current time 269, horizon 64\n", - "adding: mem time206, current time 269, horizon 63\n", - "adding: mem time207, current time 269, horizon 62\n", - "adding: mem time208, current time 269, horizon 61\n", - "adding: mem time209, current time 269, horizon 60\n", - "adding: mem time210, current time 269, horizon 59\n", - "adding: mem time211, current time 269, horizon 58\n", - "adding: mem time212, current time 269, horizon 57\n", - "adding: mem time213, current time 269, horizon 56\n", - "adding: mem time214, current time 269, horizon 55\n", - "adding: mem time215, current time 269, horizon 54\n", - "adding: mem time216, current time 269, horizon 53\n", - "adding: mem time217, current time 269, horizon 52\n", - "adding: mem time218, current time 269, horizon 51\n", - "adding: mem time219, current time 269, horizon 50\n", - "adding: mem time220, current time 269, horizon 49\n", - "adding: mem time221, current time 269, horizon 48\n", - "adding: mem time222, current time 269, horizon 47\n", - "adding: mem time223, current time 269, horizon 46\n", - "adding: mem time224, current time 269, horizon 45\n", - "adding: mem time225, current time 269, horizon 44\n", - "adding: mem time226, current time 269, horizon 43\n", - "adding: mem time227, current time 269, horizon 42\n", - "adding: mem time228, current time 269, horizon 41\n", - "adding: mem time229, current time 269, horizon 40\n", - "adding: mem time230, current time 269, horizon 39\n", - "adding: mem time231, current time 269, horizon 38\n", - "adding: mem time232, current time 269, horizon 37\n", - "adding: mem time233, current time 269, horizon 36\n", - "adding: mem time234, current time 269, horizon 35\n", - "adding: mem time235, current time 269, horizon 34\n", - "adding: mem time236, current time 269, horizon 33\n", - "adding: mem time237, current time 269, horizon 32\n", - "adding: mem time238, current time 269, horizon 31\n", - "adding: mem time239, current time 269, horizon 30\n", - "adding: mem time240, current time 269, horizon 29\n", - "adding: mem time241, current time 269, horizon 28\n", - "adding: mem time242, current time 269, horizon 27\n", - "adding: mem time243, current time 269, horizon 26\n", - "adding: mem time244, current time 269, horizon 25\n", - "adding: mem time245, current time 269, horizon 24\n", - "adding: mem time246, current time 269, horizon 23\n", - "adding: mem time247, current time 269, horizon 22\n", - "adding: mem time248, current time 269, horizon 21\n", - "adding: mem time249, current time 269, horizon 20\n", - "adding: mem time250, current time 269, horizon 19\n", - "adding: mem time251, current time 269, horizon 18\n", - "adding: mem time252, current time 269, horizon 17\n", - "adding: mem time253, current time 269, horizon 16\n", - "adding: mem time254, current time 269, horizon 15\n", - "adding: mem time255, current time 269, horizon 14\n", - "adding: mem time256, current time 269, horizon 13\n", - "adding: mem time257, current time 269, horizon 12\n", - "adding: mem time258, current time 269, horizon 11\n", - "adding: mem time259, current time 269, horizon 10\n", - "adding: mem time260, current time 269, horizon 9\n", - "adding: mem time261, current time 269, horizon 8\n", - "adding: mem time262, current time 269, horizon 7\n", - "adding: mem time263, current time 269, horizon 6\n", - "adding: mem time264, current time 269, horizon 5\n", - "adding: mem time265, current time 269, horizon 4\n", - "adding: mem time266, current time 269, horizon 3\n", - "adding: mem time267, current time 269, horizon 2\n", - "adding: mem time268, current time 269, horizon 1\n", - "adding: mem time200, current time 270, horizon 70\n", - "adding: mem time201, current time 270, horizon 69\n", - "adding: mem time202, current time 270, horizon 68\n", - "adding: mem time203, current time 270, horizon 67\n", - "adding: mem time204, current time 270, horizon 66\n", - "adding: mem time205, current time 270, horizon 65\n", - "adding: mem time206, current time 270, horizon 64\n", - "adding: mem time207, current time 270, horizon 63\n", - "adding: mem time208, current time 270, horizon 62\n", - "adding: mem time209, current time 270, horizon 61\n", - "adding: mem time210, current time 270, horizon 60\n", - "adding: mem time211, current time 270, horizon 59\n", - "adding: mem time212, current time 270, horizon 58\n", - "adding: mem time213, current time 270, horizon 57\n", - "adding: mem time214, current time 270, horizon 56\n", - "adding: mem time215, current time 270, horizon 55\n", - "adding: mem time216, current time 270, horizon 54\n", - "adding: mem time217, current time 270, horizon 53\n", - "adding: mem time218, current time 270, horizon 52\n", - "adding: mem time219, current time 270, horizon 51\n", - "adding: mem time220, current time 270, horizon 50\n", - "adding: mem time221, current time 270, horizon 49\n", - "adding: mem time222, current time 270, horizon 48\n", - "adding: mem time223, current time 270, horizon 47\n", - "adding: mem time224, current time 270, horizon 46\n", - "adding: mem time225, current time 270, horizon 45\n", - "adding: mem time226, current time 270, horizon 44\n", - "adding: mem time227, current time 270, horizon 43\n", - "adding: mem time228, current time 270, horizon 42\n", - "adding: mem time229, current time 270, horizon 41\n", - "adding: mem time230, current time 270, horizon 40\n", - "adding: mem time231, current time 270, horizon 39\n", - "adding: mem time232, current time 270, horizon 38\n", - "adding: mem time233, current time 270, horizon 37\n", - "adding: mem time234, current time 270, horizon 36\n", - "adding: mem time235, current time 270, horizon 35\n", - "adding: mem time236, current time 270, horizon 34\n", - "adding: mem time237, current time 270, horizon 33\n", - "adding: mem time238, current time 270, horizon 32\n", - "adding: mem time239, current time 270, horizon 31\n", - "adding: mem time240, current time 270, horizon 30\n", - "adding: mem time241, current time 270, horizon 29\n", - "adding: mem time242, current time 270, horizon 28\n", - "adding: mem time243, current time 270, horizon 27\n", - "adding: mem time244, current time 270, horizon 26\n", - "adding: mem time245, current time 270, horizon 25\n", - "adding: mem time246, current time 270, horizon 24\n", - "adding: mem time247, current time 270, horizon 23\n", - "adding: mem time248, current time 270, horizon 22\n", - "adding: mem time249, current time 270, horizon 21\n", - "adding: mem time250, current time 270, horizon 20\n", - "adding: mem time251, current time 270, horizon 19\n", - "adding: mem time252, current time 270, horizon 18\n", - "adding: mem time253, current time 270, horizon 17\n", - "adding: mem time254, current time 270, horizon 16\n", - "adding: mem time255, current time 270, horizon 15\n", - "adding: mem time256, current time 270, horizon 14\n", - "adding: mem time257, current time 270, horizon 13\n", - "adding: mem time258, current time 270, horizon 12\n", - "adding: mem time259, current time 270, horizon 11\n", - "adding: mem time260, current time 270, horizon 10\n", - "adding: mem time261, current time 270, horizon 9\n", - "adding: mem time262, current time 270, horizon 8\n", - "adding: mem time263, current time 270, horizon 7\n", - "adding: mem time264, current time 270, horizon 6\n", - "adding: mem time265, current time 270, horizon 5\n", - "adding: mem time266, current time 270, horizon 4\n", - "adding: mem time267, current time 270, horizon 3\n", - "adding: mem time268, current time 270, horizon 2\n", - "adding: mem time269, current time 270, horizon 1\n", - "adding: mem time200, current time 271, horizon 71\n", - "adding: mem time201, current time 271, horizon 70\n", - "adding: mem time202, current time 271, horizon 69\n", - "adding: mem time203, current time 271, horizon 68\n", - "adding: mem time204, current time 271, horizon 67\n", - "adding: mem time205, current time 271, horizon 66\n", - "adding: mem time206, current time 271, horizon 65\n", - "adding: mem time207, current time 271, horizon 64\n", - "adding: mem time208, current time 271, horizon 63\n", - "adding: mem time209, current time 271, horizon 62\n", - "adding: mem time210, current time 271, horizon 61\n", - "adding: mem time211, current time 271, horizon 60\n", - "adding: mem time212, current time 271, horizon 59\n", - "adding: mem time213, current time 271, horizon 58\n", - "adding: mem time214, current time 271, horizon 57\n", - "adding: mem time215, current time 271, horizon 56\n", - "adding: mem time216, current time 271, horizon 55\n", - "adding: mem time217, current time 271, horizon 54\n", - "adding: mem time218, current time 271, horizon 53\n", - "adding: mem time219, current time 271, horizon 52\n", - "adding: mem time220, current time 271, horizon 51\n", - "adding: mem time221, current time 271, horizon 50\n", - "adding: mem time222, current time 271, horizon 49\n", - "adding: mem time223, current time 271, horizon 48\n", - "adding: mem time224, current time 271, horizon 47\n", - "adding: mem time225, current time 271, horizon 46\n", - "adding: mem time226, current time 271, horizon 45\n", - "adding: mem time227, current time 271, horizon 44\n", - "adding: mem time228, current time 271, horizon 43\n", - "adding: mem time229, current time 271, horizon 42\n", - "adding: mem time230, current time 271, horizon 41\n", - "adding: mem time231, current time 271, horizon 40\n", - "adding: mem time232, current time 271, horizon 39\n", - "adding: mem time233, current time 271, horizon 38\n", - "adding: mem time234, current time 271, horizon 37\n", - "adding: mem time235, current time 271, horizon 36\n", - "adding: mem time236, current time 271, horizon 35\n", - "adding: mem time237, current time 271, horizon 34\n", - "adding: mem time238, current time 271, horizon 33\n", - "adding: mem time239, current time 271, horizon 32\n", - "adding: mem time240, current time 271, horizon 31\n", - "adding: mem time241, current time 271, horizon 30\n", - "adding: mem time242, current time 271, horizon 29\n", - "adding: mem time243, current time 271, horizon 28\n", - "adding: mem time244, current time 271, horizon 27\n", - "adding: mem time245, current time 271, horizon 26\n", - "adding: mem time246, current time 271, horizon 25\n", - "adding: mem time247, current time 271, horizon 24\n", - "adding: mem time248, current time 271, horizon 23\n", - "adding: mem time249, current time 271, horizon 22\n", - "adding: mem time250, current time 271, horizon 21\n", - "adding: mem time251, current time 271, horizon 20\n", - "adding: mem time252, current time 271, horizon 19\n", - "adding: mem time253, current time 271, horizon 18\n", - "adding: mem time254, current time 271, horizon 17\n", - "adding: mem time255, current time 271, horizon 16\n", - "adding: mem time256, current time 271, horizon 15\n", - "adding: mem time257, current time 271, horizon 14\n", - "adding: mem time258, current time 271, horizon 13\n", - "adding: mem time259, current time 271, horizon 12\n", - "adding: mem time260, current time 271, horizon 11\n", - "adding: mem time261, current time 271, horizon 10\n", - "adding: mem time262, current time 271, horizon 9\n", - "adding: mem time263, current time 271, horizon 8\n", - "adding: mem time264, current time 271, horizon 7\n", - "adding: mem time265, current time 271, horizon 6\n", - "adding: mem time266, current time 271, horizon 5\n", - "adding: mem time267, current time 271, horizon 4\n", - "adding: mem time268, current time 271, horizon 3\n", - "adding: mem time269, current time 271, horizon 2\n", - "adding: mem time270, current time 271, horizon 1\n", - "adding: mem time200, current time 272, horizon 72\n", - "adding: mem time201, current time 272, horizon 71\n", - "adding: mem time202, current time 272, horizon 70\n", - "adding: mem time203, current time 272, horizon 69\n", - "adding: mem time204, current time 272, horizon 68\n", - "adding: mem time205, current time 272, horizon 67\n", - "adding: mem time206, current time 272, horizon 66\n", - "adding: mem time207, current time 272, horizon 65\n", - "adding: mem time208, current time 272, horizon 64\n", - "adding: mem time209, current time 272, horizon 63\n", - "adding: mem time210, current time 272, horizon 62\n", - "adding: mem time211, current time 272, horizon 61\n", - "adding: mem time212, current time 272, horizon 60\n", - "adding: mem time213, current time 272, horizon 59\n", - "adding: mem time214, current time 272, horizon 58\n", - "adding: mem time215, current time 272, horizon 57\n", - "adding: mem time216, current time 272, horizon 56\n", - "adding: mem time217, current time 272, horizon 55\n", - "adding: mem time218, current time 272, horizon 54\n", - "adding: mem time219, current time 272, horizon 53\n", - "adding: mem time220, current time 272, horizon 52\n", - "adding: mem time221, current time 272, horizon 51\n", - "adding: mem time222, current time 272, horizon 50\n", - "adding: mem time223, current time 272, horizon 49\n", - "adding: mem time224, current time 272, horizon 48\n", - "adding: mem time225, current time 272, horizon 47\n", - "adding: mem time226, current time 272, horizon 46\n", - "adding: mem time227, current time 272, horizon 45\n", - "adding: mem time228, current time 272, horizon 44\n", - "adding: mem time229, current time 272, horizon 43\n", - "adding: mem time230, current time 272, horizon 42\n", - "adding: mem time231, current time 272, horizon 41\n", - "adding: mem time232, current time 272, horizon 40\n", - "adding: mem time233, current time 272, horizon 39\n", - "adding: mem time234, current time 272, horizon 38\n", - "adding: mem time235, current time 272, horizon 37\n", - "adding: mem time236, current time 272, horizon 36\n", - "adding: mem time237, current time 272, horizon 35\n", - "adding: mem time238, current time 272, horizon 34\n", - "adding: mem time239, current time 272, horizon 33\n", - "adding: mem time240, current time 272, horizon 32\n", - "adding: mem time241, current time 272, horizon 31\n", - "adding: mem time242, current time 272, horizon 30\n", - "adding: mem time243, current time 272, horizon 29\n", - "adding: mem time244, current time 272, horizon 28\n", - "adding: mem time245, current time 272, horizon 27\n", - "adding: mem time246, current time 272, horizon 26\n", - "adding: mem time247, current time 272, horizon 25\n", - "adding: mem time248, current time 272, horizon 24\n", - "adding: mem time249, current time 272, horizon 23\n", - "adding: mem time250, current time 272, horizon 22\n", - "adding: mem time251, current time 272, horizon 21\n", - "adding: mem time252, current time 272, horizon 20\n", - "adding: mem time253, current time 272, horizon 19\n", - "adding: mem time254, current time 272, horizon 18\n", - "adding: mem time255, current time 272, horizon 17\n", - "adding: mem time256, current time 272, horizon 16\n", - "adding: mem time257, current time 272, horizon 15\n", - "adding: mem time258, current time 272, horizon 14\n", - "adding: mem time259, current time 272, horizon 13\n", - "adding: mem time260, current time 272, horizon 12\n", - "adding: mem time261, current time 272, horizon 11\n", - "adding: mem time262, current time 272, horizon 10\n", - "adding: mem time263, current time 272, horizon 9\n", - "adding: mem time264, current time 272, horizon 8\n", - "adding: mem time265, current time 272, horizon 7\n", - "adding: mem time266, current time 272, horizon 6\n", - "adding: mem time267, current time 272, horizon 5\n", - "adding: mem time268, current time 272, horizon 4\n", - "adding: mem time269, current time 272, horizon 3\n", - "adding: mem time270, current time 272, horizon 2\n", - "adding: mem time271, current time 272, horizon 1\n", - "adding: mem time200, current time 273, horizon 73\n", - "adding: mem time201, current time 273, horizon 72\n", - "adding: mem time202, current time 273, horizon 71\n", - "adding: mem time203, current time 273, horizon 70\n", - "adding: mem time204, current time 273, horizon 69\n", - "adding: mem time205, current time 273, horizon 68\n", - "adding: mem time206, current time 273, horizon 67\n", - "adding: mem time207, current time 273, horizon 66\n", - "adding: mem time208, current time 273, horizon 65\n", - "adding: mem time209, current time 273, horizon 64\n", - "adding: mem time210, current time 273, horizon 63\n", - "adding: mem time211, current time 273, horizon 62\n", - "adding: mem time212, current time 273, horizon 61\n", - "adding: mem time213, current time 273, horizon 60\n", - "adding: mem time214, current time 273, horizon 59\n", - "adding: mem time215, current time 273, horizon 58\n", - "adding: mem time216, current time 273, horizon 57\n", - "adding: mem time217, current time 273, horizon 56\n", - "adding: mem time218, current time 273, horizon 55\n", - "adding: mem time219, current time 273, horizon 54\n", - "adding: mem time220, current time 273, horizon 53\n", - "adding: mem time221, current time 273, horizon 52\n", - "adding: mem time222, current time 273, horizon 51\n", - "adding: mem time223, current time 273, horizon 50\n", - "adding: mem time224, current time 273, horizon 49\n", - "adding: mem time225, current time 273, horizon 48\n", - "adding: mem time226, current time 273, horizon 47\n", - "adding: mem time227, current time 273, horizon 46\n", - "adding: mem time228, current time 273, horizon 45\n", - "adding: mem time229, current time 273, horizon 44\n", - "adding: mem time230, current time 273, horizon 43\n", - "adding: mem time231, current time 273, horizon 42\n", - "adding: mem time232, current time 273, horizon 41\n", - "adding: mem time233, current time 273, horizon 40\n", - "adding: mem time234, current time 273, horizon 39\n", - "adding: mem time235, current time 273, horizon 38\n", - "adding: mem time236, current time 273, horizon 37\n", - "adding: mem time237, current time 273, horizon 36\n", - "adding: mem time238, current time 273, horizon 35\n", - "adding: mem time239, current time 273, horizon 34\n", - "adding: mem time240, current time 273, horizon 33\n", - "adding: mem time241, current time 273, horizon 32\n", - "adding: mem time242, current time 273, horizon 31\n", - "adding: mem time243, current time 273, horizon 30\n", - "adding: mem time244, current time 273, horizon 29\n", - "adding: mem time245, current time 273, horizon 28\n", - "adding: mem time246, current time 273, horizon 27\n", - "adding: mem time247, current time 273, horizon 26\n", - "adding: mem time248, current time 273, horizon 25\n", - "adding: mem time249, current time 273, horizon 24\n", - "adding: mem time250, current time 273, horizon 23\n", - "adding: mem time251, current time 273, horizon 22\n", - "adding: mem time252, current time 273, horizon 21\n", - "adding: mem time253, current time 273, horizon 20\n", - "adding: mem time254, current time 273, horizon 19\n", - "adding: mem time255, current time 273, horizon 18\n", - "adding: mem time256, current time 273, horizon 17\n", - "adding: mem time257, current time 273, horizon 16\n", - "adding: mem time258, current time 273, horizon 15\n", - "adding: mem time259, current time 273, horizon 14\n", - "adding: mem time260, current time 273, horizon 13\n", - "adding: mem time261, current time 273, horizon 12\n", - "adding: mem time262, current time 273, horizon 11\n", - "adding: mem time263, current time 273, horizon 10\n", - "adding: mem time264, current time 273, horizon 9\n", - "adding: mem time265, current time 273, horizon 8\n", - "adding: mem time266, current time 273, horizon 7\n", - "adding: mem time267, current time 273, horizon 6\n", - "adding: mem time268, current time 273, horizon 5\n", - "adding: mem time269, current time 273, horizon 4\n", - "adding: mem time270, current time 273, horizon 3\n", - "adding: mem time271, current time 273, horizon 2\n", - "adding: mem time272, current time 273, horizon 1\n", - "adding: mem time200, current time 274, horizon 74\n", - "adding: mem time201, current time 274, horizon 73\n", - "adding: mem time202, current time 274, horizon 72\n", - "adding: mem time203, current time 274, horizon 71\n", - "adding: mem time204, current time 274, horizon 70\n", - "adding: mem time205, current time 274, horizon 69\n", - "adding: mem time206, current time 274, horizon 68\n", - "adding: mem time207, current time 274, horizon 67\n", - "adding: mem time208, current time 274, horizon 66\n", - "adding: mem time209, current time 274, horizon 65\n", - "adding: mem time210, current time 274, horizon 64\n", - "adding: mem time211, current time 274, horizon 63\n", - "adding: mem time212, current time 274, horizon 62\n", - "adding: mem time213, current time 274, horizon 61\n", - "adding: mem time214, current time 274, horizon 60\n", - "adding: mem time215, current time 274, horizon 59\n", - "adding: mem time216, current time 274, horizon 58\n", - "adding: mem time217, current time 274, horizon 57\n", - "adding: mem time218, current time 274, horizon 56\n", - "adding: mem time219, current time 274, horizon 55\n", - "adding: mem time220, current time 274, horizon 54\n", - "adding: mem time221, current time 274, horizon 53\n", - "adding: mem time222, current time 274, horizon 52\n", - "adding: mem time223, current time 274, horizon 51\n", - "adding: mem time224, current time 274, horizon 50\n", - "adding: mem time225, current time 274, horizon 49\n", - "adding: mem time226, current time 274, horizon 48\n", - "adding: mem time227, current time 274, horizon 47\n", - "adding: mem time228, current time 274, horizon 46\n", - "adding: mem time229, current time 274, horizon 45\n", - "adding: mem time230, current time 274, horizon 44\n", - "adding: mem time231, current time 274, horizon 43\n", - "adding: mem time232, current time 274, horizon 42\n", - "adding: mem time233, current time 274, horizon 41\n", - "adding: mem time234, current time 274, horizon 40\n", - "adding: mem time235, current time 274, horizon 39\n", - "adding: mem time236, current time 274, horizon 38\n", - "adding: mem time237, current time 274, horizon 37\n", - "adding: mem time238, current time 274, horizon 36\n", - "adding: mem time239, current time 274, horizon 35\n", - "adding: mem time240, current time 274, horizon 34\n", - "adding: mem time241, current time 274, horizon 33\n", - "adding: mem time242, current time 274, horizon 32\n", - "adding: mem time243, current time 274, horizon 31\n", - "adding: mem time244, current time 274, horizon 30\n", - "adding: mem time245, current time 274, horizon 29\n", - "adding: mem time246, current time 274, horizon 28\n", - "adding: mem time247, current time 274, horizon 27\n", - "adding: mem time248, current time 274, horizon 26\n", - "adding: mem time249, current time 274, horizon 25\n", - "adding: mem time250, current time 274, horizon 24\n", - "adding: mem time251, current time 274, horizon 23\n", - "adding: mem time252, current time 274, horizon 22\n", - "adding: mem time253, current time 274, horizon 21\n", - "adding: mem time254, current time 274, horizon 20\n", - "adding: mem time255, current time 274, horizon 19\n", - "adding: mem time256, current time 274, horizon 18\n", - "adding: mem time257, current time 274, horizon 17\n", - "adding: mem time258, current time 274, horizon 16\n", - "adding: mem time259, current time 274, horizon 15\n", - "adding: mem time260, current time 274, horizon 14\n", - "adding: mem time261, current time 274, horizon 13\n", - "adding: mem time262, current time 274, horizon 12\n", - "adding: mem time263, current time 274, horizon 11\n", - "adding: mem time264, current time 274, horizon 10\n", - "adding: mem time265, current time 274, horizon 9\n", - "adding: mem time266, current time 274, horizon 8\n", - "adding: mem time267, current time 274, horizon 7\n", - "adding: mem time268, current time 274, horizon 6\n", - "adding: mem time269, current time 274, horizon 5\n", - "adding: mem time270, current time 274, horizon 4\n", - "adding: mem time271, current time 274, horizon 3\n", - "adding: mem time272, current time 274, horizon 2\n", - "adding: mem time273, current time 274, horizon 1\n", - "adding: mem time200, current time 275, horizon 75\n", - "adding: mem time201, current time 275, horizon 74\n", - "adding: mem time202, current time 275, horizon 73\n", - "adding: mem time203, current time 275, horizon 72\n", - "adding: mem time204, current time 275, horizon 71\n", - "adding: mem time205, current time 275, horizon 70\n", - "adding: mem time206, current time 275, horizon 69\n", - "adding: mem time207, current time 275, horizon 68\n", - "adding: mem time208, current time 275, horizon 67\n", - "adding: mem time209, current time 275, horizon 66\n", - "adding: mem time210, current time 275, horizon 65\n", - "adding: mem time211, current time 275, horizon 64\n", - "adding: mem time212, current time 275, horizon 63\n", - "adding: mem time213, current time 275, horizon 62\n", - "adding: mem time214, current time 275, horizon 61\n", - "adding: mem time215, current time 275, horizon 60\n", - "adding: mem time216, current time 275, horizon 59\n", - "adding: mem time217, current time 275, horizon 58\n", - "adding: mem time218, current time 275, horizon 57\n", - "adding: mem time219, current time 275, horizon 56\n", - "adding: mem time220, current time 275, horizon 55\n", - "adding: mem time221, current time 275, horizon 54\n", - "adding: mem time222, current time 275, horizon 53\n", - "adding: mem time223, current time 275, horizon 52\n", - "adding: mem time224, current time 275, horizon 51\n", - "adding: mem time225, current time 275, horizon 50\n", - "adding: mem time226, current time 275, horizon 49\n", - "adding: mem time227, current time 275, horizon 48\n", - "adding: mem time228, current time 275, horizon 47\n", - "adding: mem time229, current time 275, horizon 46\n", - "adding: mem time230, current time 275, horizon 45\n", - "adding: mem time231, current time 275, horizon 44\n", - "adding: mem time232, current time 275, horizon 43\n", - "adding: mem time233, current time 275, horizon 42\n", - "adding: mem time234, current time 275, horizon 41\n", - "adding: mem time235, current time 275, horizon 40\n", - "adding: mem time236, current time 275, horizon 39\n", - "adding: mem time237, current time 275, horizon 38\n", - "adding: mem time238, current time 275, horizon 37\n", - "adding: mem time239, current time 275, horizon 36\n", - "adding: mem time240, current time 275, horizon 35\n", - "adding: mem time241, current time 275, horizon 34\n", - "adding: mem time242, current time 275, horizon 33\n", - "adding: mem time243, current time 275, horizon 32\n", - "adding: mem time244, current time 275, horizon 31\n", - "adding: mem time245, current time 275, horizon 30\n", - "adding: mem time246, current time 275, horizon 29\n", - "adding: mem time247, current time 275, horizon 28\n", - "adding: mem time248, current time 275, horizon 27\n", - "adding: mem time249, current time 275, horizon 26\n", - "adding: mem time250, current time 275, horizon 25\n", - "adding: mem time251, current time 275, horizon 24\n", - "adding: mem time252, current time 275, horizon 23\n", - "adding: mem time253, current time 275, horizon 22\n", - "adding: mem time254, current time 275, horizon 21\n", - "adding: mem time255, current time 275, horizon 20\n", - "adding: mem time256, current time 275, horizon 19\n", - "adding: mem time257, current time 275, horizon 18\n", - "adding: mem time258, current time 275, horizon 17\n", - "adding: mem time259, current time 275, horizon 16\n", - "adding: mem time260, current time 275, horizon 15\n", - "adding: mem time261, current time 275, horizon 14\n", - "adding: mem time262, current time 275, horizon 13\n", - "adding: mem time263, current time 275, horizon 12\n", - "adding: mem time264, current time 275, horizon 11\n", - "adding: mem time265, current time 275, horizon 10\n", - "adding: mem time266, current time 275, horizon 9\n", - "adding: mem time267, current time 275, horizon 8\n", - "adding: mem time268, current time 275, horizon 7\n", - "adding: mem time269, current time 275, horizon 6\n", - "adding: mem time270, current time 275, horizon 5\n", - "adding: mem time271, current time 275, horizon 4\n", - "adding: mem time272, current time 275, horizon 3\n", - "adding: mem time273, current time 275, horizon 2\n", - "adding: mem time274, current time 275, horizon 1\n", - "adding: mem time200, current time 276, horizon 76\n", - "adding: mem time201, current time 276, horizon 75\n", - "adding: mem time202, current time 276, horizon 74\n", - "adding: mem time203, current time 276, horizon 73\n", - "adding: mem time204, current time 276, horizon 72\n", - "adding: mem time205, current time 276, horizon 71\n", - "adding: mem time206, current time 276, horizon 70\n", - "adding: mem time207, current time 276, horizon 69\n", - "adding: mem time208, current time 276, horizon 68\n", - "adding: mem time209, current time 276, horizon 67\n", - "adding: mem time210, current time 276, horizon 66\n", - "adding: mem time211, current time 276, horizon 65\n", - "adding: mem time212, current time 276, horizon 64\n", - "adding: mem time213, current time 276, horizon 63\n", - "adding: mem time214, current time 276, horizon 62\n", - "adding: mem time215, current time 276, horizon 61\n", - "adding: mem time216, current time 276, horizon 60\n", - "adding: mem time217, current time 276, horizon 59\n", - "adding: mem time218, current time 276, horizon 58\n", - "adding: mem time219, current time 276, horizon 57\n", - "adding: mem time220, current time 276, horizon 56\n", - "adding: mem time221, current time 276, horizon 55\n", - "adding: mem time222, current time 276, horizon 54\n", - "adding: mem time223, current time 276, horizon 53\n", - "adding: mem time224, current time 276, horizon 52\n", - "adding: mem time225, current time 276, horizon 51\n", - "adding: mem time226, current time 276, horizon 50\n", - "adding: mem time227, current time 276, horizon 49\n", - "adding: mem time228, current time 276, horizon 48\n", - "adding: mem time229, current time 276, horizon 47\n", - "adding: mem time230, current time 276, horizon 46\n", - "adding: mem time231, current time 276, horizon 45\n", - "adding: mem time232, current time 276, horizon 44\n", - "adding: mem time233, current time 276, horizon 43\n", - "adding: mem time234, current time 276, horizon 42\n", - "adding: mem time235, current time 276, horizon 41\n", - "adding: mem time236, current time 276, horizon 40\n", - "adding: mem time237, current time 276, horizon 39\n", - "adding: mem time238, current time 276, horizon 38\n", - "adding: mem time239, current time 276, horizon 37\n", - "adding: mem time240, current time 276, horizon 36\n", - "adding: mem time241, current time 276, horizon 35\n", - "adding: mem time242, current time 276, horizon 34\n", - "adding: mem time243, current time 276, horizon 33\n", - "adding: mem time244, current time 276, horizon 32\n", - "adding: mem time245, current time 276, horizon 31\n", - "adding: mem time246, current time 276, horizon 30\n", - "adding: mem time247, current time 276, horizon 29\n", - "adding: mem time248, current time 276, horizon 28\n", - "adding: mem time249, current time 276, horizon 27\n", - "adding: mem time250, current time 276, horizon 26\n", - "adding: mem time251, current time 276, horizon 25\n", - "adding: mem time252, current time 276, horizon 24\n", - "adding: mem time253, current time 276, horizon 23\n", - "adding: mem time254, current time 276, horizon 22\n", - "adding: mem time255, current time 276, horizon 21\n", - "adding: mem time256, current time 276, horizon 20\n", - "adding: mem time257, current time 276, horizon 19\n", - "adding: mem time258, current time 276, horizon 18\n", - "adding: mem time259, current time 276, horizon 17\n", - "adding: mem time260, current time 276, horizon 16\n", - "adding: mem time261, current time 276, horizon 15\n", - "adding: mem time262, current time 276, horizon 14\n", - "adding: mem time263, current time 276, horizon 13\n", - "adding: mem time264, current time 276, horizon 12\n", - "adding: mem time265, current time 276, horizon 11\n", - "adding: mem time266, current time 276, horizon 10\n", - "adding: mem time267, current time 276, horizon 9\n", - "adding: mem time268, current time 276, horizon 8\n", - "adding: mem time269, current time 276, horizon 7\n", - "adding: mem time270, current time 276, horizon 6\n", - "adding: mem time271, current time 276, horizon 5\n", - "adding: mem time272, current time 276, horizon 4\n", - "adding: mem time273, current time 276, horizon 3\n", - "adding: mem time274, current time 276, horizon 2\n", - "adding: mem time275, current time 276, horizon 1\n", - "adding: mem time200, current time 277, horizon 77\n", - "adding: mem time201, current time 277, horizon 76\n", - "adding: mem time202, current time 277, horizon 75\n", - "adding: mem time203, current time 277, horizon 74\n", - "adding: mem time204, current time 277, horizon 73\n", - "adding: mem time205, current time 277, horizon 72\n", - "adding: mem time206, current time 277, horizon 71\n", - "adding: mem time207, current time 277, horizon 70\n", - "adding: mem time208, current time 277, horizon 69\n", - "adding: mem time209, current time 277, horizon 68\n", - "adding: mem time210, current time 277, horizon 67\n", - "adding: mem time211, current time 277, horizon 66\n", - "adding: mem time212, current time 277, horizon 65\n", - "adding: mem time213, current time 277, horizon 64\n", - "adding: mem time214, current time 277, horizon 63\n", - "adding: mem time215, current time 277, horizon 62\n", - "adding: mem time216, current time 277, horizon 61\n", - "adding: mem time217, current time 277, horizon 60\n", - "adding: mem time218, current time 277, horizon 59\n", - "adding: mem time219, current time 277, horizon 58\n", - "adding: mem time220, current time 277, horizon 57\n", - "adding: mem time221, current time 277, horizon 56\n", - "adding: mem time222, current time 277, horizon 55\n", - "adding: mem time223, current time 277, horizon 54\n", - "adding: mem time224, current time 277, horizon 53\n", - "adding: mem time225, current time 277, horizon 52\n", - "adding: mem time226, current time 277, horizon 51\n", - "adding: mem time227, current time 277, horizon 50\n", - "adding: mem time228, current time 277, horizon 49\n", - "adding: mem time229, current time 277, horizon 48\n", - "adding: mem time230, current time 277, horizon 47\n", - "adding: mem time231, current time 277, horizon 46\n", - "adding: mem time232, current time 277, horizon 45\n", - "adding: mem time233, current time 277, horizon 44\n", - "adding: mem time234, current time 277, horizon 43\n", - "adding: mem time235, current time 277, horizon 42\n", - "adding: mem time236, current time 277, horizon 41\n", - "adding: mem time237, current time 277, horizon 40\n", - "adding: mem time238, current time 277, horizon 39\n", - "adding: mem time239, current time 277, horizon 38\n", - "adding: mem time240, current time 277, horizon 37\n", - "adding: mem time241, current time 277, horizon 36\n", - "adding: mem time242, current time 277, horizon 35\n", - "adding: mem time243, current time 277, horizon 34\n", - "adding: mem time244, current time 277, horizon 33\n", - "adding: mem time245, current time 277, horizon 32\n", - "adding: mem time246, current time 277, horizon 31\n", - "adding: mem time247, current time 277, horizon 30\n", - "adding: mem time248, current time 277, horizon 29\n", - "adding: mem time249, current time 277, horizon 28\n", - "adding: mem time250, current time 277, horizon 27\n", - "adding: mem time251, current time 277, horizon 26\n", - "adding: mem time252, current time 277, horizon 25\n", - "adding: mem time253, current time 277, horizon 24\n", - "adding: mem time254, current time 277, horizon 23\n", - "adding: mem time255, current time 277, horizon 22\n", - "adding: mem time256, current time 277, horizon 21\n", - "adding: mem time257, current time 277, horizon 20\n", - "adding: mem time258, current time 277, horizon 19\n", - "adding: mem time259, current time 277, horizon 18\n", - "adding: mem time260, current time 277, horizon 17\n", - "adding: mem time261, current time 277, horizon 16\n", - "adding: mem time262, current time 277, horizon 15\n", - "adding: mem time263, current time 277, horizon 14\n", - "adding: mem time264, current time 277, horizon 13\n", - "adding: mem time265, current time 277, horizon 12\n", - "adding: mem time266, current time 277, horizon 11\n", - "adding: mem time267, current time 277, horizon 10\n", - "adding: mem time268, current time 277, horizon 9\n", - "adding: mem time269, current time 277, horizon 8\n", - "adding: mem time270, current time 277, horizon 7\n", - "adding: mem time271, current time 277, horizon 6\n", - "adding: mem time272, current time 277, horizon 5\n", - "adding: mem time273, current time 277, horizon 4\n", - "adding: mem time274, current time 277, horizon 3\n", - "adding: mem time275, current time 277, horizon 2\n", - "adding: mem time276, current time 277, horizon 1\n", - "adding: mem time200, current time 278, horizon 78\n", - "adding: mem time201, current time 278, horizon 77\n", - "adding: mem time202, current time 278, horizon 76\n", - "adding: mem time203, current time 278, horizon 75\n", - "adding: mem time204, current time 278, horizon 74\n", - "adding: mem time205, current time 278, horizon 73\n", - "adding: mem time206, current time 278, horizon 72\n", - "adding: mem time207, current time 278, horizon 71\n", - "adding: mem time208, current time 278, horizon 70\n", - "adding: mem time209, current time 278, horizon 69\n", - "adding: mem time210, current time 278, horizon 68\n", - "adding: mem time211, current time 278, horizon 67\n", - "adding: mem time212, current time 278, horizon 66\n", - "adding: mem time213, current time 278, horizon 65\n", - "adding: mem time214, current time 278, horizon 64\n", - "adding: mem time215, current time 278, horizon 63\n", - "adding: mem time216, current time 278, horizon 62\n", - "adding: mem time217, current time 278, horizon 61\n", - "adding: mem time218, current time 278, horizon 60\n", - "adding: mem time219, current time 278, horizon 59\n", - "adding: mem time220, current time 278, horizon 58\n", - "adding: mem time221, current time 278, horizon 57\n", - "adding: mem time222, current time 278, horizon 56\n", - "adding: mem time223, current time 278, horizon 55\n", - "adding: mem time224, current time 278, horizon 54\n", - "adding: mem time225, current time 278, horizon 53\n", - "adding: mem time226, current time 278, horizon 52\n", - "adding: mem time227, current time 278, horizon 51\n", - "adding: mem time228, current time 278, horizon 50\n", - "adding: mem time229, current time 278, horizon 49\n", - "adding: mem time230, current time 278, horizon 48\n", - "adding: mem time231, current time 278, horizon 47\n", - "adding: mem time232, current time 278, horizon 46\n", - "adding: mem time233, current time 278, horizon 45\n", - "adding: mem time234, current time 278, horizon 44\n", - "adding: mem time235, current time 278, horizon 43\n", - "adding: mem time236, current time 278, horizon 42\n", - "adding: mem time237, current time 278, horizon 41\n", - "adding: mem time238, current time 278, horizon 40\n", - "adding: mem time239, current time 278, horizon 39\n", - "adding: mem time240, current time 278, horizon 38\n", - "adding: mem time241, current time 278, horizon 37\n", - "adding: mem time242, current time 278, horizon 36\n", - "adding: mem time243, current time 278, horizon 35\n", - "adding: mem time244, current time 278, horizon 34\n", - "adding: mem time245, current time 278, horizon 33\n", - "adding: mem time246, current time 278, horizon 32\n", - "adding: mem time247, current time 278, horizon 31\n", - "adding: mem time248, current time 278, horizon 30\n", - "adding: mem time249, current time 278, horizon 29\n", - "adding: mem time250, current time 278, horizon 28\n", - "adding: mem time251, current time 278, horizon 27\n", - "adding: mem time252, current time 278, horizon 26\n", - "adding: mem time253, current time 278, horizon 25\n", - "adding: mem time254, current time 278, horizon 24\n", - "adding: mem time255, current time 278, horizon 23\n", - "adding: mem time256, current time 278, horizon 22\n", - "adding: mem time257, current time 278, horizon 21\n", - "adding: mem time258, current time 278, horizon 20\n", - "adding: mem time259, current time 278, horizon 19\n", - "adding: mem time260, current time 278, horizon 18\n", - "adding: mem time261, current time 278, horizon 17\n", - "adding: mem time262, current time 278, horizon 16\n", - "adding: mem time263, current time 278, horizon 15\n", - "adding: mem time264, current time 278, horizon 14\n", - "adding: mem time265, current time 278, horizon 13\n", - "adding: mem time266, current time 278, horizon 12\n", - "adding: mem time267, current time 278, horizon 11\n", - "adding: mem time268, current time 278, horizon 10\n", - "adding: mem time269, current time 278, horizon 9\n", - "adding: mem time270, current time 278, horizon 8\n", - "adding: mem time271, current time 278, horizon 7\n", - "adding: mem time272, current time 278, horizon 6\n", - "adding: mem time273, current time 278, horizon 5\n", - "adding: mem time274, current time 278, horizon 4\n", - "adding: mem time275, current time 278, horizon 3\n", - "adding: mem time276, current time 278, horizon 2\n", - "adding: mem time277, current time 278, horizon 1\n", - "adding: mem time200, current time 279, horizon 79\n", - "adding: mem time201, current time 279, horizon 78\n", - "adding: mem time202, current time 279, horizon 77\n", - "adding: mem time203, current time 279, horizon 76\n", - "adding: mem time204, current time 279, horizon 75\n", - "adding: mem time205, current time 279, horizon 74\n", - "adding: mem time206, current time 279, horizon 73\n", - "adding: mem time207, current time 279, horizon 72\n", - "adding: mem time208, current time 279, horizon 71\n", - "adding: mem time209, current time 279, horizon 70\n", - "adding: mem time210, current time 279, horizon 69\n", - "adding: mem time211, current time 279, horizon 68\n", - "adding: mem time212, current time 279, horizon 67\n", - "adding: mem time213, current time 279, horizon 66\n", - "adding: mem time214, current time 279, horizon 65\n", - "adding: mem time215, current time 279, horizon 64\n", - "adding: mem time216, current time 279, horizon 63\n", - "adding: mem time217, current time 279, horizon 62\n", - "adding: mem time218, current time 279, horizon 61\n", - "adding: mem time219, current time 279, horizon 60\n", - "adding: mem time220, current time 279, horizon 59\n", - "adding: mem time221, current time 279, horizon 58\n", - "adding: mem time222, current time 279, horizon 57\n", - "adding: mem time223, current time 279, horizon 56\n", - "adding: mem time224, current time 279, horizon 55\n", - "adding: mem time225, current time 279, horizon 54\n", - "adding: mem time226, current time 279, horizon 53\n", - "adding: mem time227, current time 279, horizon 52\n", - "adding: mem time228, current time 279, horizon 51\n", - "adding: mem time229, current time 279, horizon 50\n", - "adding: mem time230, current time 279, horizon 49\n", - "adding: mem time231, current time 279, horizon 48\n", - "adding: mem time232, current time 279, horizon 47\n", - "adding: mem time233, current time 279, horizon 46\n", - "adding: mem time234, current time 279, horizon 45\n", - "adding: mem time235, current time 279, horizon 44\n", - "adding: mem time236, current time 279, horizon 43\n", - "adding: mem time237, current time 279, horizon 42\n", - "adding: mem time238, current time 279, horizon 41\n", - "adding: mem time239, current time 279, horizon 40\n", - "adding: mem time240, current time 279, horizon 39\n", - "adding: mem time241, current time 279, horizon 38\n", - "adding: mem time242, current time 279, horizon 37\n", - "adding: mem time243, current time 279, horizon 36\n", - "adding: mem time244, current time 279, horizon 35\n", - "adding: mem time245, current time 279, horizon 34\n", - "adding: mem time246, current time 279, horizon 33\n", - "adding: mem time247, current time 279, horizon 32\n", - "adding: mem time248, current time 279, horizon 31\n", - "adding: mem time249, current time 279, horizon 30\n", - "adding: mem time250, current time 279, horizon 29\n", - "adding: mem time251, current time 279, horizon 28\n", - "adding: mem time252, current time 279, horizon 27\n", - "adding: mem time253, current time 279, horizon 26\n", - "adding: mem time254, current time 279, horizon 25\n", - "adding: mem time255, current time 279, horizon 24\n", - "adding: mem time256, current time 279, horizon 23\n", - "adding: mem time257, current time 279, horizon 22\n", - "adding: mem time258, current time 279, horizon 21\n", - "adding: mem time259, current time 279, horizon 20\n", - "adding: mem time260, current time 279, horizon 19\n", - "adding: mem time261, current time 279, horizon 18\n", - "adding: mem time262, current time 279, horizon 17\n", - "adding: mem time263, current time 279, horizon 16\n", - "adding: mem time264, current time 279, horizon 15\n", - "adding: mem time265, current time 279, horizon 14\n", - "adding: mem time266, current time 279, horizon 13\n", - "adding: mem time267, current time 279, horizon 12\n", - "adding: mem time268, current time 279, horizon 11\n", - "adding: mem time269, current time 279, horizon 10\n", - "adding: mem time270, current time 279, horizon 9\n", - "adding: mem time271, current time 279, horizon 8\n", - "adding: mem time272, current time 279, horizon 7\n", - "adding: mem time273, current time 279, horizon 6\n", - "adding: mem time274, current time 279, horizon 5\n", - "adding: mem time275, current time 279, horizon 4\n", - "adding: mem time276, current time 279, horizon 3\n", - "adding: mem time277, current time 279, horizon 2\n", - "adding: mem time278, current time 279, horizon 1\n", - "adding: mem time200, current time 280, horizon 80\n", - "adding: mem time201, current time 280, horizon 79\n", - "adding: mem time202, current time 280, horizon 78\n", - "adding: mem time203, current time 280, horizon 77\n", - "adding: mem time204, current time 280, horizon 76\n", - "adding: mem time205, current time 280, horizon 75\n", - "adding: mem time206, current time 280, horizon 74\n", - "adding: mem time207, current time 280, horizon 73\n", - "adding: mem time208, current time 280, horizon 72\n", - "adding: mem time209, current time 280, horizon 71\n", - "adding: mem time210, current time 280, horizon 70\n", - "adding: mem time211, current time 280, horizon 69\n", - "adding: mem time212, current time 280, horizon 68\n", - "adding: mem time213, current time 280, horizon 67\n", - "adding: mem time214, current time 280, horizon 66\n", - "adding: mem time215, current time 280, horizon 65\n", - "adding: mem time216, current time 280, horizon 64\n", - "adding: mem time217, current time 280, horizon 63\n", - "adding: mem time218, current time 280, horizon 62\n", - "adding: mem time219, current time 280, horizon 61\n", - "adding: mem time220, current time 280, horizon 60\n", - "adding: mem time221, current time 280, horizon 59\n", - "adding: mem time222, current time 280, horizon 58\n", - "adding: mem time223, current time 280, horizon 57\n", - "adding: mem time224, current time 280, horizon 56\n", - "adding: mem time225, current time 280, horizon 55\n", - "adding: mem time226, current time 280, horizon 54\n", - "adding: mem time227, current time 280, horizon 53\n", - "adding: mem time228, current time 280, horizon 52\n", - "adding: mem time229, current time 280, horizon 51\n", - "adding: mem time230, current time 280, horizon 50\n", - "adding: mem time231, current time 280, horizon 49\n", - "adding: mem time232, current time 280, horizon 48\n", - "adding: mem time233, current time 280, horizon 47\n", - "adding: mem time234, current time 280, horizon 46\n", - "adding: mem time235, current time 280, horizon 45\n", - "adding: mem time236, current time 280, horizon 44\n", - "adding: mem time237, current time 280, horizon 43\n", - "adding: mem time238, current time 280, horizon 42\n", - "adding: mem time239, current time 280, horizon 41\n", - "adding: mem time240, current time 280, horizon 40\n", - "adding: mem time241, current time 280, horizon 39\n", - "adding: mem time242, current time 280, horizon 38\n", - "adding: mem time243, current time 280, horizon 37\n", - "adding: mem time244, current time 280, horizon 36\n", - "adding: mem time245, current time 280, horizon 35\n", - "adding: mem time246, current time 280, horizon 34\n", - "adding: mem time247, current time 280, horizon 33\n", - "adding: mem time248, current time 280, horizon 32\n", - "adding: mem time249, current time 280, horizon 31\n", - "adding: mem time250, current time 280, horizon 30\n", - "adding: mem time251, current time 280, horizon 29\n", - "adding: mem time252, current time 280, horizon 28\n", - "adding: mem time253, current time 280, horizon 27\n", - "adding: mem time254, current time 280, horizon 26\n", - "adding: mem time255, current time 280, horizon 25\n", - "adding: mem time256, current time 280, horizon 24\n", - "adding: mem time257, current time 280, horizon 23\n", - "adding: mem time258, current time 280, horizon 22\n", - "adding: mem time259, current time 280, horizon 21\n", - "adding: mem time260, current time 280, horizon 20\n", - "adding: mem time261, current time 280, horizon 19\n", - "adding: mem time262, current time 280, horizon 18\n", - "adding: mem time263, current time 280, horizon 17\n", - "adding: mem time264, current time 280, horizon 16\n", - "adding: mem time265, current time 280, horizon 15\n", - "adding: mem time266, current time 280, horizon 14\n", - "adding: mem time267, current time 280, horizon 13\n", - "adding: mem time268, current time 280, horizon 12\n", - "adding: mem time269, current time 280, horizon 11\n", - "adding: mem time270, current time 280, horizon 10\n", - "adding: mem time271, current time 280, horizon 9\n", - "adding: mem time272, current time 280, horizon 8\n", - "adding: mem time273, current time 280, horizon 7\n", - "adding: mem time274, current time 280, horizon 6\n", - "adding: mem time275, current time 280, horizon 5\n", - "adding: mem time276, current time 280, horizon 4\n", - "adding: mem time277, current time 280, horizon 3\n", - "adding: mem time278, current time 280, horizon 2\n", - "adding: mem time279, current time 280, horizon 1\n", - "adding: mem time200, current time 281, horizon 81\n", - "adding: mem time201, current time 281, horizon 80\n", - "adding: mem time202, current time 281, horizon 79\n", - "adding: mem time203, current time 281, horizon 78\n", - "adding: mem time204, current time 281, horizon 77\n", - "adding: mem time205, current time 281, horizon 76\n", - "adding: mem time206, current time 281, horizon 75\n", - "adding: mem time207, current time 281, horizon 74\n", - "adding: mem time208, current time 281, horizon 73\n", - "adding: mem time209, current time 281, horizon 72\n", - "adding: mem time210, current time 281, horizon 71\n", - "adding: mem time211, current time 281, horizon 70\n", - "adding: mem time212, current time 281, horizon 69\n", - "adding: mem time213, current time 281, horizon 68\n", - "adding: mem time214, current time 281, horizon 67\n", - "adding: mem time215, current time 281, horizon 66\n", - "adding: mem time216, current time 281, horizon 65\n", - "adding: mem time217, current time 281, horizon 64\n", - "adding: mem time218, current time 281, horizon 63\n", - "adding: mem time219, current time 281, horizon 62\n", - "adding: mem time220, current time 281, horizon 61\n", - "adding: mem time221, current time 281, horizon 60\n", - "adding: mem time222, current time 281, horizon 59\n", - "adding: mem time223, current time 281, horizon 58\n", - "adding: mem time224, current time 281, horizon 57\n", - "adding: mem time225, current time 281, horizon 56\n", - "adding: mem time226, current time 281, horizon 55\n", - "adding: mem time227, current time 281, horizon 54\n", - "adding: mem time228, current time 281, horizon 53\n", - "adding: mem time229, current time 281, horizon 52\n", - "adding: mem time230, current time 281, horizon 51\n", - "adding: mem time231, current time 281, horizon 50\n", - "adding: mem time232, current time 281, horizon 49\n", - "adding: mem time233, current time 281, horizon 48\n", - "adding: mem time234, current time 281, horizon 47\n", - "adding: mem time235, current time 281, horizon 46\n", - "adding: mem time236, current time 281, horizon 45\n", - "adding: mem time237, current time 281, horizon 44\n", - "adding: mem time238, current time 281, horizon 43\n", - "adding: mem time239, current time 281, horizon 42\n", - "adding: mem time240, current time 281, horizon 41\n", - "adding: mem time241, current time 281, horizon 40\n", - "adding: mem time242, current time 281, horizon 39\n", - "adding: mem time243, current time 281, horizon 38\n", - "adding: mem time244, current time 281, horizon 37\n", - "adding: mem time245, current time 281, horizon 36\n", - "adding: mem time246, current time 281, horizon 35\n", - "adding: mem time247, current time 281, horizon 34\n", - "adding: mem time248, current time 281, horizon 33\n", - "adding: mem time249, current time 281, horizon 32\n", - "adding: mem time250, current time 281, horizon 31\n", - "adding: mem time251, current time 281, horizon 30\n", - "adding: mem time252, current time 281, horizon 29\n", - "adding: mem time253, current time 281, horizon 28\n", - "adding: mem time254, current time 281, horizon 27\n", - "adding: mem time255, current time 281, horizon 26\n", - "adding: mem time256, current time 281, horizon 25\n", - "adding: mem time257, current time 281, horizon 24\n", - "adding: mem time258, current time 281, horizon 23\n", - "adding: mem time259, current time 281, horizon 22\n", - "adding: mem time260, current time 281, horizon 21\n", - "adding: mem time261, current time 281, horizon 20\n", - "adding: mem time262, current time 281, horizon 19\n", - "adding: mem time263, current time 281, horizon 18\n", - "adding: mem time264, current time 281, horizon 17\n", - "adding: mem time265, current time 281, horizon 16\n", - "adding: mem time266, current time 281, horizon 15\n", - "adding: mem time267, current time 281, horizon 14\n", - "adding: mem time268, current time 281, horizon 13\n", - "adding: mem time269, current time 281, horizon 12\n", - "adding: mem time270, current time 281, horizon 11\n", - "adding: mem time271, current time 281, horizon 10\n", - "adding: mem time272, current time 281, horizon 9\n", - "adding: mem time273, current time 281, horizon 8\n", - "adding: mem time274, current time 281, horizon 7\n", - "adding: mem time275, current time 281, horizon 6\n", - "adding: mem time276, current time 281, horizon 5\n", - "adding: mem time277, current time 281, horizon 4\n", - "adding: mem time278, current time 281, horizon 3\n", - "adding: mem time279, current time 281, horizon 2\n", - "adding: mem time280, current time 281, horizon 1\n", - "adding: mem time200, current time 282, horizon 82\n", - "adding: mem time201, current time 282, horizon 81\n", - "adding: mem time202, current time 282, horizon 80\n", - "adding: mem time203, current time 282, horizon 79\n", - "adding: mem time204, current time 282, horizon 78\n", - "adding: mem time205, current time 282, horizon 77\n", - "adding: mem time206, current time 282, horizon 76\n", - "adding: mem time207, current time 282, horizon 75\n", - "adding: mem time208, current time 282, horizon 74\n", - "adding: mem time209, current time 282, horizon 73\n", - "adding: mem time210, current time 282, horizon 72\n", - "adding: mem time211, current time 282, horizon 71\n", - "adding: mem time212, current time 282, horizon 70\n", - "adding: mem time213, current time 282, horizon 69\n", - "adding: mem time214, current time 282, horizon 68\n", - "adding: mem time215, current time 282, horizon 67\n", - "adding: mem time216, current time 282, horizon 66\n", - "adding: mem time217, current time 282, horizon 65\n", - "adding: mem time218, current time 282, horizon 64\n", - "adding: mem time219, current time 282, horizon 63\n", - "adding: mem time220, current time 282, horizon 62\n", - "adding: mem time221, current time 282, horizon 61\n", - "adding: mem time222, current time 282, horizon 60\n", - "adding: mem time223, current time 282, horizon 59\n", - "adding: mem time224, current time 282, horizon 58\n", - "adding: mem time225, current time 282, horizon 57\n", - "adding: mem time226, current time 282, horizon 56\n", - "adding: mem time227, current time 282, horizon 55\n", - "adding: mem time228, current time 282, horizon 54\n", - "adding: mem time229, current time 282, horizon 53\n", - "adding: mem time230, current time 282, horizon 52\n", - "adding: mem time231, current time 282, horizon 51\n", - "adding: mem time232, current time 282, horizon 50\n", - "adding: mem time233, current time 282, horizon 49\n", - "adding: mem time234, current time 282, horizon 48\n", - "adding: mem time235, current time 282, horizon 47\n", - "adding: mem time236, current time 282, horizon 46\n", - "adding: mem time237, current time 282, horizon 45\n", - "adding: mem time238, current time 282, horizon 44\n", - "adding: mem time239, current time 282, horizon 43\n", - "adding: mem time240, current time 282, horizon 42\n", - "adding: mem time241, current time 282, horizon 41\n", - "adding: mem time242, current time 282, horizon 40\n", - "adding: mem time243, current time 282, horizon 39\n", - "adding: mem time244, current time 282, horizon 38\n", - "adding: mem time245, current time 282, horizon 37\n", - "adding: mem time246, current time 282, horizon 36\n", - "adding: mem time247, current time 282, horizon 35\n", - "adding: mem time248, current time 282, horizon 34\n", - "adding: mem time249, current time 282, horizon 33\n", - "adding: mem time250, current time 282, horizon 32\n", - "adding: mem time251, current time 282, horizon 31\n", - "adding: mem time252, current time 282, horizon 30\n", - "adding: mem time253, current time 282, horizon 29\n", - "adding: mem time254, current time 282, horizon 28\n", - "adding: mem time255, current time 282, horizon 27\n", - "adding: mem time256, current time 282, horizon 26\n", - "adding: mem time257, current time 282, horizon 25\n", - "adding: mem time258, current time 282, horizon 24\n", - "adding: mem time259, current time 282, horizon 23\n", - "adding: mem time260, current time 282, horizon 22\n", - "adding: mem time261, current time 282, horizon 21\n", - "adding: mem time262, current time 282, horizon 20\n", - "adding: mem time263, current time 282, horizon 19\n", - "adding: mem time264, current time 282, horizon 18\n", - "adding: mem time265, current time 282, horizon 17\n", - "adding: mem time266, current time 282, horizon 16\n", - "adding: mem time267, current time 282, horizon 15\n", - "adding: mem time268, current time 282, horizon 14\n", - "adding: mem time269, current time 282, horizon 13\n", - "adding: mem time270, current time 282, horizon 12\n", - "adding: mem time271, current time 282, horizon 11\n", - "adding: mem time272, current time 282, horizon 10\n", - "adding: mem time273, current time 282, horizon 9\n", - "adding: mem time274, current time 282, horizon 8\n", - "adding: mem time275, current time 282, horizon 7\n", - "adding: mem time276, current time 282, horizon 6\n", - "adding: mem time277, current time 282, horizon 5\n", - "adding: mem time278, current time 282, horizon 4\n", - "adding: mem time279, current time 282, horizon 3\n", - "adding: mem time280, current time 282, horizon 2\n", - "adding: mem time281, current time 282, horizon 1\n", - "adding: mem time200, current time 283, horizon 83\n", - "adding: mem time201, current time 283, horizon 82\n", - "adding: mem time202, current time 283, horizon 81\n", - "adding: mem time203, current time 283, horizon 80\n", - "adding: mem time204, current time 283, horizon 79\n", - "adding: mem time205, current time 283, horizon 78\n", - "adding: mem time206, current time 283, horizon 77\n", - "adding: mem time207, current time 283, horizon 76\n", - "adding: mem time208, current time 283, horizon 75\n", - "adding: mem time209, current time 283, horizon 74\n", - "adding: mem time210, current time 283, horizon 73\n", - "adding: mem time211, current time 283, horizon 72\n", - "adding: mem time212, current time 283, horizon 71\n", - "adding: mem time213, current time 283, horizon 70\n", - "adding: mem time214, current time 283, horizon 69\n", - "adding: mem time215, current time 283, horizon 68\n", - "adding: mem time216, current time 283, horizon 67\n", - "adding: mem time217, current time 283, horizon 66\n", - "adding: mem time218, current time 283, horizon 65\n", - "adding: mem time219, current time 283, horizon 64\n", - "adding: mem time220, current time 283, horizon 63\n", - "adding: mem time221, current time 283, horizon 62\n", - "adding: mem time222, current time 283, horizon 61\n", - "adding: mem time223, current time 283, horizon 60\n", - "adding: mem time224, current time 283, horizon 59\n", - "adding: mem time225, current time 283, horizon 58\n", - "adding: mem time226, current time 283, horizon 57\n", - "adding: mem time227, current time 283, horizon 56\n", - "adding: mem time228, current time 283, horizon 55\n", - "adding: mem time229, current time 283, horizon 54\n", - "adding: mem time230, current time 283, horizon 53\n", - "adding: mem time231, current time 283, horizon 52\n", - "adding: mem time232, current time 283, horizon 51\n", - "adding: mem time233, current time 283, horizon 50\n", - "adding: mem time234, current time 283, horizon 49\n", - "adding: mem time235, current time 283, horizon 48\n", - "adding: mem time236, current time 283, horizon 47\n", - "adding: mem time237, current time 283, horizon 46\n", - "adding: mem time238, current time 283, horizon 45\n", - "adding: mem time239, current time 283, horizon 44\n", - "adding: mem time240, current time 283, horizon 43\n", - "adding: mem time241, current time 283, horizon 42\n", - "adding: mem time242, current time 283, horizon 41\n", - "adding: mem time243, current time 283, horizon 40\n", - "adding: mem time244, current time 283, horizon 39\n", - "adding: mem time245, current time 283, horizon 38\n", - "adding: mem time246, current time 283, horizon 37\n", - "adding: mem time247, current time 283, horizon 36\n", - "adding: mem time248, current time 283, horizon 35\n", - "adding: mem time249, current time 283, horizon 34\n", - "adding: mem time250, current time 283, horizon 33\n", - "adding: mem time251, current time 283, horizon 32\n", - "adding: mem time252, current time 283, horizon 31\n", - "adding: mem time253, current time 283, horizon 30\n", - "adding: mem time254, current time 283, horizon 29\n", - "adding: mem time255, current time 283, horizon 28\n", - "adding: mem time256, current time 283, horizon 27\n", - "adding: mem time257, current time 283, horizon 26\n", - "adding: mem time258, current time 283, horizon 25\n", - "adding: mem time259, current time 283, horizon 24\n", - "adding: mem time260, current time 283, horizon 23\n", - "adding: mem time261, current time 283, horizon 22\n", - "adding: mem time262, current time 283, horizon 21\n", - "adding: mem time263, current time 283, horizon 20\n", - "adding: mem time264, current time 283, horizon 19\n", - "adding: mem time265, current time 283, horizon 18\n", - "adding: mem time266, current time 283, horizon 17\n", - "adding: mem time267, current time 283, horizon 16\n", - "adding: mem time268, current time 283, horizon 15\n", - "adding: mem time269, current time 283, horizon 14\n", - "adding: mem time270, current time 283, horizon 13\n", - "adding: mem time271, current time 283, horizon 12\n", - "adding: mem time272, current time 283, horizon 11\n", - "adding: mem time273, current time 283, horizon 10\n", - "adding: mem time274, current time 283, horizon 9\n", - "adding: mem time275, current time 283, horizon 8\n", - "adding: mem time276, current time 283, horizon 7\n", - "adding: mem time277, current time 283, horizon 6\n", - "adding: mem time278, current time 283, horizon 5\n", - "adding: mem time279, current time 283, horizon 4\n", - "adding: mem time280, current time 283, horizon 3\n", - "adding: mem time281, current time 283, horizon 2\n", - "adding: mem time282, current time 283, horizon 1\n", - "adding: mem time200, current time 284, horizon 84\n", - "adding: mem time201, current time 284, horizon 83\n", - "adding: mem time202, current time 284, horizon 82\n", - "adding: mem time203, current time 284, horizon 81\n", - "adding: mem time204, current time 284, horizon 80\n", - "adding: mem time205, current time 284, horizon 79\n", - "adding: mem time206, current time 284, horizon 78\n", - "adding: mem time207, current time 284, horizon 77\n", - "adding: mem time208, current time 284, horizon 76\n", - "adding: mem time209, current time 284, horizon 75\n", - "adding: mem time210, current time 284, horizon 74\n", - "adding: mem time211, current time 284, horizon 73\n", - "adding: mem time212, current time 284, horizon 72\n", - "adding: mem time213, current time 284, horizon 71\n", - "adding: mem time214, current time 284, horizon 70\n", - "adding: mem time215, current time 284, horizon 69\n", - "adding: mem time216, current time 284, horizon 68\n", - "adding: mem time217, current time 284, horizon 67\n", - "adding: mem time218, current time 284, horizon 66\n", - "adding: mem time219, current time 284, horizon 65\n", - "adding: mem time220, current time 284, horizon 64\n", - "adding: mem time221, current time 284, horizon 63\n", - "adding: mem time222, current time 284, horizon 62\n", - "adding: mem time223, current time 284, horizon 61\n", - "adding: mem time224, current time 284, horizon 60\n", - "adding: mem time225, current time 284, horizon 59\n", - "adding: mem time226, current time 284, horizon 58\n", - "adding: mem time227, current time 284, horizon 57\n", - "adding: mem time228, current time 284, horizon 56\n", - "adding: mem time229, current time 284, horizon 55\n", - "adding: mem time230, current time 284, horizon 54\n", - "adding: mem time231, current time 284, horizon 53\n", - "adding: mem time232, current time 284, horizon 52\n", - "adding: mem time233, current time 284, horizon 51\n", - "adding: mem time234, current time 284, horizon 50\n", - "adding: mem time235, current time 284, horizon 49\n", - "adding: mem time236, current time 284, horizon 48\n", - "adding: mem time237, current time 284, horizon 47\n", - "adding: mem time238, current time 284, horizon 46\n", - "adding: mem time239, current time 284, horizon 45\n", - "adding: mem time240, current time 284, horizon 44\n", - "adding: mem time241, current time 284, horizon 43\n", - "adding: mem time242, current time 284, horizon 42\n", - "adding: mem time243, current time 284, horizon 41\n", - "adding: mem time244, current time 284, horizon 40\n", - "adding: mem time245, current time 284, horizon 39\n", - "adding: mem time246, current time 284, horizon 38\n", - "adding: mem time247, current time 284, horizon 37\n", - "adding: mem time248, current time 284, horizon 36\n", - "adding: mem time249, current time 284, horizon 35\n", - "adding: mem time250, current time 284, horizon 34\n", - "adding: mem time251, current time 284, horizon 33\n", - "adding: mem time252, current time 284, horizon 32\n", - "adding: mem time253, current time 284, horizon 31\n", - "adding: mem time254, current time 284, horizon 30\n", - "adding: mem time255, current time 284, horizon 29\n", - "adding: mem time256, current time 284, horizon 28\n", - "adding: mem time257, current time 284, horizon 27\n", - "adding: mem time258, current time 284, horizon 26\n", - "adding: mem time259, current time 284, horizon 25\n", - "adding: mem time260, current time 284, horizon 24\n", - "adding: mem time261, current time 284, horizon 23\n", - "adding: mem time262, current time 284, horizon 22\n", - "adding: mem time263, current time 284, horizon 21\n", - "adding: mem time264, current time 284, horizon 20\n", - "adding: mem time265, current time 284, horizon 19\n", - "adding: mem time266, current time 284, horizon 18\n", - "adding: mem time267, current time 284, horizon 17\n", - "adding: mem time268, current time 284, horizon 16\n", - "adding: mem time269, current time 284, horizon 15\n", - "adding: mem time270, current time 284, horizon 14\n", - "adding: mem time271, current time 284, horizon 13\n", - "adding: mem time272, current time 284, horizon 12\n", - "adding: mem time273, current time 284, horizon 11\n", - "adding: mem time274, current time 284, horizon 10\n", - "adding: mem time275, current time 284, horizon 9\n", - "adding: mem time276, current time 284, horizon 8\n", - "adding: mem time277, current time 284, horizon 7\n", - "adding: mem time278, current time 284, horizon 6\n", - "adding: mem time279, current time 284, horizon 5\n", - "adding: mem time280, current time 284, horizon 4\n", - "adding: mem time281, current time 284, horizon 3\n", - "adding: mem time282, current time 284, horizon 2\n", - "adding: mem time283, current time 284, horizon 1\n", - "adding: mem time200, current time 285, horizon 85\n", - "adding: mem time201, current time 285, horizon 84\n", - "adding: mem time202, current time 285, horizon 83\n", - "adding: mem time203, current time 285, horizon 82\n", - "adding: mem time204, current time 285, horizon 81\n", - "adding: mem time205, current time 285, horizon 80\n", - "adding: mem time206, current time 285, horizon 79\n", - "adding: mem time207, current time 285, horizon 78\n", - "adding: mem time208, current time 285, horizon 77\n", - "adding: mem time209, current time 285, horizon 76\n", - "adding: mem time210, current time 285, horizon 75\n", - "adding: mem time211, current time 285, horizon 74\n", - "adding: mem time212, current time 285, horizon 73\n", - "adding: mem time213, current time 285, horizon 72\n", - "adding: mem time214, current time 285, horizon 71\n", - "adding: mem time215, current time 285, horizon 70\n", - "adding: mem time216, current time 285, horizon 69\n", - "adding: mem time217, current time 285, horizon 68\n", - "adding: mem time218, current time 285, horizon 67\n", - "adding: mem time219, current time 285, horizon 66\n", - "adding: mem time220, current time 285, horizon 65\n", - "adding: mem time221, current time 285, horizon 64\n", - "adding: mem time222, current time 285, horizon 63\n", - "adding: mem time223, current time 285, horizon 62\n", - "adding: mem time224, current time 285, horizon 61\n", - "adding: mem time225, current time 285, horizon 60\n", - "adding: mem time226, current time 285, horizon 59\n", - "adding: mem time227, current time 285, horizon 58\n", - "adding: mem time228, current time 285, horizon 57\n", - "adding: mem time229, current time 285, horizon 56\n", - "adding: mem time230, current time 285, horizon 55\n", - "adding: mem time231, current time 285, horizon 54\n", - "adding: mem time232, current time 285, horizon 53\n", - "adding: mem time233, current time 285, horizon 52\n", - "adding: mem time234, current time 285, horizon 51\n", - "adding: mem time235, current time 285, horizon 50\n", - "adding: mem time236, current time 285, horizon 49\n", - "adding: mem time237, current time 285, horizon 48\n", - "adding: mem time238, current time 285, horizon 47\n", - "adding: mem time239, current time 285, horizon 46\n", - "adding: mem time240, current time 285, horizon 45\n", - "adding: mem time241, current time 285, horizon 44\n", - "adding: mem time242, current time 285, horizon 43\n", - "adding: mem time243, current time 285, horizon 42\n", - "adding: mem time244, current time 285, horizon 41\n", - "adding: mem time245, current time 285, horizon 40\n", - "adding: mem time246, current time 285, horizon 39\n", - "adding: mem time247, current time 285, horizon 38\n", - "adding: mem time248, current time 285, horizon 37\n", - "adding: mem time249, current time 285, horizon 36\n", - "adding: mem time250, current time 285, horizon 35\n", - "adding: mem time251, current time 285, horizon 34\n", - "adding: mem time252, current time 285, horizon 33\n", - "adding: mem time253, current time 285, horizon 32\n", - "adding: mem time254, current time 285, horizon 31\n", - "adding: mem time255, current time 285, horizon 30\n", - "adding: mem time256, current time 285, horizon 29\n", - "adding: mem time257, current time 285, horizon 28\n", - "adding: mem time258, current time 285, horizon 27\n", - "adding: mem time259, current time 285, horizon 26\n", - "adding: mem time260, current time 285, horizon 25\n", - "adding: mem time261, current time 285, horizon 24\n", - "adding: mem time262, current time 285, horizon 23\n", - "adding: mem time263, current time 285, horizon 22\n", - "adding: mem time264, current time 285, horizon 21\n", - "adding: mem time265, current time 285, horizon 20\n", - "adding: mem time266, current time 285, horizon 19\n", - "adding: mem time267, current time 285, horizon 18\n", - "adding: mem time268, current time 285, horizon 17\n", - "adding: mem time269, current time 285, horizon 16\n", - "adding: mem time270, current time 285, horizon 15\n", - "adding: mem time271, current time 285, horizon 14\n", - "adding: mem time272, current time 285, horizon 13\n", - "adding: mem time273, current time 285, horizon 12\n", - "adding: mem time274, current time 285, horizon 11\n", - "adding: mem time275, current time 285, horizon 10\n", - "adding: mem time276, current time 285, horizon 9\n", - "adding: mem time277, current time 285, horizon 8\n", - "adding: mem time278, current time 285, horizon 7\n", - "adding: mem time279, current time 285, horizon 6\n", - "adding: mem time280, current time 285, horizon 5\n", - "adding: mem time281, current time 285, horizon 4\n", - "adding: mem time282, current time 285, horizon 3\n", - "adding: mem time283, current time 285, horizon 2\n", - "adding: mem time284, current time 285, horizon 1\n", - "adding: mem time200, current time 286, horizon 86\n", - "adding: mem time201, current time 286, horizon 85\n", - "adding: mem time202, current time 286, horizon 84\n", - "adding: mem time203, current time 286, horizon 83\n", - "adding: mem time204, current time 286, horizon 82\n", - "adding: mem time205, current time 286, horizon 81\n", - "adding: mem time206, current time 286, horizon 80\n", - "adding: mem time207, current time 286, horizon 79\n", - "adding: mem time208, current time 286, horizon 78\n", - "adding: mem time209, current time 286, horizon 77\n", - "adding: mem time210, current time 286, horizon 76\n", - "adding: mem time211, current time 286, horizon 75\n", - "adding: mem time212, current time 286, horizon 74\n", - "adding: mem time213, current time 286, horizon 73\n", - "adding: mem time214, current time 286, horizon 72\n", - "adding: mem time215, current time 286, horizon 71\n", - "adding: mem time216, current time 286, horizon 70\n", - "adding: mem time217, current time 286, horizon 69\n", - "adding: mem time218, current time 286, horizon 68\n", - "adding: mem time219, current time 286, horizon 67\n", - "adding: mem time220, current time 286, horizon 66\n", - "adding: mem time221, current time 286, horizon 65\n", - "adding: mem time222, current time 286, horizon 64\n", - "adding: mem time223, current time 286, horizon 63\n", - "adding: mem time224, current time 286, horizon 62\n", - "adding: mem time225, current time 286, horizon 61\n", - "adding: mem time226, current time 286, horizon 60\n", - "adding: mem time227, current time 286, horizon 59\n", - "adding: mem time228, current time 286, horizon 58\n", - "adding: mem time229, current time 286, horizon 57\n", - "adding: mem time230, current time 286, horizon 56\n", - "adding: mem time231, current time 286, horizon 55\n", - "adding: mem time232, current time 286, horizon 54\n", - "adding: mem time233, current time 286, horizon 53\n", - "adding: mem time234, current time 286, horizon 52\n", - "adding: mem time235, current time 286, horizon 51\n", - "adding: mem time236, current time 286, horizon 50\n", - "adding: mem time237, current time 286, horizon 49\n", - "adding: mem time238, current time 286, horizon 48\n", - "adding: mem time239, current time 286, horizon 47\n", - "adding: mem time240, current time 286, horizon 46\n", - "adding: mem time241, current time 286, horizon 45\n", - "adding: mem time242, current time 286, horizon 44\n", - "adding: mem time243, current time 286, horizon 43\n", - "adding: mem time244, current time 286, horizon 42\n", - "adding: mem time245, current time 286, horizon 41\n", - "adding: mem time246, current time 286, horizon 40\n", - "adding: mem time247, current time 286, horizon 39\n", - "adding: mem time248, current time 286, horizon 38\n", - "adding: mem time249, current time 286, horizon 37\n", - "adding: mem time250, current time 286, horizon 36\n", - "adding: mem time251, current time 286, horizon 35\n", - "adding: mem time252, current time 286, horizon 34\n", - "adding: mem time253, current time 286, horizon 33\n", - "adding: mem time254, current time 286, horizon 32\n", - "adding: mem time255, current time 286, horizon 31\n", - "adding: mem time256, current time 286, horizon 30\n", - "adding: mem time257, current time 286, horizon 29\n", - "adding: mem time258, current time 286, horizon 28\n", - "adding: mem time259, current time 286, horizon 27\n", - "adding: mem time260, current time 286, horizon 26\n", - "adding: mem time261, current time 286, horizon 25\n", - "adding: mem time262, current time 286, horizon 24\n", - "adding: mem time263, current time 286, horizon 23\n", - "adding: mem time264, current time 286, horizon 22\n", - "adding: mem time265, current time 286, horizon 21\n", - "adding: mem time266, current time 286, horizon 20\n", - "adding: mem time267, current time 286, horizon 19\n", - "adding: mem time268, current time 286, horizon 18\n", - "adding: mem time269, current time 286, horizon 17\n", - "adding: mem time270, current time 286, horizon 16\n", - "adding: mem time271, current time 286, horizon 15\n", - "adding: mem time272, current time 286, horizon 14\n", - "adding: mem time273, current time 286, horizon 13\n", - "adding: mem time274, current time 286, horizon 12\n", - "adding: mem time275, current time 286, horizon 11\n", - "adding: mem time276, current time 286, horizon 10\n", - "adding: mem time277, current time 286, horizon 9\n", - "adding: mem time278, current time 286, horizon 8\n", - "adding: mem time279, current time 286, horizon 7\n", - "adding: mem time280, current time 286, horizon 6\n", - "adding: mem time281, current time 286, horizon 5\n", - "adding: mem time282, current time 286, horizon 4\n", - "adding: mem time283, current time 286, horizon 3\n", - "adding: mem time284, current time 286, horizon 2\n", - "adding: mem time285, current time 286, horizon 1\n", - "adding: mem time200, current time 287, horizon 87\n", - "adding: mem time201, current time 287, horizon 86\n", - "adding: mem time202, current time 287, horizon 85\n", - "adding: mem time203, current time 287, horizon 84\n", - "adding: mem time204, current time 287, horizon 83\n", - "adding: mem time205, current time 287, horizon 82\n", - "adding: mem time206, current time 287, horizon 81\n", - "adding: mem time207, current time 287, horizon 80\n", - "adding: mem time208, current time 287, horizon 79\n", - "adding: mem time209, current time 287, horizon 78\n", - "adding: mem time210, current time 287, horizon 77\n", - "adding: mem time211, current time 287, horizon 76\n", - "adding: mem time212, current time 287, horizon 75\n", - "adding: mem time213, current time 287, horizon 74\n", - "adding: mem time214, current time 287, horizon 73\n", - "adding: mem time215, current time 287, horizon 72\n", - "adding: mem time216, current time 287, horizon 71\n", - "adding: mem time217, current time 287, horizon 70\n", - "adding: mem time218, current time 287, horizon 69\n", - "adding: mem time219, current time 287, horizon 68\n", - "adding: mem time220, current time 287, horizon 67\n", - "adding: mem time221, current time 287, horizon 66\n", - "adding: mem time222, current time 287, horizon 65\n", - "adding: mem time223, current time 287, horizon 64\n", - "adding: mem time224, current time 287, horizon 63\n", - "adding: mem time225, current time 287, horizon 62\n", - "adding: mem time226, current time 287, horizon 61\n", - "adding: mem time227, current time 287, horizon 60\n", - "adding: mem time228, current time 287, horizon 59\n", - "adding: mem time229, current time 287, horizon 58\n", - "adding: mem time230, current time 287, horizon 57\n", - "adding: mem time231, current time 287, horizon 56\n", - "adding: mem time232, current time 287, horizon 55\n", - "adding: mem time233, current time 287, horizon 54\n", - "adding: mem time234, current time 287, horizon 53\n", - "adding: mem time235, current time 287, horizon 52\n", - "adding: mem time236, current time 287, horizon 51\n", - "adding: mem time237, current time 287, horizon 50\n", - "adding: mem time238, current time 287, horizon 49\n", - "adding: mem time239, current time 287, horizon 48\n", - "adding: mem time240, current time 287, horizon 47\n", - "adding: mem time241, current time 287, horizon 46\n", - "adding: mem time242, current time 287, horizon 45\n", - "adding: mem time243, current time 287, horizon 44\n", - "adding: mem time244, current time 287, horizon 43\n", - "adding: mem time245, current time 287, horizon 42\n", - "adding: mem time246, current time 287, horizon 41\n", - "adding: mem time247, current time 287, horizon 40\n", - "adding: mem time248, current time 287, horizon 39\n", - "adding: mem time249, current time 287, horizon 38\n", - "adding: mem time250, current time 287, horizon 37\n", - "adding: mem time251, current time 287, horizon 36\n", - "adding: mem time252, current time 287, horizon 35\n", - "adding: mem time253, current time 287, horizon 34\n", - "adding: mem time254, current time 287, horizon 33\n", - "adding: mem time255, current time 287, horizon 32\n", - "adding: mem time256, current time 287, horizon 31\n", - "adding: mem time257, current time 287, horizon 30\n", - "adding: mem time258, current time 287, horizon 29\n", - "adding: mem time259, current time 287, horizon 28\n", - "adding: mem time260, current time 287, horizon 27\n", - "adding: mem time261, current time 287, horizon 26\n", - "adding: mem time262, current time 287, horizon 25\n", - "adding: mem time263, current time 287, horizon 24\n", - "adding: mem time264, current time 287, horizon 23\n", - "adding: mem time265, current time 287, horizon 22\n", - "adding: mem time266, current time 287, horizon 21\n", - "adding: mem time267, current time 287, horizon 20\n", - "adding: mem time268, current time 287, horizon 19\n", - "adding: mem time269, current time 287, horizon 18\n", - "adding: mem time270, current time 287, horizon 17\n", - "adding: mem time271, current time 287, horizon 16\n", - "adding: mem time272, current time 287, horizon 15\n", - "adding: mem time273, current time 287, horizon 14\n", - "adding: mem time274, current time 287, horizon 13\n", - "adding: mem time275, current time 287, horizon 12\n", - "adding: mem time276, current time 287, horizon 11\n", - "adding: mem time277, current time 287, horizon 10\n", - "adding: mem time278, current time 287, horizon 9\n", - "adding: mem time279, current time 287, horizon 8\n", - "adding: mem time280, current time 287, horizon 7\n", - "adding: mem time281, current time 287, horizon 6\n", - "adding: mem time282, current time 287, horizon 5\n", - "adding: mem time283, current time 287, horizon 4\n", - "adding: mem time284, current time 287, horizon 3\n", - "adding: mem time285, current time 287, horizon 2\n", - "adding: mem time286, current time 287, horizon 1\n", - "adding: mem time200, current time 288, horizon 88\n", - "adding: mem time201, current time 288, horizon 87\n", - "adding: mem time202, current time 288, horizon 86\n", - "adding: mem time203, current time 288, horizon 85\n", - "adding: mem time204, current time 288, horizon 84\n", - "adding: mem time205, current time 288, horizon 83\n", - "adding: mem time206, current time 288, horizon 82\n", - "adding: mem time207, current time 288, horizon 81\n", - "adding: mem time208, current time 288, horizon 80\n", - "adding: mem time209, current time 288, horizon 79\n", - "adding: mem time210, current time 288, horizon 78\n", - "adding: mem time211, current time 288, horizon 77\n", - "adding: mem time212, current time 288, horizon 76\n", - "adding: mem time213, current time 288, horizon 75\n", - "adding: mem time214, current time 288, horizon 74\n", - "adding: mem time215, current time 288, horizon 73\n", - "adding: mem time216, current time 288, horizon 72\n", - "adding: mem time217, current time 288, horizon 71\n", - "adding: mem time218, current time 288, horizon 70\n", - "adding: mem time219, current time 288, horizon 69\n", - "adding: mem time220, current time 288, horizon 68\n", - "adding: mem time221, current time 288, horizon 67\n", - "adding: mem time222, current time 288, horizon 66\n", - "adding: mem time223, current time 288, horizon 65\n", - "adding: mem time224, current time 288, horizon 64\n", - "adding: mem time225, current time 288, horizon 63\n", - "adding: mem time226, current time 288, horizon 62\n", - "adding: mem time227, current time 288, horizon 61\n", - "adding: mem time228, current time 288, horizon 60\n", - "adding: mem time229, current time 288, horizon 59\n", - "adding: mem time230, current time 288, horizon 58\n", - "adding: mem time231, current time 288, horizon 57\n", - "adding: mem time232, current time 288, horizon 56\n", - "adding: mem time233, current time 288, horizon 55\n", - "adding: mem time234, current time 288, horizon 54\n", - "adding: mem time235, current time 288, horizon 53\n", - "adding: mem time236, current time 288, horizon 52\n", - "adding: mem time237, current time 288, horizon 51\n", - "adding: mem time238, current time 288, horizon 50\n", - "adding: mem time239, current time 288, horizon 49\n", - "adding: mem time240, current time 288, horizon 48\n", - "adding: mem time241, current time 288, horizon 47\n", - "adding: mem time242, current time 288, horizon 46\n", - "adding: mem time243, current time 288, horizon 45\n", - "adding: mem time244, current time 288, horizon 44\n", - "adding: mem time245, current time 288, horizon 43\n", - "adding: mem time246, current time 288, horizon 42\n", - "adding: mem time247, current time 288, horizon 41\n", - "adding: mem time248, current time 288, horizon 40\n", - "adding: mem time249, current time 288, horizon 39\n", - "adding: mem time250, current time 288, horizon 38\n", - "adding: mem time251, current time 288, horizon 37\n", - "adding: mem time252, current time 288, horizon 36\n", - "adding: mem time253, current time 288, horizon 35\n", - "adding: mem time254, current time 288, horizon 34\n", - "adding: mem time255, current time 288, horizon 33\n", - "adding: mem time256, current time 288, horizon 32\n", - "adding: mem time257, current time 288, horizon 31\n", - "adding: mem time258, current time 288, horizon 30\n", - "adding: mem time259, current time 288, horizon 29\n", - "adding: mem time260, current time 288, horizon 28\n", - "adding: mem time261, current time 288, horizon 27\n", - "adding: mem time262, current time 288, horizon 26\n", - "adding: mem time263, current time 288, horizon 25\n", - "adding: mem time264, current time 288, horizon 24\n", - "adding: mem time265, current time 288, horizon 23\n", - "adding: mem time266, current time 288, horizon 22\n", - "adding: mem time267, current time 288, horizon 21\n", - "adding: mem time268, current time 288, horizon 20\n", - "adding: mem time269, current time 288, horizon 19\n", - "adding: mem time270, current time 288, horizon 18\n", - "adding: mem time271, current time 288, horizon 17\n", - "adding: mem time272, current time 288, horizon 16\n", - "adding: mem time273, current time 288, horizon 15\n", - "adding: mem time274, current time 288, horizon 14\n", - "adding: mem time275, current time 288, horizon 13\n", - "adding: mem time276, current time 288, horizon 12\n", - "adding: mem time277, current time 288, horizon 11\n", - "adding: mem time278, current time 288, horizon 10\n", - "adding: mem time279, current time 288, horizon 9\n", - "adding: mem time280, current time 288, horizon 8\n", - "adding: mem time281, current time 288, horizon 7\n", - "adding: mem time282, current time 288, horizon 6\n", - "adding: mem time283, current time 288, horizon 5\n", - "adding: mem time284, current time 288, horizon 4\n", - "adding: mem time285, current time 288, horizon 3\n", - "adding: mem time286, current time 288, horizon 2\n", - "adding: mem time287, current time 288, horizon 1\n", - "adding: mem time200, current time 289, horizon 89\n", - "adding: mem time201, current time 289, horizon 88\n", - "adding: mem time202, current time 289, horizon 87\n", - "adding: mem time203, current time 289, horizon 86\n", - "adding: mem time204, current time 289, horizon 85\n", - "adding: mem time205, current time 289, horizon 84\n", - "adding: mem time206, current time 289, horizon 83\n", - "adding: mem time207, current time 289, horizon 82\n", - "adding: mem time208, current time 289, horizon 81\n", - "adding: mem time209, current time 289, horizon 80\n", - "adding: mem time210, current time 289, horizon 79\n", - "adding: mem time211, current time 289, horizon 78\n", - "adding: mem time212, current time 289, horizon 77\n", - "adding: mem time213, current time 289, horizon 76\n", - "adding: mem time214, current time 289, horizon 75\n", - "adding: mem time215, current time 289, horizon 74\n", - "adding: mem time216, current time 289, horizon 73\n", - "adding: mem time217, current time 289, horizon 72\n", - "adding: mem time218, current time 289, horizon 71\n", - "adding: mem time219, current time 289, horizon 70\n", - "adding: mem time220, current time 289, horizon 69\n", - "adding: mem time221, current time 289, horizon 68\n", - "adding: mem time222, current time 289, horizon 67\n", - "adding: mem time223, current time 289, horizon 66\n", - "adding: mem time224, current time 289, horizon 65\n", - "adding: mem time225, current time 289, horizon 64\n", - "adding: mem time226, current time 289, horizon 63\n", - "adding: mem time227, current time 289, horizon 62\n", - "adding: mem time228, current time 289, horizon 61\n", - "adding: mem time229, current time 289, horizon 60\n", - "adding: mem time230, current time 289, horizon 59\n", - "adding: mem time231, current time 289, horizon 58\n", - "adding: mem time232, current time 289, horizon 57\n", - "adding: mem time233, current time 289, horizon 56\n", - "adding: mem time234, current time 289, horizon 55\n", - "adding: mem time235, current time 289, horizon 54\n", - "adding: mem time236, current time 289, horizon 53\n", - "adding: mem time237, current time 289, horizon 52\n", - "adding: mem time238, current time 289, horizon 51\n", - "adding: mem time239, current time 289, horizon 50\n", - "adding: mem time240, current time 289, horizon 49\n", - "adding: mem time241, current time 289, horizon 48\n", - "adding: mem time242, current time 289, horizon 47\n", - "adding: mem time243, current time 289, horizon 46\n", - "adding: mem time244, current time 289, horizon 45\n", - "adding: mem time245, current time 289, horizon 44\n", - "adding: mem time246, current time 289, horizon 43\n", - "adding: mem time247, current time 289, horizon 42\n", - "adding: mem time248, current time 289, horizon 41\n", - "adding: mem time249, current time 289, horizon 40\n", - "adding: mem time250, current time 289, horizon 39\n", - "adding: mem time251, current time 289, horizon 38\n", - "adding: mem time252, current time 289, horizon 37\n", - "adding: mem time253, current time 289, horizon 36\n", - "adding: mem time254, current time 289, horizon 35\n", - "adding: mem time255, current time 289, horizon 34\n", - "adding: mem time256, current time 289, horizon 33\n", - "adding: mem time257, current time 289, horizon 32\n", - "adding: mem time258, current time 289, horizon 31\n", - "adding: mem time259, current time 289, horizon 30\n", - "adding: mem time260, current time 289, horizon 29\n", - "adding: mem time261, current time 289, horizon 28\n", - "adding: mem time262, current time 289, horizon 27\n", - "adding: mem time263, current time 289, horizon 26\n", - "adding: mem time264, current time 289, horizon 25\n", - "adding: mem time265, current time 289, horizon 24\n", - "adding: mem time266, current time 289, horizon 23\n", - "adding: mem time267, current time 289, horizon 22\n", - "adding: mem time268, current time 289, horizon 21\n", - "adding: mem time269, current time 289, horizon 20\n", - "adding: mem time270, current time 289, horizon 19\n", - "adding: mem time271, current time 289, horizon 18\n", - "adding: mem time272, current time 289, horizon 17\n", - "adding: mem time273, current time 289, horizon 16\n", - "adding: mem time274, current time 289, horizon 15\n", - "adding: mem time275, current time 289, horizon 14\n", - "adding: mem time276, current time 289, horizon 13\n", - "adding: mem time277, current time 289, horizon 12\n", - "adding: mem time278, current time 289, horizon 11\n", - "adding: mem time279, current time 289, horizon 10\n", - "adding: mem time280, current time 289, horizon 9\n", - "adding: mem time281, current time 289, horizon 8\n", - "adding: mem time282, current time 289, horizon 7\n", - "adding: mem time283, current time 289, horizon 6\n", - "adding: mem time284, current time 289, horizon 5\n", - "adding: mem time285, current time 289, horizon 4\n", - "adding: mem time286, current time 289, horizon 3\n", - "adding: mem time287, current time 289, horizon 2\n", - "adding: mem time288, current time 289, horizon 1\n", - "adding: mem time200, current time 290, horizon 90\n", - "adding: mem time201, current time 290, horizon 89\n", - "adding: mem time202, current time 290, horizon 88\n", - "adding: mem time203, current time 290, horizon 87\n", - "adding: mem time204, current time 290, horizon 86\n", - "adding: mem time205, current time 290, horizon 85\n", - "adding: mem time206, current time 290, horizon 84\n", - "adding: mem time207, current time 290, horizon 83\n", - "adding: mem time208, current time 290, horizon 82\n", - "adding: mem time209, current time 290, horizon 81\n", - "adding: mem time210, current time 290, horizon 80\n", - "adding: mem time211, current time 290, horizon 79\n", - "adding: mem time212, current time 290, horizon 78\n", - "adding: mem time213, current time 290, horizon 77\n", - "adding: mem time214, current time 290, horizon 76\n", - "adding: mem time215, current time 290, horizon 75\n", - "adding: mem time216, current time 290, horizon 74\n", - "adding: mem time217, current time 290, horizon 73\n", - "adding: mem time218, current time 290, horizon 72\n", - "adding: mem time219, current time 290, horizon 71\n", - "adding: mem time220, current time 290, horizon 70\n", - "adding: mem time221, current time 290, horizon 69\n", - "adding: mem time222, current time 290, horizon 68\n", - "adding: mem time223, current time 290, horizon 67\n", - "adding: mem time224, current time 290, horizon 66\n", - "adding: mem time225, current time 290, horizon 65\n", - "adding: mem time226, current time 290, horizon 64\n", - "adding: mem time227, current time 290, horizon 63\n", - "adding: mem time228, current time 290, horizon 62\n", - "adding: mem time229, current time 290, horizon 61\n", - "adding: mem time230, current time 290, horizon 60\n", - "adding: mem time231, current time 290, horizon 59\n", - "adding: mem time232, current time 290, horizon 58\n", - "adding: mem time233, current time 290, horizon 57\n", - "adding: mem time234, current time 290, horizon 56\n", - "adding: mem time235, current time 290, horizon 55\n", - "adding: mem time236, current time 290, horizon 54\n", - "adding: mem time237, current time 290, horizon 53\n", - "adding: mem time238, current time 290, horizon 52\n", - "adding: mem time239, current time 290, horizon 51\n", - "adding: mem time240, current time 290, horizon 50\n", - "adding: mem time241, current time 290, horizon 49\n", - "adding: mem time242, current time 290, horizon 48\n", - "adding: mem time243, current time 290, horizon 47\n", - "adding: mem time244, current time 290, horizon 46\n", - "adding: mem time245, current time 290, horizon 45\n", - "adding: mem time246, current time 290, horizon 44\n", - "adding: mem time247, current time 290, horizon 43\n", - "adding: mem time248, current time 290, horizon 42\n", - "adding: mem time249, current time 290, horizon 41\n", - "adding: mem time250, current time 290, horizon 40\n", - "adding: mem time251, current time 290, horizon 39\n", - "adding: mem time252, current time 290, horizon 38\n", - "adding: mem time253, current time 290, horizon 37\n", - "adding: mem time254, current time 290, horizon 36\n", - "adding: mem time255, current time 290, horizon 35\n", - "adding: mem time256, current time 290, horizon 34\n", - "adding: mem time257, current time 290, horizon 33\n", - "adding: mem time258, current time 290, horizon 32\n", - "adding: mem time259, current time 290, horizon 31\n", - "adding: mem time260, current time 290, horizon 30\n", - "adding: mem time261, current time 290, horizon 29\n", - "adding: mem time262, current time 290, horizon 28\n", - "adding: mem time263, current time 290, horizon 27\n", - "adding: mem time264, current time 290, horizon 26\n", - "adding: mem time265, current time 290, horizon 25\n", - "adding: mem time266, current time 290, horizon 24\n", - "adding: mem time267, current time 290, horizon 23\n", - "adding: mem time268, current time 290, horizon 22\n", - "adding: mem time269, current time 290, horizon 21\n", - "adding: mem time270, current time 290, horizon 20\n", - "adding: mem time271, current time 290, horizon 19\n", - "adding: mem time272, current time 290, horizon 18\n", - "adding: mem time273, current time 290, horizon 17\n", - "adding: mem time274, current time 290, horizon 16\n", - "adding: mem time275, current time 290, horizon 15\n", - "adding: mem time276, current time 290, horizon 14\n", - "adding: mem time277, current time 290, horizon 13\n", - "adding: mem time278, current time 290, horizon 12\n", - "adding: mem time279, current time 290, horizon 11\n", - "adding: mem time280, current time 290, horizon 10\n", - "adding: mem time281, current time 290, horizon 9\n", - "adding: mem time282, current time 290, horizon 8\n", - "adding: mem time283, current time 290, horizon 7\n", - "adding: mem time284, current time 290, horizon 6\n", - "adding: mem time285, current time 290, horizon 5\n", - "adding: mem time286, current time 290, horizon 4\n", - "adding: mem time287, current time 290, horizon 3\n", - "adding: mem time288, current time 290, horizon 2\n", - "adding: mem time289, current time 290, horizon 1\n", - "adding: mem time200, current time 291, horizon 91\n", - "adding: mem time201, current time 291, horizon 90\n", - "adding: mem time202, current time 291, horizon 89\n", - "adding: mem time203, current time 291, horizon 88\n", - "adding: mem time204, current time 291, horizon 87\n", - "adding: mem time205, current time 291, horizon 86\n", - "adding: mem time206, current time 291, horizon 85\n", - "adding: mem time207, current time 291, horizon 84\n", - "adding: mem time208, current time 291, horizon 83\n", - "adding: mem time209, current time 291, horizon 82\n", - "adding: mem time210, current time 291, horizon 81\n", - "adding: mem time211, current time 291, horizon 80\n", - "adding: mem time212, current time 291, horizon 79\n", - "adding: mem time213, current time 291, horizon 78\n", - "adding: mem time214, current time 291, horizon 77\n", - "adding: mem time215, current time 291, horizon 76\n", - "adding: mem time216, current time 291, horizon 75\n", - "adding: mem time217, current time 291, horizon 74\n", - "adding: mem time218, current time 291, horizon 73\n", - "adding: mem time219, current time 291, horizon 72\n", - "adding: mem time220, current time 291, horizon 71\n", - "adding: mem time221, current time 291, horizon 70\n", - "adding: mem time222, current time 291, horizon 69\n", - "adding: mem time223, current time 291, horizon 68\n", - "adding: mem time224, current time 291, horizon 67\n", - "adding: mem time225, current time 291, horizon 66\n", - "adding: mem time226, current time 291, horizon 65\n", - "adding: mem time227, current time 291, horizon 64\n", - "adding: mem time228, current time 291, horizon 63\n", - "adding: mem time229, current time 291, horizon 62\n", - "adding: mem time230, current time 291, horizon 61\n", - "adding: mem time231, current time 291, horizon 60\n", - "adding: mem time232, current time 291, horizon 59\n", - "adding: mem time233, current time 291, horizon 58\n", - "adding: mem time234, current time 291, horizon 57\n", - "adding: mem time235, current time 291, horizon 56\n", - "adding: mem time236, current time 291, horizon 55\n", - "adding: mem time237, current time 291, horizon 54\n", - "adding: mem time238, current time 291, horizon 53\n", - "adding: mem time239, current time 291, horizon 52\n", - "adding: mem time240, current time 291, horizon 51\n", - "adding: mem time241, current time 291, horizon 50\n", - "adding: mem time242, current time 291, horizon 49\n", - "adding: mem time243, current time 291, horizon 48\n", - "adding: mem time244, current time 291, horizon 47\n", - "adding: mem time245, current time 291, horizon 46\n", - "adding: mem time246, current time 291, horizon 45\n", - "adding: mem time247, current time 291, horizon 44\n", - "adding: mem time248, current time 291, horizon 43\n", - "adding: mem time249, current time 291, horizon 42\n", - "adding: mem time250, current time 291, horizon 41\n", - "adding: mem time251, current time 291, horizon 40\n", - "adding: mem time252, current time 291, horizon 39\n", - "adding: mem time253, current time 291, horizon 38\n", - "adding: mem time254, current time 291, horizon 37\n", - "adding: mem time255, current time 291, horizon 36\n", - "adding: mem time256, current time 291, horizon 35\n", - "adding: mem time257, current time 291, horizon 34\n", - "adding: mem time258, current time 291, horizon 33\n", - "adding: mem time259, current time 291, horizon 32\n", - "adding: mem time260, current time 291, horizon 31\n", - "adding: mem time261, current time 291, horizon 30\n", - "adding: mem time262, current time 291, horizon 29\n", - "adding: mem time263, current time 291, horizon 28\n", - "adding: mem time264, current time 291, horizon 27\n", - "adding: mem time265, current time 291, horizon 26\n", - "adding: mem time266, current time 291, horizon 25\n", - "adding: mem time267, current time 291, horizon 24\n", - "adding: mem time268, current time 291, horizon 23\n", - "adding: mem time269, current time 291, horizon 22\n", - "adding: mem time270, current time 291, horizon 21\n", - "adding: mem time271, current time 291, horizon 20\n", - "adding: mem time272, current time 291, horizon 19\n", - "adding: mem time273, current time 291, horizon 18\n", - "adding: mem time274, current time 291, horizon 17\n", - "adding: mem time275, current time 291, horizon 16\n", - "adding: mem time276, current time 291, horizon 15\n", - "adding: mem time277, current time 291, horizon 14\n", - "adding: mem time278, current time 291, horizon 13\n", - "adding: mem time279, current time 291, horizon 12\n", - "adding: mem time280, current time 291, horizon 11\n", - "adding: mem time281, current time 291, horizon 10\n", - "adding: mem time282, current time 291, horizon 9\n", - "adding: mem time283, current time 291, horizon 8\n", - "adding: mem time284, current time 291, horizon 7\n", - "adding: mem time285, current time 291, horizon 6\n", - "adding: mem time286, current time 291, horizon 5\n", - "adding: mem time287, current time 291, horizon 4\n", - "adding: mem time288, current time 291, horizon 3\n", - "adding: mem time289, current time 291, horizon 2\n", - "adding: mem time290, current time 291, horizon 1\n", - "adding: mem time200, current time 292, horizon 92\n", - "adding: mem time201, current time 292, horizon 91\n", - "adding: mem time202, current time 292, horizon 90\n", - "adding: mem time203, current time 292, horizon 89\n", - "adding: mem time204, current time 292, horizon 88\n", - "adding: mem time205, current time 292, horizon 87\n", - "adding: mem time206, current time 292, horizon 86\n", - "adding: mem time207, current time 292, horizon 85\n", - "adding: mem time208, current time 292, horizon 84\n", - "adding: mem time209, current time 292, horizon 83\n", - "adding: mem time210, current time 292, horizon 82\n", - "adding: mem time211, current time 292, horizon 81\n", - "adding: mem time212, current time 292, horizon 80\n", - "adding: mem time213, current time 292, horizon 79\n", - "adding: mem time214, current time 292, horizon 78\n", - "adding: mem time215, current time 292, horizon 77\n", - "adding: mem time216, current time 292, horizon 76\n", - "adding: mem time217, current time 292, horizon 75\n", - "adding: mem time218, current time 292, horizon 74\n", - "adding: mem time219, current time 292, horizon 73\n", - "adding: mem time220, current time 292, horizon 72\n", - "adding: mem time221, current time 292, horizon 71\n", - "adding: mem time222, current time 292, horizon 70\n", - "adding: mem time223, current time 292, horizon 69\n", - "adding: mem time224, current time 292, horizon 68\n", - "adding: mem time225, current time 292, horizon 67\n", - "adding: mem time226, current time 292, horizon 66\n", - "adding: mem time227, current time 292, horizon 65\n", - "adding: mem time228, current time 292, horizon 64\n", - "adding: mem time229, current time 292, horizon 63\n", - "adding: mem time230, current time 292, horizon 62\n", - "adding: mem time231, current time 292, horizon 61\n", - "adding: mem time232, current time 292, horizon 60\n", - "adding: mem time233, current time 292, horizon 59\n", - "adding: mem time234, current time 292, horizon 58\n", - "adding: mem time235, current time 292, horizon 57\n", - "adding: mem time236, current time 292, horizon 56\n", - "adding: mem time237, current time 292, horizon 55\n", - "adding: mem time238, current time 292, horizon 54\n", - "adding: mem time239, current time 292, horizon 53\n", - "adding: mem time240, current time 292, horizon 52\n", - "adding: mem time241, current time 292, horizon 51\n", - "adding: mem time242, current time 292, horizon 50\n", - "adding: mem time243, current time 292, horizon 49\n", - "adding: mem time244, current time 292, horizon 48\n", - "adding: mem time245, current time 292, horizon 47\n", - "adding: mem time246, current time 292, horizon 46\n", - "adding: mem time247, current time 292, horizon 45\n", - "adding: mem time248, current time 292, horizon 44\n", - "adding: mem time249, current time 292, horizon 43\n", - "adding: mem time250, current time 292, horizon 42\n", - "adding: mem time251, current time 292, horizon 41\n", - "adding: mem time252, current time 292, horizon 40\n", - "adding: mem time253, current time 292, horizon 39\n", - "adding: mem time254, current time 292, horizon 38\n", - "adding: mem time255, current time 292, horizon 37\n", - "adding: mem time256, current time 292, horizon 36\n", - "adding: mem time257, current time 292, horizon 35\n", - "adding: mem time258, current time 292, horizon 34\n", - "adding: mem time259, current time 292, horizon 33\n", - "adding: mem time260, current time 292, horizon 32\n", - "adding: mem time261, current time 292, horizon 31\n", - "adding: mem time262, current time 292, horizon 30\n", - "adding: mem time263, current time 292, horizon 29\n", - "adding: mem time264, current time 292, horizon 28\n", - "adding: mem time265, current time 292, horizon 27\n", - "adding: mem time266, current time 292, horizon 26\n", - "adding: mem time267, current time 292, horizon 25\n", - "adding: mem time268, current time 292, horizon 24\n", - "adding: mem time269, current time 292, horizon 23\n", - "adding: mem time270, current time 292, horizon 22\n", - "adding: mem time271, current time 292, horizon 21\n", - "adding: mem time272, current time 292, horizon 20\n", - "adding: mem time273, current time 292, horizon 19\n", - "adding: mem time274, current time 292, horizon 18\n", - "adding: mem time275, current time 292, horizon 17\n", - "adding: mem time276, current time 292, horizon 16\n", - "adding: mem time277, current time 292, horizon 15\n", - "adding: mem time278, current time 292, horizon 14\n", - "adding: mem time279, current time 292, horizon 13\n", - "adding: mem time280, current time 292, horizon 12\n", - "adding: mem time281, current time 292, horizon 11\n", - "adding: mem time282, current time 292, horizon 10\n", - "adding: mem time283, current time 292, horizon 9\n", - "adding: mem time284, current time 292, horizon 8\n", - "adding: mem time285, current time 292, horizon 7\n", - "adding: mem time286, current time 292, horizon 6\n", - "adding: mem time287, current time 292, horizon 5\n", - "adding: mem time288, current time 292, horizon 4\n", - "adding: mem time289, current time 292, horizon 3\n", - "adding: mem time290, current time 292, horizon 2\n", - "adding: mem time291, current time 292, horizon 1\n", - "adding: mem time200, current time 293, horizon 93\n", - "adding: mem time201, current time 293, horizon 92\n", - "adding: mem time202, current time 293, horizon 91\n", - "adding: mem time203, current time 293, horizon 90\n", - "adding: mem time204, current time 293, horizon 89\n", - "adding: mem time205, current time 293, horizon 88\n", - "adding: mem time206, current time 293, horizon 87\n", - "adding: mem time207, current time 293, horizon 86\n", - "adding: mem time208, current time 293, horizon 85\n", - "adding: mem time209, current time 293, horizon 84\n", - "adding: mem time210, current time 293, horizon 83\n", - "adding: mem time211, current time 293, horizon 82\n", - "adding: mem time212, current time 293, horizon 81\n", - "adding: mem time213, current time 293, horizon 80\n", - "adding: mem time214, current time 293, horizon 79\n", - "adding: mem time215, current time 293, horizon 78\n", - "adding: mem time216, current time 293, horizon 77\n", - "adding: mem time217, current time 293, horizon 76\n", - "adding: mem time218, current time 293, horizon 75\n", - "adding: mem time219, current time 293, horizon 74\n", - "adding: mem time220, current time 293, horizon 73\n", - "adding: mem time221, current time 293, horizon 72\n", - "adding: mem time222, current time 293, horizon 71\n", - "adding: mem time223, current time 293, horizon 70\n", - "adding: mem time224, current time 293, horizon 69\n", - "adding: mem time225, current time 293, horizon 68\n", - "adding: mem time226, current time 293, horizon 67\n", - "adding: mem time227, current time 293, horizon 66\n", - "adding: mem time228, current time 293, horizon 65\n", - "adding: mem time229, current time 293, horizon 64\n", - "adding: mem time230, current time 293, horizon 63\n", - "adding: mem time231, current time 293, horizon 62\n", - "adding: mem time232, current time 293, horizon 61\n", - "adding: mem time233, current time 293, horizon 60\n", - "adding: mem time234, current time 293, horizon 59\n", - "adding: mem time235, current time 293, horizon 58\n", - "adding: mem time236, current time 293, horizon 57\n", - "adding: mem time237, current time 293, horizon 56\n", - "adding: mem time238, current time 293, horizon 55\n", - "adding: mem time239, current time 293, horizon 54\n", - "adding: mem time240, current time 293, horizon 53\n", - "adding: mem time241, current time 293, horizon 52\n", - "adding: mem time242, current time 293, horizon 51\n", - "adding: mem time243, current time 293, horizon 50\n", - "adding: mem time244, current time 293, horizon 49\n", - "adding: mem time245, current time 293, horizon 48\n", - "adding: mem time246, current time 293, horizon 47\n", - "adding: mem time247, current time 293, horizon 46\n", - "adding: mem time248, current time 293, horizon 45\n", - "adding: mem time249, current time 293, horizon 44\n", - "adding: mem time250, current time 293, horizon 43\n", - "adding: mem time251, current time 293, horizon 42\n", - "adding: mem time252, current time 293, horizon 41\n", - "adding: mem time253, current time 293, horizon 40\n", - "adding: mem time254, current time 293, horizon 39\n", - "adding: mem time255, current time 293, horizon 38\n", - "adding: mem time256, current time 293, horizon 37\n", - "adding: mem time257, current time 293, horizon 36\n", - "adding: mem time258, current time 293, horizon 35\n", - "adding: mem time259, current time 293, horizon 34\n", - "adding: mem time260, current time 293, horizon 33\n", - "adding: mem time261, current time 293, horizon 32\n", - "adding: mem time262, current time 293, horizon 31\n", - "adding: mem time263, current time 293, horizon 30\n", - "adding: mem time264, current time 293, horizon 29\n", - "adding: mem time265, current time 293, horizon 28\n", - "adding: mem time266, current time 293, horizon 27\n", - "adding: mem time267, current time 293, horizon 26\n", - "adding: mem time268, current time 293, horizon 25\n", - "adding: mem time269, current time 293, horizon 24\n", - "adding: mem time270, current time 293, horizon 23\n", - "adding: mem time271, current time 293, horizon 22\n", - "adding: mem time272, current time 293, horizon 21\n", - "adding: mem time273, current time 293, horizon 20\n", - "adding: mem time274, current time 293, horizon 19\n", - "adding: mem time275, current time 293, horizon 18\n", - "adding: mem time276, current time 293, horizon 17\n", - "adding: mem time277, current time 293, horizon 16\n", - "adding: mem time278, current time 293, horizon 15\n", - "adding: mem time279, current time 293, horizon 14\n", - "adding: mem time280, current time 293, horizon 13\n", - "adding: mem time281, current time 293, horizon 12\n", - "adding: mem time282, current time 293, horizon 11\n", - "adding: mem time283, current time 293, horizon 10\n", - "adding: mem time284, current time 293, horizon 9\n", - "adding: mem time285, current time 293, horizon 8\n", - "adding: mem time286, current time 293, horizon 7\n", - "adding: mem time287, current time 293, horizon 6\n", - "adding: mem time288, current time 293, horizon 5\n", - "adding: mem time289, current time 293, horizon 4\n", - "adding: mem time290, current time 293, horizon 3\n", - "adding: mem time291, current time 293, horizon 2\n", - "adding: mem time292, current time 293, horizon 1\n", - "adding: mem time200, current time 294, horizon 94\n", - "adding: mem time201, current time 294, horizon 93\n", - "adding: mem time202, current time 294, horizon 92\n", - "adding: mem time203, current time 294, horizon 91\n", - "adding: mem time204, current time 294, horizon 90\n", - "adding: mem time205, current time 294, horizon 89\n", - "adding: mem time206, current time 294, horizon 88\n", - "adding: mem time207, current time 294, horizon 87\n", - "adding: mem time208, current time 294, horizon 86\n", - "adding: mem time209, current time 294, horizon 85\n", - "adding: mem time210, current time 294, horizon 84\n", - "adding: mem time211, current time 294, horizon 83\n", - "adding: mem time212, current time 294, horizon 82\n", - "adding: mem time213, current time 294, horizon 81\n", - "adding: mem time214, current time 294, horizon 80\n", - "adding: mem time215, current time 294, horizon 79\n", - "adding: mem time216, current time 294, horizon 78\n", - "adding: mem time217, current time 294, horizon 77\n", - "adding: mem time218, current time 294, horizon 76\n", - "adding: mem time219, current time 294, horizon 75\n", - "adding: mem time220, current time 294, horizon 74\n", - "adding: mem time221, current time 294, horizon 73\n", - "adding: mem time222, current time 294, horizon 72\n", - "adding: mem time223, current time 294, horizon 71\n", - "adding: mem time224, current time 294, horizon 70\n", - "adding: mem time225, current time 294, horizon 69\n", - "adding: mem time226, current time 294, horizon 68\n", - "adding: mem time227, current time 294, horizon 67\n", - "adding: mem time228, current time 294, horizon 66\n", - "adding: mem time229, current time 294, horizon 65\n", - "adding: mem time230, current time 294, horizon 64\n", - "adding: mem time231, current time 294, horizon 63\n", - "adding: mem time232, current time 294, horizon 62\n", - "adding: mem time233, current time 294, horizon 61\n", - "adding: mem time234, current time 294, horizon 60\n", - "adding: mem time235, current time 294, horizon 59\n", - "adding: mem time236, current time 294, horizon 58\n", - "adding: mem time237, current time 294, horizon 57\n", - "adding: mem time238, current time 294, horizon 56\n", - "adding: mem time239, current time 294, horizon 55\n", - "adding: mem time240, current time 294, horizon 54\n", - "adding: mem time241, current time 294, horizon 53\n", - "adding: mem time242, current time 294, horizon 52\n", - "adding: mem time243, current time 294, horizon 51\n", - "adding: mem time244, current time 294, horizon 50\n", - "adding: mem time245, current time 294, horizon 49\n", - "adding: mem time246, current time 294, horizon 48\n", - "adding: mem time247, current time 294, horizon 47\n", - "adding: mem time248, current time 294, horizon 46\n", - "adding: mem time249, current time 294, horizon 45\n", - "adding: mem time250, current time 294, horizon 44\n", - "adding: mem time251, current time 294, horizon 43\n", - "adding: mem time252, current time 294, horizon 42\n", - "adding: mem time253, current time 294, horizon 41\n", - "adding: mem time254, current time 294, horizon 40\n", - "adding: mem time255, current time 294, horizon 39\n", - "adding: mem time256, current time 294, horizon 38\n", - "adding: mem time257, current time 294, horizon 37\n", - "adding: mem time258, current time 294, horizon 36\n", - "adding: mem time259, current time 294, horizon 35\n", - "adding: mem time260, current time 294, horizon 34\n", - "adding: mem time261, current time 294, horizon 33\n", - "adding: mem time262, current time 294, horizon 32\n", - "adding: mem time263, current time 294, horizon 31\n", - "adding: mem time264, current time 294, horizon 30\n", - "adding: mem time265, current time 294, horizon 29\n", - "adding: mem time266, current time 294, horizon 28\n", - "adding: mem time267, current time 294, horizon 27\n", - "adding: mem time268, current time 294, horizon 26\n", - "adding: mem time269, current time 294, horizon 25\n", - "adding: mem time270, current time 294, horizon 24\n", - "adding: mem time271, current time 294, horizon 23\n", - "adding: mem time272, current time 294, horizon 22\n", - "adding: mem time273, current time 294, horizon 21\n", - "adding: mem time274, current time 294, horizon 20\n", - "adding: mem time275, current time 294, horizon 19\n", - "adding: mem time276, current time 294, horizon 18\n", - "adding: mem time277, current time 294, horizon 17\n", - "adding: mem time278, current time 294, horizon 16\n", - "adding: mem time279, current time 294, horizon 15\n", - "adding: mem time280, current time 294, horizon 14\n", - "adding: mem time281, current time 294, horizon 13\n", - "adding: mem time282, current time 294, horizon 12\n", - "adding: mem time283, current time 294, horizon 11\n", - "adding: mem time284, current time 294, horizon 10\n", - "adding: mem time285, current time 294, horizon 9\n", - "adding: mem time286, current time 294, horizon 8\n", - "adding: mem time287, current time 294, horizon 7\n", - "adding: mem time288, current time 294, horizon 6\n", - "adding: mem time289, current time 294, horizon 5\n", - "adding: mem time290, current time 294, horizon 4\n", - "adding: mem time291, current time 294, horizon 3\n", - "adding: mem time292, current time 294, horizon 2\n", - "adding: mem time293, current time 294, horizon 1\n", - "adding: mem time200, current time 295, horizon 95\n", - "adding: mem time201, current time 295, horizon 94\n", - "adding: mem time202, current time 295, horizon 93\n", - "adding: mem time203, current time 295, horizon 92\n", - "adding: mem time204, current time 295, horizon 91\n", - "adding: mem time205, current time 295, horizon 90\n", - "adding: mem time206, current time 295, horizon 89\n", - "adding: mem time207, current time 295, horizon 88\n", - "adding: mem time208, current time 295, horizon 87\n", - "adding: mem time209, current time 295, horizon 86\n", - "adding: mem time210, current time 295, horizon 85\n", - "adding: mem time211, current time 295, horizon 84\n", - "adding: mem time212, current time 295, horizon 83\n", - "adding: mem time213, current time 295, horizon 82\n", - "adding: mem time214, current time 295, horizon 81\n", - "adding: mem time215, current time 295, horizon 80\n", - "adding: mem time216, current time 295, horizon 79\n", - "adding: mem time217, current time 295, horizon 78\n", - "adding: mem time218, current time 295, horizon 77\n", - "adding: mem time219, current time 295, horizon 76\n", - "adding: mem time220, current time 295, horizon 75\n", - "adding: mem time221, current time 295, horizon 74\n", - "adding: mem time222, current time 295, horizon 73\n", - "adding: mem time223, current time 295, horizon 72\n", - "adding: mem time224, current time 295, horizon 71\n", - "adding: mem time225, current time 295, horizon 70\n", - "adding: mem time226, current time 295, horizon 69\n", - "adding: mem time227, current time 295, horizon 68\n", - "adding: mem time228, current time 295, horizon 67\n", - "adding: mem time229, current time 295, horizon 66\n", - "adding: mem time230, current time 295, horizon 65\n", - "adding: mem time231, current time 295, horizon 64\n", - "adding: mem time232, current time 295, horizon 63\n", - "adding: mem time233, current time 295, horizon 62\n", - "adding: mem time234, current time 295, horizon 61\n", - "adding: mem time235, current time 295, horizon 60\n", - "adding: mem time236, current time 295, horizon 59\n", - "adding: mem time237, current time 295, horizon 58\n", - "adding: mem time238, current time 295, horizon 57\n", - "adding: mem time239, current time 295, horizon 56\n", - "adding: mem time240, current time 295, horizon 55\n", - "adding: mem time241, current time 295, horizon 54\n", - "adding: mem time242, current time 295, horizon 53\n", - "adding: mem time243, current time 295, horizon 52\n", - "adding: mem time244, current time 295, horizon 51\n", - "adding: mem time245, current time 295, horizon 50\n", - "adding: mem time246, current time 295, horizon 49\n", - "adding: mem time247, current time 295, horizon 48\n", - "adding: mem time248, current time 295, horizon 47\n", - "adding: mem time249, current time 295, horizon 46\n", - "adding: mem time250, current time 295, horizon 45\n", - "adding: mem time251, current time 295, horizon 44\n", - "adding: mem time252, current time 295, horizon 43\n", - "adding: mem time253, current time 295, horizon 42\n", - "adding: mem time254, current time 295, horizon 41\n", - "adding: mem time255, current time 295, horizon 40\n", - "adding: mem time256, current time 295, horizon 39\n", - "adding: mem time257, current time 295, horizon 38\n", - "adding: mem time258, current time 295, horizon 37\n", - "adding: mem time259, current time 295, horizon 36\n", - "adding: mem time260, current time 295, horizon 35\n", - "adding: mem time261, current time 295, horizon 34\n", - "adding: mem time262, current time 295, horizon 33\n", - "adding: mem time263, current time 295, horizon 32\n", - "adding: mem time264, current time 295, horizon 31\n", - "adding: mem time265, current time 295, horizon 30\n", - "adding: mem time266, current time 295, horizon 29\n", - "adding: mem time267, current time 295, horizon 28\n", - "adding: mem time268, current time 295, horizon 27\n", - "adding: mem time269, current time 295, horizon 26\n", - "adding: mem time270, current time 295, horizon 25\n", - "adding: mem time271, current time 295, horizon 24\n", - "adding: mem time272, current time 295, horizon 23\n", - "adding: mem time273, current time 295, horizon 22\n", - "adding: mem time274, current time 295, horizon 21\n", - "adding: mem time275, current time 295, horizon 20\n", - "adding: mem time276, current time 295, horizon 19\n", - "adding: mem time277, current time 295, horizon 18\n", - "adding: mem time278, current time 295, horizon 17\n", - "adding: mem time279, current time 295, horizon 16\n", - "adding: mem time280, current time 295, horizon 15\n", - "adding: mem time281, current time 295, horizon 14\n", - "adding: mem time282, current time 295, horizon 13\n", - "adding: mem time283, current time 295, horizon 12\n", - "adding: mem time284, current time 295, horizon 11\n", - "adding: mem time285, current time 295, horizon 10\n", - "adding: mem time286, current time 295, horizon 9\n", - "adding: mem time287, current time 295, horizon 8\n", - "adding: mem time288, current time 295, horizon 7\n", - "adding: mem time289, current time 295, horizon 6\n", - "adding: mem time290, current time 295, horizon 5\n", - "adding: mem time291, current time 295, horizon 4\n", - "adding: mem time292, current time 295, horizon 3\n", - "adding: mem time293, current time 295, horizon 2\n", - "adding: mem time294, current time 295, horizon 1\n", - "adding: mem time200, current time 296, horizon 96\n", - "adding: mem time201, current time 296, horizon 95\n", - "adding: mem time202, current time 296, horizon 94\n", - "adding: mem time203, current time 296, horizon 93\n", - "adding: mem time204, current time 296, horizon 92\n", - "adding: mem time205, current time 296, horizon 91\n", - "adding: mem time206, current time 296, horizon 90\n", - "adding: mem time207, current time 296, horizon 89\n", - "adding: mem time208, current time 296, horizon 88\n", - "adding: mem time209, current time 296, horizon 87\n", - "adding: mem time210, current time 296, horizon 86\n", - "adding: mem time211, current time 296, horizon 85\n", - "adding: mem time212, current time 296, horizon 84\n", - "adding: mem time213, current time 296, horizon 83\n", - "adding: mem time214, current time 296, horizon 82\n", - "adding: mem time215, current time 296, horizon 81\n", - "adding: mem time216, current time 296, horizon 80\n", - "adding: mem time217, current time 296, horizon 79\n", - "adding: mem time218, current time 296, horizon 78\n", - "adding: mem time219, current time 296, horizon 77\n", - "adding: mem time220, current time 296, horizon 76\n", - "adding: mem time221, current time 296, horizon 75\n", - "adding: mem time222, current time 296, horizon 74\n", - "adding: mem time223, current time 296, horizon 73\n", - "adding: mem time224, current time 296, horizon 72\n", - "adding: mem time225, current time 296, horizon 71\n", - "adding: mem time226, current time 296, horizon 70\n", - "adding: mem time227, current time 296, horizon 69\n", - "adding: mem time228, current time 296, horizon 68\n", - "adding: mem time229, current time 296, horizon 67\n", - "adding: mem time230, current time 296, horizon 66\n", - "adding: mem time231, current time 296, horizon 65\n", - "adding: mem time232, current time 296, horizon 64\n", - "adding: mem time233, current time 296, horizon 63\n", - "adding: mem time234, current time 296, horizon 62\n", - "adding: mem time235, current time 296, horizon 61\n", - "adding: mem time236, current time 296, horizon 60\n", - "adding: mem time237, current time 296, horizon 59\n", - "adding: mem time238, current time 296, horizon 58\n", - "adding: mem time239, current time 296, horizon 57\n", - "adding: mem time240, current time 296, horizon 56\n", - "adding: mem time241, current time 296, horizon 55\n", - "adding: mem time242, current time 296, horizon 54\n", - "adding: mem time243, current time 296, horizon 53\n", - "adding: mem time244, current time 296, horizon 52\n", - "adding: mem time245, current time 296, horizon 51\n", - "adding: mem time246, current time 296, horizon 50\n", - "adding: mem time247, current time 296, horizon 49\n", - "adding: mem time248, current time 296, horizon 48\n", - "adding: mem time249, current time 296, horizon 47\n", - "adding: mem time250, current time 296, horizon 46\n", - "adding: mem time251, current time 296, horizon 45\n", - "adding: mem time252, current time 296, horizon 44\n", - "adding: mem time253, current time 296, horizon 43\n", - "adding: mem time254, current time 296, horizon 42\n", - "adding: mem time255, current time 296, horizon 41\n", - "adding: mem time256, current time 296, horizon 40\n", - "adding: mem time257, current time 296, horizon 39\n", - "adding: mem time258, current time 296, horizon 38\n", - "adding: mem time259, current time 296, horizon 37\n", - "adding: mem time260, current time 296, horizon 36\n", - "adding: mem time261, current time 296, horizon 35\n", - "adding: mem time262, current time 296, horizon 34\n", - "adding: mem time263, current time 296, horizon 33\n", - "adding: mem time264, current time 296, horizon 32\n", - "adding: mem time265, current time 296, horizon 31\n", - "adding: mem time266, current time 296, horizon 30\n", - "adding: mem time267, current time 296, horizon 29\n", - "adding: mem time268, current time 296, horizon 28\n", - "adding: mem time269, current time 296, horizon 27\n", - "adding: mem time270, current time 296, horizon 26\n", - "adding: mem time271, current time 296, horizon 25\n", - "adding: mem time272, current time 296, horizon 24\n", - "adding: mem time273, current time 296, horizon 23\n", - "adding: mem time274, current time 296, horizon 22\n", - "adding: mem time275, current time 296, horizon 21\n", - "adding: mem time276, current time 296, horizon 20\n", - "adding: mem time277, current time 296, horizon 19\n", - "adding: mem time278, current time 296, horizon 18\n", - "adding: mem time279, current time 296, horizon 17\n", - "adding: mem time280, current time 296, horizon 16\n", - "adding: mem time281, current time 296, horizon 15\n", - "adding: mem time282, current time 296, horizon 14\n", - "adding: mem time283, current time 296, horizon 13\n", - "adding: mem time284, current time 296, horizon 12\n", - "adding: mem time285, current time 296, horizon 11\n", - "adding: mem time286, current time 296, horizon 10\n", - "adding: mem time287, current time 296, horizon 9\n", - "adding: mem time288, current time 296, horizon 8\n", - "adding: mem time289, current time 296, horizon 7\n", - "adding: mem time290, current time 296, horizon 6\n", - "adding: mem time291, current time 296, horizon 5\n", - "adding: mem time292, current time 296, horizon 4\n", - "adding: mem time293, current time 296, horizon 3\n", - "adding: mem time294, current time 296, horizon 2\n", - "adding: mem time295, current time 296, horizon 1\n", - "adding: mem time200, current time 297, horizon 97\n", - "adding: mem time201, current time 297, horizon 96\n", - "adding: mem time202, current time 297, horizon 95\n", - "adding: mem time203, current time 297, horizon 94\n", - "adding: mem time204, current time 297, horizon 93\n", - "adding: mem time205, current time 297, horizon 92\n", - "adding: mem time206, current time 297, horizon 91\n", - "adding: mem time207, current time 297, horizon 90\n", - "adding: mem time208, current time 297, horizon 89\n", - "adding: mem time209, current time 297, horizon 88\n", - "adding: mem time210, current time 297, horizon 87\n", - "adding: mem time211, current time 297, horizon 86\n", - "adding: mem time212, current time 297, horizon 85\n", - "adding: mem time213, current time 297, horizon 84\n", - "adding: mem time214, current time 297, horizon 83\n", - "adding: mem time215, current time 297, horizon 82\n", - "adding: mem time216, current time 297, horizon 81\n", - "adding: mem time217, current time 297, horizon 80\n", - "adding: mem time218, current time 297, horizon 79\n", - "adding: mem time219, current time 297, horizon 78\n", - "adding: mem time220, current time 297, horizon 77\n", - "adding: mem time221, current time 297, horizon 76\n", - "adding: mem time222, current time 297, horizon 75\n", - "adding: mem time223, current time 297, horizon 74\n", - "adding: mem time224, current time 297, horizon 73\n", - "adding: mem time225, current time 297, horizon 72\n", - "adding: mem time226, current time 297, horizon 71\n", - "adding: mem time227, current time 297, horizon 70\n", - "adding: mem time228, current time 297, horizon 69\n", - "adding: mem time229, current time 297, horizon 68\n", - "adding: mem time230, current time 297, horizon 67\n", - "adding: mem time231, current time 297, horizon 66\n", - "adding: mem time232, current time 297, horizon 65\n", - "adding: mem time233, current time 297, horizon 64\n", - "adding: mem time234, current time 297, horizon 63\n", - "adding: mem time235, current time 297, horizon 62\n", - "adding: mem time236, current time 297, horizon 61\n", - "adding: mem time237, current time 297, horizon 60\n", - "adding: mem time238, current time 297, horizon 59\n", - "adding: mem time239, current time 297, horizon 58\n", - "adding: mem time240, current time 297, horizon 57\n", - "adding: mem time241, current time 297, horizon 56\n", - "adding: mem time242, current time 297, horizon 55\n", - "adding: mem time243, current time 297, horizon 54\n", - "adding: mem time244, current time 297, horizon 53\n", - "adding: mem time245, current time 297, horizon 52\n", - "adding: mem time246, current time 297, horizon 51\n", - "adding: mem time247, current time 297, horizon 50\n", - "adding: mem time248, current time 297, horizon 49\n", - "adding: mem time249, current time 297, horizon 48\n", - "adding: mem time250, current time 297, horizon 47\n", - "adding: mem time251, current time 297, horizon 46\n", - "adding: mem time252, current time 297, horizon 45\n", - "adding: mem time253, current time 297, horizon 44\n", - "adding: mem time254, current time 297, horizon 43\n", - "adding: mem time255, current time 297, horizon 42\n", - "adding: mem time256, current time 297, horizon 41\n", - "adding: mem time257, current time 297, horizon 40\n", - "adding: mem time258, current time 297, horizon 39\n", - "adding: mem time259, current time 297, horizon 38\n", - "adding: mem time260, current time 297, horizon 37\n", - "adding: mem time261, current time 297, horizon 36\n", - "adding: mem time262, current time 297, horizon 35\n", - "adding: mem time263, current time 297, horizon 34\n", - "adding: mem time264, current time 297, horizon 33\n", - "adding: mem time265, current time 297, horizon 32\n", - "adding: mem time266, current time 297, horizon 31\n", - "adding: mem time267, current time 297, horizon 30\n", - "adding: mem time268, current time 297, horizon 29\n", - "adding: mem time269, current time 297, horizon 28\n", - "adding: mem time270, current time 297, horizon 27\n", - "adding: mem time271, current time 297, horizon 26\n", - "adding: mem time272, current time 297, horizon 25\n", - "adding: mem time273, current time 297, horizon 24\n", - "adding: mem time274, current time 297, horizon 23\n", - "adding: mem time275, current time 297, horizon 22\n", - "adding: mem time276, current time 297, horizon 21\n", - "adding: mem time277, current time 297, horizon 20\n", - "adding: mem time278, current time 297, horizon 19\n", - "adding: mem time279, current time 297, horizon 18\n", - "adding: mem time280, current time 297, horizon 17\n", - "adding: mem time281, current time 297, horizon 16\n", - "adding: mem time282, current time 297, horizon 15\n", - "adding: mem time283, current time 297, horizon 14\n", - "adding: mem time284, current time 297, horizon 13\n", - "adding: mem time285, current time 297, horizon 12\n", - "adding: mem time286, current time 297, horizon 11\n", - "adding: mem time287, current time 297, horizon 10\n", - "adding: mem time288, current time 297, horizon 9\n", - "adding: mem time289, current time 297, horizon 8\n", - "adding: mem time290, current time 297, horizon 7\n", - "adding: mem time291, current time 297, horizon 6\n", - "adding: mem time292, current time 297, horizon 5\n", - "adding: mem time293, current time 297, horizon 4\n", - "adding: mem time294, current time 297, horizon 3\n", - "adding: mem time295, current time 297, horizon 2\n", - "adding: mem time296, current time 297, horizon 1\n", - "adding: mem time200, current time 298, horizon 98\n", - "adding: mem time201, current time 298, horizon 97\n", - "adding: mem time202, current time 298, horizon 96\n", - "adding: mem time203, current time 298, horizon 95\n", - "adding: mem time204, current time 298, horizon 94\n", - "adding: mem time205, current time 298, horizon 93\n", - "adding: mem time206, current time 298, horizon 92\n", - "adding: mem time207, current time 298, horizon 91\n", - "adding: mem time208, current time 298, horizon 90\n", - "adding: mem time209, current time 298, horizon 89\n", - "adding: mem time210, current time 298, horizon 88\n", - "adding: mem time211, current time 298, horizon 87\n", - "adding: mem time212, current time 298, horizon 86\n", - "adding: mem time213, current time 298, horizon 85\n", - "adding: mem time214, current time 298, horizon 84\n", - "adding: mem time215, current time 298, horizon 83\n", - "adding: mem time216, current time 298, horizon 82\n", - "adding: mem time217, current time 298, horizon 81\n", - "adding: mem time218, current time 298, horizon 80\n", - "adding: mem time219, current time 298, horizon 79\n", - "adding: mem time220, current time 298, horizon 78\n", - "adding: mem time221, current time 298, horizon 77\n", - "adding: mem time222, current time 298, horizon 76\n", - "adding: mem time223, current time 298, horizon 75\n", - "adding: mem time224, current time 298, horizon 74\n", - "adding: mem time225, current time 298, horizon 73\n", - "adding: mem time226, current time 298, horizon 72\n", - "adding: mem time227, current time 298, horizon 71\n", - "adding: mem time228, current time 298, horizon 70\n", - "adding: mem time229, current time 298, horizon 69\n", - "adding: mem time230, current time 298, horizon 68\n", - "adding: mem time231, current time 298, horizon 67\n", - "adding: mem time232, current time 298, horizon 66\n", - "adding: mem time233, current time 298, horizon 65\n", - "adding: mem time234, current time 298, horizon 64\n", - "adding: mem time235, current time 298, horizon 63\n", - "adding: mem time236, current time 298, horizon 62\n", - "adding: mem time237, current time 298, horizon 61\n", - "adding: mem time238, current time 298, horizon 60\n", - "adding: mem time239, current time 298, horizon 59\n", - "adding: mem time240, current time 298, horizon 58\n", - "adding: mem time241, current time 298, horizon 57\n", - "adding: mem time242, current time 298, horizon 56\n", - "adding: mem time243, current time 298, horizon 55\n", - "adding: mem time244, current time 298, horizon 54\n", - "adding: mem time245, current time 298, horizon 53\n", - "adding: mem time246, current time 298, horizon 52\n", - "adding: mem time247, current time 298, horizon 51\n", - "adding: mem time248, current time 298, horizon 50\n", - "adding: mem time249, current time 298, horizon 49\n", - "adding: mem time250, current time 298, horizon 48\n", - "adding: mem time251, current time 298, horizon 47\n", - "adding: mem time252, current time 298, horizon 46\n", - "adding: mem time253, current time 298, horizon 45\n", - "adding: mem time254, current time 298, horizon 44\n", - "adding: mem time255, current time 298, horizon 43\n", - "adding: mem time256, current time 298, horizon 42\n", - "adding: mem time257, current time 298, horizon 41\n", - "adding: mem time258, current time 298, horizon 40\n", - "adding: mem time259, current time 298, horizon 39\n", - "adding: mem time260, current time 298, horizon 38\n", - "adding: mem time261, current time 298, horizon 37\n", - "adding: mem time262, current time 298, horizon 36\n", - "adding: mem time263, current time 298, horizon 35\n", - "adding: mem time264, current time 298, horizon 34\n", - "adding: mem time265, current time 298, horizon 33\n", - "adding: mem time266, current time 298, horizon 32\n", - "adding: mem time267, current time 298, horizon 31\n", - "adding: mem time268, current time 298, horizon 30\n", - "adding: mem time269, current time 298, horizon 29\n", - "adding: mem time270, current time 298, horizon 28\n", - "adding: mem time271, current time 298, horizon 27\n", - "adding: mem time272, current time 298, horizon 26\n", - "adding: mem time273, current time 298, horizon 25\n", - "adding: mem time274, current time 298, horizon 24\n", - "adding: mem time275, current time 298, horizon 23\n", - "adding: mem time276, current time 298, horizon 22\n", - "adding: mem time277, current time 298, horizon 21\n", - "adding: mem time278, current time 298, horizon 20\n", - "adding: mem time279, current time 298, horizon 19\n", - "adding: mem time280, current time 298, horizon 18\n", - "adding: mem time281, current time 298, horizon 17\n", - "adding: mem time282, current time 298, horizon 16\n", - "adding: mem time283, current time 298, horizon 15\n", - "adding: mem time284, current time 298, horizon 14\n", - "adding: mem time285, current time 298, horizon 13\n", - "adding: mem time286, current time 298, horizon 12\n", - "adding: mem time287, current time 298, horizon 11\n", - "adding: mem time288, current time 298, horizon 10\n", - "adding: mem time289, current time 298, horizon 9\n", - "adding: mem time290, current time 298, horizon 8\n", - "adding: mem time291, current time 298, horizon 7\n", - "adding: mem time292, current time 298, horizon 6\n", - "adding: mem time293, current time 298, horizon 5\n", - "adding: mem time294, current time 298, horizon 4\n", - "adding: mem time295, current time 298, horizon 3\n", - "adding: mem time296, current time 298, horizon 2\n", - "adding: mem time297, current time 298, horizon 1\n", - "adding: mem time200, current time 299, horizon 99\n", - "adding: mem time201, current time 299, horizon 98\n", - "adding: mem time202, current time 299, horizon 97\n", - "adding: mem time203, current time 299, horizon 96\n", - "adding: mem time204, current time 299, horizon 95\n", - "adding: mem time205, current time 299, horizon 94\n", - "adding: mem time206, current time 299, horizon 93\n", - "adding: mem time207, current time 299, horizon 92\n", - "adding: mem time208, current time 299, horizon 91\n", - "adding: mem time209, current time 299, horizon 90\n", - "adding: mem time210, current time 299, horizon 89\n", - "adding: mem time211, current time 299, horizon 88\n", - "adding: mem time212, current time 299, horizon 87\n", - "adding: mem time213, current time 299, horizon 86\n", - "adding: mem time214, current time 299, horizon 85\n", - "adding: mem time215, current time 299, horizon 84\n", - "adding: mem time216, current time 299, horizon 83\n", - "adding: mem time217, current time 299, horizon 82\n", - "adding: mem time218, current time 299, horizon 81\n", - "adding: mem time219, current time 299, horizon 80\n", - "adding: mem time220, current time 299, horizon 79\n", - "adding: mem time221, current time 299, horizon 78\n", - "adding: mem time222, current time 299, horizon 77\n", - "adding: mem time223, current time 299, horizon 76\n", - "adding: mem time224, current time 299, horizon 75\n", - "adding: mem time225, current time 299, horizon 74\n", - "adding: mem time226, current time 299, horizon 73\n", - "adding: mem time227, current time 299, horizon 72\n", - "adding: mem time228, current time 299, horizon 71\n", - "adding: mem time229, current time 299, horizon 70\n", - "adding: mem time230, current time 299, horizon 69\n", - "adding: mem time231, current time 299, horizon 68\n", - "adding: mem time232, current time 299, horizon 67\n", - "adding: mem time233, current time 299, horizon 66\n", - "adding: mem time234, current time 299, horizon 65\n", - "adding: mem time235, current time 299, horizon 64\n", - "adding: mem time236, current time 299, horizon 63\n", - "adding: mem time237, current time 299, horizon 62\n", - "adding: mem time238, current time 299, horizon 61\n", - "adding: mem time239, current time 299, horizon 60\n", - "adding: mem time240, current time 299, horizon 59\n", - "adding: mem time241, current time 299, horizon 58\n", - "adding: mem time242, current time 299, horizon 57\n", - "adding: mem time243, current time 299, horizon 56\n", - "adding: mem time244, current time 299, horizon 55\n", - "adding: mem time245, current time 299, horizon 54\n", - "adding: mem time246, current time 299, horizon 53\n", - "adding: mem time247, current time 299, horizon 52\n", - "adding: mem time248, current time 299, horizon 51\n", - "adding: mem time249, current time 299, horizon 50\n", - "adding: mem time250, current time 299, horizon 49\n", - "adding: mem time251, current time 299, horizon 48\n", - "adding: mem time252, current time 299, horizon 47\n", - "adding: mem time253, current time 299, horizon 46\n", - "adding: mem time254, current time 299, horizon 45\n", - "adding: mem time255, current time 299, horizon 44\n", - "adding: mem time256, current time 299, horizon 43\n", - "adding: mem time257, current time 299, horizon 42\n", - "adding: mem time258, current time 299, horizon 41\n", - "adding: mem time259, current time 299, horizon 40\n", - "adding: mem time260, current time 299, horizon 39\n", - "adding: mem time261, current time 299, horizon 38\n", - "adding: mem time262, current time 299, horizon 37\n", - "adding: mem time263, current time 299, horizon 36\n", - "adding: mem time264, current time 299, horizon 35\n", - "adding: mem time265, current time 299, horizon 34\n", - "adding: mem time266, current time 299, horizon 33\n", - "adding: mem time267, current time 299, horizon 32\n", - "adding: mem time268, current time 299, horizon 31\n", - "adding: mem time269, current time 299, horizon 30\n", - "adding: mem time270, current time 299, horizon 29\n", - "adding: mem time271, current time 299, horizon 28\n", - "adding: mem time272, current time 299, horizon 27\n", - "adding: mem time273, current time 299, horizon 26\n", - "adding: mem time274, current time 299, horizon 25\n", - "adding: mem time275, current time 299, horizon 24\n", - "adding: mem time276, current time 299, horizon 23\n", - "adding: mem time277, current time 299, horizon 22\n", - "adding: mem time278, current time 299, horizon 21\n", - "adding: mem time279, current time 299, horizon 20\n", - "adding: mem time280, current time 299, horizon 19\n", - "adding: mem time281, current time 299, horizon 18\n", - "adding: mem time282, current time 299, horizon 17\n", - "adding: mem time283, current time 299, horizon 16\n", - "adding: mem time284, current time 299, horizon 15\n", - "adding: mem time285, current time 299, horizon 14\n", - "adding: mem time286, current time 299, horizon 13\n", - "adding: mem time287, current time 299, horizon 12\n", - "adding: mem time288, current time 299, horizon 11\n", - "adding: mem time289, current time 299, horizon 10\n", - "adding: mem time290, current time 299, horizon 9\n", - "adding: mem time291, current time 299, horizon 8\n", - "adding: mem time292, current time 299, horizon 7\n", - "adding: mem time293, current time 299, horizon 6\n", - "adding: mem time294, current time 299, horizon 5\n", - "adding: mem time295, current time 299, horizon 4\n", - "adding: mem time296, current time 299, horizon 3\n", - "adding: mem time297, current time 299, horizon 2\n", - "adding: mem time298, current time 299, horizon 1\n", - "adding: mem time200, current time 300, horizon 100\n", - "adding: mem time201, current time 300, horizon 99\n", - "adding: mem time202, current time 300, horizon 98\n", - "adding: mem time203, current time 300, horizon 97\n", - "adding: mem time204, current time 300, horizon 96\n", - "adding: mem time205, current time 300, horizon 95\n", - "adding: mem time206, current time 300, horizon 94\n", - "adding: mem time207, current time 300, horizon 93\n", - "adding: mem time208, current time 300, horizon 92\n", - "adding: mem time209, current time 300, horizon 91\n", - "adding: mem time210, current time 300, horizon 90\n", - "adding: mem time211, current time 300, horizon 89\n", - "adding: mem time212, current time 300, horizon 88\n", - "adding: mem time213, current time 300, horizon 87\n", - "adding: mem time214, current time 300, horizon 86\n", - "adding: mem time215, current time 300, horizon 85\n", - "adding: mem time216, current time 300, horizon 84\n", - "adding: mem time217, current time 300, horizon 83\n", - "adding: mem time218, current time 300, horizon 82\n", - "adding: mem time219, current time 300, horizon 81\n", - "adding: mem time220, current time 300, horizon 80\n", - "adding: mem time221, current time 300, horizon 79\n", - "adding: mem time222, current time 300, horizon 78\n", - "adding: mem time223, current time 300, horizon 77\n", - "adding: mem time224, current time 300, horizon 76\n", - "adding: mem time225, current time 300, horizon 75\n", - "adding: mem time226, current time 300, horizon 74\n", - "adding: mem time227, current time 300, horizon 73\n", - "adding: mem time228, current time 300, horizon 72\n", - "adding: mem time229, current time 300, horizon 71\n", - "adding: mem time230, current time 300, horizon 70\n", - "adding: mem time231, current time 300, horizon 69\n", - "adding: mem time232, current time 300, horizon 68\n", - "adding: mem time233, current time 300, horizon 67\n", - "adding: mem time234, current time 300, horizon 66\n", - "adding: mem time235, current time 300, horizon 65\n", - "adding: mem time236, current time 300, horizon 64\n", - "adding: mem time237, current time 300, horizon 63\n", - "adding: mem time238, current time 300, horizon 62\n", - "adding: mem time239, current time 300, horizon 61\n", - "adding: mem time240, current time 300, horizon 60\n", - "adding: mem time241, current time 300, horizon 59\n", - "adding: mem time242, current time 300, horizon 58\n", - "adding: mem time243, current time 300, horizon 57\n", - "adding: mem time244, current time 300, horizon 56\n", - "adding: mem time245, current time 300, horizon 55\n", - "adding: mem time246, current time 300, horizon 54\n", - "adding: mem time247, current time 300, horizon 53\n", - "adding: mem time248, current time 300, horizon 52\n", - "adding: mem time249, current time 300, horizon 51\n", - "adding: mem time250, current time 300, horizon 50\n", - "adding: mem time251, current time 300, horizon 49\n", - "adding: mem time252, current time 300, horizon 48\n", - "adding: mem time253, current time 300, horizon 47\n", - "adding: mem time254, current time 300, horizon 46\n", - "adding: mem time255, current time 300, horizon 45\n", - "adding: mem time256, current time 300, horizon 44\n", - "adding: mem time257, current time 300, horizon 43\n", - "adding: mem time258, current time 300, horizon 42\n", - "adding: mem time259, current time 300, horizon 41\n", - "adding: mem time260, current time 300, horizon 40\n", - "adding: mem time261, current time 300, horizon 39\n", - "adding: mem time262, current time 300, horizon 38\n", - "adding: mem time263, current time 300, horizon 37\n", - "adding: mem time264, current time 300, horizon 36\n", - "adding: mem time265, current time 300, horizon 35\n", - "adding: mem time266, current time 300, horizon 34\n", - "adding: mem time267, current time 300, horizon 33\n", - "adding: mem time268, current time 300, horizon 32\n", - "adding: mem time269, current time 300, horizon 31\n", - "adding: mem time270, current time 300, horizon 30\n", - "adding: mem time271, current time 300, horizon 29\n", - "adding: mem time272, current time 300, horizon 28\n", - "adding: mem time273, current time 300, horizon 27\n", - "adding: mem time274, current time 300, horizon 26\n", - "adding: mem time275, current time 300, horizon 25\n", - "adding: mem time276, current time 300, horizon 24\n", - "adding: mem time277, current time 300, horizon 23\n", - "adding: mem time278, current time 300, horizon 22\n", - "adding: mem time279, current time 300, horizon 21\n", - "adding: mem time280, current time 300, horizon 20\n", - "adding: mem time281, current time 300, horizon 19\n", - "adding: mem time282, current time 300, horizon 18\n", - "adding: mem time283, current time 300, horizon 17\n", - "adding: mem time284, current time 300, horizon 16\n", - "adding: mem time285, current time 300, horizon 15\n", - "adding: mem time286, current time 300, horizon 14\n", - "adding: mem time287, current time 300, horizon 13\n", - "adding: mem time288, current time 300, horizon 12\n", - "adding: mem time289, current time 300, horizon 11\n", - "adding: mem time290, current time 300, horizon 10\n", - "adding: mem time291, current time 300, horizon 9\n", - "adding: mem time292, current time 300, horizon 8\n", - "adding: mem time293, current time 300, horizon 7\n", - "adding: mem time294, current time 300, horizon 6\n", - "adding: mem time295, current time 300, horizon 5\n", - "adding: mem time296, current time 300, horizon 4\n", - "adding: mem time297, current time 300, horizon 3\n", - "adding: mem time298, current time 300, horizon 2\n", - "adding: mem time299, current time 300, horizon 1\n", - "adding: mem time200, current time 301, horizon 101\n", - "adding: mem time201, current time 301, horizon 100\n", - "adding: mem time202, current time 301, horizon 99\n", - "adding: mem time203, current time 301, horizon 98\n", - "adding: mem time204, current time 301, horizon 97\n", - "adding: mem time205, current time 301, horizon 96\n", - "adding: mem time206, current time 301, horizon 95\n", - "adding: mem time207, current time 301, horizon 94\n", - "adding: mem time208, current time 301, horizon 93\n", - "adding: mem time209, current time 301, horizon 92\n", - "adding: mem time210, current time 301, horizon 91\n", - "adding: mem time211, current time 301, horizon 90\n", - "adding: mem time212, current time 301, horizon 89\n", - "adding: mem time213, current time 301, horizon 88\n", - "adding: mem time214, current time 301, horizon 87\n", - "adding: mem time215, current time 301, horizon 86\n", - "adding: mem time216, current time 301, horizon 85\n", - "adding: mem time217, current time 301, horizon 84\n", - "adding: mem time218, current time 301, horizon 83\n", - "adding: mem time219, current time 301, horizon 82\n", - "adding: mem time220, current time 301, horizon 81\n", - "adding: mem time221, current time 301, horizon 80\n", - "adding: mem time222, current time 301, horizon 79\n", - "adding: mem time223, current time 301, horizon 78\n", - "adding: mem time224, current time 301, horizon 77\n", - "adding: mem time225, current time 301, horizon 76\n", - "adding: mem time226, current time 301, horizon 75\n", - "adding: mem time227, current time 301, horizon 74\n", - "adding: mem time228, current time 301, horizon 73\n", - "adding: mem time229, current time 301, horizon 72\n", - "adding: mem time230, current time 301, horizon 71\n", - "adding: mem time231, current time 301, horizon 70\n", - "adding: mem time232, current time 301, horizon 69\n", - "adding: mem time233, current time 301, horizon 68\n", - "adding: mem time234, current time 301, horizon 67\n", - "adding: mem time235, current time 301, horizon 66\n", - "adding: mem time236, current time 301, horizon 65\n", - "adding: mem time237, current time 301, horizon 64\n", - "adding: mem time238, current time 301, horizon 63\n", - "adding: mem time239, current time 301, horizon 62\n", - "adding: mem time240, current time 301, horizon 61\n", - "adding: mem time241, current time 301, horizon 60\n", - "adding: mem time242, current time 301, horizon 59\n", - "adding: mem time243, current time 301, horizon 58\n", - "adding: mem time244, current time 301, horizon 57\n", - "adding: mem time245, current time 301, horizon 56\n", - "adding: mem time246, current time 301, horizon 55\n", - "adding: mem time247, current time 301, horizon 54\n", - "adding: mem time248, current time 301, horizon 53\n", - "adding: mem time249, current time 301, horizon 52\n", - "adding: mem time250, current time 301, horizon 51\n", - "adding: mem time251, current time 301, horizon 50\n", - "adding: mem time252, current time 301, horizon 49\n", - "adding: mem time253, current time 301, horizon 48\n", - "adding: mem time254, current time 301, horizon 47\n", - "adding: mem time255, current time 301, horizon 46\n", - "adding: mem time256, current time 301, horizon 45\n", - "adding: mem time257, current time 301, horizon 44\n", - "adding: mem time258, current time 301, horizon 43\n", - "adding: mem time259, current time 301, horizon 42\n", - "adding: mem time260, current time 301, horizon 41\n", - "adding: mem time261, current time 301, horizon 40\n", - "adding: mem time262, current time 301, horizon 39\n", - "adding: mem time263, current time 301, horizon 38\n", - "adding: mem time264, current time 301, horizon 37\n", - "adding: mem time265, current time 301, horizon 36\n", - "adding: mem time266, current time 301, horizon 35\n", - "adding: mem time267, current time 301, horizon 34\n", - "adding: mem time268, current time 301, horizon 33\n", - "adding: mem time269, current time 301, horizon 32\n", - "adding: mem time270, current time 301, horizon 31\n", - "adding: mem time271, current time 301, horizon 30\n", - "adding: mem time272, current time 301, horizon 29\n", - "adding: mem time273, current time 301, horizon 28\n", - "adding: mem time274, current time 301, horizon 27\n", - "adding: mem time275, current time 301, horizon 26\n", - "adding: mem time276, current time 301, horizon 25\n", - "adding: mem time277, current time 301, horizon 24\n", - "adding: mem time278, current time 301, horizon 23\n", - "adding: mem time279, current time 301, horizon 22\n", - "adding: mem time280, current time 301, horizon 21\n", - "adding: mem time281, current time 301, horizon 20\n", - "adding: mem time282, current time 301, horizon 19\n", - "adding: mem time283, current time 301, horizon 18\n", - "adding: mem time284, current time 301, horizon 17\n", - "adding: mem time285, current time 301, horizon 16\n", - "adding: mem time286, current time 301, horizon 15\n", - "adding: mem time287, current time 301, horizon 14\n", - "adding: mem time288, current time 301, horizon 13\n", - "adding: mem time289, current time 301, horizon 12\n", - "adding: mem time290, current time 301, horizon 11\n", - "adding: mem time291, current time 301, horizon 10\n", - "adding: mem time292, current time 301, horizon 9\n", - "adding: mem time293, current time 301, horizon 8\n", - "adding: mem time294, current time 301, horizon 7\n", - "adding: mem time295, current time 301, horizon 6\n", - "adding: mem time296, current time 301, horizon 5\n", - "adding: mem time297, current time 301, horizon 4\n", - "adding: mem time298, current time 301, horizon 3\n", - "adding: mem time299, current time 301, horizon 2\n", - "adding: mem time300, current time 301, horizon 1\n", - "adding: mem time200, current time 302, horizon 102\n", - "adding: mem time201, current time 302, horizon 101\n", - "adding: mem time202, current time 302, horizon 100\n", - "adding: mem time203, current time 302, horizon 99\n", - "adding: mem time204, current time 302, horizon 98\n", - "adding: mem time205, current time 302, horizon 97\n", - "adding: mem time206, current time 302, horizon 96\n", - "adding: mem time207, current time 302, horizon 95\n", - "adding: mem time208, current time 302, horizon 94\n", - "adding: mem time209, current time 302, horizon 93\n", - "adding: mem time210, current time 302, horizon 92\n", - "adding: mem time211, current time 302, horizon 91\n", - "adding: mem time212, current time 302, horizon 90\n", - "adding: mem time213, current time 302, horizon 89\n", - "adding: mem time214, current time 302, horizon 88\n", - "adding: mem time215, current time 302, horizon 87\n", - "adding: mem time216, current time 302, horizon 86\n", - "adding: mem time217, current time 302, horizon 85\n", - "adding: mem time218, current time 302, horizon 84\n", - "adding: mem time219, current time 302, horizon 83\n", - "adding: mem time220, current time 302, horizon 82\n", - "adding: mem time221, current time 302, horizon 81\n", - "adding: mem time222, current time 302, horizon 80\n", - "adding: mem time223, current time 302, horizon 79\n", - "adding: mem time224, current time 302, horizon 78\n", - "adding: mem time225, current time 302, horizon 77\n", - "adding: mem time226, current time 302, horizon 76\n", - "adding: mem time227, current time 302, horizon 75\n", - "adding: mem time228, current time 302, horizon 74\n", - "adding: mem time229, current time 302, horizon 73\n", - "adding: mem time230, current time 302, horizon 72\n", - "adding: mem time231, current time 302, horizon 71\n", - "adding: mem time232, current time 302, horizon 70\n", - "adding: mem time233, current time 302, horizon 69\n", - "adding: mem time234, current time 302, horizon 68\n", - "adding: mem time235, current time 302, horizon 67\n", - "adding: mem time236, current time 302, horizon 66\n", - "adding: mem time237, current time 302, horizon 65\n", - "adding: mem time238, current time 302, horizon 64\n", - "adding: mem time239, current time 302, horizon 63\n", - "adding: mem time240, current time 302, horizon 62\n", - "adding: mem time241, current time 302, horizon 61\n", - "adding: mem time242, current time 302, horizon 60\n", - "adding: mem time243, current time 302, horizon 59\n", - "adding: mem time244, current time 302, horizon 58\n", - "adding: mem time245, current time 302, horizon 57\n", - "adding: mem time246, current time 302, horizon 56\n", - "adding: mem time247, current time 302, horizon 55\n", - "adding: mem time248, current time 302, horizon 54\n", - "adding: mem time249, current time 302, horizon 53\n", - "adding: mem time250, current time 302, horizon 52\n", - "adding: mem time251, current time 302, horizon 51\n", - "adding: mem time252, current time 302, horizon 50\n", - "adding: mem time253, current time 302, horizon 49\n", - "adding: mem time254, current time 302, horizon 48\n", - "adding: mem time255, current time 302, horizon 47\n", - "adding: mem time256, current time 302, horizon 46\n", - "adding: mem time257, current time 302, horizon 45\n", - "adding: mem time258, current time 302, horizon 44\n", - "adding: mem time259, current time 302, horizon 43\n", - "adding: mem time260, current time 302, horizon 42\n", - "adding: mem time261, current time 302, horizon 41\n", - "adding: mem time262, current time 302, horizon 40\n", - "adding: mem time263, current time 302, horizon 39\n", - "adding: mem time264, current time 302, horizon 38\n", - "adding: mem time265, current time 302, horizon 37\n", - "adding: mem time266, current time 302, horizon 36\n", - "adding: mem time267, current time 302, horizon 35\n", - "adding: mem time268, current time 302, horizon 34\n", - "adding: mem time269, current time 302, horizon 33\n", - "adding: mem time270, current time 302, horizon 32\n", - "adding: mem time271, current time 302, horizon 31\n", - "adding: mem time272, current time 302, horizon 30\n", - "adding: mem time273, current time 302, horizon 29\n", - "adding: mem time274, current time 302, horizon 28\n", - "adding: mem time275, current time 302, horizon 27\n", - "adding: mem time276, current time 302, horizon 26\n", - "adding: mem time277, current time 302, horizon 25\n", - "adding: mem time278, current time 302, horizon 24\n", - "adding: mem time279, current time 302, horizon 23\n", - "adding: mem time280, current time 302, horizon 22\n", - "adding: mem time281, current time 302, horizon 21\n", - "adding: mem time282, current time 302, horizon 20\n", - "adding: mem time283, current time 302, horizon 19\n", - "adding: mem time284, current time 302, horizon 18\n", - "adding: mem time285, current time 302, horizon 17\n", - "adding: mem time286, current time 302, horizon 16\n", - "adding: mem time287, current time 302, horizon 15\n", - "adding: mem time288, current time 302, horizon 14\n", - "adding: mem time289, current time 302, horizon 13\n", - "adding: mem time290, current time 302, horizon 12\n", - "adding: mem time291, current time 302, horizon 11\n", - "adding: mem time292, current time 302, horizon 10\n", - "adding: mem time293, current time 302, horizon 9\n", - "adding: mem time294, current time 302, horizon 8\n", - "adding: mem time295, current time 302, horizon 7\n", - "adding: mem time296, current time 302, horizon 6\n", - "adding: mem time297, current time 302, horizon 5\n", - "adding: mem time298, current time 302, horizon 4\n", - "adding: mem time299, current time 302, horizon 3\n", - "adding: mem time300, current time 302, horizon 2\n", - "adding: mem time301, current time 302, horizon 1\n", - "adding: mem time200, current time 303, horizon 103\n", - "adding: mem time201, current time 303, horizon 102\n", - "adding: mem time202, current time 303, horizon 101\n", - "adding: mem time203, current time 303, horizon 100\n", - "adding: mem time204, current time 303, horizon 99\n", - "adding: mem time205, current time 303, horizon 98\n", - "adding: mem time206, current time 303, horizon 97\n", - "adding: mem time207, current time 303, horizon 96\n", - "adding: mem time208, current time 303, horizon 95\n", - "adding: mem time209, current time 303, horizon 94\n", - "adding: mem time210, current time 303, horizon 93\n", - "adding: mem time211, current time 303, horizon 92\n", - "adding: mem time212, current time 303, horizon 91\n", - "adding: mem time213, current time 303, horizon 90\n", - "adding: mem time214, current time 303, horizon 89\n", - "adding: mem time215, current time 303, horizon 88\n", - "adding: mem time216, current time 303, horizon 87\n", - "adding: mem time217, current time 303, horizon 86\n", - "adding: mem time218, current time 303, horizon 85\n", - "adding: mem time219, current time 303, horizon 84\n", - "adding: mem time220, current time 303, horizon 83\n", - "adding: mem time221, current time 303, horizon 82\n", - "adding: mem time222, current time 303, horizon 81\n", - "adding: mem time223, current time 303, horizon 80\n", - "adding: mem time224, current time 303, horizon 79\n", - "adding: mem time225, current time 303, horizon 78\n", - "adding: mem time226, current time 303, horizon 77\n", - "adding: mem time227, current time 303, horizon 76\n", - "adding: mem time228, current time 303, horizon 75\n", - "adding: mem time229, current time 303, horizon 74\n", - "adding: mem time230, current time 303, horizon 73\n", - "adding: mem time231, current time 303, horizon 72\n", - "adding: mem time232, current time 303, horizon 71\n", - "adding: mem time233, current time 303, horizon 70\n", - "adding: mem time234, current time 303, horizon 69\n", - "adding: mem time235, current time 303, horizon 68\n", - "adding: mem time236, current time 303, horizon 67\n", - "adding: mem time237, current time 303, horizon 66\n", - "adding: mem time238, current time 303, horizon 65\n", - "adding: mem time239, current time 303, horizon 64\n", - "adding: mem time240, current time 303, horizon 63\n", - "adding: mem time241, current time 303, horizon 62\n", - "adding: mem time242, current time 303, horizon 61\n", - "adding: mem time243, current time 303, horizon 60\n", - "adding: mem time244, current time 303, horizon 59\n", - "adding: mem time245, current time 303, horizon 58\n", - "adding: mem time246, current time 303, horizon 57\n", - "adding: mem time247, current time 303, horizon 56\n", - "adding: mem time248, current time 303, horizon 55\n", - "adding: mem time249, current time 303, horizon 54\n", - "adding: mem time250, current time 303, horizon 53\n", - "adding: mem time251, current time 303, horizon 52\n", - "adding: mem time252, current time 303, horizon 51\n", - "adding: mem time253, current time 303, horizon 50\n", - "adding: mem time254, current time 303, horizon 49\n", - "adding: mem time255, current time 303, horizon 48\n", - "adding: mem time256, current time 303, horizon 47\n", - "adding: mem time257, current time 303, horizon 46\n", - "adding: mem time258, current time 303, horizon 45\n", - "adding: mem time259, current time 303, horizon 44\n", - "adding: mem time260, current time 303, horizon 43\n", - "adding: mem time261, current time 303, horizon 42\n", - "adding: mem time262, current time 303, horizon 41\n", - "adding: mem time263, current time 303, horizon 40\n", - "adding: mem time264, current time 303, horizon 39\n", - "adding: mem time265, current time 303, horizon 38\n", - "adding: mem time266, current time 303, horizon 37\n", - "adding: mem time267, current time 303, horizon 36\n", - "adding: mem time268, current time 303, horizon 35\n", - "adding: mem time269, current time 303, horizon 34\n", - "adding: mem time270, current time 303, horizon 33\n", - "adding: mem time271, current time 303, horizon 32\n", - "adding: mem time272, current time 303, horizon 31\n", - "adding: mem time273, current time 303, horizon 30\n", - "adding: mem time274, current time 303, horizon 29\n", - "adding: mem time275, current time 303, horizon 28\n", - "adding: mem time276, current time 303, horizon 27\n", - "adding: mem time277, current time 303, horizon 26\n", - "adding: mem time278, current time 303, horizon 25\n", - "adding: mem time279, current time 303, horizon 24\n", - "adding: mem time280, current time 303, horizon 23\n", - "adding: mem time281, current time 303, horizon 22\n", - "adding: mem time282, current time 303, horizon 21\n", - "adding: mem time283, current time 303, horizon 20\n", - "adding: mem time284, current time 303, horizon 19\n", - "adding: mem time285, current time 303, horizon 18\n", - "adding: mem time286, current time 303, horizon 17\n", - "adding: mem time287, current time 303, horizon 16\n", - "adding: mem time288, current time 303, horizon 15\n", - "adding: mem time289, current time 303, horizon 14\n", - "adding: mem time290, current time 303, horizon 13\n", - "adding: mem time291, current time 303, horizon 12\n", - "adding: mem time292, current time 303, horizon 11\n", - "adding: mem time293, current time 303, horizon 10\n", - "adding: mem time294, current time 303, horizon 9\n", - "adding: mem time295, current time 303, horizon 8\n", - "adding: mem time296, current time 303, horizon 7\n", - "adding: mem time297, current time 303, horizon 6\n", - "adding: mem time298, current time 303, horizon 5\n", - "adding: mem time299, current time 303, horizon 4\n", - "adding: mem time300, current time 303, horizon 3\n", - "adding: mem time301, current time 303, horizon 2\n", - "adding: mem time302, current time 303, horizon 1\n", - "adding: mem time200, current time 304, horizon 104\n", - "adding: mem time201, current time 304, horizon 103\n", - "adding: mem time202, current time 304, horizon 102\n", - "adding: mem time203, current time 304, horizon 101\n", - "adding: mem time204, current time 304, horizon 100\n", - "adding: mem time205, current time 304, horizon 99\n", - "adding: mem time206, current time 304, horizon 98\n", - "adding: mem time207, current time 304, horizon 97\n", - "adding: mem time208, current time 304, horizon 96\n", - "adding: mem time209, current time 304, horizon 95\n", - "adding: mem time210, current time 304, horizon 94\n", - "adding: mem time211, current time 304, horizon 93\n", - "adding: mem time212, current time 304, horizon 92\n", - "adding: mem time213, current time 304, horizon 91\n", - "adding: mem time214, current time 304, horizon 90\n", - "adding: mem time215, current time 304, horizon 89\n", - "adding: mem time216, current time 304, horizon 88\n", - "adding: mem time217, current time 304, horizon 87\n", - "adding: mem time218, current time 304, horizon 86\n", - "adding: mem time219, current time 304, horizon 85\n", - "adding: mem time220, current time 304, horizon 84\n", - "adding: mem time221, current time 304, horizon 83\n", - "adding: mem time222, current time 304, horizon 82\n", - "adding: mem time223, current time 304, horizon 81\n", - "adding: mem time224, current time 304, horizon 80\n", - "adding: mem time225, current time 304, horizon 79\n", - "adding: mem time226, current time 304, horizon 78\n", - "adding: mem time227, current time 304, horizon 77\n", - "adding: mem time228, current time 304, horizon 76\n", - "adding: mem time229, current time 304, horizon 75\n", - "adding: mem time230, current time 304, horizon 74\n", - "adding: mem time231, current time 304, horizon 73\n", - "adding: mem time232, current time 304, horizon 72\n", - "adding: mem time233, current time 304, horizon 71\n", - "adding: mem time234, current time 304, horizon 70\n", - "adding: mem time235, current time 304, horizon 69\n", - "adding: mem time236, current time 304, horizon 68\n", - "adding: mem time237, current time 304, horizon 67\n", - "adding: mem time238, current time 304, horizon 66\n", - "adding: mem time239, current time 304, horizon 65\n", - "adding: mem time240, current time 304, horizon 64\n", - "adding: mem time241, current time 304, horizon 63\n", - "adding: mem time242, current time 304, horizon 62\n", - "adding: mem time243, current time 304, horizon 61\n", - "adding: mem time244, current time 304, horizon 60\n", - "adding: mem time245, current time 304, horizon 59\n", - "adding: mem time246, current time 304, horizon 58\n", - "adding: mem time247, current time 304, horizon 57\n", - "adding: mem time248, current time 304, horizon 56\n", - "adding: mem time249, current time 304, horizon 55\n", - "adding: mem time250, current time 304, horizon 54\n", - "adding: mem time251, current time 304, horizon 53\n", - "adding: mem time252, current time 304, horizon 52\n", - "adding: mem time253, current time 304, horizon 51\n", - "adding: mem time254, current time 304, horizon 50\n", - "adding: mem time255, current time 304, horizon 49\n", - "adding: mem time256, current time 304, horizon 48\n", - "adding: mem time257, current time 304, horizon 47\n", - "adding: mem time258, current time 304, horizon 46\n", - "adding: mem time259, current time 304, horizon 45\n", - "adding: mem time260, current time 304, horizon 44\n", - "adding: mem time261, current time 304, horizon 43\n", - "adding: mem time262, current time 304, horizon 42\n", - "adding: mem time263, current time 304, horizon 41\n", - "adding: mem time264, current time 304, horizon 40\n", - "adding: mem time265, current time 304, horizon 39\n", - "adding: mem time266, current time 304, horizon 38\n", - "adding: mem time267, current time 304, horizon 37\n", - "adding: mem time268, current time 304, horizon 36\n", - "adding: mem time269, current time 304, horizon 35\n", - "adding: mem time270, current time 304, horizon 34\n", - "adding: mem time271, current time 304, horizon 33\n", - "adding: mem time272, current time 304, horizon 32\n", - "adding: mem time273, current time 304, horizon 31\n", - "adding: mem time274, current time 304, horizon 30\n", - "adding: mem time275, current time 304, horizon 29\n", - "adding: mem time276, current time 304, horizon 28\n", - "adding: mem time277, current time 304, horizon 27\n", - "adding: mem time278, current time 304, horizon 26\n", - "adding: mem time279, current time 304, horizon 25\n", - "adding: mem time280, current time 304, horizon 24\n", - "adding: mem time281, current time 304, horizon 23\n", - "adding: mem time282, current time 304, horizon 22\n", - "adding: mem time283, current time 304, horizon 21\n", - "adding: mem time284, current time 304, horizon 20\n", - "adding: mem time285, current time 304, horizon 19\n", - "adding: mem time286, current time 304, horizon 18\n", - "adding: mem time287, current time 304, horizon 17\n", - "adding: mem time288, current time 304, horizon 16\n", - "adding: mem time289, current time 304, horizon 15\n", - "adding: mem time290, current time 304, horizon 14\n", - "adding: mem time291, current time 304, horizon 13\n", - "adding: mem time292, current time 304, horizon 12\n", - "adding: mem time293, current time 304, horizon 11\n", - "adding: mem time294, current time 304, horizon 10\n", - "adding: mem time295, current time 304, horizon 9\n", - "adding: mem time296, current time 304, horizon 8\n", - "adding: mem time297, current time 304, horizon 7\n", - "adding: mem time298, current time 304, horizon 6\n", - "adding: mem time299, current time 304, horizon 5\n", - "adding: mem time300, current time 304, horizon 4\n", - "adding: mem time301, current time 304, horizon 3\n", - "adding: mem time302, current time 304, horizon 2\n", - "adding: mem time303, current time 304, horizon 1\n", - "adding: mem time200, current time 305, horizon 105\n", - "adding: mem time201, current time 305, horizon 104\n", - "adding: mem time202, current time 305, horizon 103\n", - "adding: mem time203, current time 305, horizon 102\n", - "adding: mem time204, current time 305, horizon 101\n", - "adding: mem time205, current time 305, horizon 100\n", - "adding: mem time206, current time 305, horizon 99\n", - "adding: mem time207, current time 305, horizon 98\n", - "adding: mem time208, current time 305, horizon 97\n", - "adding: mem time209, current time 305, horizon 96\n", - "adding: mem time210, current time 305, horizon 95\n", - "adding: mem time211, current time 305, horizon 94\n", - "adding: mem time212, current time 305, horizon 93\n", - "adding: mem time213, current time 305, horizon 92\n", - "adding: mem time214, current time 305, horizon 91\n", - "adding: mem time215, current time 305, horizon 90\n", - "adding: mem time216, current time 305, horizon 89\n", - "adding: mem time217, current time 305, horizon 88\n", - "adding: mem time218, current time 305, horizon 87\n", - "adding: mem time219, current time 305, horizon 86\n", - "adding: mem time220, current time 305, horizon 85\n", - "adding: mem time221, current time 305, horizon 84\n", - "adding: mem time222, current time 305, horizon 83\n", - "adding: mem time223, current time 305, horizon 82\n", - "adding: mem time224, current time 305, horizon 81\n", - "adding: mem time225, current time 305, horizon 80\n", - "adding: mem time226, current time 305, horizon 79\n", - "adding: mem time227, current time 305, horizon 78\n", - "adding: mem time228, current time 305, horizon 77\n", - "adding: mem time229, current time 305, horizon 76\n", - "adding: mem time230, current time 305, horizon 75\n", - "adding: mem time231, current time 305, horizon 74\n", - "adding: mem time232, current time 305, horizon 73\n", - "adding: mem time233, current time 305, horizon 72\n", - "adding: mem time234, current time 305, horizon 71\n", - "adding: mem time235, current time 305, horizon 70\n", - "adding: mem time236, current time 305, horizon 69\n", - "adding: mem time237, current time 305, horizon 68\n", - "adding: mem time238, current time 305, horizon 67\n", - "adding: mem time239, current time 305, horizon 66\n", - "adding: mem time240, current time 305, horizon 65\n", - "adding: mem time241, current time 305, horizon 64\n", - "adding: mem time242, current time 305, horizon 63\n", - "adding: mem time243, current time 305, horizon 62\n", - "adding: mem time244, current time 305, horizon 61\n", - "adding: mem time245, current time 305, horizon 60\n", - "adding: mem time246, current time 305, horizon 59\n", - "adding: mem time247, current time 305, horizon 58\n", - "adding: mem time248, current time 305, horizon 57\n", - "adding: mem time249, current time 305, horizon 56\n", - "adding: mem time250, current time 305, horizon 55\n", - "adding: mem time251, current time 305, horizon 54\n", - "adding: mem time252, current time 305, horizon 53\n", - "adding: mem time253, current time 305, horizon 52\n", - "adding: mem time254, current time 305, horizon 51\n", - "adding: mem time255, current time 305, horizon 50\n", - "adding: mem time256, current time 305, horizon 49\n", - "adding: mem time257, current time 305, horizon 48\n", - "adding: mem time258, current time 305, horizon 47\n", - "adding: mem time259, current time 305, horizon 46\n", - "adding: mem time260, current time 305, horizon 45\n", - "adding: mem time261, current time 305, horizon 44\n", - "adding: mem time262, current time 305, horizon 43\n", - "adding: mem time263, current time 305, horizon 42\n", - "adding: mem time264, current time 305, horizon 41\n", - "adding: mem time265, current time 305, horizon 40\n", - "adding: mem time266, current time 305, horizon 39\n", - "adding: mem time267, current time 305, horizon 38\n", - "adding: mem time268, current time 305, horizon 37\n", - "adding: mem time269, current time 305, horizon 36\n", - "adding: mem time270, current time 305, horizon 35\n", - "adding: mem time271, current time 305, horizon 34\n", - "adding: mem time272, current time 305, horizon 33\n", - "adding: mem time273, current time 305, horizon 32\n", - "adding: mem time274, current time 305, horizon 31\n", - "adding: mem time275, current time 305, horizon 30\n", - "adding: mem time276, current time 305, horizon 29\n", - "adding: mem time277, current time 305, horizon 28\n", - "adding: mem time278, current time 305, horizon 27\n", - "adding: mem time279, current time 305, horizon 26\n", - "adding: mem time280, current time 305, horizon 25\n", - "adding: mem time281, current time 305, horizon 24\n", - "adding: mem time282, current time 305, horizon 23\n", - "adding: mem time283, current time 305, horizon 22\n", - "adding: mem time284, current time 305, horizon 21\n", - "adding: mem time285, current time 305, horizon 20\n", - "adding: mem time286, current time 305, horizon 19\n", - "adding: mem time287, current time 305, horizon 18\n", - "adding: mem time288, current time 305, horizon 17\n", - "adding: mem time289, current time 305, horizon 16\n", - "adding: mem time290, current time 305, horizon 15\n", - "adding: mem time291, current time 305, horizon 14\n", - "adding: mem time292, current time 305, horizon 13\n", - "adding: mem time293, current time 305, horizon 12\n", - "adding: mem time294, current time 305, horizon 11\n", - "adding: mem time295, current time 305, horizon 10\n", - "adding: mem time296, current time 305, horizon 9\n", - "adding: mem time297, current time 305, horizon 8\n", - "adding: mem time298, current time 305, horizon 7\n", - "adding: mem time299, current time 305, horizon 6\n", - "adding: mem time300, current time 305, horizon 5\n", - "adding: mem time301, current time 305, horizon 4\n", - "adding: mem time302, current time 305, horizon 3\n", - "adding: mem time303, current time 305, horizon 2\n", - "adding: mem time304, current time 305, horizon 1\n", - "adding: mem time200, current time 306, horizon 106\n", - "adding: mem time201, current time 306, horizon 105\n", - "adding: mem time202, current time 306, horizon 104\n", - "adding: mem time203, current time 306, horizon 103\n", - "adding: mem time204, current time 306, horizon 102\n", - "adding: mem time205, current time 306, horizon 101\n", - "adding: mem time206, current time 306, horizon 100\n", - "adding: mem time207, current time 306, horizon 99\n", - "adding: mem time208, current time 306, horizon 98\n", - "adding: mem time209, current time 306, horizon 97\n", - "adding: mem time210, current time 306, horizon 96\n", - "adding: mem time211, current time 306, horizon 95\n", - "adding: mem time212, current time 306, horizon 94\n", - "adding: mem time213, current time 306, horizon 93\n", - "adding: mem time214, current time 306, horizon 92\n", - "adding: mem time215, current time 306, horizon 91\n", - "adding: mem time216, current time 306, horizon 90\n", - "adding: mem time217, current time 306, horizon 89\n", - "adding: mem time218, current time 306, horizon 88\n", - "adding: mem time219, current time 306, horizon 87\n", - "adding: mem time220, current time 306, horizon 86\n", - "adding: mem time221, current time 306, horizon 85\n", - "adding: mem time222, current time 306, horizon 84\n", - "adding: mem time223, current time 306, horizon 83\n", - "adding: mem time224, current time 306, horizon 82\n", - "adding: mem time225, current time 306, horizon 81\n", - "adding: mem time226, current time 306, horizon 80\n", - "adding: mem time227, current time 306, horizon 79\n", - "adding: mem time228, current time 306, horizon 78\n", - "adding: mem time229, current time 306, horizon 77\n", - "adding: mem time230, current time 306, horizon 76\n", - "adding: mem time231, current time 306, horizon 75\n", - "adding: mem time232, current time 306, horizon 74\n", - "adding: mem time233, current time 306, horizon 73\n", - "adding: mem time234, current time 306, horizon 72\n", - "adding: mem time235, current time 306, horizon 71\n", - "adding: mem time236, current time 306, horizon 70\n", - "adding: mem time237, current time 306, horizon 69\n", - "adding: mem time238, current time 306, horizon 68\n", - "adding: mem time239, current time 306, horizon 67\n", - "adding: mem time240, current time 306, horizon 66\n", - "adding: mem time241, current time 306, horizon 65\n", - "adding: mem time242, current time 306, horizon 64\n", - "adding: mem time243, current time 306, horizon 63\n", - "adding: mem time244, current time 306, horizon 62\n", - "adding: mem time245, current time 306, horizon 61\n", - "adding: mem time246, current time 306, horizon 60\n", - "adding: mem time247, current time 306, horizon 59\n", - "adding: mem time248, current time 306, horizon 58\n", - "adding: mem time249, current time 306, horizon 57\n", - "adding: mem time250, current time 306, horizon 56\n", - "adding: mem time251, current time 306, horizon 55\n", - "adding: mem time252, current time 306, horizon 54\n", - "adding: mem time253, current time 306, horizon 53\n", - "adding: mem time254, current time 306, horizon 52\n", - "adding: mem time255, current time 306, horizon 51\n", - "adding: mem time256, current time 306, horizon 50\n", - "adding: mem time257, current time 306, horizon 49\n", - "adding: mem time258, current time 306, horizon 48\n", - "adding: mem time259, current time 306, horizon 47\n", - "adding: mem time260, current time 306, horizon 46\n", - "adding: mem time261, current time 306, horizon 45\n", - "adding: mem time262, current time 306, horizon 44\n", - "adding: mem time263, current time 306, horizon 43\n", - "adding: mem time264, current time 306, horizon 42\n", - "adding: mem time265, current time 306, horizon 41\n", - "adding: mem time266, current time 306, horizon 40\n", - "adding: mem time267, current time 306, horizon 39\n", - "adding: mem time268, current time 306, horizon 38\n", - "adding: mem time269, current time 306, horizon 37\n", - "adding: mem time270, current time 306, horizon 36\n", - "adding: mem time271, current time 306, horizon 35\n", - "adding: mem time272, current time 306, horizon 34\n", - "adding: mem time273, current time 306, horizon 33\n", - "adding: mem time274, current time 306, horizon 32\n", - "adding: mem time275, current time 306, horizon 31\n", - "adding: mem time276, current time 306, horizon 30\n", - "adding: mem time277, current time 306, horizon 29\n", - "adding: mem time278, current time 306, horizon 28\n", - "adding: mem time279, current time 306, horizon 27\n", - "adding: mem time280, current time 306, horizon 26\n", - "adding: mem time281, current time 306, horizon 25\n", - "adding: mem time282, current time 306, horizon 24\n", - "adding: mem time283, current time 306, horizon 23\n", - "adding: mem time284, current time 306, horizon 22\n", - "adding: mem time285, current time 306, horizon 21\n", - "adding: mem time286, current time 306, horizon 20\n", - "adding: mem time287, current time 306, horizon 19\n", - "adding: mem time288, current time 306, horizon 18\n", - "adding: mem time289, current time 306, horizon 17\n", - "adding: mem time290, current time 306, horizon 16\n", - "adding: mem time291, current time 306, horizon 15\n", - "adding: mem time292, current time 306, horizon 14\n", - "adding: mem time293, current time 306, horizon 13\n", - "adding: mem time294, current time 306, horizon 12\n", - "adding: mem time295, current time 306, horizon 11\n", - "adding: mem time296, current time 306, horizon 10\n", - "adding: mem time297, current time 306, horizon 9\n", - "adding: mem time298, current time 306, horizon 8\n", - "adding: mem time299, current time 306, horizon 7\n", - "adding: mem time300, current time 306, horizon 6\n", - "adding: mem time301, current time 306, horizon 5\n", - "adding: mem time302, current time 306, horizon 4\n", - "adding: mem time303, current time 306, horizon 3\n", - "adding: mem time304, current time 306, horizon 2\n", - "adding: mem time305, current time 306, horizon 1\n", - "adding: mem time200, current time 307, horizon 107\n", - "adding: mem time201, current time 307, horizon 106\n", - "adding: mem time202, current time 307, horizon 105\n", - "adding: mem time203, current time 307, horizon 104\n", - "adding: mem time204, current time 307, horizon 103\n", - "adding: mem time205, current time 307, horizon 102\n", - "adding: mem time206, current time 307, horizon 101\n", - "adding: mem time207, current time 307, horizon 100\n", - "adding: mem time208, current time 307, horizon 99\n", - "adding: mem time209, current time 307, horizon 98\n", - "adding: mem time210, current time 307, horizon 97\n", - "adding: mem time211, current time 307, horizon 96\n", - "adding: mem time212, current time 307, horizon 95\n", - "adding: mem time213, current time 307, horizon 94\n", - "adding: mem time214, current time 307, horizon 93\n", - "adding: mem time215, current time 307, horizon 92\n", - "adding: mem time216, current time 307, horizon 91\n", - "adding: mem time217, current time 307, horizon 90\n", - "adding: mem time218, current time 307, horizon 89\n", - "adding: mem time219, current time 307, horizon 88\n", - "adding: mem time220, current time 307, horizon 87\n", - "adding: mem time221, current time 307, horizon 86\n", - "adding: mem time222, current time 307, horizon 85\n", - "adding: mem time223, current time 307, horizon 84\n", - "adding: mem time224, current time 307, horizon 83\n", - "adding: mem time225, current time 307, horizon 82\n", - "adding: mem time226, current time 307, horizon 81\n", - "adding: mem time227, current time 307, horizon 80\n", - "adding: mem time228, current time 307, horizon 79\n", - "adding: mem time229, current time 307, horizon 78\n", - "adding: mem time230, current time 307, horizon 77\n", - "adding: mem time231, current time 307, horizon 76\n", - "adding: mem time232, current time 307, horizon 75\n", - "adding: mem time233, current time 307, horizon 74\n", - "adding: mem time234, current time 307, horizon 73\n", - "adding: mem time235, current time 307, horizon 72\n", - "adding: mem time236, current time 307, horizon 71\n", - "adding: mem time237, current time 307, horizon 70\n", - "adding: mem time238, current time 307, horizon 69\n", - "adding: mem time239, current time 307, horizon 68\n", - "adding: mem time240, current time 307, horizon 67\n", - "adding: mem time241, current time 307, horizon 66\n", - "adding: mem time242, current time 307, horizon 65\n", - "adding: mem time243, current time 307, horizon 64\n", - "adding: mem time244, current time 307, horizon 63\n", - "adding: mem time245, current time 307, horizon 62\n", - "adding: mem time246, current time 307, horizon 61\n", - "adding: mem time247, current time 307, horizon 60\n", - "adding: mem time248, current time 307, horizon 59\n", - "adding: mem time249, current time 307, horizon 58\n", - "adding: mem time250, current time 307, horizon 57\n", - "adding: mem time251, current time 307, horizon 56\n", - "adding: mem time252, current time 307, horizon 55\n", - "adding: mem time253, current time 307, horizon 54\n", - "adding: mem time254, current time 307, horizon 53\n", - "adding: mem time255, current time 307, horizon 52\n", - "adding: mem time256, current time 307, horizon 51\n", - "adding: mem time257, current time 307, horizon 50\n", - "adding: mem time258, current time 307, horizon 49\n", - "adding: mem time259, current time 307, horizon 48\n", - "adding: mem time260, current time 307, horizon 47\n", - "adding: mem time261, current time 307, horizon 46\n", - "adding: mem time262, current time 307, horizon 45\n", - "adding: mem time263, current time 307, horizon 44\n", - "adding: mem time264, current time 307, horizon 43\n", - "adding: mem time265, current time 307, horizon 42\n", - "adding: mem time266, current time 307, horizon 41\n", - "adding: mem time267, current time 307, horizon 40\n", - "adding: mem time268, current time 307, horizon 39\n", - "adding: mem time269, current time 307, horizon 38\n", - "adding: mem time270, current time 307, horizon 37\n", - "adding: mem time271, current time 307, horizon 36\n", - "adding: mem time272, current time 307, horizon 35\n", - "adding: mem time273, current time 307, horizon 34\n", - "adding: mem time274, current time 307, horizon 33\n", - "adding: mem time275, current time 307, horizon 32\n", - "adding: mem time276, current time 307, horizon 31\n", - "adding: mem time277, current time 307, horizon 30\n", - "adding: mem time278, current time 307, horizon 29\n", - "adding: mem time279, current time 307, horizon 28\n", - "adding: mem time280, current time 307, horizon 27\n", - "adding: mem time281, current time 307, horizon 26\n", - "adding: mem time282, current time 307, horizon 25\n", - "adding: mem time283, current time 307, horizon 24\n", - "adding: mem time284, current time 307, horizon 23\n", - "adding: mem time285, current time 307, horizon 22\n", - "adding: mem time286, current time 307, horizon 21\n", - "adding: mem time287, current time 307, horizon 20\n", - "adding: mem time288, current time 307, horizon 19\n", - "adding: mem time289, current time 307, horizon 18\n", - "adding: mem time290, current time 307, horizon 17\n", - "adding: mem time291, current time 307, horizon 16\n", - "adding: mem time292, current time 307, horizon 15\n", - "adding: mem time293, current time 307, horizon 14\n", - "adding: mem time294, current time 307, horizon 13\n", - "adding: mem time295, current time 307, horizon 12\n", - "adding: mem time296, current time 307, horizon 11\n", - "adding: mem time297, current time 307, horizon 10\n", - "adding: mem time298, current time 307, horizon 9\n", - "adding: mem time299, current time 307, horizon 8\n", - "adding: mem time300, current time 307, horizon 7\n", - "adding: mem time301, current time 307, horizon 6\n", - "adding: mem time302, current time 307, horizon 5\n", - "adding: mem time303, current time 307, horizon 4\n", - "adding: mem time304, current time 307, horizon 3\n", - "adding: mem time305, current time 307, horizon 2\n", - "adding: mem time306, current time 307, horizon 1\n", - "adding: mem time200, current time 308, horizon 108\n", - "adding: mem time201, current time 308, horizon 107\n", - "adding: mem time202, current time 308, horizon 106\n", - "adding: mem time203, current time 308, horizon 105\n", - "adding: mem time204, current time 308, horizon 104\n", - "adding: mem time205, current time 308, horizon 103\n", - "adding: mem time206, current time 308, horizon 102\n", - "adding: mem time207, current time 308, horizon 101\n", - "adding: mem time208, current time 308, horizon 100\n", - "adding: mem time209, current time 308, horizon 99\n", - "adding: mem time210, current time 308, horizon 98\n", - "adding: mem time211, current time 308, horizon 97\n", - "adding: mem time212, current time 308, horizon 96\n", - "adding: mem time213, current time 308, horizon 95\n", - "adding: mem time214, current time 308, horizon 94\n", - "adding: mem time215, current time 308, horizon 93\n", - "adding: mem time216, current time 308, horizon 92\n", - "adding: mem time217, current time 308, horizon 91\n", - "adding: mem time218, current time 308, horizon 90\n", - "adding: mem time219, current time 308, horizon 89\n", - "adding: mem time220, current time 308, horizon 88\n", - "adding: mem time221, current time 308, horizon 87\n", - "adding: mem time222, current time 308, horizon 86\n", - "adding: mem time223, current time 308, horizon 85\n", - "adding: mem time224, current time 308, horizon 84\n", - "adding: mem time225, current time 308, horizon 83\n", - "adding: mem time226, current time 308, horizon 82\n", - "adding: mem time227, current time 308, horizon 81\n", - "adding: mem time228, current time 308, horizon 80\n", - "adding: mem time229, current time 308, horizon 79\n", - "adding: mem time230, current time 308, horizon 78\n", - "adding: mem time231, current time 308, horizon 77\n", - "adding: mem time232, current time 308, horizon 76\n", - "adding: mem time233, current time 308, horizon 75\n", - "adding: mem time234, current time 308, horizon 74\n", - "adding: mem time235, current time 308, horizon 73\n", - "adding: mem time236, current time 308, horizon 72\n", - "adding: mem time237, current time 308, horizon 71\n", - "adding: mem time238, current time 308, horizon 70\n", - "adding: mem time239, current time 308, horizon 69\n", - "adding: mem time240, current time 308, horizon 68\n", - "adding: mem time241, current time 308, horizon 67\n", - "adding: mem time242, current time 308, horizon 66\n", - "adding: mem time243, current time 308, horizon 65\n", - "adding: mem time244, current time 308, horizon 64\n", - "adding: mem time245, current time 308, horizon 63\n", - "adding: mem time246, current time 308, horizon 62\n", - "adding: mem time247, current time 308, horizon 61\n", - "adding: mem time248, current time 308, horizon 60\n", - "adding: mem time249, current time 308, horizon 59\n", - "adding: mem time250, current time 308, horizon 58\n", - "adding: mem time251, current time 308, horizon 57\n", - "adding: mem time252, current time 308, horizon 56\n", - "adding: mem time253, current time 308, horizon 55\n", - "adding: mem time254, current time 308, horizon 54\n", - "adding: mem time255, current time 308, horizon 53\n", - "adding: mem time256, current time 308, horizon 52\n", - "adding: mem time257, current time 308, horizon 51\n", - "adding: mem time258, current time 308, horizon 50\n", - "adding: mem time259, current time 308, horizon 49\n", - "adding: mem time260, current time 308, horizon 48\n", - "adding: mem time261, current time 308, horizon 47\n", - "adding: mem time262, current time 308, horizon 46\n", - "adding: mem time263, current time 308, horizon 45\n", - "adding: mem time264, current time 308, horizon 44\n", - "adding: mem time265, current time 308, horizon 43\n", - "adding: mem time266, current time 308, horizon 42\n", - "adding: mem time267, current time 308, horizon 41\n", - "adding: mem time268, current time 308, horizon 40\n", - "adding: mem time269, current time 308, horizon 39\n", - "adding: mem time270, current time 308, horizon 38\n", - "adding: mem time271, current time 308, horizon 37\n", - "adding: mem time272, current time 308, horizon 36\n", - "adding: mem time273, current time 308, horizon 35\n", - "adding: mem time274, current time 308, horizon 34\n", - "adding: mem time275, current time 308, horizon 33\n", - "adding: mem time276, current time 308, horizon 32\n", - "adding: mem time277, current time 308, horizon 31\n", - "adding: mem time278, current time 308, horizon 30\n", - "adding: mem time279, current time 308, horizon 29\n", - "adding: mem time280, current time 308, horizon 28\n", - "adding: mem time281, current time 308, horizon 27\n", - "adding: mem time282, current time 308, horizon 26\n", - "adding: mem time283, current time 308, horizon 25\n", - "adding: mem time284, current time 308, horizon 24\n", - "adding: mem time285, current time 308, horizon 23\n", - "adding: mem time286, current time 308, horizon 22\n", - "adding: mem time287, current time 308, horizon 21\n", - "adding: mem time288, current time 308, horizon 20\n", - "adding: mem time289, current time 308, horizon 19\n", - "adding: mem time290, current time 308, horizon 18\n", - "adding: mem time291, current time 308, horizon 17\n", - "adding: mem time292, current time 308, horizon 16\n", - "adding: mem time293, current time 308, horizon 15\n", - "adding: mem time294, current time 308, horizon 14\n", - "adding: mem time295, current time 308, horizon 13\n", - "adding: mem time296, current time 308, horizon 12\n", - "adding: mem time297, current time 308, horizon 11\n", - "adding: mem time298, current time 308, horizon 10\n", - "adding: mem time299, current time 308, horizon 9\n", - "adding: mem time300, current time 308, horizon 8\n", - "adding: mem time301, current time 308, horizon 7\n", - "adding: mem time302, current time 308, horizon 6\n", - "adding: mem time303, current time 308, horizon 5\n", - "adding: mem time304, current time 308, horizon 4\n", - "adding: mem time305, current time 308, horizon 3\n", - "adding: mem time306, current time 308, horizon 2\n", - "adding: mem time307, current time 308, horizon 1\n", - "adding: mem time200, current time 309, horizon 109\n", - "adding: mem time201, current time 309, horizon 108\n", - "adding: mem time202, current time 309, horizon 107\n", - "adding: mem time203, current time 309, horizon 106\n", - "adding: mem time204, current time 309, horizon 105\n", - "adding: mem time205, current time 309, horizon 104\n", - "adding: mem time206, current time 309, horizon 103\n", - "adding: mem time207, current time 309, horizon 102\n", - "adding: mem time208, current time 309, horizon 101\n", - "adding: mem time209, current time 309, horizon 100\n", - "adding: mem time210, current time 309, horizon 99\n", - "adding: mem time211, current time 309, horizon 98\n", - "adding: mem time212, current time 309, horizon 97\n", - "adding: mem time213, current time 309, horizon 96\n", - "adding: mem time214, current time 309, horizon 95\n", - "adding: mem time215, current time 309, horizon 94\n", - "adding: mem time216, current time 309, horizon 93\n", - "adding: mem time217, current time 309, horizon 92\n", - "adding: mem time218, current time 309, horizon 91\n", - "adding: mem time219, current time 309, horizon 90\n", - "adding: mem time220, current time 309, horizon 89\n", - "adding: mem time221, current time 309, horizon 88\n", - "adding: mem time222, current time 309, horizon 87\n", - "adding: mem time223, current time 309, horizon 86\n", - "adding: mem time224, current time 309, horizon 85\n", - "adding: mem time225, current time 309, horizon 84\n", - "adding: mem time226, current time 309, horizon 83\n", - "adding: mem time227, current time 309, horizon 82\n", - "adding: mem time228, current time 309, horizon 81\n", - "adding: mem time229, current time 309, horizon 80\n", - "adding: mem time230, current time 309, horizon 79\n", - "adding: mem time231, current time 309, horizon 78\n", - "adding: mem time232, current time 309, horizon 77\n", - "adding: mem time233, current time 309, horizon 76\n", - "adding: mem time234, current time 309, horizon 75\n", - "adding: mem time235, current time 309, horizon 74\n", - "adding: mem time236, current time 309, horizon 73\n", - "adding: mem time237, current time 309, horizon 72\n", - "adding: mem time238, current time 309, horizon 71\n", - "adding: mem time239, current time 309, horizon 70\n", - "adding: mem time240, current time 309, horizon 69\n", - "adding: mem time241, current time 309, horizon 68\n", - "adding: mem time242, current time 309, horizon 67\n", - "adding: mem time243, current time 309, horizon 66\n", - "adding: mem time244, current time 309, horizon 65\n", - "adding: mem time245, current time 309, horizon 64\n", - "adding: mem time246, current time 309, horizon 63\n", - "adding: mem time247, current time 309, horizon 62\n", - "adding: mem time248, current time 309, horizon 61\n", - "adding: mem time249, current time 309, horizon 60\n", - "adding: mem time250, current time 309, horizon 59\n", - "adding: mem time251, current time 309, horizon 58\n", - "adding: mem time252, current time 309, horizon 57\n", - "adding: mem time253, current time 309, horizon 56\n", - "adding: mem time254, current time 309, horizon 55\n", - "adding: mem time255, current time 309, horizon 54\n", - "adding: mem time256, current time 309, horizon 53\n", - "adding: mem time257, current time 309, horizon 52\n", - "adding: mem time258, current time 309, horizon 51\n", - "adding: mem time259, current time 309, horizon 50\n", - "adding: mem time260, current time 309, horizon 49\n", - "adding: mem time261, current time 309, horizon 48\n", - "adding: mem time262, current time 309, horizon 47\n", - "adding: mem time263, current time 309, horizon 46\n", - "adding: mem time264, current time 309, horizon 45\n", - "adding: mem time265, current time 309, horizon 44\n", - "adding: mem time266, current time 309, horizon 43\n", - "adding: mem time267, current time 309, horizon 42\n", - "adding: mem time268, current time 309, horizon 41\n", - "adding: mem time269, current time 309, horizon 40\n", - "adding: mem time270, current time 309, horizon 39\n", - "adding: mem time271, current time 309, horizon 38\n", - "adding: mem time272, current time 309, horizon 37\n", - "adding: mem time273, current time 309, horizon 36\n", - "adding: mem time274, current time 309, horizon 35\n", - "adding: mem time275, current time 309, horizon 34\n", - "adding: mem time276, current time 309, horizon 33\n", - "adding: mem time277, current time 309, horizon 32\n", - "adding: mem time278, current time 309, horizon 31\n", - "adding: mem time279, current time 309, horizon 30\n", - "adding: mem time280, current time 309, horizon 29\n", - "adding: mem time281, current time 309, horizon 28\n", - "adding: mem time282, current time 309, horizon 27\n", - "adding: mem time283, current time 309, horizon 26\n", - "adding: mem time284, current time 309, horizon 25\n", - "adding: mem time285, current time 309, horizon 24\n", - "adding: mem time286, current time 309, horizon 23\n", - "adding: mem time287, current time 309, horizon 22\n", - "adding: mem time288, current time 309, horizon 21\n", - "adding: mem time289, current time 309, horizon 20\n", - "adding: mem time290, current time 309, horizon 19\n", - "adding: mem time291, current time 309, horizon 18\n", - "adding: mem time292, current time 309, horizon 17\n", - "adding: mem time293, current time 309, horizon 16\n", - "adding: mem time294, current time 309, horizon 15\n", - "adding: mem time295, current time 309, horizon 14\n", - "adding: mem time296, current time 309, horizon 13\n", - "adding: mem time297, current time 309, horizon 12\n", - "adding: mem time298, current time 309, horizon 11\n", - "adding: mem time299, current time 309, horizon 10\n", - "adding: mem time300, current time 309, horizon 9\n", - "adding: mem time301, current time 309, horizon 8\n", - "adding: mem time302, current time 309, horizon 7\n", - "adding: mem time303, current time 309, horizon 6\n", - "adding: mem time304, current time 309, horizon 5\n", - "adding: mem time305, current time 309, horizon 4\n", - "adding: mem time306, current time 309, horizon 3\n", - "adding: mem time307, current time 309, horizon 2\n", - "adding: mem time308, current time 309, horizon 1\n", - "adding: mem time200, current time 310, horizon 110\n", - "adding: mem time201, current time 310, horizon 109\n", - "adding: mem time202, current time 310, horizon 108\n", - "adding: mem time203, current time 310, horizon 107\n", - "adding: mem time204, current time 310, horizon 106\n", - "adding: mem time205, current time 310, horizon 105\n", - "adding: mem time206, current time 310, horizon 104\n", - "adding: mem time207, current time 310, horizon 103\n", - "adding: mem time208, current time 310, horizon 102\n", - "adding: mem time209, current time 310, horizon 101\n", - "adding: mem time210, current time 310, horizon 100\n", - "adding: mem time211, current time 310, horizon 99\n", - "adding: mem time212, current time 310, horizon 98\n", - "adding: mem time213, current time 310, horizon 97\n", - "adding: mem time214, current time 310, horizon 96\n", - "adding: mem time215, current time 310, horizon 95\n", - "adding: mem time216, current time 310, horizon 94\n", - "adding: mem time217, current time 310, horizon 93\n", - "adding: mem time218, current time 310, horizon 92\n", - "adding: mem time219, current time 310, horizon 91\n", - "adding: mem time220, current time 310, horizon 90\n", - "adding: mem time221, current time 310, horizon 89\n", - "adding: mem time222, current time 310, horizon 88\n", - "adding: mem time223, current time 310, horizon 87\n", - "adding: mem time224, current time 310, horizon 86\n", - "adding: mem time225, current time 310, horizon 85\n", - "adding: mem time226, current time 310, horizon 84\n", - "adding: mem time227, current time 310, horizon 83\n", - "adding: mem time228, current time 310, horizon 82\n", - "adding: mem time229, current time 310, horizon 81\n", - "adding: mem time230, current time 310, horizon 80\n", - "adding: mem time231, current time 310, horizon 79\n", - "adding: mem time232, current time 310, horizon 78\n", - "adding: mem time233, current time 310, horizon 77\n", - "adding: mem time234, current time 310, horizon 76\n", - "adding: mem time235, current time 310, horizon 75\n", - "adding: mem time236, current time 310, horizon 74\n", - "adding: mem time237, current time 310, horizon 73\n", - "adding: mem time238, current time 310, horizon 72\n", - "adding: mem time239, current time 310, horizon 71\n", - "adding: mem time240, current time 310, horizon 70\n", - "adding: mem time241, current time 310, horizon 69\n", - "adding: mem time242, current time 310, horizon 68\n", - "adding: mem time243, current time 310, horizon 67\n", - "adding: mem time244, current time 310, horizon 66\n", - "adding: mem time245, current time 310, horizon 65\n", - "adding: mem time246, current time 310, horizon 64\n", - "adding: mem time247, current time 310, horizon 63\n", - "adding: mem time248, current time 310, horizon 62\n", - "adding: mem time249, current time 310, horizon 61\n", - "adding: mem time250, current time 310, horizon 60\n", - "adding: mem time251, current time 310, horizon 59\n", - "adding: mem time252, current time 310, horizon 58\n", - "adding: mem time253, current time 310, horizon 57\n", - "adding: mem time254, current time 310, horizon 56\n", - "adding: mem time255, current time 310, horizon 55\n", - "adding: mem time256, current time 310, horizon 54\n", - "adding: mem time257, current time 310, horizon 53\n", - "adding: mem time258, current time 310, horizon 52\n", - "adding: mem time259, current time 310, horizon 51\n", - "adding: mem time260, current time 310, horizon 50\n", - "adding: mem time261, current time 310, horizon 49\n", - "adding: mem time262, current time 310, horizon 48\n", - "adding: mem time263, current time 310, horizon 47\n", - "adding: mem time264, current time 310, horizon 46\n", - "adding: mem time265, current time 310, horizon 45\n", - "adding: mem time266, current time 310, horizon 44\n", - "adding: mem time267, current time 310, horizon 43\n", - "adding: mem time268, current time 310, horizon 42\n", - "adding: mem time269, current time 310, horizon 41\n", - "adding: mem time270, current time 310, horizon 40\n", - "adding: mem time271, current time 310, horizon 39\n", - "adding: mem time272, current time 310, horizon 38\n", - "adding: mem time273, current time 310, horizon 37\n", - "adding: mem time274, current time 310, horizon 36\n", - "adding: mem time275, current time 310, horizon 35\n", - "adding: mem time276, current time 310, horizon 34\n", - "adding: mem time277, current time 310, horizon 33\n", - "adding: mem time278, current time 310, horizon 32\n", - "adding: mem time279, current time 310, horizon 31\n", - "adding: mem time280, current time 310, horizon 30\n", - "adding: mem time281, current time 310, horizon 29\n", - "adding: mem time282, current time 310, horizon 28\n", - "adding: mem time283, current time 310, horizon 27\n", - "adding: mem time284, current time 310, horizon 26\n", - "adding: mem time285, current time 310, horizon 25\n", - "adding: mem time286, current time 310, horizon 24\n", - "adding: mem time287, current time 310, horizon 23\n", - "adding: mem time288, current time 310, horizon 22\n", - "adding: mem time289, current time 310, horizon 21\n", - "adding: mem time290, current time 310, horizon 20\n", - "adding: mem time291, current time 310, horizon 19\n", - "adding: mem time292, current time 310, horizon 18\n", - "adding: mem time293, current time 310, horizon 17\n", - "adding: mem time294, current time 310, horizon 16\n", - "adding: mem time295, current time 310, horizon 15\n", - "adding: mem time296, current time 310, horizon 14\n", - "adding: mem time297, current time 310, horizon 13\n", - "adding: mem time298, current time 310, horizon 12\n", - "adding: mem time299, current time 310, horizon 11\n", - "adding: mem time300, current time 310, horizon 10\n", - "adding: mem time301, current time 310, horizon 9\n", - "adding: mem time302, current time 310, horizon 8\n", - "adding: mem time303, current time 310, horizon 7\n", - "adding: mem time304, current time 310, horizon 6\n", - "adding: mem time305, current time 310, horizon 5\n", - "adding: mem time306, current time 310, horizon 4\n", - "adding: mem time307, current time 310, horizon 3\n", - "adding: mem time308, current time 310, horizon 2\n", - "adding: mem time309, current time 310, horizon 1\n", - "adding: mem time200, current time 311, horizon 111\n", - "adding: mem time201, current time 311, horizon 110\n", - "adding: mem time202, current time 311, horizon 109\n", - "adding: mem time203, current time 311, horizon 108\n", - "adding: mem time204, current time 311, horizon 107\n", - "adding: mem time205, current time 311, horizon 106\n", - "adding: mem time206, current time 311, horizon 105\n", - "adding: mem time207, current time 311, horizon 104\n", - "adding: mem time208, current time 311, horizon 103\n", - "adding: mem time209, current time 311, horizon 102\n", - "adding: mem time210, current time 311, horizon 101\n", - "adding: mem time211, current time 311, horizon 100\n", - "adding: mem time212, current time 311, horizon 99\n", - "adding: mem time213, current time 311, horizon 98\n", - "adding: mem time214, current time 311, horizon 97\n", - "adding: mem time215, current time 311, horizon 96\n", - "adding: mem time216, current time 311, horizon 95\n", - "adding: mem time217, current time 311, horizon 94\n", - "adding: mem time218, current time 311, horizon 93\n", - "adding: mem time219, current time 311, horizon 92\n", - "adding: mem time220, current time 311, horizon 91\n", - "adding: mem time221, current time 311, horizon 90\n", - "adding: mem time222, current time 311, horizon 89\n", - "adding: mem time223, current time 311, horizon 88\n", - "adding: mem time224, current time 311, horizon 87\n", - "adding: mem time225, current time 311, horizon 86\n", - "adding: mem time226, current time 311, horizon 85\n", - "adding: mem time227, current time 311, horizon 84\n", - "adding: mem time228, current time 311, horizon 83\n", - "adding: mem time229, current time 311, horizon 82\n", - "adding: mem time230, current time 311, horizon 81\n", - "adding: mem time231, current time 311, horizon 80\n", - "adding: mem time232, current time 311, horizon 79\n", - "adding: mem time233, current time 311, horizon 78\n", - "adding: mem time234, current time 311, horizon 77\n", - "adding: mem time235, current time 311, horizon 76\n", - "adding: mem time236, current time 311, horizon 75\n", - "adding: mem time237, current time 311, horizon 74\n", - "adding: mem time238, current time 311, horizon 73\n", - "adding: mem time239, current time 311, horizon 72\n", - "adding: mem time240, current time 311, horizon 71\n", - "adding: mem time241, current time 311, horizon 70\n", - "adding: mem time242, current time 311, horizon 69\n", - "adding: mem time243, current time 311, horizon 68\n", - "adding: mem time244, current time 311, horizon 67\n", - "adding: mem time245, current time 311, horizon 66\n", - "adding: mem time246, current time 311, horizon 65\n", - "adding: mem time247, current time 311, horizon 64\n", - "adding: mem time248, current time 311, horizon 63\n", - "adding: mem time249, current time 311, horizon 62\n", - "adding: mem time250, current time 311, horizon 61\n", - "adding: mem time251, current time 311, horizon 60\n", - "adding: mem time252, current time 311, horizon 59\n", - "adding: mem time253, current time 311, horizon 58\n", - "adding: mem time254, current time 311, horizon 57\n", - "adding: mem time255, current time 311, horizon 56\n", - "adding: mem time256, current time 311, horizon 55\n", - "adding: mem time257, current time 311, horizon 54\n", - "adding: mem time258, current time 311, horizon 53\n", - "adding: mem time259, current time 311, horizon 52\n", - "adding: mem time260, current time 311, horizon 51\n", - "adding: mem time261, current time 311, horizon 50\n", - "adding: mem time262, current time 311, horizon 49\n", - "adding: mem time263, current time 311, horizon 48\n", - "adding: mem time264, current time 311, horizon 47\n", - "adding: mem time265, current time 311, horizon 46\n", - "adding: mem time266, current time 311, horizon 45\n", - "adding: mem time267, current time 311, horizon 44\n", - "adding: mem time268, current time 311, horizon 43\n", - "adding: mem time269, current time 311, horizon 42\n", - "adding: mem time270, current time 311, horizon 41\n", - "adding: mem time271, current time 311, horizon 40\n", - "adding: mem time272, current time 311, horizon 39\n", - "adding: mem time273, current time 311, horizon 38\n", - "adding: mem time274, current time 311, horizon 37\n", - "adding: mem time275, current time 311, horizon 36\n", - "adding: mem time276, current time 311, horizon 35\n", - "adding: mem time277, current time 311, horizon 34\n", - "adding: mem time278, current time 311, horizon 33\n", - "adding: mem time279, current time 311, horizon 32\n", - "adding: mem time280, current time 311, horizon 31\n", - "adding: mem time281, current time 311, horizon 30\n", - "adding: mem time282, current time 311, horizon 29\n", - "adding: mem time283, current time 311, horizon 28\n", - "adding: mem time284, current time 311, horizon 27\n", - "adding: mem time285, current time 311, horizon 26\n", - "adding: mem time286, current time 311, horizon 25\n", - "adding: mem time287, current time 311, horizon 24\n", - "adding: mem time288, current time 311, horizon 23\n", - "adding: mem time289, current time 311, horizon 22\n", - "adding: mem time290, current time 311, horizon 21\n", - "adding: mem time291, current time 311, horizon 20\n", - "adding: mem time292, current time 311, horizon 19\n", - "adding: mem time293, current time 311, horizon 18\n", - "adding: mem time294, current time 311, horizon 17\n", - "adding: mem time295, current time 311, horizon 16\n", - "adding: mem time296, current time 311, horizon 15\n", - "adding: mem time297, current time 311, horizon 14\n", - "adding: mem time298, current time 311, horizon 13\n", - "adding: mem time299, current time 311, horizon 12\n", - "adding: mem time300, current time 311, horizon 11\n", - "adding: mem time301, current time 311, horizon 10\n", - "adding: mem time302, current time 311, horizon 9\n", - "adding: mem time303, current time 311, horizon 8\n", - "adding: mem time304, current time 311, horizon 7\n", - "adding: mem time305, current time 311, horizon 6\n", - "adding: mem time306, current time 311, horizon 5\n", - "adding: mem time307, current time 311, horizon 4\n", - "adding: mem time308, current time 311, horizon 3\n", - "adding: mem time309, current time 311, horizon 2\n", - "adding: mem time310, current time 311, horizon 1\n", - "adding: mem time200, current time 312, horizon 112\n", - "adding: mem time201, current time 312, horizon 111\n", - "adding: mem time202, current time 312, horizon 110\n", - "adding: mem time203, current time 312, horizon 109\n", - "adding: mem time204, current time 312, horizon 108\n", - "adding: mem time205, current time 312, horizon 107\n", - "adding: mem time206, current time 312, horizon 106\n", - "adding: mem time207, current time 312, horizon 105\n", - "adding: mem time208, current time 312, horizon 104\n", - "adding: mem time209, current time 312, horizon 103\n", - "adding: mem time210, current time 312, horizon 102\n", - "adding: mem time211, current time 312, horizon 101\n", - "adding: mem time212, current time 312, horizon 100\n", - "adding: mem time213, current time 312, horizon 99\n", - "adding: mem time214, current time 312, horizon 98\n", - "adding: mem time215, current time 312, horizon 97\n", - "adding: mem time216, current time 312, horizon 96\n", - "adding: mem time217, current time 312, horizon 95\n", - "adding: mem time218, current time 312, horizon 94\n", - "adding: mem time219, current time 312, horizon 93\n", - "adding: mem time220, current time 312, horizon 92\n", - "adding: mem time221, current time 312, horizon 91\n", - "adding: mem time222, current time 312, horizon 90\n", - "adding: mem time223, current time 312, horizon 89\n", - "adding: mem time224, current time 312, horizon 88\n", - "adding: mem time225, current time 312, horizon 87\n", - "adding: mem time226, current time 312, horizon 86\n", - "adding: mem time227, current time 312, horizon 85\n", - "adding: mem time228, current time 312, horizon 84\n", - "adding: mem time229, current time 312, horizon 83\n", - "adding: mem time230, current time 312, horizon 82\n", - "adding: mem time231, current time 312, horizon 81\n", - "adding: mem time232, current time 312, horizon 80\n", - "adding: mem time233, current time 312, horizon 79\n", - "adding: mem time234, current time 312, horizon 78\n", - "adding: mem time235, current time 312, horizon 77\n", - "adding: mem time236, current time 312, horizon 76\n", - "adding: mem time237, current time 312, horizon 75\n", - "adding: mem time238, current time 312, horizon 74\n", - "adding: mem time239, current time 312, horizon 73\n", - "adding: mem time240, current time 312, horizon 72\n", - "adding: mem time241, current time 312, horizon 71\n", - "adding: mem time242, current time 312, horizon 70\n", - "adding: mem time243, current time 312, horizon 69\n", - "adding: mem time244, current time 312, horizon 68\n", - "adding: mem time245, current time 312, horizon 67\n", - "adding: mem time246, current time 312, horizon 66\n", - "adding: mem time247, current time 312, horizon 65\n", - "adding: mem time248, current time 312, horizon 64\n", - "adding: mem time249, current time 312, horizon 63\n", - "adding: mem time250, current time 312, horizon 62\n", - "adding: mem time251, current time 312, horizon 61\n", - "adding: mem time252, current time 312, horizon 60\n", - "adding: mem time253, current time 312, horizon 59\n", - "adding: mem time254, current time 312, horizon 58\n", - "adding: mem time255, current time 312, horizon 57\n", - "adding: mem time256, current time 312, horizon 56\n", - "adding: mem time257, current time 312, horizon 55\n", - "adding: mem time258, current time 312, horizon 54\n", - "adding: mem time259, current time 312, horizon 53\n", - "adding: mem time260, current time 312, horizon 52\n", - "adding: mem time261, current time 312, horizon 51\n", - "adding: mem time262, current time 312, horizon 50\n", - "adding: mem time263, current time 312, horizon 49\n", - "adding: mem time264, current time 312, horizon 48\n", - "adding: mem time265, current time 312, horizon 47\n", - "adding: mem time266, current time 312, horizon 46\n", - "adding: mem time267, current time 312, horizon 45\n", - "adding: mem time268, current time 312, horizon 44\n", - "adding: mem time269, current time 312, horizon 43\n", - "adding: mem time270, current time 312, horizon 42\n", - "adding: mem time271, current time 312, horizon 41\n", - "adding: mem time272, current time 312, horizon 40\n", - "adding: mem time273, current time 312, horizon 39\n", - "adding: mem time274, current time 312, horizon 38\n", - "adding: mem time275, current time 312, horizon 37\n", - "adding: mem time276, current time 312, horizon 36\n", - "adding: mem time277, current time 312, horizon 35\n", - "adding: mem time278, current time 312, horizon 34\n", - "adding: mem time279, current time 312, horizon 33\n", - "adding: mem time280, current time 312, horizon 32\n", - "adding: mem time281, current time 312, horizon 31\n", - "adding: mem time282, current time 312, horizon 30\n", - "adding: mem time283, current time 312, horizon 29\n", - "adding: mem time284, current time 312, horizon 28\n", - "adding: mem time285, current time 312, horizon 27\n", - "adding: mem time286, current time 312, horizon 26\n", - "adding: mem time287, current time 312, horizon 25\n", - "adding: mem time288, current time 312, horizon 24\n", - "adding: mem time289, current time 312, horizon 23\n", - "adding: mem time290, current time 312, horizon 22\n", - "adding: mem time291, current time 312, horizon 21\n", - "adding: mem time292, current time 312, horizon 20\n", - "adding: mem time293, current time 312, horizon 19\n", - "adding: mem time294, current time 312, horizon 18\n", - "adding: mem time295, current time 312, horizon 17\n", - "adding: mem time296, current time 312, horizon 16\n", - "adding: mem time297, current time 312, horizon 15\n", - "adding: mem time298, current time 312, horizon 14\n", - "adding: mem time299, current time 312, horizon 13\n", - "adding: mem time300, current time 312, horizon 12\n", - "adding: mem time301, current time 312, horizon 11\n", - "adding: mem time302, current time 312, horizon 10\n", - "adding: mem time303, current time 312, horizon 9\n", - "adding: mem time304, current time 312, horizon 8\n", - "adding: mem time305, current time 312, horizon 7\n", - "adding: mem time306, current time 312, horizon 6\n", - "adding: mem time307, current time 312, horizon 5\n", - "adding: mem time308, current time 312, horizon 4\n", - "adding: mem time309, current time 312, horizon 3\n", - "adding: mem time310, current time 312, horizon 2\n", - "adding: mem time311, current time 312, horizon 1\n", - "adding: mem time200, current time 313, horizon 113\n", - "adding: mem time201, current time 313, horizon 112\n", - "adding: mem time202, current time 313, horizon 111\n", - "adding: mem time203, current time 313, horizon 110\n", - "adding: mem time204, current time 313, horizon 109\n", - "adding: mem time205, current time 313, horizon 108\n", - "adding: mem time206, current time 313, horizon 107\n", - "adding: mem time207, current time 313, horizon 106\n", - "adding: mem time208, current time 313, horizon 105\n", - "adding: mem time209, current time 313, horizon 104\n", - "adding: mem time210, current time 313, horizon 103\n", - "adding: mem time211, current time 313, horizon 102\n", - "adding: mem time212, current time 313, horizon 101\n", - "adding: mem time213, current time 313, horizon 100\n", - "adding: mem time214, current time 313, horizon 99\n", - "adding: mem time215, current time 313, horizon 98\n", - "adding: mem time216, current time 313, horizon 97\n", - "adding: mem time217, current time 313, horizon 96\n", - "adding: mem time218, current time 313, horizon 95\n", - "adding: mem time219, current time 313, horizon 94\n", - "adding: mem time220, current time 313, horizon 93\n", - "adding: mem time221, current time 313, horizon 92\n", - "adding: mem time222, current time 313, horizon 91\n", - "adding: mem time223, current time 313, horizon 90\n", - "adding: mem time224, current time 313, horizon 89\n", - "adding: mem time225, current time 313, horizon 88\n", - "adding: mem time226, current time 313, horizon 87\n", - "adding: mem time227, current time 313, horizon 86\n", - "adding: mem time228, current time 313, horizon 85\n", - "adding: mem time229, current time 313, horizon 84\n", - "adding: mem time230, current time 313, horizon 83\n", - "adding: mem time231, current time 313, horizon 82\n", - "adding: mem time232, current time 313, horizon 81\n", - "adding: mem time233, current time 313, horizon 80\n", - "adding: mem time234, current time 313, horizon 79\n", - "adding: mem time235, current time 313, horizon 78\n", - "adding: mem time236, current time 313, horizon 77\n", - "adding: mem time237, current time 313, horizon 76\n", - "adding: mem time238, current time 313, horizon 75\n", - "adding: mem time239, current time 313, horizon 74\n", - "adding: mem time240, current time 313, horizon 73\n", - "adding: mem time241, current time 313, horizon 72\n", - "adding: mem time242, current time 313, horizon 71\n", - "adding: mem time243, current time 313, horizon 70\n", - "adding: mem time244, current time 313, horizon 69\n", - "adding: mem time245, current time 313, horizon 68\n", - "adding: mem time246, current time 313, horizon 67\n", - "adding: mem time247, current time 313, horizon 66\n", - "adding: mem time248, current time 313, horizon 65\n", - "adding: mem time249, current time 313, horizon 64\n", - "adding: mem time250, current time 313, horizon 63\n", - "adding: mem time251, current time 313, horizon 62\n", - "adding: mem time252, current time 313, horizon 61\n", - "adding: mem time253, current time 313, horizon 60\n", - "adding: mem time254, current time 313, horizon 59\n", - "adding: mem time255, current time 313, horizon 58\n", - "adding: mem time256, current time 313, horizon 57\n", - "adding: mem time257, current time 313, horizon 56\n", - "adding: mem time258, current time 313, horizon 55\n", - "adding: mem time259, current time 313, horizon 54\n", - "adding: mem time260, current time 313, horizon 53\n", - "adding: mem time261, current time 313, horizon 52\n", - "adding: mem time262, current time 313, horizon 51\n", - "adding: mem time263, current time 313, horizon 50\n", - "adding: mem time264, current time 313, horizon 49\n", - "adding: mem time265, current time 313, horizon 48\n", - "adding: mem time266, current time 313, horizon 47\n", - "adding: mem time267, current time 313, horizon 46\n", - "adding: mem time268, current time 313, horizon 45\n", - "adding: mem time269, current time 313, horizon 44\n", - "adding: mem time270, current time 313, horizon 43\n", - "adding: mem time271, current time 313, horizon 42\n", - "adding: mem time272, current time 313, horizon 41\n", - "adding: mem time273, current time 313, horizon 40\n", - "adding: mem time274, current time 313, horizon 39\n", - "adding: mem time275, current time 313, horizon 38\n", - "adding: mem time276, current time 313, horizon 37\n", - "adding: mem time277, current time 313, horizon 36\n", - "adding: mem time278, current time 313, horizon 35\n", - "adding: mem time279, current time 313, horizon 34\n", - "adding: mem time280, current time 313, horizon 33\n", - "adding: mem time281, current time 313, horizon 32\n", - "adding: mem time282, current time 313, horizon 31\n", - "adding: mem time283, current time 313, horizon 30\n", - "adding: mem time284, current time 313, horizon 29\n", - "adding: mem time285, current time 313, horizon 28\n", - "adding: mem time286, current time 313, horizon 27\n", - "adding: mem time287, current time 313, horizon 26\n", - "adding: mem time288, current time 313, horizon 25\n", - "adding: mem time289, current time 313, horizon 24\n", - "adding: mem time290, current time 313, horizon 23\n", - "adding: mem time291, current time 313, horizon 22\n", - "adding: mem time292, current time 313, horizon 21\n", - "adding: mem time293, current time 313, horizon 20\n", - "adding: mem time294, current time 313, horizon 19\n", - "adding: mem time295, current time 313, horizon 18\n", - "adding: mem time296, current time 313, horizon 17\n", - "adding: mem time297, current time 313, horizon 16\n", - "adding: mem time298, current time 313, horizon 15\n", - "adding: mem time299, current time 313, horizon 14\n", - "adding: mem time300, current time 313, horizon 13\n", - "adding: mem time301, current time 313, horizon 12\n", - "adding: mem time302, current time 313, horizon 11\n", - "adding: mem time303, current time 313, horizon 10\n", - "adding: mem time304, current time 313, horizon 9\n", - "adding: mem time305, current time 313, horizon 8\n", - "adding: mem time306, current time 313, horizon 7\n", - "adding: mem time307, current time 313, horizon 6\n", - "adding: mem time308, current time 313, horizon 5\n", - "adding: mem time309, current time 313, horizon 4\n", - "adding: mem time310, current time 313, horizon 3\n", - "adding: mem time311, current time 313, horizon 2\n", - "adding: mem time312, current time 313, horizon 1\n", - "adding: mem time200, current time 314, horizon 114\n", - "adding: mem time201, current time 314, horizon 113\n", - "adding: mem time202, current time 314, horizon 112\n", - "adding: mem time203, current time 314, horizon 111\n", - "adding: mem time204, current time 314, horizon 110\n", - "adding: mem time205, current time 314, horizon 109\n", - "adding: mem time206, current time 314, horizon 108\n", - "adding: mem time207, current time 314, horizon 107\n", - "adding: mem time208, current time 314, horizon 106\n", - "adding: mem time209, current time 314, horizon 105\n", - "adding: mem time210, current time 314, horizon 104\n", - "adding: mem time211, current time 314, horizon 103\n", - "adding: mem time212, current time 314, horizon 102\n", - "adding: mem time213, current time 314, horizon 101\n", - "adding: mem time214, current time 314, horizon 100\n", - "adding: mem time215, current time 314, horizon 99\n", - "adding: mem time216, current time 314, horizon 98\n", - "adding: mem time217, current time 314, horizon 97\n", - "adding: mem time218, current time 314, horizon 96\n", - "adding: mem time219, current time 314, horizon 95\n", - "adding: mem time220, current time 314, horizon 94\n", - "adding: mem time221, current time 314, horizon 93\n", - "adding: mem time222, current time 314, horizon 92\n", - "adding: mem time223, current time 314, horizon 91\n", - "adding: mem time224, current time 314, horizon 90\n", - "adding: mem time225, current time 314, horizon 89\n", - "adding: mem time226, current time 314, horizon 88\n", - "adding: mem time227, current time 314, horizon 87\n", - "adding: mem time228, current time 314, horizon 86\n", - "adding: mem time229, current time 314, horizon 85\n", - "adding: mem time230, current time 314, horizon 84\n", - "adding: mem time231, current time 314, horizon 83\n", - "adding: mem time232, current time 314, horizon 82\n", - "adding: mem time233, current time 314, horizon 81\n", - "adding: mem time234, current time 314, horizon 80\n", - "adding: mem time235, current time 314, horizon 79\n", - "adding: mem time236, current time 314, horizon 78\n", - "adding: mem time237, current time 314, horizon 77\n", - "adding: mem time238, current time 314, horizon 76\n", - "adding: mem time239, current time 314, horizon 75\n", - "adding: mem time240, current time 314, horizon 74\n", - "adding: mem time241, current time 314, horizon 73\n", - "adding: mem time242, current time 314, horizon 72\n", - "adding: mem time243, current time 314, horizon 71\n", - "adding: mem time244, current time 314, horizon 70\n", - "adding: mem time245, current time 314, horizon 69\n", - "adding: mem time246, current time 314, horizon 68\n", - "adding: mem time247, current time 314, horizon 67\n", - "adding: mem time248, current time 314, horizon 66\n", - "adding: mem time249, current time 314, horizon 65\n", - "adding: mem time250, current time 314, horizon 64\n", - "adding: mem time251, current time 314, horizon 63\n", - "adding: mem time252, current time 314, horizon 62\n", - "adding: mem time253, current time 314, horizon 61\n", - "adding: mem time254, current time 314, horizon 60\n", - "adding: mem time255, current time 314, horizon 59\n", - "adding: mem time256, current time 314, horizon 58\n", - "adding: mem time257, current time 314, horizon 57\n", - "adding: mem time258, current time 314, horizon 56\n", - "adding: mem time259, current time 314, horizon 55\n", - "adding: mem time260, current time 314, horizon 54\n", - "adding: mem time261, current time 314, horizon 53\n", - "adding: mem time262, current time 314, horizon 52\n", - "adding: mem time263, current time 314, horizon 51\n", - "adding: mem time264, current time 314, horizon 50\n", - "adding: mem time265, current time 314, horizon 49\n", - "adding: mem time266, current time 314, horizon 48\n", - "adding: mem time267, current time 314, horizon 47\n", - "adding: mem time268, current time 314, horizon 46\n", - "adding: mem time269, current time 314, horizon 45\n", - "adding: mem time270, current time 314, horizon 44\n", - "adding: mem time271, current time 314, horizon 43\n", - "adding: mem time272, current time 314, horizon 42\n", - "adding: mem time273, current time 314, horizon 41\n", - "adding: mem time274, current time 314, horizon 40\n", - "adding: mem time275, current time 314, horizon 39\n", - "adding: mem time276, current time 314, horizon 38\n", - "adding: mem time277, current time 314, horizon 37\n", - "adding: mem time278, current time 314, horizon 36\n", - "adding: mem time279, current time 314, horizon 35\n", - "adding: mem time280, current time 314, horizon 34\n", - "adding: mem time281, current time 314, horizon 33\n", - "adding: mem time282, current time 314, horizon 32\n", - "adding: mem time283, current time 314, horizon 31\n", - "adding: mem time284, current time 314, horizon 30\n", - "adding: mem time285, current time 314, horizon 29\n", - "adding: mem time286, current time 314, horizon 28\n", - "adding: mem time287, current time 314, horizon 27\n", - "adding: mem time288, current time 314, horizon 26\n", - "adding: mem time289, current time 314, horizon 25\n", - "adding: mem time290, current time 314, horizon 24\n", - "adding: mem time291, current time 314, horizon 23\n", - "adding: mem time292, current time 314, horizon 22\n", - "adding: mem time293, current time 314, horizon 21\n", - "adding: mem time294, current time 314, horizon 20\n", - "adding: mem time295, current time 314, horizon 19\n", - "adding: mem time296, current time 314, horizon 18\n", - "adding: mem time297, current time 314, horizon 17\n", - "adding: mem time298, current time 314, horizon 16\n", - "adding: mem time299, current time 314, horizon 15\n", - "adding: mem time300, current time 314, horizon 14\n", - "adding: mem time301, current time 314, horizon 13\n", - "adding: mem time302, current time 314, horizon 12\n", - "adding: mem time303, current time 314, horizon 11\n", - "adding: mem time304, current time 314, horizon 10\n", - "adding: mem time305, current time 314, horizon 9\n", - "adding: mem time306, current time 314, horizon 8\n", - "adding: mem time307, current time 314, horizon 7\n", - "adding: mem time308, current time 314, horizon 6\n", - "adding: mem time309, current time 314, horizon 5\n", - "adding: mem time310, current time 314, horizon 4\n", - "adding: mem time311, current time 314, horizon 3\n", - "adding: mem time312, current time 314, horizon 2\n", - "adding: mem time313, current time 314, horizon 1\n", - "adding: mem time200, current time 315, horizon 115\n", - "adding: mem time201, current time 315, horizon 114\n", - "adding: mem time202, current time 315, horizon 113\n", - "adding: mem time203, current time 315, horizon 112\n", - "adding: mem time204, current time 315, horizon 111\n", - "adding: mem time205, current time 315, horizon 110\n", - "adding: mem time206, current time 315, horizon 109\n", - "adding: mem time207, current time 315, horizon 108\n", - "adding: mem time208, current time 315, horizon 107\n", - "adding: mem time209, current time 315, horizon 106\n", - "adding: mem time210, current time 315, horizon 105\n", - "adding: mem time211, current time 315, horizon 104\n", - "adding: mem time212, current time 315, horizon 103\n", - "adding: mem time213, current time 315, horizon 102\n", - "adding: mem time214, current time 315, horizon 101\n", - "adding: mem time215, current time 315, horizon 100\n", - "adding: mem time216, current time 315, horizon 99\n", - "adding: mem time217, current time 315, horizon 98\n", - "adding: mem time218, current time 315, horizon 97\n", - "adding: mem time219, current time 315, horizon 96\n", - "adding: mem time220, current time 315, horizon 95\n", - "adding: mem time221, current time 315, horizon 94\n", - "adding: mem time222, current time 315, horizon 93\n", - "adding: mem time223, current time 315, horizon 92\n", - "adding: mem time224, current time 315, horizon 91\n", - "adding: mem time225, current time 315, horizon 90\n", - "adding: mem time226, current time 315, horizon 89\n", - "adding: mem time227, current time 315, horizon 88\n", - "adding: mem time228, current time 315, horizon 87\n", - "adding: mem time229, current time 315, horizon 86\n", - "adding: mem time230, current time 315, horizon 85\n", - "adding: mem time231, current time 315, horizon 84\n", - "adding: mem time232, current time 315, horizon 83\n", - "adding: mem time233, current time 315, horizon 82\n", - "adding: mem time234, current time 315, horizon 81\n", - "adding: mem time235, current time 315, horizon 80\n", - "adding: mem time236, current time 315, horizon 79\n", - "adding: mem time237, current time 315, horizon 78\n", - "adding: mem time238, current time 315, horizon 77\n", - "adding: mem time239, current time 315, horizon 76\n", - "adding: mem time240, current time 315, horizon 75\n", - "adding: mem time241, current time 315, horizon 74\n", - "adding: mem time242, current time 315, horizon 73\n", - "adding: mem time243, current time 315, horizon 72\n", - "adding: mem time244, current time 315, horizon 71\n", - "adding: mem time245, current time 315, horizon 70\n", - "adding: mem time246, current time 315, horizon 69\n", - "adding: mem time247, current time 315, horizon 68\n", - "adding: mem time248, current time 315, horizon 67\n", - "adding: mem time249, current time 315, horizon 66\n", - "adding: mem time250, current time 315, horizon 65\n", - "adding: mem time251, current time 315, horizon 64\n", - "adding: mem time252, current time 315, horizon 63\n", - "adding: mem time253, current time 315, horizon 62\n", - "adding: mem time254, current time 315, horizon 61\n", - "adding: mem time255, current time 315, horizon 60\n", - "adding: mem time256, current time 315, horizon 59\n", - "adding: mem time257, current time 315, horizon 58\n", - "adding: mem time258, current time 315, horizon 57\n", - "adding: mem time259, current time 315, horizon 56\n", - "adding: mem time260, current time 315, horizon 55\n", - "adding: mem time261, current time 315, horizon 54\n", - "adding: mem time262, current time 315, horizon 53\n", - "adding: mem time263, current time 315, horizon 52\n", - "adding: mem time264, current time 315, horizon 51\n", - "adding: mem time265, current time 315, horizon 50\n", - "adding: mem time266, current time 315, horizon 49\n", - "adding: mem time267, current time 315, horizon 48\n", - "adding: mem time268, current time 315, horizon 47\n", - "adding: mem time269, current time 315, horizon 46\n", - "adding: mem time270, current time 315, horizon 45\n", - "adding: mem time271, current time 315, horizon 44\n", - "adding: mem time272, current time 315, horizon 43\n", - "adding: mem time273, current time 315, horizon 42\n", - "adding: mem time274, current time 315, horizon 41\n", - "adding: mem time275, current time 315, horizon 40\n", - "adding: mem time276, current time 315, horizon 39\n", - "adding: mem time277, current time 315, horizon 38\n", - "adding: mem time278, current time 315, horizon 37\n", - "adding: mem time279, current time 315, horizon 36\n", - "adding: mem time280, current time 315, horizon 35\n", - "adding: mem time281, current time 315, horizon 34\n", - "adding: mem time282, current time 315, horizon 33\n", - "adding: mem time283, current time 315, horizon 32\n", - "adding: mem time284, current time 315, horizon 31\n", - "adding: mem time285, current time 315, horizon 30\n", - "adding: mem time286, current time 315, horizon 29\n", - "adding: mem time287, current time 315, horizon 28\n", - "adding: mem time288, current time 315, horizon 27\n", - "adding: mem time289, current time 315, horizon 26\n", - "adding: mem time290, current time 315, horizon 25\n", - "adding: mem time291, current time 315, horizon 24\n", - "adding: mem time292, current time 315, horizon 23\n", - "adding: mem time293, current time 315, horizon 22\n", - "adding: mem time294, current time 315, horizon 21\n", - "adding: mem time295, current time 315, horizon 20\n", - "adding: mem time296, current time 315, horizon 19\n", - "adding: mem time297, current time 315, horizon 18\n", - "adding: mem time298, current time 315, horizon 17\n", - "adding: mem time299, current time 315, horizon 16\n", - "adding: mem time300, current time 315, horizon 15\n", - "adding: mem time301, current time 315, horizon 14\n", - "adding: mem time302, current time 315, horizon 13\n", - "adding: mem time303, current time 315, horizon 12\n", - "adding: mem time304, current time 315, horizon 11\n", - "adding: mem time305, current time 315, horizon 10\n", - "adding: mem time306, current time 315, horizon 9\n", - "adding: mem time307, current time 315, horizon 8\n", - "adding: mem time308, current time 315, horizon 7\n", - "adding: mem time309, current time 315, horizon 6\n", - "adding: mem time310, current time 315, horizon 5\n", - "adding: mem time311, current time 315, horizon 4\n", - "adding: mem time312, current time 315, horizon 3\n", - "adding: mem time313, current time 315, horizon 2\n", - "adding: mem time314, current time 315, horizon 1\n", - "adding: mem time200, current time 316, horizon 116\n", - "adding: mem time201, current time 316, horizon 115\n", - "adding: mem time202, current time 316, horizon 114\n", - "adding: mem time203, current time 316, horizon 113\n", - "adding: mem time204, current time 316, horizon 112\n", - "adding: mem time205, current time 316, horizon 111\n", - "adding: mem time206, current time 316, horizon 110\n", - "adding: mem time207, current time 316, horizon 109\n", - "adding: mem time208, current time 316, horizon 108\n", - "adding: mem time209, current time 316, horizon 107\n", - "adding: mem time210, current time 316, horizon 106\n", - "adding: mem time211, current time 316, horizon 105\n", - "adding: mem time212, current time 316, horizon 104\n", - "adding: mem time213, current time 316, horizon 103\n", - "adding: mem time214, current time 316, horizon 102\n", - "adding: mem time215, current time 316, horizon 101\n", - "adding: mem time216, current time 316, horizon 100\n", - "adding: mem time217, current time 316, horizon 99\n", - "adding: mem time218, current time 316, horizon 98\n", - "adding: mem time219, current time 316, horizon 97\n", - "adding: mem time220, current time 316, horizon 96\n", - "adding: mem time221, current time 316, horizon 95\n", - "adding: mem time222, current time 316, horizon 94\n", - "adding: mem time223, current time 316, horizon 93\n", - "adding: mem time224, current time 316, horizon 92\n", - "adding: mem time225, current time 316, horizon 91\n", - "adding: mem time226, current time 316, horizon 90\n", - "adding: mem time227, current time 316, horizon 89\n", - "adding: mem time228, current time 316, horizon 88\n", - "adding: mem time229, current time 316, horizon 87\n", - "adding: mem time230, current time 316, horizon 86\n", - "adding: mem time231, current time 316, horizon 85\n", - "adding: mem time232, current time 316, horizon 84\n", - "adding: mem time233, current time 316, horizon 83\n", - "adding: mem time234, current time 316, horizon 82\n", - "adding: mem time235, current time 316, horizon 81\n", - "adding: mem time236, current time 316, horizon 80\n", - "adding: mem time237, current time 316, horizon 79\n", - "adding: mem time238, current time 316, horizon 78\n", - "adding: mem time239, current time 316, horizon 77\n", - "adding: mem time240, current time 316, horizon 76\n", - "adding: mem time241, current time 316, horizon 75\n", - "adding: mem time242, current time 316, horizon 74\n", - "adding: mem time243, current time 316, horizon 73\n", - "adding: mem time244, current time 316, horizon 72\n", - "adding: mem time245, current time 316, horizon 71\n", - "adding: mem time246, current time 316, horizon 70\n", - "adding: mem time247, current time 316, horizon 69\n", - "adding: mem time248, current time 316, horizon 68\n", - "adding: mem time249, current time 316, horizon 67\n", - "adding: mem time250, current time 316, horizon 66\n", - "adding: mem time251, current time 316, horizon 65\n", - "adding: mem time252, current time 316, horizon 64\n", - "adding: mem time253, current time 316, horizon 63\n", - "adding: mem time254, current time 316, horizon 62\n", - "adding: mem time255, current time 316, horizon 61\n", - "adding: mem time256, current time 316, horizon 60\n", - "adding: mem time257, current time 316, horizon 59\n", - "adding: mem time258, current time 316, horizon 58\n", - "adding: mem time259, current time 316, horizon 57\n", - "adding: mem time260, current time 316, horizon 56\n", - "adding: mem time261, current time 316, horizon 55\n", - "adding: mem time262, current time 316, horizon 54\n", - "adding: mem time263, current time 316, horizon 53\n", - "adding: mem time264, current time 316, horizon 52\n", - "adding: mem time265, current time 316, horizon 51\n", - "adding: mem time266, current time 316, horizon 50\n", - "adding: mem time267, current time 316, horizon 49\n", - "adding: mem time268, current time 316, horizon 48\n", - "adding: mem time269, current time 316, horizon 47\n", - "adding: mem time270, current time 316, horizon 46\n", - "adding: mem time271, current time 316, horizon 45\n", - "adding: mem time272, current time 316, horizon 44\n", - "adding: mem time273, current time 316, horizon 43\n", - "adding: mem time274, current time 316, horizon 42\n", - "adding: mem time275, current time 316, horizon 41\n", - "adding: mem time276, current time 316, horizon 40\n", - "adding: mem time277, current time 316, horizon 39\n", - "adding: mem time278, current time 316, horizon 38\n", - "adding: mem time279, current time 316, horizon 37\n", - "adding: mem time280, current time 316, horizon 36\n", - "adding: mem time281, current time 316, horizon 35\n", - "adding: mem time282, current time 316, horizon 34\n", - "adding: mem time283, current time 316, horizon 33\n", - "adding: mem time284, current time 316, horizon 32\n", - "adding: mem time285, current time 316, horizon 31\n", - "adding: mem time286, current time 316, horizon 30\n", - "adding: mem time287, current time 316, horizon 29\n", - "adding: mem time288, current time 316, horizon 28\n", - "adding: mem time289, current time 316, horizon 27\n", - "adding: mem time290, current time 316, horizon 26\n", - "adding: mem time291, current time 316, horizon 25\n", - "adding: mem time292, current time 316, horizon 24\n", - "adding: mem time293, current time 316, horizon 23\n", - "adding: mem time294, current time 316, horizon 22\n", - "adding: mem time295, current time 316, horizon 21\n", - "adding: mem time296, current time 316, horizon 20\n", - "adding: mem time297, current time 316, horizon 19\n", - "adding: mem time298, current time 316, horizon 18\n", - "adding: mem time299, current time 316, horizon 17\n", - "adding: mem time300, current time 316, horizon 16\n", - "adding: mem time301, current time 316, horizon 15\n", - "adding: mem time302, current time 316, horizon 14\n", - "adding: mem time303, current time 316, horizon 13\n", - "adding: mem time304, current time 316, horizon 12\n", - "adding: mem time305, current time 316, horizon 11\n", - "adding: mem time306, current time 316, horizon 10\n", - "adding: mem time307, current time 316, horizon 9\n", - "adding: mem time308, current time 316, horizon 8\n", - "adding: mem time309, current time 316, horizon 7\n", - "adding: mem time310, current time 316, horizon 6\n", - "adding: mem time311, current time 316, horizon 5\n", - "adding: mem time312, current time 316, horizon 4\n", - "adding: mem time313, current time 316, horizon 3\n", - "adding: mem time314, current time 316, horizon 2\n", - "adding: mem time315, current time 316, horizon 1\n", - "adding: mem time200, current time 317, horizon 117\n", - "adding: mem time201, current time 317, horizon 116\n", - "adding: mem time202, current time 317, horizon 115\n", - "adding: mem time203, current time 317, horizon 114\n", - "adding: mem time204, current time 317, horizon 113\n", - "adding: mem time205, current time 317, horizon 112\n", - "adding: mem time206, current time 317, horizon 111\n", - "adding: mem time207, current time 317, horizon 110\n", - "adding: mem time208, current time 317, horizon 109\n", - "adding: mem time209, current time 317, horizon 108\n", - "adding: mem time210, current time 317, horizon 107\n", - "adding: mem time211, current time 317, horizon 106\n", - "adding: mem time212, current time 317, horizon 105\n", - "adding: mem time213, current time 317, horizon 104\n", - "adding: mem time214, current time 317, horizon 103\n", - "adding: mem time215, current time 317, horizon 102\n", - "adding: mem time216, current time 317, horizon 101\n", - "adding: mem time217, current time 317, horizon 100\n", - "adding: mem time218, current time 317, horizon 99\n", - "adding: mem time219, current time 317, horizon 98\n", - "adding: mem time220, current time 317, horizon 97\n", - "adding: mem time221, current time 317, horizon 96\n", - "adding: mem time222, current time 317, horizon 95\n", - "adding: mem time223, current time 317, horizon 94\n", - "adding: mem time224, current time 317, horizon 93\n", - "adding: mem time225, current time 317, horizon 92\n", - "adding: mem time226, current time 317, horizon 91\n", - "adding: mem time227, current time 317, horizon 90\n", - "adding: mem time228, current time 317, horizon 89\n", - "adding: mem time229, current time 317, horizon 88\n", - "adding: mem time230, current time 317, horizon 87\n", - "adding: mem time231, current time 317, horizon 86\n", - "adding: mem time232, current time 317, horizon 85\n", - "adding: mem time233, current time 317, horizon 84\n", - "adding: mem time234, current time 317, horizon 83\n", - "adding: mem time235, current time 317, horizon 82\n", - "adding: mem time236, current time 317, horizon 81\n", - "adding: mem time237, current time 317, horizon 80\n", - "adding: mem time238, current time 317, horizon 79\n", - "adding: mem time239, current time 317, horizon 78\n", - "adding: mem time240, current time 317, horizon 77\n", - "adding: mem time241, current time 317, horizon 76\n", - "adding: mem time242, current time 317, horizon 75\n", - "adding: mem time243, current time 317, horizon 74\n", - "adding: mem time244, current time 317, horizon 73\n", - "adding: mem time245, current time 317, horizon 72\n", - "adding: mem time246, current time 317, horizon 71\n", - "adding: mem time247, current time 317, horizon 70\n", - "adding: mem time248, current time 317, horizon 69\n", - "adding: mem time249, current time 317, horizon 68\n", - "adding: mem time250, current time 317, horizon 67\n", - "adding: mem time251, current time 317, horizon 66\n", - "adding: mem time252, current time 317, horizon 65\n", - "adding: mem time253, current time 317, horizon 64\n", - "adding: mem time254, current time 317, horizon 63\n", - "adding: mem time255, current time 317, horizon 62\n", - "adding: mem time256, current time 317, horizon 61\n", - "adding: mem time257, current time 317, horizon 60\n", - "adding: mem time258, current time 317, horizon 59\n", - "adding: mem time259, current time 317, horizon 58\n", - "adding: mem time260, current time 317, horizon 57\n", - "adding: mem time261, current time 317, horizon 56\n", - "adding: mem time262, current time 317, horizon 55\n", - "adding: mem time263, current time 317, horizon 54\n", - "adding: mem time264, current time 317, horizon 53\n", - "adding: mem time265, current time 317, horizon 52\n", - "adding: mem time266, current time 317, horizon 51\n", - "adding: mem time267, current time 317, horizon 50\n", - "adding: mem time268, current time 317, horizon 49\n", - "adding: mem time269, current time 317, horizon 48\n", - "adding: mem time270, current time 317, horizon 47\n", - "adding: mem time271, current time 317, horizon 46\n", - "adding: mem time272, current time 317, horizon 45\n", - "adding: mem time273, current time 317, horizon 44\n", - "adding: mem time274, current time 317, horizon 43\n", - "adding: mem time275, current time 317, horizon 42\n", - "adding: mem time276, current time 317, horizon 41\n", - "adding: mem time277, current time 317, horizon 40\n", - "adding: mem time278, current time 317, horizon 39\n", - "adding: mem time279, current time 317, horizon 38\n", - "adding: mem time280, current time 317, horizon 37\n", - "adding: mem time281, current time 317, horizon 36\n", - "adding: mem time282, current time 317, horizon 35\n", - "adding: mem time283, current time 317, horizon 34\n", - "adding: mem time284, current time 317, horizon 33\n", - "adding: mem time285, current time 317, horizon 32\n", - "adding: mem time286, current time 317, horizon 31\n", - "adding: mem time287, current time 317, horizon 30\n", - "adding: mem time288, current time 317, horizon 29\n", - "adding: mem time289, current time 317, horizon 28\n", - "adding: mem time290, current time 317, horizon 27\n", - "adding: mem time291, current time 317, horizon 26\n", - "adding: mem time292, current time 317, horizon 25\n", - "adding: mem time293, current time 317, horizon 24\n", - "adding: mem time294, current time 317, horizon 23\n", - "adding: mem time295, current time 317, horizon 22\n", - "adding: mem time296, current time 317, horizon 21\n", - "adding: mem time297, current time 317, horizon 20\n", - "adding: mem time298, current time 317, horizon 19\n", - "adding: mem time299, current time 317, horizon 18\n", - "adding: mem time300, current time 317, horizon 17\n", - "adding: mem time301, current time 317, horizon 16\n", - "adding: mem time302, current time 317, horizon 15\n", - "adding: mem time303, current time 317, horizon 14\n", - "adding: mem time304, current time 317, horizon 13\n", - "adding: mem time305, current time 317, horizon 12\n", - "adding: mem time306, current time 317, horizon 11\n", - "adding: mem time307, current time 317, horizon 10\n", - "adding: mem time308, current time 317, horizon 9\n", - "adding: mem time309, current time 317, horizon 8\n", - "adding: mem time310, current time 317, horizon 7\n", - "adding: mem time311, current time 317, horizon 6\n", - "adding: mem time312, current time 317, horizon 5\n", - "adding: mem time313, current time 317, horizon 4\n", - "adding: mem time314, current time 317, horizon 3\n", - "adding: mem time315, current time 317, horizon 2\n", - "adding: mem time316, current time 317, horizon 1\n", - "adding: mem time200, current time 318, horizon 118\n", - "adding: mem time201, current time 318, horizon 117\n", - "adding: mem time202, current time 318, horizon 116\n", - "adding: mem time203, current time 318, horizon 115\n", - "adding: mem time204, current time 318, horizon 114\n", - "adding: mem time205, current time 318, horizon 113\n", - "adding: mem time206, current time 318, horizon 112\n", - "adding: mem time207, current time 318, horizon 111\n", - "adding: mem time208, current time 318, horizon 110\n", - "adding: mem time209, current time 318, horizon 109\n", - "adding: mem time210, current time 318, horizon 108\n", - "adding: mem time211, current time 318, horizon 107\n", - "adding: mem time212, current time 318, horizon 106\n", - "adding: mem time213, current time 318, horizon 105\n", - "adding: mem time214, current time 318, horizon 104\n", - "adding: mem time215, current time 318, horizon 103\n", - "adding: mem time216, current time 318, horizon 102\n", - "adding: mem time217, current time 318, horizon 101\n", - "adding: mem time218, current time 318, horizon 100\n", - "adding: mem time219, current time 318, horizon 99\n", - "adding: mem time220, current time 318, horizon 98\n", - "adding: mem time221, current time 318, horizon 97\n", - "adding: mem time222, current time 318, horizon 96\n", - "adding: mem time223, current time 318, horizon 95\n", - "adding: mem time224, current time 318, horizon 94\n", - "adding: mem time225, current time 318, horizon 93\n", - "adding: mem time226, current time 318, horizon 92\n", - "adding: mem time227, current time 318, horizon 91\n", - "adding: mem time228, current time 318, horizon 90\n", - "adding: mem time229, current time 318, horizon 89\n", - "adding: mem time230, current time 318, horizon 88\n", - "adding: mem time231, current time 318, horizon 87\n", - "adding: mem time232, current time 318, horizon 86\n", - "adding: mem time233, current time 318, horizon 85\n", - "adding: mem time234, current time 318, horizon 84\n", - "adding: mem time235, current time 318, horizon 83\n", - "adding: mem time236, current time 318, horizon 82\n", - "adding: mem time237, current time 318, horizon 81\n", - "adding: mem time238, current time 318, horizon 80\n", - "adding: mem time239, current time 318, horizon 79\n", - "adding: mem time240, current time 318, horizon 78\n", - "adding: mem time241, current time 318, horizon 77\n", - "adding: mem time242, current time 318, horizon 76\n", - "adding: mem time243, current time 318, horizon 75\n", - "adding: mem time244, current time 318, horizon 74\n", - "adding: mem time245, current time 318, horizon 73\n", - "adding: mem time246, current time 318, horizon 72\n", - "adding: mem time247, current time 318, horizon 71\n", - "adding: mem time248, current time 318, horizon 70\n", - "adding: mem time249, current time 318, horizon 69\n", - "adding: mem time250, current time 318, horizon 68\n", - "adding: mem time251, current time 318, horizon 67\n", - "adding: mem time252, current time 318, horizon 66\n", - "adding: mem time253, current time 318, horizon 65\n", - "adding: mem time254, current time 318, horizon 64\n", - "adding: mem time255, current time 318, horizon 63\n", - "adding: mem time256, current time 318, horizon 62\n", - "adding: mem time257, current time 318, horizon 61\n", - "adding: mem time258, current time 318, horizon 60\n", - "adding: mem time259, current time 318, horizon 59\n", - "adding: mem time260, current time 318, horizon 58\n", - "adding: mem time261, current time 318, horizon 57\n", - "adding: mem time262, current time 318, horizon 56\n", - "adding: mem time263, current time 318, horizon 55\n", - "adding: mem time264, current time 318, horizon 54\n", - "adding: mem time265, current time 318, horizon 53\n", - "adding: mem time266, current time 318, horizon 52\n", - "adding: mem time267, current time 318, horizon 51\n", - "adding: mem time268, current time 318, horizon 50\n", - "adding: mem time269, current time 318, horizon 49\n", - "adding: mem time270, current time 318, horizon 48\n", - "adding: mem time271, current time 318, horizon 47\n", - "adding: mem time272, current time 318, horizon 46\n", - "adding: mem time273, current time 318, horizon 45\n", - "adding: mem time274, current time 318, horizon 44\n", - "adding: mem time275, current time 318, horizon 43\n", - "adding: mem time276, current time 318, horizon 42\n", - "adding: mem time277, current time 318, horizon 41\n", - "adding: mem time278, current time 318, horizon 40\n", - "adding: mem time279, current time 318, horizon 39\n", - "adding: mem time280, current time 318, horizon 38\n", - "adding: mem time281, current time 318, horizon 37\n", - "adding: mem time282, current time 318, horizon 36\n", - "adding: mem time283, current time 318, horizon 35\n", - "adding: mem time284, current time 318, horizon 34\n", - "adding: mem time285, current time 318, horizon 33\n", - "adding: mem time286, current time 318, horizon 32\n", - "adding: mem time287, current time 318, horizon 31\n", - "adding: mem time288, current time 318, horizon 30\n", - "adding: mem time289, current time 318, horizon 29\n", - "adding: mem time290, current time 318, horizon 28\n", - "adding: mem time291, current time 318, horizon 27\n", - "adding: mem time292, current time 318, horizon 26\n", - "adding: mem time293, current time 318, horizon 25\n", - "adding: mem time294, current time 318, horizon 24\n", - "adding: mem time295, current time 318, horizon 23\n", - "adding: mem time296, current time 318, horizon 22\n", - "adding: mem time297, current time 318, horizon 21\n", - "adding: mem time298, current time 318, horizon 20\n", - "adding: mem time299, current time 318, horizon 19\n", - "adding: mem time300, current time 318, horizon 18\n", - "adding: mem time301, current time 318, horizon 17\n", - "adding: mem time302, current time 318, horizon 16\n", - "adding: mem time303, current time 318, horizon 15\n", - "adding: mem time304, current time 318, horizon 14\n", - "adding: mem time305, current time 318, horizon 13\n", - "adding: mem time306, current time 318, horizon 12\n", - "adding: mem time307, current time 318, horizon 11\n", - "adding: mem time308, current time 318, horizon 10\n", - "adding: mem time309, current time 318, horizon 9\n", - "adding: mem time310, current time 318, horizon 8\n", - "adding: mem time311, current time 318, horizon 7\n", - "adding: mem time312, current time 318, horizon 6\n", - "adding: mem time313, current time 318, horizon 5\n", - "adding: mem time314, current time 318, horizon 4\n", - "adding: mem time315, current time 318, horizon 3\n", - "adding: mem time316, current time 318, horizon 2\n", - "adding: mem time317, current time 318, horizon 1\n", - "adding: mem time200, current time 319, horizon 119\n", - "adding: mem time201, current time 319, horizon 118\n", - "adding: mem time202, current time 319, horizon 117\n", - "adding: mem time203, current time 319, horizon 116\n", - "adding: mem time204, current time 319, horizon 115\n", - "adding: mem time205, current time 319, horizon 114\n", - "adding: mem time206, current time 319, horizon 113\n", - "adding: mem time207, current time 319, horizon 112\n", - "adding: mem time208, current time 319, horizon 111\n", - "adding: mem time209, current time 319, horizon 110\n", - "adding: mem time210, current time 319, horizon 109\n", - "adding: mem time211, current time 319, horizon 108\n", - "adding: mem time212, current time 319, horizon 107\n", - "adding: mem time213, current time 319, horizon 106\n", - "adding: mem time214, current time 319, horizon 105\n", - "adding: mem time215, current time 319, horizon 104\n", - "adding: mem time216, current time 319, horizon 103\n", - "adding: mem time217, current time 319, horizon 102\n", - "adding: mem time218, current time 319, horizon 101\n", - "adding: mem time219, current time 319, horizon 100\n", - "adding: mem time220, current time 319, horizon 99\n", - "adding: mem time221, current time 319, horizon 98\n", - "adding: mem time222, current time 319, horizon 97\n", - "adding: mem time223, current time 319, horizon 96\n", - "adding: mem time224, current time 319, horizon 95\n", - "adding: mem time225, current time 319, horizon 94\n", - "adding: mem time226, current time 319, horizon 93\n", - "adding: mem time227, current time 319, horizon 92\n", - "adding: mem time228, current time 319, horizon 91\n", - "adding: mem time229, current time 319, horizon 90\n", - "adding: mem time230, current time 319, horizon 89\n", - "adding: mem time231, current time 319, horizon 88\n", - "adding: mem time232, current time 319, horizon 87\n", - "adding: mem time233, current time 319, horizon 86\n", - "adding: mem time234, current time 319, horizon 85\n", - "adding: mem time235, current time 319, horizon 84\n", - "adding: mem time236, current time 319, horizon 83\n", - "adding: mem time237, current time 319, horizon 82\n", - "adding: mem time238, current time 319, horizon 81\n", - "adding: mem time239, current time 319, horizon 80\n", - "adding: mem time240, current time 319, horizon 79\n", - "adding: mem time241, current time 319, horizon 78\n", - "adding: mem time242, current time 319, horizon 77\n", - "adding: mem time243, current time 319, horizon 76\n", - "adding: mem time244, current time 319, horizon 75\n", - "adding: mem time245, current time 319, horizon 74\n", - "adding: mem time246, current time 319, horizon 73\n", - "adding: mem time247, current time 319, horizon 72\n", - "adding: mem time248, current time 319, horizon 71\n", - "adding: mem time249, current time 319, horizon 70\n", - "adding: mem time250, current time 319, horizon 69\n", - "adding: mem time251, current time 319, horizon 68\n", - "adding: mem time252, current time 319, horizon 67\n", - "adding: mem time253, current time 319, horizon 66\n", - "adding: mem time254, current time 319, horizon 65\n", - "adding: mem time255, current time 319, horizon 64\n", - "adding: mem time256, current time 319, horizon 63\n", - "adding: mem time257, current time 319, horizon 62\n", - "adding: mem time258, current time 319, horizon 61\n", - "adding: mem time259, current time 319, horizon 60\n", - "adding: mem time260, current time 319, horizon 59\n", - "adding: mem time261, current time 319, horizon 58\n", - "adding: mem time262, current time 319, horizon 57\n", - "adding: mem time263, current time 319, horizon 56\n", - "adding: mem time264, current time 319, horizon 55\n", - "adding: mem time265, current time 319, horizon 54\n", - "adding: mem time266, current time 319, horizon 53\n", - "adding: mem time267, current time 319, horizon 52\n", - "adding: mem time268, current time 319, horizon 51\n", - "adding: mem time269, current time 319, horizon 50\n", - "adding: mem time270, current time 319, horizon 49\n", - "adding: mem time271, current time 319, horizon 48\n", - "adding: mem time272, current time 319, horizon 47\n", - "adding: mem time273, current time 319, horizon 46\n", - "adding: mem time274, current time 319, horizon 45\n", - "adding: mem time275, current time 319, horizon 44\n", - "adding: mem time276, current time 319, horizon 43\n", - "adding: mem time277, current time 319, horizon 42\n", - "adding: mem time278, current time 319, horizon 41\n", - "adding: mem time279, current time 319, horizon 40\n", - "adding: mem time280, current time 319, horizon 39\n", - "adding: mem time281, current time 319, horizon 38\n", - "adding: mem time282, current time 319, horizon 37\n", - "adding: mem time283, current time 319, horizon 36\n", - "adding: mem time284, current time 319, horizon 35\n", - "adding: mem time285, current time 319, horizon 34\n", - "adding: mem time286, current time 319, horizon 33\n", - "adding: mem time287, current time 319, horizon 32\n", - "adding: mem time288, current time 319, horizon 31\n", - "adding: mem time289, current time 319, horizon 30\n", - "adding: mem time290, current time 319, horizon 29\n", - "adding: mem time291, current time 319, horizon 28\n", - "adding: mem time292, current time 319, horizon 27\n", - "adding: mem time293, current time 319, horizon 26\n", - "adding: mem time294, current time 319, horizon 25\n", - "adding: mem time295, current time 319, horizon 24\n", - "adding: mem time296, current time 319, horizon 23\n", - "adding: mem time297, current time 319, horizon 22\n", - "adding: mem time298, current time 319, horizon 21\n", - "adding: mem time299, current time 319, horizon 20\n", - "adding: mem time300, current time 319, horizon 19\n", - "adding: mem time301, current time 319, horizon 18\n", - "adding: mem time302, current time 319, horizon 17\n", - "adding: mem time303, current time 319, horizon 16\n", - "adding: mem time304, current time 319, horizon 15\n", - "adding: mem time305, current time 319, horizon 14\n", - "adding: mem time306, current time 319, horizon 13\n", - "adding: mem time307, current time 319, horizon 12\n", - "adding: mem time308, current time 319, horizon 11\n", - "adding: mem time309, current time 319, horizon 10\n", - "adding: mem time310, current time 319, horizon 9\n", - "adding: mem time311, current time 319, horizon 8\n", - "adding: mem time312, current time 319, horizon 7\n", - "adding: mem time313, current time 319, horizon 6\n", - "adding: mem time314, current time 319, horizon 5\n", - "adding: mem time315, current time 319, horizon 4\n", - "adding: mem time316, current time 319, horizon 3\n", - "adding: mem time317, current time 319, horizon 2\n", - "adding: mem time318, current time 319, horizon 1\n", - "adding: mem time200, current time 320, horizon 120\n", - "adding: mem time201, current time 320, horizon 119\n", - "adding: mem time202, current time 320, horizon 118\n", - "adding: mem time203, current time 320, horizon 117\n", - "adding: mem time204, current time 320, horizon 116\n", - "adding: mem time205, current time 320, horizon 115\n", - "adding: mem time206, current time 320, horizon 114\n", - "adding: mem time207, current time 320, horizon 113\n", - "adding: mem time208, current time 320, horizon 112\n", - "adding: mem time209, current time 320, horizon 111\n", - "adding: mem time210, current time 320, horizon 110\n", - "adding: mem time211, current time 320, horizon 109\n", - "adding: mem time212, current time 320, horizon 108\n", - "adding: mem time213, current time 320, horizon 107\n", - "adding: mem time214, current time 320, horizon 106\n", - "adding: mem time215, current time 320, horizon 105\n", - "adding: mem time216, current time 320, horizon 104\n", - "adding: mem time217, current time 320, horizon 103\n", - "adding: mem time218, current time 320, horizon 102\n", - "adding: mem time219, current time 320, horizon 101\n", - "adding: mem time220, current time 320, horizon 100\n", - "adding: mem time221, current time 320, horizon 99\n", - "adding: mem time222, current time 320, horizon 98\n", - "adding: mem time223, current time 320, horizon 97\n", - "adding: mem time224, current time 320, horizon 96\n", - "adding: mem time225, current time 320, horizon 95\n", - "adding: mem time226, current time 320, horizon 94\n", - "adding: mem time227, current time 320, horizon 93\n", - "adding: mem time228, current time 320, horizon 92\n", - "adding: mem time229, current time 320, horizon 91\n", - "adding: mem time230, current time 320, horizon 90\n", - "adding: mem time231, current time 320, horizon 89\n", - "adding: mem time232, current time 320, horizon 88\n", - "adding: mem time233, current time 320, horizon 87\n", - "adding: mem time234, current time 320, horizon 86\n", - "adding: mem time235, current time 320, horizon 85\n", - "adding: mem time236, current time 320, horizon 84\n", - "adding: mem time237, current time 320, horizon 83\n", - "adding: mem time238, current time 320, horizon 82\n", - "adding: mem time239, current time 320, horizon 81\n", - "adding: mem time240, current time 320, horizon 80\n", - "adding: mem time241, current time 320, horizon 79\n", - "adding: mem time242, current time 320, horizon 78\n", - "adding: mem time243, current time 320, horizon 77\n", - "adding: mem time244, current time 320, horizon 76\n", - "adding: mem time245, current time 320, horizon 75\n", - "adding: mem time246, current time 320, horizon 74\n", - "adding: mem time247, current time 320, horizon 73\n", - "adding: mem time248, current time 320, horizon 72\n", - "adding: mem time249, current time 320, horizon 71\n", - "adding: mem time250, current time 320, horizon 70\n", - "adding: mem time251, current time 320, horizon 69\n", - "adding: mem time252, current time 320, horizon 68\n", - "adding: mem time253, current time 320, horizon 67\n", - "adding: mem time254, current time 320, horizon 66\n", - "adding: mem time255, current time 320, horizon 65\n", - "adding: mem time256, current time 320, horizon 64\n", - "adding: mem time257, current time 320, horizon 63\n", - "adding: mem time258, current time 320, horizon 62\n", - "adding: mem time259, current time 320, horizon 61\n", - "adding: mem time260, current time 320, horizon 60\n", - "adding: mem time261, current time 320, horizon 59\n", - "adding: mem time262, current time 320, horizon 58\n", - "adding: mem time263, current time 320, horizon 57\n", - "adding: mem time264, current time 320, horizon 56\n", - "adding: mem time265, current time 320, horizon 55\n", - "adding: mem time266, current time 320, horizon 54\n", - "adding: mem time267, current time 320, horizon 53\n", - "adding: mem time268, current time 320, horizon 52\n", - "adding: mem time269, current time 320, horizon 51\n", - "adding: mem time270, current time 320, horizon 50\n", - "adding: mem time271, current time 320, horizon 49\n", - "adding: mem time272, current time 320, horizon 48\n", - "adding: mem time273, current time 320, horizon 47\n", - "adding: mem time274, current time 320, horizon 46\n", - "adding: mem time275, current time 320, horizon 45\n", - "adding: mem time276, current time 320, horizon 44\n", - "adding: mem time277, current time 320, horizon 43\n", - "adding: mem time278, current time 320, horizon 42\n", - "adding: mem time279, current time 320, horizon 41\n", - "adding: mem time280, current time 320, horizon 40\n", - "adding: mem time281, current time 320, horizon 39\n", - "adding: mem time282, current time 320, horizon 38\n", - "adding: mem time283, current time 320, horizon 37\n", - "adding: mem time284, current time 320, horizon 36\n", - "adding: mem time285, current time 320, horizon 35\n", - "adding: mem time286, current time 320, horizon 34\n", - "adding: mem time287, current time 320, horizon 33\n", - "adding: mem time288, current time 320, horizon 32\n", - "adding: mem time289, current time 320, horizon 31\n", - "adding: mem time290, current time 320, horizon 30\n", - "adding: mem time291, current time 320, horizon 29\n", - "adding: mem time292, current time 320, horizon 28\n", - "adding: mem time293, current time 320, horizon 27\n", - "adding: mem time294, current time 320, horizon 26\n", - "adding: mem time295, current time 320, horizon 25\n", - "adding: mem time296, current time 320, horizon 24\n", - "adding: mem time297, current time 320, horizon 23\n", - "adding: mem time298, current time 320, horizon 22\n", - "adding: mem time299, current time 320, horizon 21\n", - "adding: mem time300, current time 320, horizon 20\n", - "adding: mem time301, current time 320, horizon 19\n", - "adding: mem time302, current time 320, horizon 18\n", - "adding: mem time303, current time 320, horizon 17\n", - "adding: mem time304, current time 320, horizon 16\n", - "adding: mem time305, current time 320, horizon 15\n", - "adding: mem time306, current time 320, horizon 14\n", - "adding: mem time307, current time 320, horizon 13\n", - "adding: mem time308, current time 320, horizon 12\n", - "adding: mem time309, current time 320, horizon 11\n", - "adding: mem time310, current time 320, horizon 10\n", - "adding: mem time311, current time 320, horizon 9\n", - "adding: mem time312, current time 320, horizon 8\n", - "adding: mem time313, current time 320, horizon 7\n", - "adding: mem time314, current time 320, horizon 6\n", - "adding: mem time315, current time 320, horizon 5\n", - "adding: mem time316, current time 320, horizon 4\n", - "adding: mem time317, current time 320, horizon 3\n", - "adding: mem time318, current time 320, horizon 2\n", - "adding: mem time319, current time 320, horizon 1\n", - "adding: mem time200, current time 321, horizon 121\n", - "adding: mem time201, current time 321, horizon 120\n", - "adding: mem time202, current time 321, horizon 119\n", - "adding: mem time203, current time 321, horizon 118\n", - "adding: mem time204, current time 321, horizon 117\n", - "adding: mem time205, current time 321, horizon 116\n", - "adding: mem time206, current time 321, horizon 115\n", - "adding: mem time207, current time 321, horizon 114\n", - "adding: mem time208, current time 321, horizon 113\n", - "adding: mem time209, current time 321, horizon 112\n", - "adding: mem time210, current time 321, horizon 111\n", - "adding: mem time211, current time 321, horizon 110\n", - "adding: mem time212, current time 321, horizon 109\n", - "adding: mem time213, current time 321, horizon 108\n", - "adding: mem time214, current time 321, horizon 107\n", - "adding: mem time215, current time 321, horizon 106\n", - "adding: mem time216, current time 321, horizon 105\n", - "adding: mem time217, current time 321, horizon 104\n", - "adding: mem time218, current time 321, horizon 103\n", - "adding: mem time219, current time 321, horizon 102\n", - "adding: mem time220, current time 321, horizon 101\n", - "adding: mem time221, current time 321, horizon 100\n", - "adding: mem time222, current time 321, horizon 99\n", - "adding: mem time223, current time 321, horizon 98\n", - "adding: mem time224, current time 321, horizon 97\n", - "adding: mem time225, current time 321, horizon 96\n", - "adding: mem time226, current time 321, horizon 95\n", - "adding: mem time227, current time 321, horizon 94\n", - "adding: mem time228, current time 321, horizon 93\n", - "adding: mem time229, current time 321, horizon 92\n", - "adding: mem time230, current time 321, horizon 91\n", - "adding: mem time231, current time 321, horizon 90\n", - "adding: mem time232, current time 321, horizon 89\n", - "adding: mem time233, current time 321, horizon 88\n", - "adding: mem time234, current time 321, horizon 87\n", - "adding: mem time235, current time 321, horizon 86\n", - "adding: mem time236, current time 321, horizon 85\n", - "adding: mem time237, current time 321, horizon 84\n", - "adding: mem time238, current time 321, horizon 83\n", - "adding: mem time239, current time 321, horizon 82\n", - "adding: mem time240, current time 321, horizon 81\n", - "adding: mem time241, current time 321, horizon 80\n", - "adding: mem time242, current time 321, horizon 79\n", - "adding: mem time243, current time 321, horizon 78\n", - "adding: mem time244, current time 321, horizon 77\n", - "adding: mem time245, current time 321, horizon 76\n", - "adding: mem time246, current time 321, horizon 75\n", - "adding: mem time247, current time 321, horizon 74\n", - "adding: mem time248, current time 321, horizon 73\n", - "adding: mem time249, current time 321, horizon 72\n", - "adding: mem time250, current time 321, horizon 71\n", - "adding: mem time251, current time 321, horizon 70\n", - "adding: mem time252, current time 321, horizon 69\n", - "adding: mem time253, current time 321, horizon 68\n", - "adding: mem time254, current time 321, horizon 67\n", - "adding: mem time255, current time 321, horizon 66\n", - "adding: mem time256, current time 321, horizon 65\n", - "adding: mem time257, current time 321, horizon 64\n", - "adding: mem time258, current time 321, horizon 63\n", - "adding: mem time259, current time 321, horizon 62\n", - "adding: mem time260, current time 321, horizon 61\n", - "adding: mem time261, current time 321, horizon 60\n", - "adding: mem time262, current time 321, horizon 59\n", - "adding: mem time263, current time 321, horizon 58\n", - "adding: mem time264, current time 321, horizon 57\n", - "adding: mem time265, current time 321, horizon 56\n", - "adding: mem time266, current time 321, horizon 55\n", - "adding: mem time267, current time 321, horizon 54\n", - "adding: mem time268, current time 321, horizon 53\n", - "adding: mem time269, current time 321, horizon 52\n", - "adding: mem time270, current time 321, horizon 51\n", - "adding: mem time271, current time 321, horizon 50\n", - "adding: mem time272, current time 321, horizon 49\n", - "adding: mem time273, current time 321, horizon 48\n", - "adding: mem time274, current time 321, horizon 47\n", - "adding: mem time275, current time 321, horizon 46\n", - "adding: mem time276, current time 321, horizon 45\n", - "adding: mem time277, current time 321, horizon 44\n", - "adding: mem time278, current time 321, horizon 43\n", - "adding: mem time279, current time 321, horizon 42\n", - "adding: mem time280, current time 321, horizon 41\n", - "adding: mem time281, current time 321, horizon 40\n", - "adding: mem time282, current time 321, horizon 39\n", - "adding: mem time283, current time 321, horizon 38\n", - "adding: mem time284, current time 321, horizon 37\n", - "adding: mem time285, current time 321, horizon 36\n", - "adding: mem time286, current time 321, horizon 35\n", - "adding: mem time287, current time 321, horizon 34\n", - "adding: mem time288, current time 321, horizon 33\n", - "adding: mem time289, current time 321, horizon 32\n", - "adding: mem time290, current time 321, horizon 31\n", - "adding: mem time291, current time 321, horizon 30\n", - "adding: mem time292, current time 321, horizon 29\n", - "adding: mem time293, current time 321, horizon 28\n", - "adding: mem time294, current time 321, horizon 27\n", - "adding: mem time295, current time 321, horizon 26\n", - "adding: mem time296, current time 321, horizon 25\n", - "adding: mem time297, current time 321, horizon 24\n", - "adding: mem time298, current time 321, horizon 23\n", - "adding: mem time299, current time 321, horizon 22\n", - "adding: mem time300, current time 321, horizon 21\n", - "adding: mem time301, current time 321, horizon 20\n", - "adding: mem time302, current time 321, horizon 19\n", - "adding: mem time303, current time 321, horizon 18\n", - "adding: mem time304, current time 321, horizon 17\n", - "adding: mem time305, current time 321, horizon 16\n", - "adding: mem time306, current time 321, horizon 15\n", - "adding: mem time307, current time 321, horizon 14\n", - "adding: mem time308, current time 321, horizon 13\n", - "adding: mem time309, current time 321, horizon 12\n", - "adding: mem time310, current time 321, horizon 11\n", - "adding: mem time311, current time 321, horizon 10\n", - "adding: mem time312, current time 321, horizon 9\n", - "adding: mem time313, current time 321, horizon 8\n", - "adding: mem time314, current time 321, horizon 7\n", - "adding: mem time315, current time 321, horizon 6\n", - "adding: mem time316, current time 321, horizon 5\n", - "adding: mem time317, current time 321, horizon 4\n", - "adding: mem time318, current time 321, horizon 3\n", - "adding: mem time319, current time 321, horizon 2\n", - "adding: mem time320, current time 321, horizon 1\n", - "adding: mem time200, current time 322, horizon 122\n", - "adding: mem time201, current time 322, horizon 121\n", - "adding: mem time202, current time 322, horizon 120\n", - "adding: mem time203, current time 322, horizon 119\n", - "adding: mem time204, current time 322, horizon 118\n", - "adding: mem time205, current time 322, horizon 117\n", - "adding: mem time206, current time 322, horizon 116\n", - "adding: mem time207, current time 322, horizon 115\n", - "adding: mem time208, current time 322, horizon 114\n", - "adding: mem time209, current time 322, horizon 113\n", - "adding: mem time210, current time 322, horizon 112\n", - "adding: mem time211, current time 322, horizon 111\n", - "adding: mem time212, current time 322, horizon 110\n", - "adding: mem time213, current time 322, horizon 109\n", - "adding: mem time214, current time 322, horizon 108\n", - "adding: mem time215, current time 322, horizon 107\n", - "adding: mem time216, current time 322, horizon 106\n", - "adding: mem time217, current time 322, horizon 105\n", - "adding: mem time218, current time 322, horizon 104\n", - "adding: mem time219, current time 322, horizon 103\n", - "adding: mem time220, current time 322, horizon 102\n", - "adding: mem time221, current time 322, horizon 101\n", - "adding: mem time222, current time 322, horizon 100\n", - "adding: mem time223, current time 322, horizon 99\n", - "adding: mem time224, current time 322, horizon 98\n", - "adding: mem time225, current time 322, horizon 97\n", - "adding: mem time226, current time 322, horizon 96\n", - "adding: mem time227, current time 322, horizon 95\n", - "adding: mem time228, current time 322, horizon 94\n", - "adding: mem time229, current time 322, horizon 93\n", - "adding: mem time230, current time 322, horizon 92\n", - "adding: mem time231, current time 322, horizon 91\n", - "adding: mem time232, current time 322, horizon 90\n", - "adding: mem time233, current time 322, horizon 89\n", - "adding: mem time234, current time 322, horizon 88\n", - "adding: mem time235, current time 322, horizon 87\n", - "adding: mem time236, current time 322, horizon 86\n", - "adding: mem time237, current time 322, horizon 85\n", - "adding: mem time238, current time 322, horizon 84\n", - "adding: mem time239, current time 322, horizon 83\n", - "adding: mem time240, current time 322, horizon 82\n", - "adding: mem time241, current time 322, horizon 81\n", - "adding: mem time242, current time 322, horizon 80\n", - "adding: mem time243, current time 322, horizon 79\n", - "adding: mem time244, current time 322, horizon 78\n", - "adding: mem time245, current time 322, horizon 77\n", - "adding: mem time246, current time 322, horizon 76\n", - "adding: mem time247, current time 322, horizon 75\n", - "adding: mem time248, current time 322, horizon 74\n", - "adding: mem time249, current time 322, horizon 73\n", - "adding: mem time250, current time 322, horizon 72\n", - "adding: mem time251, current time 322, horizon 71\n", - "adding: mem time252, current time 322, horizon 70\n", - "adding: mem time253, current time 322, horizon 69\n", - "adding: mem time254, current time 322, horizon 68\n", - "adding: mem time255, current time 322, horizon 67\n", - "adding: mem time256, current time 322, horizon 66\n", - "adding: mem time257, current time 322, horizon 65\n", - "adding: mem time258, current time 322, horizon 64\n", - "adding: mem time259, current time 322, horizon 63\n", - "adding: mem time260, current time 322, horizon 62\n", - "adding: mem time261, current time 322, horizon 61\n", - "adding: mem time262, current time 322, horizon 60\n", - "adding: mem time263, current time 322, horizon 59\n", - "adding: mem time264, current time 322, horizon 58\n", - "adding: mem time265, current time 322, horizon 57\n", - "adding: mem time266, current time 322, horizon 56\n", - "adding: mem time267, current time 322, horizon 55\n", - "adding: mem time268, current time 322, horizon 54\n", - "adding: mem time269, current time 322, horizon 53\n", - "adding: mem time270, current time 322, horizon 52\n", - "adding: mem time271, current time 322, horizon 51\n", - "adding: mem time272, current time 322, horizon 50\n", - "adding: mem time273, current time 322, horizon 49\n", - "adding: mem time274, current time 322, horizon 48\n", - "adding: mem time275, current time 322, horizon 47\n", - "adding: mem time276, current time 322, horizon 46\n", - "adding: mem time277, current time 322, horizon 45\n", - "adding: mem time278, current time 322, horizon 44\n", - "adding: mem time279, current time 322, horizon 43\n", - "adding: mem time280, current time 322, horizon 42\n", - "adding: mem time281, current time 322, horizon 41\n", - "adding: mem time282, current time 322, horizon 40\n", - "adding: mem time283, current time 322, horizon 39\n", - "adding: mem time284, current time 322, horizon 38\n", - "adding: mem time285, current time 322, horizon 37\n", - "adding: mem time286, current time 322, horizon 36\n", - "adding: mem time287, current time 322, horizon 35\n", - "adding: mem time288, current time 322, horizon 34\n", - "adding: mem time289, current time 322, horizon 33\n", - "adding: mem time290, current time 322, horizon 32\n", - "adding: mem time291, current time 322, horizon 31\n", - "adding: mem time292, current time 322, horizon 30\n", - "adding: mem time293, current time 322, horizon 29\n", - "adding: mem time294, current time 322, horizon 28\n", - "adding: mem time295, current time 322, horizon 27\n", - "adding: mem time296, current time 322, horizon 26\n", - "adding: mem time297, current time 322, horizon 25\n", - "adding: mem time298, current time 322, horizon 24\n", - "adding: mem time299, current time 322, horizon 23\n", - "adding: mem time300, current time 322, horizon 22\n", - "adding: mem time301, current time 322, horizon 21\n", - "adding: mem time302, current time 322, horizon 20\n", - "adding: mem time303, current time 322, horizon 19\n", - "adding: mem time304, current time 322, horizon 18\n", - "adding: mem time305, current time 322, horizon 17\n", - "adding: mem time306, current time 322, horizon 16\n", - "adding: mem time307, current time 322, horizon 15\n", - "adding: mem time308, current time 322, horizon 14\n", - "adding: mem time309, current time 322, horizon 13\n", - "adding: mem time310, current time 322, horizon 12\n", - "adding: mem time311, current time 322, horizon 11\n", - "adding: mem time312, current time 322, horizon 10\n", - "adding: mem time313, current time 322, horizon 9\n", - "adding: mem time314, current time 322, horizon 8\n", - "adding: mem time315, current time 322, horizon 7\n", - "adding: mem time316, current time 322, horizon 6\n", - "adding: mem time317, current time 322, horizon 5\n", - "adding: mem time318, current time 322, horizon 4\n", - "adding: mem time319, current time 322, horizon 3\n", - "adding: mem time320, current time 322, horizon 2\n", - "adding: mem time321, current time 322, horizon 1\n", - "adding: mem time200, current time 323, horizon 123\n", - "adding: mem time201, current time 323, horizon 122\n", - "adding: mem time202, current time 323, horizon 121\n", - "adding: mem time203, current time 323, horizon 120\n", - "adding: mem time204, current time 323, horizon 119\n", - "adding: mem time205, current time 323, horizon 118\n", - "adding: mem time206, current time 323, horizon 117\n", - "adding: mem time207, current time 323, horizon 116\n", - "adding: mem time208, current time 323, horizon 115\n", - "adding: mem time209, current time 323, horizon 114\n", - "adding: mem time210, current time 323, horizon 113\n", - "adding: mem time211, current time 323, horizon 112\n", - "adding: mem time212, current time 323, horizon 111\n", - "adding: mem time213, current time 323, horizon 110\n", - "adding: mem time214, current time 323, horizon 109\n", - "adding: mem time215, current time 323, horizon 108\n", - "adding: mem time216, current time 323, horizon 107\n", - "adding: mem time217, current time 323, horizon 106\n", - "adding: mem time218, current time 323, horizon 105\n", - "adding: mem time219, current time 323, horizon 104\n", - "adding: mem time220, current time 323, horizon 103\n", - "adding: mem time221, current time 323, horizon 102\n", - "adding: mem time222, current time 323, horizon 101\n", - "adding: mem time223, current time 323, horizon 100\n", - "adding: mem time224, current time 323, horizon 99\n", - "adding: mem time225, current time 323, horizon 98\n", - "adding: mem time226, current time 323, horizon 97\n", - "adding: mem time227, current time 323, horizon 96\n", - "adding: mem time228, current time 323, horizon 95\n", - "adding: mem time229, current time 323, horizon 94\n", - "adding: mem time230, current time 323, horizon 93\n", - "adding: mem time231, current time 323, horizon 92\n", - "adding: mem time232, current time 323, horizon 91\n", - "adding: mem time233, current time 323, horizon 90\n", - "adding: mem time234, current time 323, horizon 89\n", - "adding: mem time235, current time 323, horizon 88\n", - "adding: mem time236, current time 323, horizon 87\n", - "adding: mem time237, current time 323, horizon 86\n", - "adding: mem time238, current time 323, horizon 85\n", - "adding: mem time239, current time 323, horizon 84\n", - "adding: mem time240, current time 323, horizon 83\n", - "adding: mem time241, current time 323, horizon 82\n", - "adding: mem time242, current time 323, horizon 81\n", - "adding: mem time243, current time 323, horizon 80\n", - "adding: mem time244, current time 323, horizon 79\n", - "adding: mem time245, current time 323, horizon 78\n", - "adding: mem time246, current time 323, horizon 77\n", - "adding: mem time247, current time 323, horizon 76\n", - "adding: mem time248, current time 323, horizon 75\n", - "adding: mem time249, current time 323, horizon 74\n", - "adding: mem time250, current time 323, horizon 73\n", - "adding: mem time251, current time 323, horizon 72\n", - "adding: mem time252, current time 323, horizon 71\n", - "adding: mem time253, current time 323, horizon 70\n", - "adding: mem time254, current time 323, horizon 69\n", - "adding: mem time255, current time 323, horizon 68\n", - "adding: mem time256, current time 323, horizon 67\n", - "adding: mem time257, current time 323, horizon 66\n", - "adding: mem time258, current time 323, horizon 65\n", - "adding: mem time259, current time 323, horizon 64\n", - "adding: mem time260, current time 323, horizon 63\n", - "adding: mem time261, current time 323, horizon 62\n", - "adding: mem time262, current time 323, horizon 61\n", - "adding: mem time263, current time 323, horizon 60\n", - "adding: mem time264, current time 323, horizon 59\n", - "adding: mem time265, current time 323, horizon 58\n", - "adding: mem time266, current time 323, horizon 57\n", - "adding: mem time267, current time 323, horizon 56\n", - "adding: mem time268, current time 323, horizon 55\n", - "adding: mem time269, current time 323, horizon 54\n", - "adding: mem time270, current time 323, horizon 53\n", - "adding: mem time271, current time 323, horizon 52\n", - "adding: mem time272, current time 323, horizon 51\n", - "adding: mem time273, current time 323, horizon 50\n", - "adding: mem time274, current time 323, horizon 49\n", - "adding: mem time275, current time 323, horizon 48\n", - "adding: mem time276, current time 323, horizon 47\n", - "adding: mem time277, current time 323, horizon 46\n", - "adding: mem time278, current time 323, horizon 45\n", - "adding: mem time279, current time 323, horizon 44\n", - "adding: mem time280, current time 323, horizon 43\n", - "adding: mem time281, current time 323, horizon 42\n", - "adding: mem time282, current time 323, horizon 41\n", - "adding: mem time283, current time 323, horizon 40\n", - "adding: mem time284, current time 323, horizon 39\n", - "adding: mem time285, current time 323, horizon 38\n", - "adding: mem time286, current time 323, horizon 37\n", - "adding: mem time287, current time 323, horizon 36\n", - "adding: mem time288, current time 323, horizon 35\n", - "adding: mem time289, current time 323, horizon 34\n", - "adding: mem time290, current time 323, horizon 33\n", - "adding: mem time291, current time 323, horizon 32\n", - "adding: mem time292, current time 323, horizon 31\n", - "adding: mem time293, current time 323, horizon 30\n", - "adding: mem time294, current time 323, horizon 29\n", - "adding: mem time295, current time 323, horizon 28\n", - "adding: mem time296, current time 323, horizon 27\n", - "adding: mem time297, current time 323, horizon 26\n", - "adding: mem time298, current time 323, horizon 25\n", - "adding: mem time299, current time 323, horizon 24\n", - "adding: mem time300, current time 323, horizon 23\n", - "adding: mem time301, current time 323, horizon 22\n", - "adding: mem time302, current time 323, horizon 21\n", - "adding: mem time303, current time 323, horizon 20\n", - "adding: mem time304, current time 323, horizon 19\n", - "adding: mem time305, current time 323, horizon 18\n", - "adding: mem time306, current time 323, horizon 17\n", - "adding: mem time307, current time 323, horizon 16\n", - "adding: mem time308, current time 323, horizon 15\n", - "adding: mem time309, current time 323, horizon 14\n", - "adding: mem time310, current time 323, horizon 13\n", - "adding: mem time311, current time 323, horizon 12\n", - "adding: mem time312, current time 323, horizon 11\n", - "adding: mem time313, current time 323, horizon 10\n", - "adding: mem time314, current time 323, horizon 9\n", - "adding: mem time315, current time 323, horizon 8\n", - "adding: mem time316, current time 323, horizon 7\n", - "adding: mem time317, current time 323, horizon 6\n", - "adding: mem time318, current time 323, horizon 5\n", - "adding: mem time319, current time 323, horizon 4\n", - "adding: mem time320, current time 323, horizon 3\n", - "adding: mem time321, current time 323, horizon 2\n", - "adding: mem time322, current time 323, horizon 1\n", - "adding: mem time200, current time 324, horizon 124\n", - "adding: mem time201, current time 324, horizon 123\n", - "adding: mem time202, current time 324, horizon 122\n", - "adding: mem time203, current time 324, horizon 121\n", - "adding: mem time204, current time 324, horizon 120\n", - "adding: mem time205, current time 324, horizon 119\n", - "adding: mem time206, current time 324, horizon 118\n", - "adding: mem time207, current time 324, horizon 117\n", - "adding: mem time208, current time 324, horizon 116\n", - "adding: mem time209, current time 324, horizon 115\n", - "adding: mem time210, current time 324, horizon 114\n", - "adding: mem time211, current time 324, horizon 113\n", - "adding: mem time212, current time 324, horizon 112\n", - "adding: mem time213, current time 324, horizon 111\n", - "adding: mem time214, current time 324, horizon 110\n", - "adding: mem time215, current time 324, horizon 109\n", - "adding: mem time216, current time 324, horizon 108\n", - "adding: mem time217, current time 324, horizon 107\n", - "adding: mem time218, current time 324, horizon 106\n", - "adding: mem time219, current time 324, horizon 105\n", - "adding: mem time220, current time 324, horizon 104\n", - "adding: mem time221, current time 324, horizon 103\n", - "adding: mem time222, current time 324, horizon 102\n", - "adding: mem time223, current time 324, horizon 101\n", - "adding: mem time224, current time 324, horizon 100\n", - "adding: mem time225, current time 324, horizon 99\n", - "adding: mem time226, current time 324, horizon 98\n", - "adding: mem time227, current time 324, horizon 97\n", - "adding: mem time228, current time 324, horizon 96\n", - "adding: mem time229, current time 324, horizon 95\n", - "adding: mem time230, current time 324, horizon 94\n", - "adding: mem time231, current time 324, horizon 93\n", - "adding: mem time232, current time 324, horizon 92\n", - "adding: mem time233, current time 324, horizon 91\n", - "adding: mem time234, current time 324, horizon 90\n", - "adding: mem time235, current time 324, horizon 89\n", - "adding: mem time236, current time 324, horizon 88\n", - "adding: mem time237, current time 324, horizon 87\n", - "adding: mem time238, current time 324, horizon 86\n", - "adding: mem time239, current time 324, horizon 85\n", - "adding: mem time240, current time 324, horizon 84\n", - "adding: mem time241, current time 324, horizon 83\n", - "adding: mem time242, current time 324, horizon 82\n", - "adding: mem time243, current time 324, horizon 81\n", - "adding: mem time244, current time 324, horizon 80\n", - "adding: mem time245, current time 324, horizon 79\n", - "adding: mem time246, current time 324, horizon 78\n", - "adding: mem time247, current time 324, horizon 77\n", - "adding: mem time248, current time 324, horizon 76\n", - "adding: mem time249, current time 324, horizon 75\n", - "adding: mem time250, current time 324, horizon 74\n", - "adding: mem time251, current time 324, horizon 73\n", - "adding: mem time252, current time 324, horizon 72\n", - "adding: mem time253, current time 324, horizon 71\n", - "adding: mem time254, current time 324, horizon 70\n", - "adding: mem time255, current time 324, horizon 69\n", - "adding: mem time256, current time 324, horizon 68\n", - "adding: mem time257, current time 324, horizon 67\n", - "adding: mem time258, current time 324, horizon 66\n", - "adding: mem time259, current time 324, horizon 65\n", - "adding: mem time260, current time 324, horizon 64\n", - "adding: mem time261, current time 324, horizon 63\n", - "adding: mem time262, current time 324, horizon 62\n", - "adding: mem time263, current time 324, horizon 61\n", - "adding: mem time264, current time 324, horizon 60\n", - "adding: mem time265, current time 324, horizon 59\n", - "adding: mem time266, current time 324, horizon 58\n", - "adding: mem time267, current time 324, horizon 57\n", - "adding: mem time268, current time 324, horizon 56\n", - "adding: mem time269, current time 324, horizon 55\n", - "adding: mem time270, current time 324, horizon 54\n", - "adding: mem time271, current time 324, horizon 53\n", - "adding: mem time272, current time 324, horizon 52\n", - "adding: mem time273, current time 324, horizon 51\n", - "adding: mem time274, current time 324, horizon 50\n", - "adding: mem time275, current time 324, horizon 49\n", - "adding: mem time276, current time 324, horizon 48\n", - "adding: mem time277, current time 324, horizon 47\n", - "adding: mem time278, current time 324, horizon 46\n", - "adding: mem time279, current time 324, horizon 45\n", - "adding: mem time280, current time 324, horizon 44\n", - "adding: mem time281, current time 324, horizon 43\n", - "adding: mem time282, current time 324, horizon 42\n", - "adding: mem time283, current time 324, horizon 41\n", - "adding: mem time284, current time 324, horizon 40\n", - "adding: mem time285, current time 324, horizon 39\n", - "adding: mem time286, current time 324, horizon 38\n", - "adding: mem time287, current time 324, horizon 37\n", - "adding: mem time288, current time 324, horizon 36\n", - "adding: mem time289, current time 324, horizon 35\n", - "adding: mem time290, current time 324, horizon 34\n", - "adding: mem time291, current time 324, horizon 33\n", - "adding: mem time292, current time 324, horizon 32\n", - "adding: mem time293, current time 324, horizon 31\n", - "adding: mem time294, current time 324, horizon 30\n", - "adding: mem time295, current time 324, horizon 29\n", - "adding: mem time296, current time 324, horizon 28\n", - "adding: mem time297, current time 324, horizon 27\n", - "adding: mem time298, current time 324, horizon 26\n", - "adding: mem time299, current time 324, horizon 25\n", - "adding: mem time300, current time 324, horizon 24\n", - "adding: mem time301, current time 324, horizon 23\n", - "adding: mem time302, current time 324, horizon 22\n", - "adding: mem time303, current time 324, horizon 21\n", - "adding: mem time304, current time 324, horizon 20\n", - "adding: mem time305, current time 324, horizon 19\n", - "adding: mem time306, current time 324, horizon 18\n", - "adding: mem time307, current time 324, horizon 17\n", - "adding: mem time308, current time 324, horizon 16\n", - "adding: mem time309, current time 324, horizon 15\n", - "adding: mem time310, current time 324, horizon 14\n", - "adding: mem time311, current time 324, horizon 13\n", - "adding: mem time312, current time 324, horizon 12\n", - "adding: mem time313, current time 324, horizon 11\n", - "adding: mem time314, current time 324, horizon 10\n", - "adding: mem time315, current time 324, horizon 9\n", - "adding: mem time316, current time 324, horizon 8\n", - "adding: mem time317, current time 324, horizon 7\n", - "adding: mem time318, current time 324, horizon 6\n", - "adding: mem time319, current time 324, horizon 5\n", - "adding: mem time320, current time 324, horizon 4\n", - "adding: mem time321, current time 324, horizon 3\n", - "adding: mem time322, current time 324, horizon 2\n", - "adding: mem time323, current time 324, horizon 1\n", - "adding: mem time200, current time 325, horizon 125\n", - "adding: mem time201, current time 325, horizon 124\n", - "adding: mem time202, current time 325, horizon 123\n", - "adding: mem time203, current time 325, horizon 122\n", - "adding: mem time204, current time 325, horizon 121\n", - "adding: mem time205, current time 325, horizon 120\n", - "adding: mem time206, current time 325, horizon 119\n", - "adding: mem time207, current time 325, horizon 118\n", - "adding: mem time208, current time 325, horizon 117\n", - "adding: mem time209, current time 325, horizon 116\n", - "adding: mem time210, current time 325, horizon 115\n", - "adding: mem time211, current time 325, horizon 114\n", - "adding: mem time212, current time 325, horizon 113\n", - "adding: mem time213, current time 325, horizon 112\n", - "adding: mem time214, current time 325, horizon 111\n", - "adding: mem time215, current time 325, horizon 110\n", - "adding: mem time216, current time 325, horizon 109\n", - "adding: mem time217, current time 325, horizon 108\n", - "adding: mem time218, current time 325, horizon 107\n", - "adding: mem time219, current time 325, horizon 106\n", - "adding: mem time220, current time 325, horizon 105\n", - "adding: mem time221, current time 325, horizon 104\n", - "adding: mem time222, current time 325, horizon 103\n", - "adding: mem time223, current time 325, horizon 102\n", - "adding: mem time224, current time 325, horizon 101\n", - "adding: mem time225, current time 325, horizon 100\n", - "adding: mem time226, current time 325, horizon 99\n", - "adding: mem time227, current time 325, horizon 98\n", - "adding: mem time228, current time 325, horizon 97\n", - "adding: mem time229, current time 325, horizon 96\n", - "adding: mem time230, current time 325, horizon 95\n", - "adding: mem time231, current time 325, horizon 94\n", - "adding: mem time232, current time 325, horizon 93\n", - "adding: mem time233, current time 325, horizon 92\n", - "adding: mem time234, current time 325, horizon 91\n", - "adding: mem time235, current time 325, horizon 90\n", - "adding: mem time236, current time 325, horizon 89\n", - "adding: mem time237, current time 325, horizon 88\n", - "adding: mem time238, current time 325, horizon 87\n", - "adding: mem time239, current time 325, horizon 86\n", - "adding: mem time240, current time 325, horizon 85\n", - "adding: mem time241, current time 325, horizon 84\n", - "adding: mem time242, current time 325, horizon 83\n", - "adding: mem time243, current time 325, horizon 82\n", - "adding: mem time244, current time 325, horizon 81\n", - "adding: mem time245, current time 325, horizon 80\n", - "adding: mem time246, current time 325, horizon 79\n", - "adding: mem time247, current time 325, horizon 78\n", - "adding: mem time248, current time 325, horizon 77\n", - "adding: mem time249, current time 325, horizon 76\n", - "adding: mem time250, current time 325, horizon 75\n", - "adding: mem time251, current time 325, horizon 74\n", - "adding: mem time252, current time 325, horizon 73\n", - "adding: mem time253, current time 325, horizon 72\n", - "adding: mem time254, current time 325, horizon 71\n", - "adding: mem time255, current time 325, horizon 70\n", - "adding: mem time256, current time 325, horizon 69\n", - "adding: mem time257, current time 325, horizon 68\n", - "adding: mem time258, current time 325, horizon 67\n", - "adding: mem time259, current time 325, horizon 66\n", - "adding: mem time260, current time 325, horizon 65\n", - "adding: mem time261, current time 325, horizon 64\n", - "adding: mem time262, current time 325, horizon 63\n", - "adding: mem time263, current time 325, horizon 62\n", - "adding: mem time264, current time 325, horizon 61\n", - "adding: mem time265, current time 325, horizon 60\n", - "adding: mem time266, current time 325, horizon 59\n", - "adding: mem time267, current time 325, horizon 58\n", - "adding: mem time268, current time 325, horizon 57\n", - "adding: mem time269, current time 325, horizon 56\n", - "adding: mem time270, current time 325, horizon 55\n", - "adding: mem time271, current time 325, horizon 54\n", - "adding: mem time272, current time 325, horizon 53\n", - "adding: mem time273, current time 325, horizon 52\n", - "adding: mem time274, current time 325, horizon 51\n", - "adding: mem time275, current time 325, horizon 50\n", - "adding: mem time276, current time 325, horizon 49\n", - "adding: mem time277, current time 325, horizon 48\n", - "adding: mem time278, current time 325, horizon 47\n", - "adding: mem time279, current time 325, horizon 46\n", - "adding: mem time280, current time 325, horizon 45\n", - "adding: mem time281, current time 325, horizon 44\n", - "adding: mem time282, current time 325, horizon 43\n", - "adding: mem time283, current time 325, horizon 42\n", - "adding: mem time284, current time 325, horizon 41\n", - "adding: mem time285, current time 325, horizon 40\n", - "adding: mem time286, current time 325, horizon 39\n", - "adding: mem time287, current time 325, horizon 38\n", - "adding: mem time288, current time 325, horizon 37\n", - "adding: mem time289, current time 325, horizon 36\n", - "adding: mem time290, current time 325, horizon 35\n", - "adding: mem time291, current time 325, horizon 34\n", - "adding: mem time292, current time 325, horizon 33\n", - "adding: mem time293, current time 325, horizon 32\n", - "adding: mem time294, current time 325, horizon 31\n", - "adding: mem time295, current time 325, horizon 30\n", - "adding: mem time296, current time 325, horizon 29\n", - "adding: mem time297, current time 325, horizon 28\n", - "adding: mem time298, current time 325, horizon 27\n", - "adding: mem time299, current time 325, horizon 26\n", - "adding: mem time300, current time 325, horizon 25\n", - "adding: mem time301, current time 325, horizon 24\n", - "adding: mem time302, current time 325, horizon 23\n", - "adding: mem time303, current time 325, horizon 22\n", - "adding: mem time304, current time 325, horizon 21\n", - "adding: mem time305, current time 325, horizon 20\n", - "adding: mem time306, current time 325, horizon 19\n", - "adding: mem time307, current time 325, horizon 18\n", - "adding: mem time308, current time 325, horizon 17\n", - "adding: mem time309, current time 325, horizon 16\n", - "adding: mem time310, current time 325, horizon 15\n", - "adding: mem time311, current time 325, horizon 14\n", - "adding: mem time312, current time 325, horizon 13\n", - "adding: mem time313, current time 325, horizon 12\n", - "adding: mem time314, current time 325, horizon 11\n", - "adding: mem time315, current time 325, horizon 10\n", - "adding: mem time316, current time 325, horizon 9\n", - "adding: mem time317, current time 325, horizon 8\n", - "adding: mem time318, current time 325, horizon 7\n", - "adding: mem time319, current time 325, horizon 6\n", - "adding: mem time320, current time 325, horizon 5\n", - "adding: mem time321, current time 325, horizon 4\n", - "adding: mem time322, current time 325, horizon 3\n", - "adding: mem time323, current time 325, horizon 2\n", - "adding: mem time324, current time 325, horizon 1\n", - "adding: mem time200, current time 326, horizon 126\n", - "adding: mem time201, current time 326, horizon 125\n", - "adding: mem time202, current time 326, horizon 124\n", - "adding: mem time203, current time 326, horizon 123\n", - "adding: mem time204, current time 326, horizon 122\n", - "adding: mem time205, current time 326, horizon 121\n", - "adding: mem time206, current time 326, horizon 120\n", - "adding: mem time207, current time 326, horizon 119\n", - "adding: mem time208, current time 326, horizon 118\n", - "adding: mem time209, current time 326, horizon 117\n", - "adding: mem time210, current time 326, horizon 116\n", - "adding: mem time211, current time 326, horizon 115\n", - "adding: mem time212, current time 326, horizon 114\n", - "adding: mem time213, current time 326, horizon 113\n", - "adding: mem time214, current time 326, horizon 112\n", - "adding: mem time215, current time 326, horizon 111\n", - "adding: mem time216, current time 326, horizon 110\n", - "adding: mem time217, current time 326, horizon 109\n", - "adding: mem time218, current time 326, horizon 108\n", - "adding: mem time219, current time 326, horizon 107\n", - "adding: mem time220, current time 326, horizon 106\n", - "adding: mem time221, current time 326, horizon 105\n", - "adding: mem time222, current time 326, horizon 104\n", - "adding: mem time223, current time 326, horizon 103\n", - "adding: mem time224, current time 326, horizon 102\n", - "adding: mem time225, current time 326, horizon 101\n", - "adding: mem time226, current time 326, horizon 100\n", - "adding: mem time227, current time 326, horizon 99\n", - "adding: mem time228, current time 326, horizon 98\n", - "adding: mem time229, current time 326, horizon 97\n", - "adding: mem time230, current time 326, horizon 96\n", - "adding: mem time231, current time 326, horizon 95\n", - "adding: mem time232, current time 326, horizon 94\n", - "adding: mem time233, current time 326, horizon 93\n", - "adding: mem time234, current time 326, horizon 92\n", - "adding: mem time235, current time 326, horizon 91\n", - "adding: mem time236, current time 326, horizon 90\n", - "adding: mem time237, current time 326, horizon 89\n", - "adding: mem time238, current time 326, horizon 88\n", - "adding: mem time239, current time 326, horizon 87\n", - "adding: mem time240, current time 326, horizon 86\n", - "adding: mem time241, current time 326, horizon 85\n", - "adding: mem time242, current time 326, horizon 84\n", - "adding: mem time243, current time 326, horizon 83\n", - "adding: mem time244, current time 326, horizon 82\n", - "adding: mem time245, current time 326, horizon 81\n", - "adding: mem time246, current time 326, horizon 80\n", - "adding: mem time247, current time 326, horizon 79\n", - "adding: mem time248, current time 326, horizon 78\n", - "adding: mem time249, current time 326, horizon 77\n", - "adding: mem time250, current time 326, horizon 76\n", - "adding: mem time251, current time 326, horizon 75\n", - "adding: mem time252, current time 326, horizon 74\n", - "adding: mem time253, current time 326, horizon 73\n", - "adding: mem time254, current time 326, horizon 72\n", - "adding: mem time255, current time 326, horizon 71\n", - "adding: mem time256, current time 326, horizon 70\n", - "adding: mem time257, current time 326, horizon 69\n", - "adding: mem time258, current time 326, horizon 68\n", - "adding: mem time259, current time 326, horizon 67\n", - "adding: mem time260, current time 326, horizon 66\n", - "adding: mem time261, current time 326, horizon 65\n", - "adding: mem time262, current time 326, horizon 64\n", - "adding: mem time263, current time 326, horizon 63\n", - "adding: mem time264, current time 326, horizon 62\n", - "adding: mem time265, current time 326, horizon 61\n", - "adding: mem time266, current time 326, horizon 60\n", - "adding: mem time267, current time 326, horizon 59\n", - "adding: mem time268, current time 326, horizon 58\n", - "adding: mem time269, current time 326, horizon 57\n", - "adding: mem time270, current time 326, horizon 56\n", - "adding: mem time271, current time 326, horizon 55\n", - "adding: mem time272, current time 326, horizon 54\n", - "adding: mem time273, current time 326, horizon 53\n", - "adding: mem time274, current time 326, horizon 52\n", - "adding: mem time275, current time 326, horizon 51\n", - "adding: mem time276, current time 326, horizon 50\n", - "adding: mem time277, current time 326, horizon 49\n", - "adding: mem time278, current time 326, horizon 48\n", - "adding: mem time279, current time 326, horizon 47\n", - "adding: mem time280, current time 326, horizon 46\n", - "adding: mem time281, current time 326, horizon 45\n", - "adding: mem time282, current time 326, horizon 44\n", - "adding: mem time283, current time 326, horizon 43\n", - "adding: mem time284, current time 326, horizon 42\n", - "adding: mem time285, current time 326, horizon 41\n", - "adding: mem time286, current time 326, horizon 40\n", - "adding: mem time287, current time 326, horizon 39\n", - "adding: mem time288, current time 326, horizon 38\n", - "adding: mem time289, current time 326, horizon 37\n", - "adding: mem time290, current time 326, horizon 36\n", - "adding: mem time291, current time 326, horizon 35\n", - "adding: mem time292, current time 326, horizon 34\n", - "adding: mem time293, current time 326, horizon 33\n", - "adding: mem time294, current time 326, horizon 32\n", - "adding: mem time295, current time 326, horizon 31\n", - "adding: mem time296, current time 326, horizon 30\n", - "adding: mem time297, current time 326, horizon 29\n", - "adding: mem time298, current time 326, horizon 28\n", - "adding: mem time299, current time 326, horizon 27\n", - "adding: mem time300, current time 326, horizon 26\n", - "adding: mem time301, current time 326, horizon 25\n", - "adding: mem time302, current time 326, horizon 24\n", - "adding: mem time303, current time 326, horizon 23\n", - "adding: mem time304, current time 326, horizon 22\n", - "adding: mem time305, current time 326, horizon 21\n", - "adding: mem time306, current time 326, horizon 20\n", - "adding: mem time307, current time 326, horizon 19\n", - "adding: mem time308, current time 326, horizon 18\n", - "adding: mem time309, current time 326, horizon 17\n", - "adding: mem time310, current time 326, horizon 16\n", - "adding: mem time311, current time 326, horizon 15\n", - "adding: mem time312, current time 326, horizon 14\n", - "adding: mem time313, current time 326, horizon 13\n", - "adding: mem time314, current time 326, horizon 12\n", - "adding: mem time315, current time 326, horizon 11\n", - "adding: mem time316, current time 326, horizon 10\n", - "adding: mem time317, current time 326, horizon 9\n", - "adding: mem time318, current time 326, horizon 8\n", - "adding: mem time319, current time 326, horizon 7\n", - "adding: mem time320, current time 326, horizon 6\n", - "adding: mem time321, current time 326, horizon 5\n", - "adding: mem time322, current time 326, horizon 4\n", - "adding: mem time323, current time 326, horizon 3\n", - "adding: mem time324, current time 326, horizon 2\n", - "adding: mem time325, current time 326, horizon 1\n", - "adding: mem time200, current time 327, horizon 127\n", - "adding: mem time201, current time 327, horizon 126\n", - "adding: mem time202, current time 327, horizon 125\n", - "adding: mem time203, current time 327, horizon 124\n", - "adding: mem time204, current time 327, horizon 123\n", - "adding: mem time205, current time 327, horizon 122\n", - "adding: mem time206, current time 327, horizon 121\n", - "adding: mem time207, current time 327, horizon 120\n", - "adding: mem time208, current time 327, horizon 119\n", - "adding: mem time209, current time 327, horizon 118\n", - "adding: mem time210, current time 327, horizon 117\n", - "adding: mem time211, current time 327, horizon 116\n", - "adding: mem time212, current time 327, horizon 115\n", - "adding: mem time213, current time 327, horizon 114\n", - "adding: mem time214, current time 327, horizon 113\n", - "adding: mem time215, current time 327, horizon 112\n", - "adding: mem time216, current time 327, horizon 111\n", - "adding: mem time217, current time 327, horizon 110\n", - "adding: mem time218, current time 327, horizon 109\n", - "adding: mem time219, current time 327, horizon 108\n", - "adding: mem time220, current time 327, horizon 107\n", - "adding: mem time221, current time 327, horizon 106\n", - "adding: mem time222, current time 327, horizon 105\n", - "adding: mem time223, current time 327, horizon 104\n", - "adding: mem time224, current time 327, horizon 103\n", - "adding: mem time225, current time 327, horizon 102\n", - "adding: mem time226, current time 327, horizon 101\n", - "adding: mem time227, current time 327, horizon 100\n", - "adding: mem time228, current time 327, horizon 99\n", - "adding: mem time229, current time 327, horizon 98\n", - "adding: mem time230, current time 327, horizon 97\n", - "adding: mem time231, current time 327, horizon 96\n", - "adding: mem time232, current time 327, horizon 95\n", - "adding: mem time233, current time 327, horizon 94\n", - "adding: mem time234, current time 327, horizon 93\n", - "adding: mem time235, current time 327, horizon 92\n", - "adding: mem time236, current time 327, horizon 91\n", - "adding: mem time237, current time 327, horizon 90\n", - "adding: mem time238, current time 327, horizon 89\n", - "adding: mem time239, current time 327, horizon 88\n", - "adding: mem time240, current time 327, horizon 87\n", - "adding: mem time241, current time 327, horizon 86\n", - "adding: mem time242, current time 327, horizon 85\n", - "adding: mem time243, current time 327, horizon 84\n", - "adding: mem time244, current time 327, horizon 83\n", - "adding: mem time245, current time 327, horizon 82\n", - "adding: mem time246, current time 327, horizon 81\n", - "adding: mem time247, current time 327, horizon 80\n", - "adding: mem time248, current time 327, horizon 79\n", - "adding: mem time249, current time 327, horizon 78\n", - "adding: mem time250, current time 327, horizon 77\n", - "adding: mem time251, current time 327, horizon 76\n", - "adding: mem time252, current time 327, horizon 75\n", - "adding: mem time253, current time 327, horizon 74\n", - "adding: mem time254, current time 327, horizon 73\n", - "adding: mem time255, current time 327, horizon 72\n", - "adding: mem time256, current time 327, horizon 71\n", - "adding: mem time257, current time 327, horizon 70\n", - "adding: mem time258, current time 327, horizon 69\n", - "adding: mem time259, current time 327, horizon 68\n", - "adding: mem time260, current time 327, horizon 67\n", - "adding: mem time261, current time 327, horizon 66\n", - "adding: mem time262, current time 327, horizon 65\n", - "adding: mem time263, current time 327, horizon 64\n", - "adding: mem time264, current time 327, horizon 63\n", - "adding: mem time265, current time 327, horizon 62\n", - "adding: mem time266, current time 327, horizon 61\n", - "adding: mem time267, current time 327, horizon 60\n", - "adding: mem time268, current time 327, horizon 59\n", - "adding: mem time269, current time 327, horizon 58\n", - "adding: mem time270, current time 327, horizon 57\n", - "adding: mem time271, current time 327, horizon 56\n", - "adding: mem time272, current time 327, horizon 55\n", - "adding: mem time273, current time 327, horizon 54\n", - "adding: mem time274, current time 327, horizon 53\n", - "adding: mem time275, current time 327, horizon 52\n", - "adding: mem time276, current time 327, horizon 51\n", - "adding: mem time277, current time 327, horizon 50\n", - "adding: mem time278, current time 327, horizon 49\n", - "adding: mem time279, current time 327, horizon 48\n", - "adding: mem time280, current time 327, horizon 47\n", - "adding: mem time281, current time 327, horizon 46\n", - "adding: mem time282, current time 327, horizon 45\n", - "adding: mem time283, current time 327, horizon 44\n", - "adding: mem time284, current time 327, horizon 43\n", - "adding: mem time285, current time 327, horizon 42\n", - "adding: mem time286, current time 327, horizon 41\n", - "adding: mem time287, current time 327, horizon 40\n", - "adding: mem time288, current time 327, horizon 39\n", - "adding: mem time289, current time 327, horizon 38\n", - "adding: mem time290, current time 327, horizon 37\n", - "adding: mem time291, current time 327, horizon 36\n", - "adding: mem time292, current time 327, horizon 35\n", - "adding: mem time293, current time 327, horizon 34\n", - "adding: mem time294, current time 327, horizon 33\n", - "adding: mem time295, current time 327, horizon 32\n", - "adding: mem time296, current time 327, horizon 31\n", - "adding: mem time297, current time 327, horizon 30\n", - "adding: mem time298, current time 327, horizon 29\n", - "adding: mem time299, current time 327, horizon 28\n", - "adding: mem time300, current time 327, horizon 27\n", - "adding: mem time301, current time 327, horizon 26\n", - "adding: mem time302, current time 327, horizon 25\n", - "adding: mem time303, current time 327, horizon 24\n", - "adding: mem time304, current time 327, horizon 23\n", - "adding: mem time305, current time 327, horizon 22\n", - "adding: mem time306, current time 327, horizon 21\n", - "adding: mem time307, current time 327, horizon 20\n", - "adding: mem time308, current time 327, horizon 19\n", - "adding: mem time309, current time 327, horizon 18\n", - "adding: mem time310, current time 327, horizon 17\n", - "adding: mem time311, current time 327, horizon 16\n", - "adding: mem time312, current time 327, horizon 15\n", - "adding: mem time313, current time 327, horizon 14\n", - "adding: mem time314, current time 327, horizon 13\n", - "adding: mem time315, current time 327, horizon 12\n", - "adding: mem time316, current time 327, horizon 11\n", - "adding: mem time317, current time 327, horizon 10\n", - "adding: mem time318, current time 327, horizon 9\n", - "adding: mem time319, current time 327, horizon 8\n", - "adding: mem time320, current time 327, horizon 7\n", - "adding: mem time321, current time 327, horizon 6\n", - "adding: mem time322, current time 327, horizon 5\n", - "adding: mem time323, current time 327, horizon 4\n", - "adding: mem time324, current time 327, horizon 3\n", - "adding: mem time325, current time 327, horizon 2\n", - "adding: mem time326, current time 327, horizon 1\n", - "adding: mem time200, current time 328, horizon 128\n", - "adding: mem time201, current time 328, horizon 127\n", - "adding: mem time202, current time 328, horizon 126\n", - "adding: mem time203, current time 328, horizon 125\n", - "adding: mem time204, current time 328, horizon 124\n", - "adding: mem time205, current time 328, horizon 123\n", - "adding: mem time206, current time 328, horizon 122\n", - "adding: mem time207, current time 328, horizon 121\n", - "adding: mem time208, current time 328, horizon 120\n", - "adding: mem time209, current time 328, horizon 119\n", - "adding: mem time210, current time 328, horizon 118\n", - "adding: mem time211, current time 328, horizon 117\n", - "adding: mem time212, current time 328, horizon 116\n", - "adding: mem time213, current time 328, horizon 115\n", - "adding: mem time214, current time 328, horizon 114\n", - "adding: mem time215, current time 328, horizon 113\n", - "adding: mem time216, current time 328, horizon 112\n", - "adding: mem time217, current time 328, horizon 111\n", - "adding: mem time218, current time 328, horizon 110\n", - "adding: mem time219, current time 328, horizon 109\n", - "adding: mem time220, current time 328, horizon 108\n", - "adding: mem time221, current time 328, horizon 107\n", - "adding: mem time222, current time 328, horizon 106\n", - "adding: mem time223, current time 328, horizon 105\n", - "adding: mem time224, current time 328, horizon 104\n", - "adding: mem time225, current time 328, horizon 103\n", - "adding: mem time226, current time 328, horizon 102\n", - "adding: mem time227, current time 328, horizon 101\n", - "adding: mem time228, current time 328, horizon 100\n", - "adding: mem time229, current time 328, horizon 99\n", - "adding: mem time230, current time 328, horizon 98\n", - "adding: mem time231, current time 328, horizon 97\n", - "adding: mem time232, current time 328, horizon 96\n", - "adding: mem time233, current time 328, horizon 95\n", - "adding: mem time234, current time 328, horizon 94\n", - "adding: mem time235, current time 328, horizon 93\n", - "adding: mem time236, current time 328, horizon 92\n", - "adding: mem time237, current time 328, horizon 91\n", - "adding: mem time238, current time 328, horizon 90\n", - "adding: mem time239, current time 328, horizon 89\n", - "adding: mem time240, current time 328, horizon 88\n", - "adding: mem time241, current time 328, horizon 87\n", - "adding: mem time242, current time 328, horizon 86\n", - "adding: mem time243, current time 328, horizon 85\n", - "adding: mem time244, current time 328, horizon 84\n", - "adding: mem time245, current time 328, horizon 83\n", - "adding: mem time246, current time 328, horizon 82\n", - "adding: mem time247, current time 328, horizon 81\n", - "adding: mem time248, current time 328, horizon 80\n", - "adding: mem time249, current time 328, horizon 79\n", - "adding: mem time250, current time 328, horizon 78\n", - "adding: mem time251, current time 328, horizon 77\n", - "adding: mem time252, current time 328, horizon 76\n", - "adding: mem time253, current time 328, horizon 75\n", - "adding: mem time254, current time 328, horizon 74\n", - "adding: mem time255, current time 328, horizon 73\n", - "adding: mem time256, current time 328, horizon 72\n", - "adding: mem time257, current time 328, horizon 71\n", - "adding: mem time258, current time 328, horizon 70\n", - "adding: mem time259, current time 328, horizon 69\n", - "adding: mem time260, current time 328, horizon 68\n", - "adding: mem time261, current time 328, horizon 67\n", - "adding: mem time262, current time 328, horizon 66\n", - "adding: mem time263, current time 328, horizon 65\n", - "adding: mem time264, current time 328, horizon 64\n", - "adding: mem time265, current time 328, horizon 63\n", - "adding: mem time266, current time 328, horizon 62\n", - "adding: mem time267, current time 328, horizon 61\n", - "adding: mem time268, current time 328, horizon 60\n", - "adding: mem time269, current time 328, horizon 59\n", - "adding: mem time270, current time 328, horizon 58\n", - "adding: mem time271, current time 328, horizon 57\n", - "adding: mem time272, current time 328, horizon 56\n", - "adding: mem time273, current time 328, horizon 55\n", - "adding: mem time274, current time 328, horizon 54\n", - "adding: mem time275, current time 328, horizon 53\n", - "adding: mem time276, current time 328, horizon 52\n", - "adding: mem time277, current time 328, horizon 51\n", - "adding: mem time278, current time 328, horizon 50\n", - "adding: mem time279, current time 328, horizon 49\n", - "adding: mem time280, current time 328, horizon 48\n", - "adding: mem time281, current time 328, horizon 47\n", - "adding: mem time282, current time 328, horizon 46\n", - "adding: mem time283, current time 328, horizon 45\n", - "adding: mem time284, current time 328, horizon 44\n", - "adding: mem time285, current time 328, horizon 43\n", - "adding: mem time286, current time 328, horizon 42\n", - "adding: mem time287, current time 328, horizon 41\n", - "adding: mem time288, current time 328, horizon 40\n", - "adding: mem time289, current time 328, horizon 39\n", - "adding: mem time290, current time 328, horizon 38\n", - "adding: mem time291, current time 328, horizon 37\n", - "adding: mem time292, current time 328, horizon 36\n", - "adding: mem time293, current time 328, horizon 35\n", - "adding: mem time294, current time 328, horizon 34\n", - "adding: mem time295, current time 328, horizon 33\n", - "adding: mem time296, current time 328, horizon 32\n", - "adding: mem time297, current time 328, horizon 31\n", - "adding: mem time298, current time 328, horizon 30\n", - "adding: mem time299, current time 328, horizon 29\n", - "adding: mem time300, current time 328, horizon 28\n", - "adding: mem time301, current time 328, horizon 27\n", - "adding: mem time302, current time 328, horizon 26\n", - "adding: mem time303, current time 328, horizon 25\n", - "adding: mem time304, current time 328, horizon 24\n", - "adding: mem time305, current time 328, horizon 23\n", - "adding: mem time306, current time 328, horizon 22\n", - "adding: mem time307, current time 328, horizon 21\n", - "adding: mem time308, current time 328, horizon 20\n", - "adding: mem time309, current time 328, horizon 19\n", - "adding: mem time310, current time 328, horizon 18\n", - "adding: mem time311, current time 328, horizon 17\n", - "adding: mem time312, current time 328, horizon 16\n", - "adding: mem time313, current time 328, horizon 15\n", - "adding: mem time314, current time 328, horizon 14\n", - "adding: mem time315, current time 328, horizon 13\n", - "adding: mem time316, current time 328, horizon 12\n", - "adding: mem time317, current time 328, horizon 11\n", - "adding: mem time318, current time 328, horizon 10\n", - "adding: mem time319, current time 328, horizon 9\n", - "adding: mem time320, current time 328, horizon 8\n", - "adding: mem time321, current time 328, horizon 7\n", - "adding: mem time322, current time 328, horizon 6\n", - "adding: mem time323, current time 328, horizon 5\n", - "adding: mem time324, current time 328, horizon 4\n", - "adding: mem time325, current time 328, horizon 3\n", - "adding: mem time326, current time 328, horizon 2\n", - "adding: mem time327, current time 328, horizon 1\n", - "adding: mem time200, current time 329, horizon 129\n", - "adding: mem time201, current time 329, horizon 128\n", - "adding: mem time202, current time 329, horizon 127\n", - "adding: mem time203, current time 329, horizon 126\n", - "adding: mem time204, current time 329, horizon 125\n", - "adding: mem time205, current time 329, horizon 124\n", - "adding: mem time206, current time 329, horizon 123\n", - "adding: mem time207, current time 329, horizon 122\n", - "adding: mem time208, current time 329, horizon 121\n", - "adding: mem time209, current time 329, horizon 120\n", - "adding: mem time210, current time 329, horizon 119\n", - "adding: mem time211, current time 329, horizon 118\n", - "adding: mem time212, current time 329, horizon 117\n", - "adding: mem time213, current time 329, horizon 116\n", - "adding: mem time214, current time 329, horizon 115\n", - "adding: mem time215, current time 329, horizon 114\n", - "adding: mem time216, current time 329, horizon 113\n", - "adding: mem time217, current time 329, horizon 112\n", - "adding: mem time218, current time 329, horizon 111\n", - "adding: mem time219, current time 329, horizon 110\n", - "adding: mem time220, current time 329, horizon 109\n", - "adding: mem time221, current time 329, horizon 108\n", - "adding: mem time222, current time 329, horizon 107\n", - "adding: mem time223, current time 329, horizon 106\n", - "adding: mem time224, current time 329, horizon 105\n", - "adding: mem time225, current time 329, horizon 104\n", - "adding: mem time226, current time 329, horizon 103\n", - "adding: mem time227, current time 329, horizon 102\n", - "adding: mem time228, current time 329, horizon 101\n", - "adding: mem time229, current time 329, horizon 100\n", - "adding: mem time230, current time 329, horizon 99\n", - "adding: mem time231, current time 329, horizon 98\n", - "adding: mem time232, current time 329, horizon 97\n", - "adding: mem time233, current time 329, horizon 96\n", - "adding: mem time234, current time 329, horizon 95\n", - "adding: mem time235, current time 329, horizon 94\n", - "adding: mem time236, current time 329, horizon 93\n", - "adding: mem time237, current time 329, horizon 92\n", - "adding: mem time238, current time 329, horizon 91\n", - "adding: mem time239, current time 329, horizon 90\n", - "adding: mem time240, current time 329, horizon 89\n", - "adding: mem time241, current time 329, horizon 88\n", - "adding: mem time242, current time 329, horizon 87\n", - "adding: mem time243, current time 329, horizon 86\n", - "adding: mem time244, current time 329, horizon 85\n", - "adding: mem time245, current time 329, horizon 84\n", - "adding: mem time246, current time 329, horizon 83\n", - "adding: mem time247, current time 329, horizon 82\n", - "adding: mem time248, current time 329, horizon 81\n", - "adding: mem time249, current time 329, horizon 80\n", - "adding: mem time250, current time 329, horizon 79\n", - "adding: mem time251, current time 329, horizon 78\n", - "adding: mem time252, current time 329, horizon 77\n", - "adding: mem time253, current time 329, horizon 76\n", - "adding: mem time254, current time 329, horizon 75\n", - "adding: mem time255, current time 329, horizon 74\n", - "adding: mem time256, current time 329, horizon 73\n", - "adding: mem time257, current time 329, horizon 72\n", - "adding: mem time258, current time 329, horizon 71\n", - "adding: mem time259, current time 329, horizon 70\n", - "adding: mem time260, current time 329, horizon 69\n", - "adding: mem time261, current time 329, horizon 68\n", - "adding: mem time262, current time 329, horizon 67\n", - "adding: mem time263, current time 329, horizon 66\n", - "adding: mem time264, current time 329, horizon 65\n", - "adding: mem time265, current time 329, horizon 64\n", - "adding: mem time266, current time 329, horizon 63\n", - "adding: mem time267, current time 329, horizon 62\n", - "adding: mem time268, current time 329, horizon 61\n", - "adding: mem time269, current time 329, horizon 60\n", - "adding: mem time270, current time 329, horizon 59\n", - "adding: mem time271, current time 329, horizon 58\n", - "adding: mem time272, current time 329, horizon 57\n", - "adding: mem time273, current time 329, horizon 56\n", - "adding: mem time274, current time 329, horizon 55\n", - "adding: mem time275, current time 329, horizon 54\n", - "adding: mem time276, current time 329, horizon 53\n", - "adding: mem time277, current time 329, horizon 52\n", - "adding: mem time278, current time 329, horizon 51\n", - "adding: mem time279, current time 329, horizon 50\n", - "adding: mem time280, current time 329, horizon 49\n", - "adding: mem time281, current time 329, horizon 48\n", - "adding: mem time282, current time 329, horizon 47\n", - "adding: mem time283, current time 329, horizon 46\n", - "adding: mem time284, current time 329, horizon 45\n", - "adding: mem time285, current time 329, horizon 44\n", - "adding: mem time286, current time 329, horizon 43\n", - "adding: mem time287, current time 329, horizon 42\n", - "adding: mem time288, current time 329, horizon 41\n", - "adding: mem time289, current time 329, horizon 40\n", - "adding: mem time290, current time 329, horizon 39\n", - "adding: mem time291, current time 329, horizon 38\n", - "adding: mem time292, current time 329, horizon 37\n", - "adding: mem time293, current time 329, horizon 36\n", - "adding: mem time294, current time 329, horizon 35\n", - "adding: mem time295, current time 329, horizon 34\n", - "adding: mem time296, current time 329, horizon 33\n", - "adding: mem time297, current time 329, horizon 32\n", - "adding: mem time298, current time 329, horizon 31\n", - "adding: mem time299, current time 329, horizon 30\n", - "adding: mem time300, current time 329, horizon 29\n", - "adding: mem time301, current time 329, horizon 28\n", - "adding: mem time302, current time 329, horizon 27\n", - "adding: mem time303, current time 329, horizon 26\n", - "adding: mem time304, current time 329, horizon 25\n", - "adding: mem time305, current time 329, horizon 24\n", - "adding: mem time306, current time 329, horizon 23\n", - "adding: mem time307, current time 329, horizon 22\n", - "adding: mem time308, current time 329, horizon 21\n", - "adding: mem time309, current time 329, horizon 20\n", - "adding: mem time310, current time 329, horizon 19\n", - "adding: mem time311, current time 329, horizon 18\n", - "adding: mem time312, current time 329, horizon 17\n", - "adding: mem time313, current time 329, horizon 16\n", - "adding: mem time314, current time 329, horizon 15\n", - "adding: mem time315, current time 329, horizon 14\n", - "adding: mem time316, current time 329, horizon 13\n", - "adding: mem time317, current time 329, horizon 12\n", - "adding: mem time318, current time 329, horizon 11\n", - "adding: mem time319, current time 329, horizon 10\n", - "adding: mem time320, current time 329, horizon 9\n", - "adding: mem time321, current time 329, horizon 8\n", - "adding: mem time322, current time 329, horizon 7\n", - "adding: mem time323, current time 329, horizon 6\n", - "adding: mem time324, current time 329, horizon 5\n", - "adding: mem time325, current time 329, horizon 4\n", - "adding: mem time326, current time 329, horizon 3\n", - "adding: mem time327, current time 329, horizon 2\n", - "adding: mem time328, current time 329, horizon 1\n", - "adding: mem time200, current time 330, horizon 130\n", - "adding: mem time201, current time 330, horizon 129\n", - "adding: mem time202, current time 330, horizon 128\n", - "adding: mem time203, current time 330, horizon 127\n", - "adding: mem time204, current time 330, horizon 126\n", - "adding: mem time205, current time 330, horizon 125\n", - "adding: mem time206, current time 330, horizon 124\n", - "adding: mem time207, current time 330, horizon 123\n", - "adding: mem time208, current time 330, horizon 122\n", - "adding: mem time209, current time 330, horizon 121\n", - "adding: mem time210, current time 330, horizon 120\n", - "adding: mem time211, current time 330, horizon 119\n", - "adding: mem time212, current time 330, horizon 118\n", - "adding: mem time213, current time 330, horizon 117\n", - "adding: mem time214, current time 330, horizon 116\n", - "adding: mem time215, current time 330, horizon 115\n", - "adding: mem time216, current time 330, horizon 114\n", - "adding: mem time217, current time 330, horizon 113\n", - "adding: mem time218, current time 330, horizon 112\n", - "adding: mem time219, current time 330, horizon 111\n", - "adding: mem time220, current time 330, horizon 110\n", - "adding: mem time221, current time 330, horizon 109\n", - "adding: mem time222, current time 330, horizon 108\n", - "adding: mem time223, current time 330, horizon 107\n", - "adding: mem time224, current time 330, horizon 106\n", - "adding: mem time225, current time 330, horizon 105\n", - "adding: mem time226, current time 330, horizon 104\n", - "adding: mem time227, current time 330, horizon 103\n", - "adding: mem time228, current time 330, horizon 102\n", - "adding: mem time229, current time 330, horizon 101\n", - "adding: mem time230, current time 330, horizon 100\n", - "adding: mem time231, current time 330, horizon 99\n", - "adding: mem time232, current time 330, horizon 98\n", - "adding: mem time233, current time 330, horizon 97\n", - "adding: mem time234, current time 330, horizon 96\n", - "adding: mem time235, current time 330, horizon 95\n", - "adding: mem time236, current time 330, horizon 94\n", - "adding: mem time237, current time 330, horizon 93\n", - "adding: mem time238, current time 330, horizon 92\n", - "adding: mem time239, current time 330, horizon 91\n", - "adding: mem time240, current time 330, horizon 90\n", - "adding: mem time241, current time 330, horizon 89\n", - "adding: mem time242, current time 330, horizon 88\n", - "adding: mem time243, current time 330, horizon 87\n", - "adding: mem time244, current time 330, horizon 86\n", - "adding: mem time245, current time 330, horizon 85\n", - "adding: mem time246, current time 330, horizon 84\n", - "adding: mem time247, current time 330, horizon 83\n", - "adding: mem time248, current time 330, horizon 82\n", - "adding: mem time249, current time 330, horizon 81\n", - "adding: mem time250, current time 330, horizon 80\n", - "adding: mem time251, current time 330, horizon 79\n", - "adding: mem time252, current time 330, horizon 78\n", - "adding: mem time253, current time 330, horizon 77\n", - "adding: mem time254, current time 330, horizon 76\n", - "adding: mem time255, current time 330, horizon 75\n", - "adding: mem time256, current time 330, horizon 74\n", - "adding: mem time257, current time 330, horizon 73\n", - "adding: mem time258, current time 330, horizon 72\n", - "adding: mem time259, current time 330, horizon 71\n", - "adding: mem time260, current time 330, horizon 70\n", - "adding: mem time261, current time 330, horizon 69\n", - "adding: mem time262, current time 330, horizon 68\n", - "adding: mem time263, current time 330, horizon 67\n", - "adding: mem time264, current time 330, horizon 66\n", - "adding: mem time265, current time 330, horizon 65\n", - "adding: mem time266, current time 330, horizon 64\n", - "adding: mem time267, current time 330, horizon 63\n", - "adding: mem time268, current time 330, horizon 62\n", - "adding: mem time269, current time 330, horizon 61\n", - "adding: mem time270, current time 330, horizon 60\n", - "adding: mem time271, current time 330, horizon 59\n", - "adding: mem time272, current time 330, horizon 58\n", - "adding: mem time273, current time 330, horizon 57\n", - "adding: mem time274, current time 330, horizon 56\n", - "adding: mem time275, current time 330, horizon 55\n", - "adding: mem time276, current time 330, horizon 54\n", - "adding: mem time277, current time 330, horizon 53\n", - "adding: mem time278, current time 330, horizon 52\n", - "adding: mem time279, current time 330, horizon 51\n", - "adding: mem time280, current time 330, horizon 50\n", - "adding: mem time281, current time 330, horizon 49\n", - "adding: mem time282, current time 330, horizon 48\n", - "adding: mem time283, current time 330, horizon 47\n", - "adding: mem time284, current time 330, horizon 46\n", - "adding: mem time285, current time 330, horizon 45\n", - "adding: mem time286, current time 330, horizon 44\n", - "adding: mem time287, current time 330, horizon 43\n", - "adding: mem time288, current time 330, horizon 42\n", - "adding: mem time289, current time 330, horizon 41\n", - "adding: mem time290, current time 330, horizon 40\n", - "adding: mem time291, current time 330, horizon 39\n", - "adding: mem time292, current time 330, horizon 38\n", - "adding: mem time293, current time 330, horizon 37\n", - "adding: mem time294, current time 330, horizon 36\n", - "adding: mem time295, current time 330, horizon 35\n", - "adding: mem time296, current time 330, horizon 34\n", - "adding: mem time297, current time 330, horizon 33\n", - "adding: mem time298, current time 330, horizon 32\n", - "adding: mem time299, current time 330, horizon 31\n", - "adding: mem time300, current time 330, horizon 30\n", - "adding: mem time301, current time 330, horizon 29\n", - "adding: mem time302, current time 330, horizon 28\n", - "adding: mem time303, current time 330, horizon 27\n", - "adding: mem time304, current time 330, horizon 26\n", - "adding: mem time305, current time 330, horizon 25\n", - "adding: mem time306, current time 330, horizon 24\n", - "adding: mem time307, current time 330, horizon 23\n", - "adding: mem time308, current time 330, horizon 22\n", - "adding: mem time309, current time 330, horizon 21\n", - "adding: mem time310, current time 330, horizon 20\n", - "adding: mem time311, current time 330, horizon 19\n", - "adding: mem time312, current time 330, horizon 18\n", - "adding: mem time313, current time 330, horizon 17\n", - "adding: mem time314, current time 330, horizon 16\n", - "adding: mem time315, current time 330, horizon 15\n", - "adding: mem time316, current time 330, horizon 14\n", - "adding: mem time317, current time 330, horizon 13\n", - "adding: mem time318, current time 330, horizon 12\n", - "adding: mem time319, current time 330, horizon 11\n", - "adding: mem time320, current time 330, horizon 10\n", - "adding: mem time321, current time 330, horizon 9\n", - "adding: mem time322, current time 330, horizon 8\n", - "adding: mem time323, current time 330, horizon 7\n", - "adding: mem time324, current time 330, horizon 6\n", - "adding: mem time325, current time 330, horizon 5\n", - "adding: mem time326, current time 330, horizon 4\n", - "adding: mem time327, current time 330, horizon 3\n", - "adding: mem time328, current time 330, horizon 2\n", - "adding: mem time329, current time 330, horizon 1\n", - "adding: mem time200, current time 331, horizon 131\n", - "adding: mem time201, current time 331, horizon 130\n", - "adding: mem time202, current time 331, horizon 129\n", - "adding: mem time203, current time 331, horizon 128\n", - "adding: mem time204, current time 331, horizon 127\n", - "adding: mem time205, current time 331, horizon 126\n", - "adding: mem time206, current time 331, horizon 125\n", - "adding: mem time207, current time 331, horizon 124\n", - "adding: mem time208, current time 331, horizon 123\n", - "adding: mem time209, current time 331, horizon 122\n", - "adding: mem time210, current time 331, horizon 121\n", - "adding: mem time211, current time 331, horizon 120\n", - "adding: mem time212, current time 331, horizon 119\n", - "adding: mem time213, current time 331, horizon 118\n", - "adding: mem time214, current time 331, horizon 117\n", - "adding: mem time215, current time 331, horizon 116\n", - "adding: mem time216, current time 331, horizon 115\n", - "adding: mem time217, current time 331, horizon 114\n", - "adding: mem time218, current time 331, horizon 113\n", - "adding: mem time219, current time 331, horizon 112\n", - "adding: mem time220, current time 331, horizon 111\n", - "adding: mem time221, current time 331, horizon 110\n", - "adding: mem time222, current time 331, horizon 109\n", - "adding: mem time223, current time 331, horizon 108\n", - "adding: mem time224, current time 331, horizon 107\n", - "adding: mem time225, current time 331, horizon 106\n", - "adding: mem time226, current time 331, horizon 105\n", - "adding: mem time227, current time 331, horizon 104\n", - "adding: mem time228, current time 331, horizon 103\n", - "adding: mem time229, current time 331, horizon 102\n", - "adding: mem time230, current time 331, horizon 101\n", - "adding: mem time231, current time 331, horizon 100\n", - "adding: mem time232, current time 331, horizon 99\n", - "adding: mem time233, current time 331, horizon 98\n", - "adding: mem time234, current time 331, horizon 97\n", - "adding: mem time235, current time 331, horizon 96\n", - "adding: mem time236, current time 331, horizon 95\n", - "adding: mem time237, current time 331, horizon 94\n", - "adding: mem time238, current time 331, horizon 93\n", - "adding: mem time239, current time 331, horizon 92\n", - "adding: mem time240, current time 331, horizon 91\n", - "adding: mem time241, current time 331, horizon 90\n", - "adding: mem time242, current time 331, horizon 89\n", - "adding: mem time243, current time 331, horizon 88\n", - "adding: mem time244, current time 331, horizon 87\n", - "adding: mem time245, current time 331, horizon 86\n", - "adding: mem time246, current time 331, horizon 85\n", - "adding: mem time247, current time 331, horizon 84\n", - "adding: mem time248, current time 331, horizon 83\n", - "adding: mem time249, current time 331, horizon 82\n", - "adding: mem time250, current time 331, horizon 81\n", - "adding: mem time251, current time 331, horizon 80\n", - "adding: mem time252, current time 331, horizon 79\n", - "adding: mem time253, current time 331, horizon 78\n", - "adding: mem time254, current time 331, horizon 77\n", - "adding: mem time255, current time 331, horizon 76\n", - "adding: mem time256, current time 331, horizon 75\n", - "adding: mem time257, current time 331, horizon 74\n", - "adding: mem time258, current time 331, horizon 73\n", - "adding: mem time259, current time 331, horizon 72\n", - "adding: mem time260, current time 331, horizon 71\n", - "adding: mem time261, current time 331, horizon 70\n", - "adding: mem time262, current time 331, horizon 69\n", - "adding: mem time263, current time 331, horizon 68\n", - "adding: mem time264, current time 331, horizon 67\n", - "adding: mem time265, current time 331, horizon 66\n", - "adding: mem time266, current time 331, horizon 65\n", - "adding: mem time267, current time 331, horizon 64\n", - "adding: mem time268, current time 331, horizon 63\n", - "adding: mem time269, current time 331, horizon 62\n", - "adding: mem time270, current time 331, horizon 61\n", - "adding: mem time271, current time 331, horizon 60\n", - "adding: mem time272, current time 331, horizon 59\n", - "adding: mem time273, current time 331, horizon 58\n", - "adding: mem time274, current time 331, horizon 57\n", - "adding: mem time275, current time 331, horizon 56\n", - "adding: mem time276, current time 331, horizon 55\n", - "adding: mem time277, current time 331, horizon 54\n", - "adding: mem time278, current time 331, horizon 53\n", - "adding: mem time279, current time 331, horizon 52\n", - "adding: mem time280, current time 331, horizon 51\n", - "adding: mem time281, current time 331, horizon 50\n", - "adding: mem time282, current time 331, horizon 49\n", - "adding: mem time283, current time 331, horizon 48\n", - "adding: mem time284, current time 331, horizon 47\n", - "adding: mem time285, current time 331, horizon 46\n", - "adding: mem time286, current time 331, horizon 45\n", - "adding: mem time287, current time 331, horizon 44\n", - "adding: mem time288, current time 331, horizon 43\n", - "adding: mem time289, current time 331, horizon 42\n", - "adding: mem time290, current time 331, horizon 41\n", - "adding: mem time291, current time 331, horizon 40\n", - "adding: mem time292, current time 331, horizon 39\n", - "adding: mem time293, current time 331, horizon 38\n", - "adding: mem time294, current time 331, horizon 37\n", - "adding: mem time295, current time 331, horizon 36\n", - "adding: mem time296, current time 331, horizon 35\n", - "adding: mem time297, current time 331, horizon 34\n", - "adding: mem time298, current time 331, horizon 33\n", - "adding: mem time299, current time 331, horizon 32\n", - "adding: mem time300, current time 331, horizon 31\n", - "adding: mem time301, current time 331, horizon 30\n", - "adding: mem time302, current time 331, horizon 29\n", - "adding: mem time303, current time 331, horizon 28\n", - "adding: mem time304, current time 331, horizon 27\n", - "adding: mem time305, current time 331, horizon 26\n", - "adding: mem time306, current time 331, horizon 25\n", - "adding: mem time307, current time 331, horizon 24\n", - "adding: mem time308, current time 331, horizon 23\n", - "adding: mem time309, current time 331, horizon 22\n", - "adding: mem time310, current time 331, horizon 21\n", - "adding: mem time311, current time 331, horizon 20\n", - "adding: mem time312, current time 331, horizon 19\n", - "adding: mem time313, current time 331, horizon 18\n", - "adding: mem time314, current time 331, horizon 17\n", - "adding: mem time315, current time 331, horizon 16\n", - "adding: mem time316, current time 331, horizon 15\n", - "adding: mem time317, current time 331, horizon 14\n", - "adding: mem time318, current time 331, horizon 13\n", - "adding: mem time319, current time 331, horizon 12\n", - "adding: mem time320, current time 331, horizon 11\n", - "adding: mem time321, current time 331, horizon 10\n", - "adding: mem time322, current time 331, horizon 9\n", - "adding: mem time323, current time 331, horizon 8\n", - "adding: mem time324, current time 331, horizon 7\n", - "adding: mem time325, current time 331, horizon 6\n", - "adding: mem time326, current time 331, horizon 5\n", - "adding: mem time327, current time 331, horizon 4\n", - "adding: mem time328, current time 331, horizon 3\n", - "adding: mem time329, current time 331, horizon 2\n", - "adding: mem time330, current time 331, horizon 1\n", - "adding: mem time200, current time 332, horizon 132\n", - "adding: mem time201, current time 332, horizon 131\n", - "adding: mem time202, current time 332, horizon 130\n", - "adding: mem time203, current time 332, horizon 129\n", - "adding: mem time204, current time 332, horizon 128\n", - "adding: mem time205, current time 332, horizon 127\n", - "adding: mem time206, current time 332, horizon 126\n", - "adding: mem time207, current time 332, horizon 125\n", - "adding: mem time208, current time 332, horizon 124\n", - "adding: mem time209, current time 332, horizon 123\n", - "adding: mem time210, current time 332, horizon 122\n", - "adding: mem time211, current time 332, horizon 121\n", - "adding: mem time212, current time 332, horizon 120\n", - "adding: mem time213, current time 332, horizon 119\n", - "adding: mem time214, current time 332, horizon 118\n", - "adding: mem time215, current time 332, horizon 117\n", - "adding: mem time216, current time 332, horizon 116\n", - "adding: mem time217, current time 332, horizon 115\n", - "adding: mem time218, current time 332, horizon 114\n", - "adding: mem time219, current time 332, horizon 113\n", - "adding: mem time220, current time 332, horizon 112\n", - "adding: mem time221, current time 332, horizon 111\n", - "adding: mem time222, current time 332, horizon 110\n", - "adding: mem time223, current time 332, horizon 109\n", - "adding: mem time224, current time 332, horizon 108\n", - "adding: mem time225, current time 332, horizon 107\n", - "adding: mem time226, current time 332, horizon 106\n", - "adding: mem time227, current time 332, horizon 105\n", - "adding: mem time228, current time 332, horizon 104\n", - "adding: mem time229, current time 332, horizon 103\n", - "adding: mem time230, current time 332, horizon 102\n", - "adding: mem time231, current time 332, horizon 101\n", - "adding: mem time232, current time 332, horizon 100\n", - "adding: mem time233, current time 332, horizon 99\n", - "adding: mem time234, current time 332, horizon 98\n", - "adding: mem time235, current time 332, horizon 97\n", - "adding: mem time236, current time 332, horizon 96\n", - "adding: mem time237, current time 332, horizon 95\n", - "adding: mem time238, current time 332, horizon 94\n", - "adding: mem time239, current time 332, horizon 93\n", - "adding: mem time240, current time 332, horizon 92\n", - "adding: mem time241, current time 332, horizon 91\n", - "adding: mem time242, current time 332, horizon 90\n", - "adding: mem time243, current time 332, horizon 89\n", - "adding: mem time244, current time 332, horizon 88\n", - "adding: mem time245, current time 332, horizon 87\n", - "adding: mem time246, current time 332, horizon 86\n", - "adding: mem time247, current time 332, horizon 85\n", - "adding: mem time248, current time 332, horizon 84\n", - "adding: mem time249, current time 332, horizon 83\n", - "adding: mem time250, current time 332, horizon 82\n", - "adding: mem time251, current time 332, horizon 81\n", - "adding: mem time252, current time 332, horizon 80\n", - "adding: mem time253, current time 332, horizon 79\n", - "adding: mem time254, current time 332, horizon 78\n", - "adding: mem time255, current time 332, horizon 77\n", - "adding: mem time256, current time 332, horizon 76\n", - "adding: mem time257, current time 332, horizon 75\n", - "adding: mem time258, current time 332, horizon 74\n", - "adding: mem time259, current time 332, horizon 73\n", - "adding: mem time260, current time 332, horizon 72\n", - "adding: mem time261, current time 332, horizon 71\n", - "adding: mem time262, current time 332, horizon 70\n", - "adding: mem time263, current time 332, horizon 69\n", - "adding: mem time264, current time 332, horizon 68\n", - "adding: mem time265, current time 332, horizon 67\n", - "adding: mem time266, current time 332, horizon 66\n", - "adding: mem time267, current time 332, horizon 65\n", - "adding: mem time268, current time 332, horizon 64\n", - "adding: mem time269, current time 332, horizon 63\n", - "adding: mem time270, current time 332, horizon 62\n", - "adding: mem time271, current time 332, horizon 61\n", - "adding: mem time272, current time 332, horizon 60\n", - "adding: mem time273, current time 332, horizon 59\n", - "adding: mem time274, current time 332, horizon 58\n", - "adding: mem time275, current time 332, horizon 57\n", - "adding: mem time276, current time 332, horizon 56\n", - "adding: mem time277, current time 332, horizon 55\n", - "adding: mem time278, current time 332, horizon 54\n", - "adding: mem time279, current time 332, horizon 53\n", - "adding: mem time280, current time 332, horizon 52\n", - "adding: mem time281, current time 332, horizon 51\n", - "adding: mem time282, current time 332, horizon 50\n", - "adding: mem time283, current time 332, horizon 49\n", - "adding: mem time284, current time 332, horizon 48\n", - "adding: mem time285, current time 332, horizon 47\n", - "adding: mem time286, current time 332, horizon 46\n", - "adding: mem time287, current time 332, horizon 45\n", - "adding: mem time288, current time 332, horizon 44\n", - "adding: mem time289, current time 332, horizon 43\n", - "adding: mem time290, current time 332, horizon 42\n", - "adding: mem time291, current time 332, horizon 41\n", - "adding: mem time292, current time 332, horizon 40\n", - "adding: mem time293, current time 332, horizon 39\n", - "adding: mem time294, current time 332, horizon 38\n", - "adding: mem time295, current time 332, horizon 37\n", - "adding: mem time296, current time 332, horizon 36\n", - "adding: mem time297, current time 332, horizon 35\n", - "adding: mem time298, current time 332, horizon 34\n", - "adding: mem time299, current time 332, horizon 33\n", - "adding: mem time300, current time 332, horizon 32\n", - "adding: mem time301, current time 332, horizon 31\n", - "adding: mem time302, current time 332, horizon 30\n", - "adding: mem time303, current time 332, horizon 29\n", - "adding: mem time304, current time 332, horizon 28\n", - "adding: mem time305, current time 332, horizon 27\n", - "adding: mem time306, current time 332, horizon 26\n", - "adding: mem time307, current time 332, horizon 25\n", - "adding: mem time308, current time 332, horizon 24\n", - "adding: mem time309, current time 332, horizon 23\n", - "adding: mem time310, current time 332, horizon 22\n", - "adding: mem time311, current time 332, horizon 21\n", - "adding: mem time312, current time 332, horizon 20\n", - "adding: mem time313, current time 332, horizon 19\n", - "adding: mem time314, current time 332, horizon 18\n", - "adding: mem time315, current time 332, horizon 17\n", - "adding: mem time316, current time 332, horizon 16\n", - "adding: mem time317, current time 332, horizon 15\n", - "adding: mem time318, current time 332, horizon 14\n", - "adding: mem time319, current time 332, horizon 13\n", - "adding: mem time320, current time 332, horizon 12\n", - "adding: mem time321, current time 332, horizon 11\n", - "adding: mem time322, current time 332, horizon 10\n", - "adding: mem time323, current time 332, horizon 9\n", - "adding: mem time324, current time 332, horizon 8\n", - "adding: mem time325, current time 332, horizon 7\n", - "adding: mem time326, current time 332, horizon 6\n", - "adding: mem time327, current time 332, horizon 5\n", - "adding: mem time328, current time 332, horizon 4\n", - "adding: mem time329, current time 332, horizon 3\n", - "adding: mem time330, current time 332, horizon 2\n", - "adding: mem time331, current time 332, horizon 1\n", - "adding: mem time200, current time 333, horizon 133\n", - "adding: mem time201, current time 333, horizon 132\n", - "adding: mem time202, current time 333, horizon 131\n", - "adding: mem time203, current time 333, horizon 130\n", - "adding: mem time204, current time 333, horizon 129\n", - "adding: mem time205, current time 333, horizon 128\n", - "adding: mem time206, current time 333, horizon 127\n", - "adding: mem time207, current time 333, horizon 126\n", - "adding: mem time208, current time 333, horizon 125\n", - "adding: mem time209, current time 333, horizon 124\n", - "adding: mem time210, current time 333, horizon 123\n", - "adding: mem time211, current time 333, horizon 122\n", - "adding: mem time212, current time 333, horizon 121\n", - "adding: mem time213, current time 333, horizon 120\n", - "adding: mem time214, current time 333, horizon 119\n", - "adding: mem time215, current time 333, horizon 118\n", - "adding: mem time216, current time 333, horizon 117\n", - "adding: mem time217, current time 333, horizon 116\n", - "adding: mem time218, current time 333, horizon 115\n", - "adding: mem time219, current time 333, horizon 114\n", - "adding: mem time220, current time 333, horizon 113\n", - "adding: mem time221, current time 333, horizon 112\n", - "adding: mem time222, current time 333, horizon 111\n", - "adding: mem time223, current time 333, horizon 110\n", - "adding: mem time224, current time 333, horizon 109\n", - "adding: mem time225, current time 333, horizon 108\n", - "adding: mem time226, current time 333, horizon 107\n", - "adding: mem time227, current time 333, horizon 106\n", - "adding: mem time228, current time 333, horizon 105\n", - "adding: mem time229, current time 333, horizon 104\n", - "adding: mem time230, current time 333, horizon 103\n", - "adding: mem time231, current time 333, horizon 102\n", - "adding: mem time232, current time 333, horizon 101\n", - "adding: mem time233, current time 333, horizon 100\n", - "adding: mem time234, current time 333, horizon 99\n", - "adding: mem time235, current time 333, horizon 98\n", - "adding: mem time236, current time 333, horizon 97\n", - "adding: mem time237, current time 333, horizon 96\n", - "adding: mem time238, current time 333, horizon 95\n", - "adding: mem time239, current time 333, horizon 94\n", - "adding: mem time240, current time 333, horizon 93\n", - "adding: mem time241, current time 333, horizon 92\n", - "adding: mem time242, current time 333, horizon 91\n", - "adding: mem time243, current time 333, horizon 90\n", - "adding: mem time244, current time 333, horizon 89\n", - "adding: mem time245, current time 333, horizon 88\n", - "adding: mem time246, current time 333, horizon 87\n", - "adding: mem time247, current time 333, horizon 86\n", - "adding: mem time248, current time 333, horizon 85\n", - "adding: mem time249, current time 333, horizon 84\n", - "adding: mem time250, current time 333, horizon 83\n", - "adding: mem time251, current time 333, horizon 82\n", - "adding: mem time252, current time 333, horizon 81\n", - "adding: mem time253, current time 333, horizon 80\n", - "adding: mem time254, current time 333, horizon 79\n", - "adding: mem time255, current time 333, horizon 78\n", - "adding: mem time256, current time 333, horizon 77\n", - "adding: mem time257, current time 333, horizon 76\n", - "adding: mem time258, current time 333, horizon 75\n", - "adding: mem time259, current time 333, horizon 74\n", - "adding: mem time260, current time 333, horizon 73\n", - "adding: mem time261, current time 333, horizon 72\n", - "adding: mem time262, current time 333, horizon 71\n", - "adding: mem time263, current time 333, horizon 70\n", - "adding: mem time264, current time 333, horizon 69\n", - "adding: mem time265, current time 333, horizon 68\n", - "adding: mem time266, current time 333, horizon 67\n", - "adding: mem time267, current time 333, horizon 66\n", - "adding: mem time268, current time 333, horizon 65\n", - "adding: mem time269, current time 333, horizon 64\n", - "adding: mem time270, current time 333, horizon 63\n", - "adding: mem time271, current time 333, horizon 62\n", - "adding: mem time272, current time 333, horizon 61\n", - "adding: mem time273, current time 333, horizon 60\n", - "adding: mem time274, current time 333, horizon 59\n", - "adding: mem time275, current time 333, horizon 58\n", - "adding: mem time276, current time 333, horizon 57\n", - "adding: mem time277, current time 333, horizon 56\n", - "adding: mem time278, current time 333, horizon 55\n", - "adding: mem time279, current time 333, horizon 54\n", - "adding: mem time280, current time 333, horizon 53\n", - "adding: mem time281, current time 333, horizon 52\n", - "adding: mem time282, current time 333, horizon 51\n", - "adding: mem time283, current time 333, horizon 50\n", - "adding: mem time284, current time 333, horizon 49\n", - "adding: mem time285, current time 333, horizon 48\n", - "adding: mem time286, current time 333, horizon 47\n", - "adding: mem time287, current time 333, horizon 46\n", - "adding: mem time288, current time 333, horizon 45\n", - "adding: mem time289, current time 333, horizon 44\n", - "adding: mem time290, current time 333, horizon 43\n", - "adding: mem time291, current time 333, horizon 42\n", - "adding: mem time292, current time 333, horizon 41\n", - "adding: mem time293, current time 333, horizon 40\n", - "adding: mem time294, current time 333, horizon 39\n", - "adding: mem time295, current time 333, horizon 38\n", - "adding: mem time296, current time 333, horizon 37\n", - "adding: mem time297, current time 333, horizon 36\n", - "adding: mem time298, current time 333, horizon 35\n", - "adding: mem time299, current time 333, horizon 34\n", - "adding: mem time300, current time 333, horizon 33\n", - "adding: mem time301, current time 333, horizon 32\n", - "adding: mem time302, current time 333, horizon 31\n", - "adding: mem time303, current time 333, horizon 30\n", - "adding: mem time304, current time 333, horizon 29\n", - "adding: mem time305, current time 333, horizon 28\n", - "adding: mem time306, current time 333, horizon 27\n", - "adding: mem time307, current time 333, horizon 26\n", - "adding: mem time308, current time 333, horizon 25\n", - "adding: mem time309, current time 333, horizon 24\n", - "adding: mem time310, current time 333, horizon 23\n", - "adding: mem time311, current time 333, horizon 22\n", - "adding: mem time312, current time 333, horizon 21\n", - "adding: mem time313, current time 333, horizon 20\n", - "adding: mem time314, current time 333, horizon 19\n", - "adding: mem time315, current time 333, horizon 18\n", - "adding: mem time316, current time 333, horizon 17\n", - "adding: mem time317, current time 333, horizon 16\n", - "adding: mem time318, current time 333, horizon 15\n", - "adding: mem time319, current time 333, horizon 14\n", - "adding: mem time320, current time 333, horizon 13\n", - "adding: mem time321, current time 333, horizon 12\n", - "adding: mem time322, current time 333, horizon 11\n", - "adding: mem time323, current time 333, horizon 10\n", - "adding: mem time324, current time 333, horizon 9\n", - "adding: mem time325, current time 333, horizon 8\n", - "adding: mem time326, current time 333, horizon 7\n", - "adding: mem time327, current time 333, horizon 6\n", - "adding: mem time328, current time 333, horizon 5\n", - "adding: mem time329, current time 333, horizon 4\n", - "adding: mem time330, current time 333, horizon 3\n", - "adding: mem time331, current time 333, horizon 2\n", - "adding: mem time332, current time 333, horizon 1\n", - "adding: mem time200, current time 334, horizon 134\n", - "adding: mem time201, current time 334, horizon 133\n", - "adding: mem time202, current time 334, horizon 132\n", - "adding: mem time203, current time 334, horizon 131\n", - "adding: mem time204, current time 334, horizon 130\n", - "adding: mem time205, current time 334, horizon 129\n", - "adding: mem time206, current time 334, horizon 128\n", - "adding: mem time207, current time 334, horizon 127\n", - "adding: mem time208, current time 334, horizon 126\n", - "adding: mem time209, current time 334, horizon 125\n", - "adding: mem time210, current time 334, horizon 124\n", - "adding: mem time211, current time 334, horizon 123\n", - "adding: mem time212, current time 334, horizon 122\n", - "adding: mem time213, current time 334, horizon 121\n", - "adding: mem time214, current time 334, horizon 120\n", - "adding: mem time215, current time 334, horizon 119\n", - "adding: mem time216, current time 334, horizon 118\n", - "adding: mem time217, current time 334, horizon 117\n", - "adding: mem time218, current time 334, horizon 116\n", - "adding: mem time219, current time 334, horizon 115\n", - "adding: mem time220, current time 334, horizon 114\n", - "adding: mem time221, current time 334, horizon 113\n", - "adding: mem time222, current time 334, horizon 112\n", - "adding: mem time223, current time 334, horizon 111\n", - "adding: mem time224, current time 334, horizon 110\n", - "adding: mem time225, current time 334, horizon 109\n", - "adding: mem time226, current time 334, horizon 108\n", - "adding: mem time227, current time 334, horizon 107\n", - "adding: mem time228, current time 334, horizon 106\n", - "adding: mem time229, current time 334, horizon 105\n", - "adding: mem time230, current time 334, horizon 104\n", - "adding: mem time231, current time 334, horizon 103\n", - "adding: mem time232, current time 334, horizon 102\n", - "adding: mem time233, current time 334, horizon 101\n", - "adding: mem time234, current time 334, horizon 100\n", - "adding: mem time235, current time 334, horizon 99\n", - "adding: mem time236, current time 334, horizon 98\n", - "adding: mem time237, current time 334, horizon 97\n", - "adding: mem time238, current time 334, horizon 96\n", - "adding: mem time239, current time 334, horizon 95\n", - "adding: mem time240, current time 334, horizon 94\n", - "adding: mem time241, current time 334, horizon 93\n", - "adding: mem time242, current time 334, horizon 92\n", - "adding: mem time243, current time 334, horizon 91\n", - "adding: mem time244, current time 334, horizon 90\n", - "adding: mem time245, current time 334, horizon 89\n", - "adding: mem time246, current time 334, horizon 88\n", - "adding: mem time247, current time 334, horizon 87\n", - "adding: mem time248, current time 334, horizon 86\n", - "adding: mem time249, current time 334, horizon 85\n", - "adding: mem time250, current time 334, horizon 84\n", - "adding: mem time251, current time 334, horizon 83\n", - "adding: mem time252, current time 334, horizon 82\n", - "adding: mem time253, current time 334, horizon 81\n", - "adding: mem time254, current time 334, horizon 80\n", - "adding: mem time255, current time 334, horizon 79\n", - "adding: mem time256, current time 334, horizon 78\n", - "adding: mem time257, current time 334, horizon 77\n", - "adding: mem time258, current time 334, horizon 76\n", - "adding: mem time259, current time 334, horizon 75\n", - "adding: mem time260, current time 334, horizon 74\n", - "adding: mem time261, current time 334, horizon 73\n", - "adding: mem time262, current time 334, horizon 72\n", - "adding: mem time263, current time 334, horizon 71\n", - "adding: mem time264, current time 334, horizon 70\n", - "adding: mem time265, current time 334, horizon 69\n", - "adding: mem time266, current time 334, horizon 68\n", - "adding: mem time267, current time 334, horizon 67\n", - "adding: mem time268, current time 334, horizon 66\n", - "adding: mem time269, current time 334, horizon 65\n", - "adding: mem time270, current time 334, horizon 64\n", - "adding: mem time271, current time 334, horizon 63\n", - "adding: mem time272, current time 334, horizon 62\n", - "adding: mem time273, current time 334, horizon 61\n", - "adding: mem time274, current time 334, horizon 60\n", - "adding: mem time275, current time 334, horizon 59\n", - "adding: mem time276, current time 334, horizon 58\n", - "adding: mem time277, current time 334, horizon 57\n", - "adding: mem time278, current time 334, horizon 56\n", - "adding: mem time279, current time 334, horizon 55\n", - "adding: mem time280, current time 334, horizon 54\n", - "adding: mem time281, current time 334, horizon 53\n", - "adding: mem time282, current time 334, horizon 52\n", - "adding: mem time283, current time 334, horizon 51\n", - "adding: mem time284, current time 334, horizon 50\n", - "adding: mem time285, current time 334, horizon 49\n", - "adding: mem time286, current time 334, horizon 48\n", - "adding: mem time287, current time 334, horizon 47\n", - "adding: mem time288, current time 334, horizon 46\n", - "adding: mem time289, current time 334, horizon 45\n", - "adding: mem time290, current time 334, horizon 44\n", - "adding: mem time291, current time 334, horizon 43\n", - "adding: mem time292, current time 334, horizon 42\n", - "adding: mem time293, current time 334, horizon 41\n", - "adding: mem time294, current time 334, horizon 40\n", - "adding: mem time295, current time 334, horizon 39\n", - "adding: mem time296, current time 334, horizon 38\n", - "adding: mem time297, current time 334, horizon 37\n", - "adding: mem time298, current time 334, horizon 36\n", - "adding: mem time299, current time 334, horizon 35\n", - "adding: mem time300, current time 334, horizon 34\n", - "adding: mem time301, current time 334, horizon 33\n", - "adding: mem time302, current time 334, horizon 32\n", - "adding: mem time303, current time 334, horizon 31\n", - "adding: mem time304, current time 334, horizon 30\n", - "adding: mem time305, current time 334, horizon 29\n", - "adding: mem time306, current time 334, horizon 28\n", - "adding: mem time307, current time 334, horizon 27\n", - "adding: mem time308, current time 334, horizon 26\n", - "adding: mem time309, current time 334, horizon 25\n", - "adding: mem time310, current time 334, horizon 24\n", - "adding: mem time311, current time 334, horizon 23\n", - "adding: mem time312, current time 334, horizon 22\n", - "adding: mem time313, current time 334, horizon 21\n", - "adding: mem time314, current time 334, horizon 20\n", - "adding: mem time315, current time 334, horizon 19\n", - "adding: mem time316, current time 334, horizon 18\n", - "adding: mem time317, current time 334, horizon 17\n", - "adding: mem time318, current time 334, horizon 16\n", - "adding: mem time319, current time 334, horizon 15\n", - "adding: mem time320, current time 334, horizon 14\n", - "adding: mem time321, current time 334, horizon 13\n", - "adding: mem time322, current time 334, horizon 12\n", - "adding: mem time323, current time 334, horizon 11\n", - "adding: mem time324, current time 334, horizon 10\n", - "adding: mem time325, current time 334, horizon 9\n", - "adding: mem time326, current time 334, horizon 8\n", - "adding: mem time327, current time 334, horizon 7\n", - "adding: mem time328, current time 334, horizon 6\n", - "adding: mem time329, current time 334, horizon 5\n", - "adding: mem time330, current time 334, horizon 4\n", - "adding: mem time331, current time 334, horizon 3\n", - "adding: mem time332, current time 334, horizon 2\n", - "adding: mem time333, current time 334, horizon 1\n", - "adding: mem time200, current time 335, horizon 135\n", - "adding: mem time201, current time 335, horizon 134\n", - "adding: mem time202, current time 335, horizon 133\n", - "adding: mem time203, current time 335, horizon 132\n", - "adding: mem time204, current time 335, horizon 131\n", - "adding: mem time205, current time 335, horizon 130\n", - "adding: mem time206, current time 335, horizon 129\n", - "adding: mem time207, current time 335, horizon 128\n", - "adding: mem time208, current time 335, horizon 127\n", - "adding: mem time209, current time 335, horizon 126\n", - "adding: mem time210, current time 335, horizon 125\n", - "adding: mem time211, current time 335, horizon 124\n", - "adding: mem time212, current time 335, horizon 123\n", - "adding: mem time213, current time 335, horizon 122\n", - "adding: mem time214, current time 335, horizon 121\n", - "adding: mem time215, current time 335, horizon 120\n", - "adding: mem time216, current time 335, horizon 119\n", - "adding: mem time217, current time 335, horizon 118\n", - "adding: mem time218, current time 335, horizon 117\n", - "adding: mem time219, current time 335, horizon 116\n", - "adding: mem time220, current time 335, horizon 115\n", - "adding: mem time221, current time 335, horizon 114\n", - "adding: mem time222, current time 335, horizon 113\n", - "adding: mem time223, current time 335, horizon 112\n", - "adding: mem time224, current time 335, horizon 111\n", - "adding: mem time225, current time 335, horizon 110\n", - "adding: mem time226, current time 335, horizon 109\n", - "adding: mem time227, current time 335, horizon 108\n", - "adding: mem time228, current time 335, horizon 107\n", - "adding: mem time229, current time 335, horizon 106\n", - "adding: mem time230, current time 335, horizon 105\n", - "adding: mem time231, current time 335, horizon 104\n", - "adding: mem time232, current time 335, horizon 103\n", - "adding: mem time233, current time 335, horizon 102\n", - "adding: mem time234, current time 335, horizon 101\n", - "adding: mem time235, current time 335, horizon 100\n", - "adding: mem time236, current time 335, horizon 99\n", - "adding: mem time237, current time 335, horizon 98\n", - "adding: mem time238, current time 335, horizon 97\n", - "adding: mem time239, current time 335, horizon 96\n", - "adding: mem time240, current time 335, horizon 95\n", - "adding: mem time241, current time 335, horizon 94\n", - "adding: mem time242, current time 335, horizon 93\n", - "adding: mem time243, current time 335, horizon 92\n", - "adding: mem time244, current time 335, horizon 91\n", - "adding: mem time245, current time 335, horizon 90\n", - "adding: mem time246, current time 335, horizon 89\n", - "adding: mem time247, current time 335, horizon 88\n", - "adding: mem time248, current time 335, horizon 87\n", - "adding: mem time249, current time 335, horizon 86\n", - "adding: mem time250, current time 335, horizon 85\n", - "adding: mem time251, current time 335, horizon 84\n", - "adding: mem time252, current time 335, horizon 83\n", - "adding: mem time253, current time 335, horizon 82\n", - "adding: mem time254, current time 335, horizon 81\n", - "adding: mem time255, current time 335, horizon 80\n", - "adding: mem time256, current time 335, horizon 79\n", - "adding: mem time257, current time 335, horizon 78\n", - "adding: mem time258, current time 335, horizon 77\n", - "adding: mem time259, current time 335, horizon 76\n", - "adding: mem time260, current time 335, horizon 75\n", - "adding: mem time261, current time 335, horizon 74\n", - "adding: mem time262, current time 335, horizon 73\n", - "adding: mem time263, current time 335, horizon 72\n", - "adding: mem time264, current time 335, horizon 71\n", - "adding: mem time265, current time 335, horizon 70\n", - "adding: mem time266, current time 335, horizon 69\n", - "adding: mem time267, current time 335, horizon 68\n", - "adding: mem time268, current time 335, horizon 67\n", - "adding: mem time269, current time 335, horizon 66\n", - "adding: mem time270, current time 335, horizon 65\n", - "adding: mem time271, current time 335, horizon 64\n", - "adding: mem time272, current time 335, horizon 63\n", - "adding: mem time273, current time 335, horizon 62\n", - "adding: mem time274, current time 335, horizon 61\n", - "adding: mem time275, current time 335, horizon 60\n", - "adding: mem time276, current time 335, horizon 59\n", - "adding: mem time277, current time 335, horizon 58\n", - "adding: mem time278, current time 335, horizon 57\n", - "adding: mem time279, current time 335, horizon 56\n", - "adding: mem time280, current time 335, horizon 55\n", - "adding: mem time281, current time 335, horizon 54\n", - "adding: mem time282, current time 335, horizon 53\n", - "adding: mem time283, current time 335, horizon 52\n", - "adding: mem time284, current time 335, horizon 51\n", - "adding: mem time285, current time 335, horizon 50\n", - "adding: mem time286, current time 335, horizon 49\n", - "adding: mem time287, current time 335, horizon 48\n", - "adding: mem time288, current time 335, horizon 47\n", - "adding: mem time289, current time 335, horizon 46\n", - "adding: mem time290, current time 335, horizon 45\n", - "adding: mem time291, current time 335, horizon 44\n", - "adding: mem time292, current time 335, horizon 43\n", - "adding: mem time293, current time 335, horizon 42\n", - "adding: mem time294, current time 335, horizon 41\n", - "adding: mem time295, current time 335, horizon 40\n", - "adding: mem time296, current time 335, horizon 39\n", - "adding: mem time297, current time 335, horizon 38\n", - "adding: mem time298, current time 335, horizon 37\n", - "adding: mem time299, current time 335, horizon 36\n", - "adding: mem time300, current time 335, horizon 35\n", - "adding: mem time301, current time 335, horizon 34\n", - "adding: mem time302, current time 335, horizon 33\n", - "adding: mem time303, current time 335, horizon 32\n", - "adding: mem time304, current time 335, horizon 31\n", - "adding: mem time305, current time 335, horizon 30\n", - "adding: mem time306, current time 335, horizon 29\n", - "adding: mem time307, current time 335, horizon 28\n", - "adding: mem time308, current time 335, horizon 27\n", - "adding: mem time309, current time 335, horizon 26\n", - "adding: mem time310, current time 335, horizon 25\n", - "adding: mem time311, current time 335, horizon 24\n", - "adding: mem time312, current time 335, horizon 23\n", - "adding: mem time313, current time 335, horizon 22\n", - "adding: mem time314, current time 335, horizon 21\n", - "adding: mem time315, current time 335, horizon 20\n", - "adding: mem time316, current time 335, horizon 19\n", - "adding: mem time317, current time 335, horizon 18\n", - "adding: mem time318, current time 335, horizon 17\n", - "adding: mem time319, current time 335, horizon 16\n", - "adding: mem time320, current time 335, horizon 15\n", - "adding: mem time321, current time 335, horizon 14\n", - "adding: mem time322, current time 335, horizon 13\n", - "adding: mem time323, current time 335, horizon 12\n", - "adding: mem time324, current time 335, horizon 11\n", - "adding: mem time325, current time 335, horizon 10\n", - "adding: mem time326, current time 335, horizon 9\n", - "adding: mem time327, current time 335, horizon 8\n", - "adding: mem time328, current time 335, horizon 7\n", - "adding: mem time329, current time 335, horizon 6\n", - "adding: mem time330, current time 335, horizon 5\n", - "adding: mem time331, current time 335, horizon 4\n", - "adding: mem time332, current time 335, horizon 3\n", - "adding: mem time333, current time 335, horizon 2\n", - "adding: mem time334, current time 335, horizon 1\n", - "adding: mem time200, current time 336, horizon 136\n", - "adding: mem time201, current time 336, horizon 135\n", - "adding: mem time202, current time 336, horizon 134\n", - "adding: mem time203, current time 336, horizon 133\n", - "adding: mem time204, current time 336, horizon 132\n", - "adding: mem time205, current time 336, horizon 131\n", - "adding: mem time206, current time 336, horizon 130\n", - "adding: mem time207, current time 336, horizon 129\n", - "adding: mem time208, current time 336, horizon 128\n", - "adding: mem time209, current time 336, horizon 127\n", - "adding: mem time210, current time 336, horizon 126\n", - "adding: mem time211, current time 336, horizon 125\n", - "adding: mem time212, current time 336, horizon 124\n", - "adding: mem time213, current time 336, horizon 123\n", - "adding: mem time214, current time 336, horizon 122\n", - "adding: mem time215, current time 336, horizon 121\n", - "adding: mem time216, current time 336, horizon 120\n", - "adding: mem time217, current time 336, horizon 119\n", - "adding: mem time218, current time 336, horizon 118\n", - "adding: mem time219, current time 336, horizon 117\n", - "adding: mem time220, current time 336, horizon 116\n", - "adding: mem time221, current time 336, horizon 115\n", - "adding: mem time222, current time 336, horizon 114\n", - "adding: mem time223, current time 336, horizon 113\n", - "adding: mem time224, current time 336, horizon 112\n", - "adding: mem time225, current time 336, horizon 111\n", - "adding: mem time226, current time 336, horizon 110\n", - "adding: mem time227, current time 336, horizon 109\n", - "adding: mem time228, current time 336, horizon 108\n", - "adding: mem time229, current time 336, horizon 107\n", - "adding: mem time230, current time 336, horizon 106\n", - "adding: mem time231, current time 336, horizon 105\n", - "adding: mem time232, current time 336, horizon 104\n", - "adding: mem time233, current time 336, horizon 103\n", - "adding: mem time234, current time 336, horizon 102\n", - "adding: mem time235, current time 336, horizon 101\n", - "adding: mem time236, current time 336, horizon 100\n", - "adding: mem time237, current time 336, horizon 99\n", - "adding: mem time238, current time 336, horizon 98\n", - "adding: mem time239, current time 336, horizon 97\n", - "adding: mem time240, current time 336, horizon 96\n", - "adding: mem time241, current time 336, horizon 95\n", - "adding: mem time242, current time 336, horizon 94\n", - "adding: mem time243, current time 336, horizon 93\n", - "adding: mem time244, current time 336, horizon 92\n", - "adding: mem time245, current time 336, horizon 91\n", - "adding: mem time246, current time 336, horizon 90\n", - "adding: mem time247, current time 336, horizon 89\n", - "adding: mem time248, current time 336, horizon 88\n", - "adding: mem time249, current time 336, horizon 87\n", - "adding: mem time250, current time 336, horizon 86\n", - "adding: mem time251, current time 336, horizon 85\n", - "adding: mem time252, current time 336, horizon 84\n", - "adding: mem time253, current time 336, horizon 83\n", - "adding: mem time254, current time 336, horizon 82\n", - "adding: mem time255, current time 336, horizon 81\n", - "adding: mem time256, current time 336, horizon 80\n", - "adding: mem time257, current time 336, horizon 79\n", - "adding: mem time258, current time 336, horizon 78\n", - "adding: mem time259, current time 336, horizon 77\n", - "adding: mem time260, current time 336, horizon 76\n", - "adding: mem time261, current time 336, horizon 75\n", - "adding: mem time262, current time 336, horizon 74\n", - "adding: mem time263, current time 336, horizon 73\n", - "adding: mem time264, current time 336, horizon 72\n", - "adding: mem time265, current time 336, horizon 71\n", - "adding: mem time266, current time 336, horizon 70\n", - "adding: mem time267, current time 336, horizon 69\n", - "adding: mem time268, current time 336, horizon 68\n", - "adding: mem time269, current time 336, horizon 67\n", - "adding: mem time270, current time 336, horizon 66\n", - "adding: mem time271, current time 336, horizon 65\n", - "adding: mem time272, current time 336, horizon 64\n", - "adding: mem time273, current time 336, horizon 63\n", - "adding: mem time274, current time 336, horizon 62\n", - "adding: mem time275, current time 336, horizon 61\n", - "adding: mem time276, current time 336, horizon 60\n", - "adding: mem time277, current time 336, horizon 59\n", - "adding: mem time278, current time 336, horizon 58\n", - "adding: mem time279, current time 336, horizon 57\n", - "adding: mem time280, current time 336, horizon 56\n", - "adding: mem time281, current time 336, horizon 55\n", - "adding: mem time282, current time 336, horizon 54\n", - "adding: mem time283, current time 336, horizon 53\n", - "adding: mem time284, current time 336, horizon 52\n", - "adding: mem time285, current time 336, horizon 51\n", - "adding: mem time286, current time 336, horizon 50\n", - "adding: mem time287, current time 336, horizon 49\n", - "adding: mem time288, current time 336, horizon 48\n", - "adding: mem time289, current time 336, horizon 47\n", - "adding: mem time290, current time 336, horizon 46\n", - "adding: mem time291, current time 336, horizon 45\n", - "adding: mem time292, current time 336, horizon 44\n", - "adding: mem time293, current time 336, horizon 43\n", - "adding: mem time294, current time 336, horizon 42\n", - "adding: mem time295, current time 336, horizon 41\n", - "adding: mem time296, current time 336, horizon 40\n", - "adding: mem time297, current time 336, horizon 39\n", - "adding: mem time298, current time 336, horizon 38\n", - "adding: mem time299, current time 336, horizon 37\n", - "adding: mem time300, current time 336, horizon 36\n", - "adding: mem time301, current time 336, horizon 35\n", - "adding: mem time302, current time 336, horizon 34\n", - "adding: mem time303, current time 336, horizon 33\n", - "adding: mem time304, current time 336, horizon 32\n", - "adding: mem time305, current time 336, horizon 31\n", - "adding: mem time306, current time 336, horizon 30\n", - "adding: mem time307, current time 336, horizon 29\n", - "adding: mem time308, current time 336, horizon 28\n", - "adding: mem time309, current time 336, horizon 27\n", - "adding: mem time310, current time 336, horizon 26\n", - "adding: mem time311, current time 336, horizon 25\n", - "adding: mem time312, current time 336, horizon 24\n", - "adding: mem time313, current time 336, horizon 23\n", - "adding: mem time314, current time 336, horizon 22\n", - "adding: mem time315, current time 336, horizon 21\n", - "adding: mem time316, current time 336, horizon 20\n", - "adding: mem time317, current time 336, horizon 19\n", - "adding: mem time318, current time 336, horizon 18\n", - "adding: mem time319, current time 336, horizon 17\n", - "adding: mem time320, current time 336, horizon 16\n", - "adding: mem time321, current time 336, horizon 15\n", - "adding: mem time322, current time 336, horizon 14\n", - "adding: mem time323, current time 336, horizon 13\n", - "adding: mem time324, current time 336, horizon 12\n", - "adding: mem time325, current time 336, horizon 11\n", - "adding: mem time326, current time 336, horizon 10\n", - "adding: mem time327, current time 336, horizon 9\n", - "adding: mem time328, current time 336, horizon 8\n", - "adding: mem time329, current time 336, horizon 7\n", - "adding: mem time330, current time 336, horizon 6\n", - "adding: mem time331, current time 336, horizon 5\n", - "adding: mem time332, current time 336, horizon 4\n", - "adding: mem time333, current time 336, horizon 3\n", - "adding: mem time334, current time 336, horizon 2\n", - "adding: mem time335, current time 336, horizon 1\n", - "adding: mem time200, current time 337, horizon 137\n", - "adding: mem time201, current time 337, horizon 136\n", - "adding: mem time202, current time 337, horizon 135\n", - "adding: mem time203, current time 337, horizon 134\n", - "adding: mem time204, current time 337, horizon 133\n", - "adding: mem time205, current time 337, horizon 132\n", - "adding: mem time206, current time 337, horizon 131\n", - "adding: mem time207, current time 337, horizon 130\n", - "adding: mem time208, current time 337, horizon 129\n", - "adding: mem time209, current time 337, horizon 128\n", - "adding: mem time210, current time 337, horizon 127\n", - "adding: mem time211, current time 337, horizon 126\n", - "adding: mem time212, current time 337, horizon 125\n", - "adding: mem time213, current time 337, horizon 124\n", - "adding: mem time214, current time 337, horizon 123\n", - "adding: mem time215, current time 337, horizon 122\n", - "adding: mem time216, current time 337, horizon 121\n", - "adding: mem time217, current time 337, horizon 120\n", - "adding: mem time218, current time 337, horizon 119\n", - "adding: mem time219, current time 337, horizon 118\n", - "adding: mem time220, current time 337, horizon 117\n", - "adding: mem time221, current time 337, horizon 116\n", - "adding: mem time222, current time 337, horizon 115\n", - "adding: mem time223, current time 337, horizon 114\n", - "adding: mem time224, current time 337, horizon 113\n", - "adding: mem time225, current time 337, horizon 112\n", - "adding: mem time226, current time 337, horizon 111\n", - "adding: mem time227, current time 337, horizon 110\n", - "adding: mem time228, current time 337, horizon 109\n", - "adding: mem time229, current time 337, horizon 108\n", - "adding: mem time230, current time 337, horizon 107\n", - "adding: mem time231, current time 337, horizon 106\n", - "adding: mem time232, current time 337, horizon 105\n", - "adding: mem time233, current time 337, horizon 104\n", - "adding: mem time234, current time 337, horizon 103\n", - "adding: mem time235, current time 337, horizon 102\n", - "adding: mem time236, current time 337, horizon 101\n", - "adding: mem time237, current time 337, horizon 100\n", - "adding: mem time238, current time 337, horizon 99\n", - "adding: mem time239, current time 337, horizon 98\n", - "adding: mem time240, current time 337, horizon 97\n", - "adding: mem time241, current time 337, horizon 96\n", - "adding: mem time242, current time 337, horizon 95\n", - "adding: mem time243, current time 337, horizon 94\n", - "adding: mem time244, current time 337, horizon 93\n", - "adding: mem time245, current time 337, horizon 92\n", - "adding: mem time246, current time 337, horizon 91\n", - "adding: mem time247, current time 337, horizon 90\n", - "adding: mem time248, current time 337, horizon 89\n", - "adding: mem time249, current time 337, horizon 88\n", - "adding: mem time250, current time 337, horizon 87\n", - "adding: mem time251, current time 337, horizon 86\n", - "adding: mem time252, current time 337, horizon 85\n", - "adding: mem time253, current time 337, horizon 84\n", - "adding: mem time254, current time 337, horizon 83\n", - "adding: mem time255, current time 337, horizon 82\n", - "adding: mem time256, current time 337, horizon 81\n", - "adding: mem time257, current time 337, horizon 80\n", - "adding: mem time258, current time 337, horizon 79\n", - "adding: mem time259, current time 337, horizon 78\n", - "adding: mem time260, current time 337, horizon 77\n", - "adding: mem time261, current time 337, horizon 76\n", - "adding: mem time262, current time 337, horizon 75\n", - "adding: mem time263, current time 337, horizon 74\n", - "adding: mem time264, current time 337, horizon 73\n", - "adding: mem time265, current time 337, horizon 72\n", - "adding: mem time266, current time 337, horizon 71\n", - "adding: mem time267, current time 337, horizon 70\n", - "adding: mem time268, current time 337, horizon 69\n", - "adding: mem time269, current time 337, horizon 68\n", - "adding: mem time270, current time 337, horizon 67\n", - "adding: mem time271, current time 337, horizon 66\n", - "adding: mem time272, current time 337, horizon 65\n", - "adding: mem time273, current time 337, horizon 64\n", - "adding: mem time274, current time 337, horizon 63\n", - "adding: mem time275, current time 337, horizon 62\n", - "adding: mem time276, current time 337, horizon 61\n", - "adding: mem time277, current time 337, horizon 60\n", - "adding: mem time278, current time 337, horizon 59\n", - "adding: mem time279, current time 337, horizon 58\n", - "adding: mem time280, current time 337, horizon 57\n", - "adding: mem time281, current time 337, horizon 56\n", - "adding: mem time282, current time 337, horizon 55\n", - "adding: mem time283, current time 337, horizon 54\n", - "adding: mem time284, current time 337, horizon 53\n", - "adding: mem time285, current time 337, horizon 52\n", - "adding: mem time286, current time 337, horizon 51\n", - "adding: mem time287, current time 337, horizon 50\n", - "adding: mem time288, current time 337, horizon 49\n", - "adding: mem time289, current time 337, horizon 48\n", - "adding: mem time290, current time 337, horizon 47\n", - "adding: mem time291, current time 337, horizon 46\n", - "adding: mem time292, current time 337, horizon 45\n", - "adding: mem time293, current time 337, horizon 44\n", - "adding: mem time294, current time 337, horizon 43\n", - "adding: mem time295, current time 337, horizon 42\n", - "adding: mem time296, current time 337, horizon 41\n", - "adding: mem time297, current time 337, horizon 40\n", - "adding: mem time298, current time 337, horizon 39\n", - "adding: mem time299, current time 337, horizon 38\n", - "adding: mem time300, current time 337, horizon 37\n", - "adding: mem time301, current time 337, horizon 36\n", - "adding: mem time302, current time 337, horizon 35\n", - "adding: mem time303, current time 337, horizon 34\n", - "adding: mem time304, current time 337, horizon 33\n", - "adding: mem time305, current time 337, horizon 32\n", - "adding: mem time306, current time 337, horizon 31\n", - "adding: mem time307, current time 337, horizon 30\n", - "adding: mem time308, current time 337, horizon 29\n", - "adding: mem time309, current time 337, horizon 28\n", - "adding: mem time310, current time 337, horizon 27\n", - "adding: mem time311, current time 337, horizon 26\n", - "adding: mem time312, current time 337, horizon 25\n", - "adding: mem time313, current time 337, horizon 24\n", - "adding: mem time314, current time 337, horizon 23\n", - "adding: mem time315, current time 337, horizon 22\n", - "adding: mem time316, current time 337, horizon 21\n", - "adding: mem time317, current time 337, horizon 20\n", - "adding: mem time318, current time 337, horizon 19\n", - "adding: mem time319, current time 337, horizon 18\n", - "adding: mem time320, current time 337, horizon 17\n", - "adding: mem time321, current time 337, horizon 16\n", - "adding: mem time322, current time 337, horizon 15\n", - "adding: mem time323, current time 337, horizon 14\n", - "adding: mem time324, current time 337, horizon 13\n", - "adding: mem time325, current time 337, horizon 12\n", - "adding: mem time326, current time 337, horizon 11\n", - "adding: mem time327, current time 337, horizon 10\n", - "adding: mem time328, current time 337, horizon 9\n", - "adding: mem time329, current time 337, horizon 8\n", - "adding: mem time330, current time 337, horizon 7\n", - "adding: mem time331, current time 337, horizon 6\n", - "adding: mem time332, current time 337, horizon 5\n", - "adding: mem time333, current time 337, horizon 4\n", - "adding: mem time334, current time 337, horizon 3\n", - "adding: mem time335, current time 337, horizon 2\n", - "adding: mem time336, current time 337, horizon 1\n", - "adding: mem time200, current time 338, horizon 138\n", - "adding: mem time201, current time 338, horizon 137\n", - "adding: mem time202, current time 338, horizon 136\n", - "adding: mem time203, current time 338, horizon 135\n", - "adding: mem time204, current time 338, horizon 134\n", - "adding: mem time205, current time 338, horizon 133\n", - "adding: mem time206, current time 338, horizon 132\n", - "adding: mem time207, current time 338, horizon 131\n", - "adding: mem time208, current time 338, horizon 130\n", - "adding: mem time209, current time 338, horizon 129\n", - "adding: mem time210, current time 338, horizon 128\n", - "adding: mem time211, current time 338, horizon 127\n", - "adding: mem time212, current time 338, horizon 126\n", - "adding: mem time213, current time 338, horizon 125\n", - "adding: mem time214, current time 338, horizon 124\n", - "adding: mem time215, current time 338, horizon 123\n", - "adding: mem time216, current time 338, horizon 122\n", - "adding: mem time217, current time 338, horizon 121\n", - "adding: mem time218, current time 338, horizon 120\n", - "adding: mem time219, current time 338, horizon 119\n", - "adding: mem time220, current time 338, horizon 118\n", - "adding: mem time221, current time 338, horizon 117\n", - "adding: mem time222, current time 338, horizon 116\n", - "adding: mem time223, current time 338, horizon 115\n", - "adding: mem time224, current time 338, horizon 114\n", - "adding: mem time225, current time 338, horizon 113\n", - "adding: mem time226, current time 338, horizon 112\n", - "adding: mem time227, current time 338, horizon 111\n", - "adding: mem time228, current time 338, horizon 110\n", - "adding: mem time229, current time 338, horizon 109\n", - "adding: mem time230, current time 338, horizon 108\n", - "adding: mem time231, current time 338, horizon 107\n", - "adding: mem time232, current time 338, horizon 106\n", - "adding: mem time233, current time 338, horizon 105\n", - "adding: mem time234, current time 338, horizon 104\n", - "adding: mem time235, current time 338, horizon 103\n", - "adding: mem time236, current time 338, horizon 102\n", - "adding: mem time237, current time 338, horizon 101\n", - "adding: mem time238, current time 338, horizon 100\n", - "adding: mem time239, current time 338, horizon 99\n", - "adding: mem time240, current time 338, horizon 98\n", - "adding: mem time241, current time 338, horizon 97\n", - "adding: mem time242, current time 338, horizon 96\n", - "adding: mem time243, current time 338, horizon 95\n", - "adding: mem time244, current time 338, horizon 94\n", - "adding: mem time245, current time 338, horizon 93\n", - "adding: mem time246, current time 338, horizon 92\n", - "adding: mem time247, current time 338, horizon 91\n", - "adding: mem time248, current time 338, horizon 90\n", - "adding: mem time249, current time 338, horizon 89\n", - "adding: mem time250, current time 338, horizon 88\n", - "adding: mem time251, current time 338, horizon 87\n", - "adding: mem time252, current time 338, horizon 86\n", - "adding: mem time253, current time 338, horizon 85\n", - "adding: mem time254, current time 338, horizon 84\n", - "adding: mem time255, current time 338, horizon 83\n", - "adding: mem time256, current time 338, horizon 82\n", - "adding: mem time257, current time 338, horizon 81\n", - "adding: mem time258, current time 338, horizon 80\n", - "adding: mem time259, current time 338, horizon 79\n", - "adding: mem time260, current time 338, horizon 78\n", - "adding: mem time261, current time 338, horizon 77\n", - "adding: mem time262, current time 338, horizon 76\n", - "adding: mem time263, current time 338, horizon 75\n", - "adding: mem time264, current time 338, horizon 74\n", - "adding: mem time265, current time 338, horizon 73\n", - "adding: mem time266, current time 338, horizon 72\n", - "adding: mem time267, current time 338, horizon 71\n", - "adding: mem time268, current time 338, horizon 70\n", - "adding: mem time269, current time 338, horizon 69\n", - "adding: mem time270, current time 338, horizon 68\n", - "adding: mem time271, current time 338, horizon 67\n", - "adding: mem time272, current time 338, horizon 66\n", - "adding: mem time273, current time 338, horizon 65\n", - "adding: mem time274, current time 338, horizon 64\n", - "adding: mem time275, current time 338, horizon 63\n", - "adding: mem time276, current time 338, horizon 62\n", - "adding: mem time277, current time 338, horizon 61\n", - "adding: mem time278, current time 338, horizon 60\n", - "adding: mem time279, current time 338, horizon 59\n", - "adding: mem time280, current time 338, horizon 58\n", - "adding: mem time281, current time 338, horizon 57\n", - "adding: mem time282, current time 338, horizon 56\n", - "adding: mem time283, current time 338, horizon 55\n", - "adding: mem time284, current time 338, horizon 54\n", - "adding: mem time285, current time 338, horizon 53\n", - "adding: mem time286, current time 338, horizon 52\n", - "adding: mem time287, current time 338, horizon 51\n", - "adding: mem time288, current time 338, horizon 50\n", - "adding: mem time289, current time 338, horizon 49\n", - "adding: mem time290, current time 338, horizon 48\n", - "adding: mem time291, current time 338, horizon 47\n", - "adding: mem time292, current time 338, horizon 46\n", - "adding: mem time293, current time 338, horizon 45\n", - "adding: mem time294, current time 338, horizon 44\n", - "adding: mem time295, current time 338, horizon 43\n", - "adding: mem time296, current time 338, horizon 42\n", - "adding: mem time297, current time 338, horizon 41\n", - "adding: mem time298, current time 338, horizon 40\n", - "adding: mem time299, current time 338, horizon 39\n", - "adding: mem time300, current time 338, horizon 38\n", - "adding: mem time301, current time 338, horizon 37\n", - "adding: mem time302, current time 338, horizon 36\n", - "adding: mem time303, current time 338, horizon 35\n", - "adding: mem time304, current time 338, horizon 34\n", - "adding: mem time305, current time 338, horizon 33\n", - "adding: mem time306, current time 338, horizon 32\n", - "adding: mem time307, current time 338, horizon 31\n", - "adding: mem time308, current time 338, horizon 30\n", - "adding: mem time309, current time 338, horizon 29\n", - "adding: mem time310, current time 338, horizon 28\n", - "adding: mem time311, current time 338, horizon 27\n", - "adding: mem time312, current time 338, horizon 26\n", - "adding: mem time313, current time 338, horizon 25\n", - "adding: mem time314, current time 338, horizon 24\n", - "adding: mem time315, current time 338, horizon 23\n", - "adding: mem time316, current time 338, horizon 22\n", - "adding: mem time317, current time 338, horizon 21\n", - "adding: mem time318, current time 338, horizon 20\n", - "adding: mem time319, current time 338, horizon 19\n", - "adding: mem time320, current time 338, horizon 18\n", - "adding: mem time321, current time 338, horizon 17\n", - "adding: mem time322, current time 338, horizon 16\n", - "adding: mem time323, current time 338, horizon 15\n", - "adding: mem time324, current time 338, horizon 14\n", - "adding: mem time325, current time 338, horizon 13\n", - "adding: mem time326, current time 338, horizon 12\n", - "adding: mem time327, current time 338, horizon 11\n", - "adding: mem time328, current time 338, horizon 10\n", - "adding: mem time329, current time 338, horizon 9\n", - "adding: mem time330, current time 338, horizon 8\n", - "adding: mem time331, current time 338, horizon 7\n", - "adding: mem time332, current time 338, horizon 6\n", - "adding: mem time333, current time 338, horizon 5\n", - "adding: mem time334, current time 338, horizon 4\n", - "adding: mem time335, current time 338, horizon 3\n", - "adding: mem time336, current time 338, horizon 2\n", - "adding: mem time337, current time 338, horizon 1\n", - "adding: mem time200, current time 339, horizon 139\n", - "adding: mem time201, current time 339, horizon 138\n", - "adding: mem time202, current time 339, horizon 137\n", - "adding: mem time203, current time 339, horizon 136\n", - "adding: mem time204, current time 339, horizon 135\n", - "adding: mem time205, current time 339, horizon 134\n", - "adding: mem time206, current time 339, horizon 133\n", - "adding: mem time207, current time 339, horizon 132\n", - "adding: mem time208, current time 339, horizon 131\n", - "adding: mem time209, current time 339, horizon 130\n", - "adding: mem time210, current time 339, horizon 129\n", - "adding: mem time211, current time 339, horizon 128\n", - "adding: mem time212, current time 339, horizon 127\n", - "adding: mem time213, current time 339, horizon 126\n", - "adding: mem time214, current time 339, horizon 125\n", - "adding: mem time215, current time 339, horizon 124\n", - "adding: mem time216, current time 339, horizon 123\n", - "adding: mem time217, current time 339, horizon 122\n", - "adding: mem time218, current time 339, horizon 121\n", - "adding: mem time219, current time 339, horizon 120\n", - "adding: mem time220, current time 339, horizon 119\n", - "adding: mem time221, current time 339, horizon 118\n", - "adding: mem time222, current time 339, horizon 117\n", - "adding: mem time223, current time 339, horizon 116\n", - "adding: mem time224, current time 339, horizon 115\n", - "adding: mem time225, current time 339, horizon 114\n", - "adding: mem time226, current time 339, horizon 113\n", - "adding: mem time227, current time 339, horizon 112\n", - "adding: mem time228, current time 339, horizon 111\n", - "adding: mem time229, current time 339, horizon 110\n", - "adding: mem time230, current time 339, horizon 109\n", - "adding: mem time231, current time 339, horizon 108\n", - "adding: mem time232, current time 339, horizon 107\n", - "adding: mem time233, current time 339, horizon 106\n", - "adding: mem time234, current time 339, horizon 105\n", - "adding: mem time235, current time 339, horizon 104\n", - "adding: mem time236, current time 339, horizon 103\n", - "adding: mem time237, current time 339, horizon 102\n", - "adding: mem time238, current time 339, horizon 101\n", - "adding: mem time239, current time 339, horizon 100\n", - "adding: mem time240, current time 339, horizon 99\n", - "adding: mem time241, current time 339, horizon 98\n", - "adding: mem time242, current time 339, horizon 97\n", - "adding: mem time243, current time 339, horizon 96\n", - "adding: mem time244, current time 339, horizon 95\n", - "adding: mem time245, current time 339, horizon 94\n", - "adding: mem time246, current time 339, horizon 93\n", - "adding: mem time247, current time 339, horizon 92\n", - "adding: mem time248, current time 339, horizon 91\n", - "adding: mem time249, current time 339, horizon 90\n", - "adding: mem time250, current time 339, horizon 89\n", - "adding: mem time251, current time 339, horizon 88\n", - "adding: mem time252, current time 339, horizon 87\n", - "adding: mem time253, current time 339, horizon 86\n", - "adding: mem time254, current time 339, horizon 85\n", - "adding: mem time255, current time 339, horizon 84\n", - "adding: mem time256, current time 339, horizon 83\n", - "adding: mem time257, current time 339, horizon 82\n", - "adding: mem time258, current time 339, horizon 81\n", - "adding: mem time259, current time 339, horizon 80\n", - "adding: mem time260, current time 339, horizon 79\n", - "adding: mem time261, current time 339, horizon 78\n", - "adding: mem time262, current time 339, horizon 77\n", - "adding: mem time263, current time 339, horizon 76\n", - "adding: mem time264, current time 339, horizon 75\n", - "adding: mem time265, current time 339, horizon 74\n", - "adding: mem time266, current time 339, horizon 73\n", - "adding: mem time267, current time 339, horizon 72\n", - "adding: mem time268, current time 339, horizon 71\n", - "adding: mem time269, current time 339, horizon 70\n", - "adding: mem time270, current time 339, horizon 69\n", - "adding: mem time271, current time 339, horizon 68\n", - "adding: mem time272, current time 339, horizon 67\n", - "adding: mem time273, current time 339, horizon 66\n", - "adding: mem time274, current time 339, horizon 65\n", - "adding: mem time275, current time 339, horizon 64\n", - "adding: mem time276, current time 339, horizon 63\n", - "adding: mem time277, current time 339, horizon 62\n", - "adding: mem time278, current time 339, horizon 61\n", - "adding: mem time279, current time 339, horizon 60\n", - "adding: mem time280, current time 339, horizon 59\n", - "adding: mem time281, current time 339, horizon 58\n", - "adding: mem time282, current time 339, horizon 57\n", - "adding: mem time283, current time 339, horizon 56\n", - "adding: mem time284, current time 339, horizon 55\n", - "adding: mem time285, current time 339, horizon 54\n", - "adding: mem time286, current time 339, horizon 53\n", - "adding: mem time287, current time 339, horizon 52\n", - "adding: mem time288, current time 339, horizon 51\n", - "adding: mem time289, current time 339, horizon 50\n", - "adding: mem time290, current time 339, horizon 49\n", - "adding: mem time291, current time 339, horizon 48\n", - "adding: mem time292, current time 339, horizon 47\n", - "adding: mem time293, current time 339, horizon 46\n", - "adding: mem time294, current time 339, horizon 45\n", - "adding: mem time295, current time 339, horizon 44\n", - "adding: mem time296, current time 339, horizon 43\n", - "adding: mem time297, current time 339, horizon 42\n", - "adding: mem time298, current time 339, horizon 41\n", - "adding: mem time299, current time 339, horizon 40\n", - "adding: mem time300, current time 339, horizon 39\n", - "adding: mem time301, current time 339, horizon 38\n", - "adding: mem time302, current time 339, horizon 37\n", - "adding: mem time303, current time 339, horizon 36\n", - "adding: mem time304, current time 339, horizon 35\n", - "adding: mem time305, current time 339, horizon 34\n", - "adding: mem time306, current time 339, horizon 33\n", - "adding: mem time307, current time 339, horizon 32\n", - "adding: mem time308, current time 339, horizon 31\n", - "adding: mem time309, current time 339, horizon 30\n", - "adding: mem time310, current time 339, horizon 29\n", - "adding: mem time311, current time 339, horizon 28\n", - "adding: mem time312, current time 339, horizon 27\n", - "adding: mem time313, current time 339, horizon 26\n", - "adding: mem time314, current time 339, horizon 25\n", - "adding: mem time315, current time 339, horizon 24\n", - "adding: mem time316, current time 339, horizon 23\n", - "adding: mem time317, current time 339, horizon 22\n", - "adding: mem time318, current time 339, horizon 21\n", - "adding: mem time319, current time 339, horizon 20\n", - "adding: mem time320, current time 339, horizon 19\n", - "adding: mem time321, current time 339, horizon 18\n", - "adding: mem time322, current time 339, horizon 17\n", - "adding: mem time323, current time 339, horizon 16\n", - "adding: mem time324, current time 339, horizon 15\n", - "adding: mem time325, current time 339, horizon 14\n", - "adding: mem time326, current time 339, horizon 13\n", - "adding: mem time327, current time 339, horizon 12\n", - "adding: mem time328, current time 339, horizon 11\n", - "adding: mem time329, current time 339, horizon 10\n", - "adding: mem time330, current time 339, horizon 9\n", - "adding: mem time331, current time 339, horizon 8\n", - "adding: mem time332, current time 339, horizon 7\n", - "adding: mem time333, current time 339, horizon 6\n", - "adding: mem time334, current time 339, horizon 5\n", - "adding: mem time335, current time 339, horizon 4\n", - "adding: mem time336, current time 339, horizon 3\n", - "adding: mem time337, current time 339, horizon 2\n", - "adding: mem time338, current time 339, horizon 1\n", - "adding: mem time200, current time 340, horizon 140\n", - "adding: mem time201, current time 340, horizon 139\n", - "adding: mem time202, current time 340, horizon 138\n", - "adding: mem time203, current time 340, horizon 137\n", - "adding: mem time204, current time 340, horizon 136\n", - "adding: mem time205, current time 340, horizon 135\n", - "adding: mem time206, current time 340, horizon 134\n", - "adding: mem time207, current time 340, horizon 133\n", - "adding: mem time208, current time 340, horizon 132\n", - "adding: mem time209, current time 340, horizon 131\n", - "adding: mem time210, current time 340, horizon 130\n", - "adding: mem time211, current time 340, horizon 129\n", - "adding: mem time212, current time 340, horizon 128\n", - "adding: mem time213, current time 340, horizon 127\n", - "adding: mem time214, current time 340, horizon 126\n", - "adding: mem time215, current time 340, horizon 125\n", - "adding: mem time216, current time 340, horizon 124\n", - "adding: mem time217, current time 340, horizon 123\n", - "adding: mem time218, current time 340, horizon 122\n", - "adding: mem time219, current time 340, horizon 121\n", - "adding: mem time220, current time 340, horizon 120\n", - "adding: mem time221, current time 340, horizon 119\n", - "adding: mem time222, current time 340, horizon 118\n", - "adding: mem time223, current time 340, horizon 117\n", - "adding: mem time224, current time 340, horizon 116\n", - "adding: mem time225, current time 340, horizon 115\n", - "adding: mem time226, current time 340, horizon 114\n", - "adding: mem time227, current time 340, horizon 113\n", - "adding: mem time228, current time 340, horizon 112\n", - "adding: mem time229, current time 340, horizon 111\n", - "adding: mem time230, current time 340, horizon 110\n", - "adding: mem time231, current time 340, horizon 109\n", - "adding: mem time232, current time 340, horizon 108\n", - "adding: mem time233, current time 340, horizon 107\n", - "adding: mem time234, current time 340, horizon 106\n", - "adding: mem time235, current time 340, horizon 105\n", - "adding: mem time236, current time 340, horizon 104\n", - "adding: mem time237, current time 340, horizon 103\n", - "adding: mem time238, current time 340, horizon 102\n", - "adding: mem time239, current time 340, horizon 101\n", - "adding: mem time240, current time 340, horizon 100\n", - "adding: mem time241, current time 340, horizon 99\n", - "adding: mem time242, current time 340, horizon 98\n", - "adding: mem time243, current time 340, horizon 97\n", - "adding: mem time244, current time 340, horizon 96\n", - "adding: mem time245, current time 340, horizon 95\n", - "adding: mem time246, current time 340, horizon 94\n", - "adding: mem time247, current time 340, horizon 93\n", - "adding: mem time248, current time 340, horizon 92\n", - "adding: mem time249, current time 340, horizon 91\n", - "adding: mem time250, current time 340, horizon 90\n", - "adding: mem time251, current time 340, horizon 89\n", - "adding: mem time252, current time 340, horizon 88\n", - "adding: mem time253, current time 340, horizon 87\n", - "adding: mem time254, current time 340, horizon 86\n", - "adding: mem time255, current time 340, horizon 85\n", - "adding: mem time256, current time 340, horizon 84\n", - "adding: mem time257, current time 340, horizon 83\n", - "adding: mem time258, current time 340, horizon 82\n", - "adding: mem time259, current time 340, horizon 81\n", - "adding: mem time260, current time 340, horizon 80\n", - "adding: mem time261, current time 340, horizon 79\n", - "adding: mem time262, current time 340, horizon 78\n", - "adding: mem time263, current time 340, horizon 77\n", - "adding: mem time264, current time 340, horizon 76\n", - "adding: mem time265, current time 340, horizon 75\n", - "adding: mem time266, current time 340, horizon 74\n", - "adding: mem time267, current time 340, horizon 73\n", - "adding: mem time268, current time 340, horizon 72\n", - "adding: mem time269, current time 340, horizon 71\n", - "adding: mem time270, current time 340, horizon 70\n", - "adding: mem time271, current time 340, horizon 69\n", - "adding: mem time272, current time 340, horizon 68\n", - "adding: mem time273, current time 340, horizon 67\n", - "adding: mem time274, current time 340, horizon 66\n", - "adding: mem time275, current time 340, horizon 65\n", - "adding: mem time276, current time 340, horizon 64\n", - "adding: mem time277, current time 340, horizon 63\n", - "adding: mem time278, current time 340, horizon 62\n", - "adding: mem time279, current time 340, horizon 61\n", - "adding: mem time280, current time 340, horizon 60\n", - "adding: mem time281, current time 340, horizon 59\n", - "adding: mem time282, current time 340, horizon 58\n", - "adding: mem time283, current time 340, horizon 57\n", - "adding: mem time284, current time 340, horizon 56\n", - "adding: mem time285, current time 340, horizon 55\n", - "adding: mem time286, current time 340, horizon 54\n", - "adding: mem time287, current time 340, horizon 53\n", - "adding: mem time288, current time 340, horizon 52\n", - "adding: mem time289, current time 340, horizon 51\n", - "adding: mem time290, current time 340, horizon 50\n", - "adding: mem time291, current time 340, horizon 49\n", - "adding: mem time292, current time 340, horizon 48\n", - "adding: mem time293, current time 340, horizon 47\n", - "adding: mem time294, current time 340, horizon 46\n", - "adding: mem time295, current time 340, horizon 45\n", - "adding: mem time296, current time 340, horizon 44\n", - "adding: mem time297, current time 340, horizon 43\n", - "adding: mem time298, current time 340, horizon 42\n", - "adding: mem time299, current time 340, horizon 41\n", - "adding: mem time300, current time 340, horizon 40\n", - "adding: mem time301, current time 340, horizon 39\n", - "adding: mem time302, current time 340, horizon 38\n", - "adding: mem time303, current time 340, horizon 37\n", - "adding: mem time304, current time 340, horizon 36\n", - "adding: mem time305, current time 340, horizon 35\n", - "adding: mem time306, current time 340, horizon 34\n", - "adding: mem time307, current time 340, horizon 33\n", - "adding: mem time308, current time 340, horizon 32\n", - "adding: mem time309, current time 340, horizon 31\n", - "adding: mem time310, current time 340, horizon 30\n", - "adding: mem time311, current time 340, horizon 29\n", - "adding: mem time312, current time 340, horizon 28\n", - "adding: mem time313, current time 340, horizon 27\n", - "adding: mem time314, current time 340, horizon 26\n", - "adding: mem time315, current time 340, horizon 25\n", - "adding: mem time316, current time 340, horizon 24\n", - "adding: mem time317, current time 340, horizon 23\n", - "adding: mem time318, current time 340, horizon 22\n", - "adding: mem time319, current time 340, horizon 21\n", - "adding: mem time320, current time 340, horizon 20\n", - "adding: mem time321, current time 340, horizon 19\n", - "adding: mem time322, current time 340, horizon 18\n", - "adding: mem time323, current time 340, horizon 17\n", - "adding: mem time324, current time 340, horizon 16\n", - "adding: mem time325, current time 340, horizon 15\n", - "adding: mem time326, current time 340, horizon 14\n", - "adding: mem time327, current time 340, horizon 13\n", - "adding: mem time328, current time 340, horizon 12\n", - "adding: mem time329, current time 340, horizon 11\n", - "adding: mem time330, current time 340, horizon 10\n", - "adding: mem time331, current time 340, horizon 9\n", - "adding: mem time332, current time 340, horizon 8\n", - "adding: mem time333, current time 340, horizon 7\n", - "adding: mem time334, current time 340, horizon 6\n", - "adding: mem time335, current time 340, horizon 5\n", - "adding: mem time336, current time 340, horizon 4\n", - "adding: mem time337, current time 340, horizon 3\n", - "adding: mem time338, current time 340, horizon 2\n", - "adding: mem time339, current time 340, horizon 1\n", - "adding: mem time200, current time 341, horizon 141\n", - "adding: mem time201, current time 341, horizon 140\n", - "adding: mem time202, current time 341, horizon 139\n", - "adding: mem time203, current time 341, horizon 138\n", - "adding: mem time204, current time 341, horizon 137\n", - "adding: mem time205, current time 341, horizon 136\n", - "adding: mem time206, current time 341, horizon 135\n", - "adding: mem time207, current time 341, horizon 134\n", - "adding: mem time208, current time 341, horizon 133\n", - "adding: mem time209, current time 341, horizon 132\n", - "adding: mem time210, current time 341, horizon 131\n", - "adding: mem time211, current time 341, horizon 130\n", - "adding: mem time212, current time 341, horizon 129\n", - "adding: mem time213, current time 341, horizon 128\n", - "adding: mem time214, current time 341, horizon 127\n", - "adding: mem time215, current time 341, horizon 126\n", - "adding: mem time216, current time 341, horizon 125\n", - "adding: mem time217, current time 341, horizon 124\n", - "adding: mem time218, current time 341, horizon 123\n", - "adding: mem time219, current time 341, horizon 122\n", - "adding: mem time220, current time 341, horizon 121\n", - "adding: mem time221, current time 341, horizon 120\n", - "adding: mem time222, current time 341, horizon 119\n", - "adding: mem time223, current time 341, horizon 118\n", - "adding: mem time224, current time 341, horizon 117\n", - "adding: mem time225, current time 341, horizon 116\n", - "adding: mem time226, current time 341, horizon 115\n", - "adding: mem time227, current time 341, horizon 114\n", - "adding: mem time228, current time 341, horizon 113\n", - "adding: mem time229, current time 341, horizon 112\n", - "adding: mem time230, current time 341, horizon 111\n", - "adding: mem time231, current time 341, horizon 110\n", - "adding: mem time232, current time 341, horizon 109\n", - "adding: mem time233, current time 341, horizon 108\n", - "adding: mem time234, current time 341, horizon 107\n", - "adding: mem time235, current time 341, horizon 106\n", - "adding: mem time236, current time 341, horizon 105\n", - "adding: mem time237, current time 341, horizon 104\n", - "adding: mem time238, current time 341, horizon 103\n", - "adding: mem time239, current time 341, horizon 102\n", - "adding: mem time240, current time 341, horizon 101\n", - "adding: mem time241, current time 341, horizon 100\n", - "adding: mem time242, current time 341, horizon 99\n", - "adding: mem time243, current time 341, horizon 98\n", - "adding: mem time244, current time 341, horizon 97\n", - "adding: mem time245, current time 341, horizon 96\n", - "adding: mem time246, current time 341, horizon 95\n", - "adding: mem time247, current time 341, horizon 94\n", - "adding: mem time248, current time 341, horizon 93\n", - "adding: mem time249, current time 341, horizon 92\n", - "adding: mem time250, current time 341, horizon 91\n", - "adding: mem time251, current time 341, horizon 90\n", - "adding: mem time252, current time 341, horizon 89\n", - "adding: mem time253, current time 341, horizon 88\n", - "adding: mem time254, current time 341, horizon 87\n", - "adding: mem time255, current time 341, horizon 86\n", - "adding: mem time256, current time 341, horizon 85\n", - "adding: mem time257, current time 341, horizon 84\n", - "adding: mem time258, current time 341, horizon 83\n", - "adding: mem time259, current time 341, horizon 82\n", - "adding: mem time260, current time 341, horizon 81\n", - "adding: mem time261, current time 341, horizon 80\n", - "adding: mem time262, current time 341, horizon 79\n", - "adding: mem time263, current time 341, horizon 78\n", - "adding: mem time264, current time 341, horizon 77\n", - "adding: mem time265, current time 341, horizon 76\n", - "adding: mem time266, current time 341, horizon 75\n", - "adding: mem time267, current time 341, horizon 74\n", - "adding: mem time268, current time 341, horizon 73\n", - "adding: mem time269, current time 341, horizon 72\n", - "adding: mem time270, current time 341, horizon 71\n", - "adding: mem time271, current time 341, horizon 70\n", - "adding: mem time272, current time 341, horizon 69\n", - "adding: mem time273, current time 341, horizon 68\n", - "adding: mem time274, current time 341, horizon 67\n", - "adding: mem time275, current time 341, horizon 66\n", - "adding: mem time276, current time 341, horizon 65\n", - "adding: mem time277, current time 341, horizon 64\n", - "adding: mem time278, current time 341, horizon 63\n", - "adding: mem time279, current time 341, horizon 62\n", - "adding: mem time280, current time 341, horizon 61\n", - "adding: mem time281, current time 341, horizon 60\n", - "adding: mem time282, current time 341, horizon 59\n", - "adding: mem time283, current time 341, horizon 58\n", - "adding: mem time284, current time 341, horizon 57\n", - "adding: mem time285, current time 341, horizon 56\n", - "adding: mem time286, current time 341, horizon 55\n", - "adding: mem time287, current time 341, horizon 54\n", - "adding: mem time288, current time 341, horizon 53\n", - "adding: mem time289, current time 341, horizon 52\n", - "adding: mem time290, current time 341, horizon 51\n", - "adding: mem time291, current time 341, horizon 50\n", - "adding: mem time292, current time 341, horizon 49\n", - "adding: mem time293, current time 341, horizon 48\n", - "adding: mem time294, current time 341, horizon 47\n", - "adding: mem time295, current time 341, horizon 46\n", - "adding: mem time296, current time 341, horizon 45\n", - "adding: mem time297, current time 341, horizon 44\n", - "adding: mem time298, current time 341, horizon 43\n", - "adding: mem time299, current time 341, horizon 42\n", - "adding: mem time300, current time 341, horizon 41\n", - "adding: mem time301, current time 341, horizon 40\n", - "adding: mem time302, current time 341, horizon 39\n", - "adding: mem time303, current time 341, horizon 38\n", - "adding: mem time304, current time 341, horizon 37\n", - "adding: mem time305, current time 341, horizon 36\n", - "adding: mem time306, current time 341, horizon 35\n", - "adding: mem time307, current time 341, horizon 34\n", - "adding: mem time308, current time 341, horizon 33\n", - "adding: mem time309, current time 341, horizon 32\n", - "adding: mem time310, current time 341, horizon 31\n", - "adding: mem time311, current time 341, horizon 30\n", - "adding: mem time312, current time 341, horizon 29\n", - "adding: mem time313, current time 341, horizon 28\n", - "adding: mem time314, current time 341, horizon 27\n", - "adding: mem time315, current time 341, horizon 26\n", - "adding: mem time316, current time 341, horizon 25\n", - "adding: mem time317, current time 341, horizon 24\n", - "adding: mem time318, current time 341, horizon 23\n", - "adding: mem time319, current time 341, horizon 22\n", - "adding: mem time320, current time 341, horizon 21\n", - "adding: mem time321, current time 341, horizon 20\n", - "adding: mem time322, current time 341, horizon 19\n", - "adding: mem time323, current time 341, horizon 18\n", - "adding: mem time324, current time 341, horizon 17\n", - "adding: mem time325, current time 341, horizon 16\n", - "adding: mem time326, current time 341, horizon 15\n", - "adding: mem time327, current time 341, horizon 14\n", - "adding: mem time328, current time 341, horizon 13\n", - "adding: mem time329, current time 341, horizon 12\n", - "adding: mem time330, current time 341, horizon 11\n", - "adding: mem time331, current time 341, horizon 10\n", - "adding: mem time332, current time 341, horizon 9\n", - "adding: mem time333, current time 341, horizon 8\n", - "adding: mem time334, current time 341, horizon 7\n", - "adding: mem time335, current time 341, horizon 6\n", - "adding: mem time336, current time 341, horizon 5\n", - "adding: mem time337, current time 341, horizon 4\n", - "adding: mem time338, current time 341, horizon 3\n", - "adding: mem time339, current time 341, horizon 2\n", - "adding: mem time340, current time 341, horizon 1\n", - "adding: mem time200, current time 342, horizon 142\n", - "adding: mem time201, current time 342, horizon 141\n", - "adding: mem time202, current time 342, horizon 140\n", - "adding: mem time203, current time 342, horizon 139\n", - "adding: mem time204, current time 342, horizon 138\n", - "adding: mem time205, current time 342, horizon 137\n", - "adding: mem time206, current time 342, horizon 136\n", - "adding: mem time207, current time 342, horizon 135\n", - "adding: mem time208, current time 342, horizon 134\n", - "adding: mem time209, current time 342, horizon 133\n", - "adding: mem time210, current time 342, horizon 132\n", - "adding: mem time211, current time 342, horizon 131\n", - "adding: mem time212, current time 342, horizon 130\n", - "adding: mem time213, current time 342, horizon 129\n", - "adding: mem time214, current time 342, horizon 128\n", - "adding: mem time215, current time 342, horizon 127\n", - "adding: mem time216, current time 342, horizon 126\n", - "adding: mem time217, current time 342, horizon 125\n", - "adding: mem time218, current time 342, horizon 124\n", - "adding: mem time219, current time 342, horizon 123\n", - "adding: mem time220, current time 342, horizon 122\n", - "adding: mem time221, current time 342, horizon 121\n", - "adding: mem time222, current time 342, horizon 120\n", - "adding: mem time223, current time 342, horizon 119\n", - "adding: mem time224, current time 342, horizon 118\n", - "adding: mem time225, current time 342, horizon 117\n", - "adding: mem time226, current time 342, horizon 116\n", - "adding: mem time227, current time 342, horizon 115\n", - "adding: mem time228, current time 342, horizon 114\n", - "adding: mem time229, current time 342, horizon 113\n", - "adding: mem time230, current time 342, horizon 112\n", - "adding: mem time231, current time 342, horizon 111\n", - "adding: mem time232, current time 342, horizon 110\n", - "adding: mem time233, current time 342, horizon 109\n", - "adding: mem time234, current time 342, horizon 108\n", - "adding: mem time235, current time 342, horizon 107\n", - "adding: mem time236, current time 342, horizon 106\n", - "adding: mem time237, current time 342, horizon 105\n", - "adding: mem time238, current time 342, horizon 104\n", - "adding: mem time239, current time 342, horizon 103\n", - "adding: mem time240, current time 342, horizon 102\n", - "adding: mem time241, current time 342, horizon 101\n", - "adding: mem time242, current time 342, horizon 100\n", - "adding: mem time243, current time 342, horizon 99\n", - "adding: mem time244, current time 342, horizon 98\n", - "adding: mem time245, current time 342, horizon 97\n", - "adding: mem time246, current time 342, horizon 96\n", - "adding: mem time247, current time 342, horizon 95\n", - "adding: mem time248, current time 342, horizon 94\n", - "adding: mem time249, current time 342, horizon 93\n", - "adding: mem time250, current time 342, horizon 92\n", - "adding: mem time251, current time 342, horizon 91\n", - "adding: mem time252, current time 342, horizon 90\n", - "adding: mem time253, current time 342, horizon 89\n", - "adding: mem time254, current time 342, horizon 88\n", - "adding: mem time255, current time 342, horizon 87\n", - "adding: mem time256, current time 342, horizon 86\n", - "adding: mem time257, current time 342, horizon 85\n", - "adding: mem time258, current time 342, horizon 84\n", - "adding: mem time259, current time 342, horizon 83\n", - "adding: mem time260, current time 342, horizon 82\n", - "adding: mem time261, current time 342, horizon 81\n", - "adding: mem time262, current time 342, horizon 80\n", - "adding: mem time263, current time 342, horizon 79\n", - "adding: mem time264, current time 342, horizon 78\n", - "adding: mem time265, current time 342, horizon 77\n", - "adding: mem time266, current time 342, horizon 76\n", - "adding: mem time267, current time 342, horizon 75\n", - "adding: mem time268, current time 342, horizon 74\n", - "adding: mem time269, current time 342, horizon 73\n", - "adding: mem time270, current time 342, horizon 72\n", - "adding: mem time271, current time 342, horizon 71\n", - "adding: mem time272, current time 342, horizon 70\n", - "adding: mem time273, current time 342, horizon 69\n", - "adding: mem time274, current time 342, horizon 68\n", - "adding: mem time275, current time 342, horizon 67\n", - "adding: mem time276, current time 342, horizon 66\n", - "adding: mem time277, current time 342, horizon 65\n", - "adding: mem time278, current time 342, horizon 64\n", - "adding: mem time279, current time 342, horizon 63\n", - "adding: mem time280, current time 342, horizon 62\n", - "adding: mem time281, current time 342, horizon 61\n", - "adding: mem time282, current time 342, horizon 60\n", - "adding: mem time283, current time 342, horizon 59\n", - "adding: mem time284, current time 342, horizon 58\n", - "adding: mem time285, current time 342, horizon 57\n", - "adding: mem time286, current time 342, horizon 56\n", - "adding: mem time287, current time 342, horizon 55\n", - "adding: mem time288, current time 342, horizon 54\n", - "adding: mem time289, current time 342, horizon 53\n", - "adding: mem time290, current time 342, horizon 52\n", - "adding: mem time291, current time 342, horizon 51\n", - "adding: mem time292, current time 342, horizon 50\n", - "adding: mem time293, current time 342, horizon 49\n", - "adding: mem time294, current time 342, horizon 48\n", - "adding: mem time295, current time 342, horizon 47\n", - "adding: mem time296, current time 342, horizon 46\n", - "adding: mem time297, current time 342, horizon 45\n", - "adding: mem time298, current time 342, horizon 44\n", - "adding: mem time299, current time 342, horizon 43\n", - "adding: mem time300, current time 342, horizon 42\n", - "adding: mem time301, current time 342, horizon 41\n", - "adding: mem time302, current time 342, horizon 40\n", - "adding: mem time303, current time 342, horizon 39\n", - "adding: mem time304, current time 342, horizon 38\n", - "adding: mem time305, current time 342, horizon 37\n", - "adding: mem time306, current time 342, horizon 36\n", - "adding: mem time307, current time 342, horizon 35\n", - "adding: mem time308, current time 342, horizon 34\n", - "adding: mem time309, current time 342, horizon 33\n", - "adding: mem time310, current time 342, horizon 32\n", - "adding: mem time311, current time 342, horizon 31\n", - "adding: mem time312, current time 342, horizon 30\n", - "adding: mem time313, current time 342, horizon 29\n", - "adding: mem time314, current time 342, horizon 28\n", - "adding: mem time315, current time 342, horizon 27\n", - "adding: mem time316, current time 342, horizon 26\n", - "adding: mem time317, current time 342, horizon 25\n", - "adding: mem time318, current time 342, horizon 24\n", - "adding: mem time319, current time 342, horizon 23\n", - "adding: mem time320, current time 342, horizon 22\n", - "adding: mem time321, current time 342, horizon 21\n", - "adding: mem time322, current time 342, horizon 20\n", - "adding: mem time323, current time 342, horizon 19\n", - "adding: mem time324, current time 342, horizon 18\n", - "adding: mem time325, current time 342, horizon 17\n", - "adding: mem time326, current time 342, horizon 16\n", - "adding: mem time327, current time 342, horizon 15\n", - "adding: mem time328, current time 342, horizon 14\n", - "adding: mem time329, current time 342, horizon 13\n", - "adding: mem time330, current time 342, horizon 12\n", - "adding: mem time331, current time 342, horizon 11\n", - "adding: mem time332, current time 342, horizon 10\n", - "adding: mem time333, current time 342, horizon 9\n", - "adding: mem time334, current time 342, horizon 8\n", - "adding: mem time335, current time 342, horizon 7\n", - "adding: mem time336, current time 342, horizon 6\n", - "adding: mem time337, current time 342, horizon 5\n", - "adding: mem time338, current time 342, horizon 4\n", - "adding: mem time339, current time 342, horizon 3\n", - "adding: mem time340, current time 342, horizon 2\n", - "adding: mem time341, current time 342, horizon 1\n", - "adding: mem time200, current time 343, horizon 143\n", - "adding: mem time201, current time 343, horizon 142\n", - "adding: mem time202, current time 343, horizon 141\n", - "adding: mem time203, current time 343, horizon 140\n", - "adding: mem time204, current time 343, horizon 139\n", - "adding: mem time205, current time 343, horizon 138\n", - "adding: mem time206, current time 343, horizon 137\n", - "adding: mem time207, current time 343, horizon 136\n", - "adding: mem time208, current time 343, horizon 135\n", - "adding: mem time209, current time 343, horizon 134\n", - "adding: mem time210, current time 343, horizon 133\n", - "adding: mem time211, current time 343, horizon 132\n", - "adding: mem time212, current time 343, horizon 131\n", - "adding: mem time213, current time 343, horizon 130\n", - "adding: mem time214, current time 343, horizon 129\n", - "adding: mem time215, current time 343, horizon 128\n", - "adding: mem time216, current time 343, horizon 127\n", - "adding: mem time217, current time 343, horizon 126\n", - "adding: mem time218, current time 343, horizon 125\n", - "adding: mem time219, current time 343, horizon 124\n", - "adding: mem time220, current time 343, horizon 123\n", - "adding: mem time221, current time 343, horizon 122\n", - "adding: mem time222, current time 343, horizon 121\n", - "adding: mem time223, current time 343, horizon 120\n", - "adding: mem time224, current time 343, horizon 119\n", - "adding: mem time225, current time 343, horizon 118\n", - "adding: mem time226, current time 343, horizon 117\n", - "adding: mem time227, current time 343, horizon 116\n", - "adding: mem time228, current time 343, horizon 115\n", - "adding: mem time229, current time 343, horizon 114\n", - "adding: mem time230, current time 343, horizon 113\n", - "adding: mem time231, current time 343, horizon 112\n", - "adding: mem time232, current time 343, horizon 111\n", - "adding: mem time233, current time 343, horizon 110\n", - "adding: mem time234, current time 343, horizon 109\n", - "adding: mem time235, current time 343, horizon 108\n", - "adding: mem time236, current time 343, horizon 107\n", - "adding: mem time237, current time 343, horizon 106\n", - "adding: mem time238, current time 343, horizon 105\n", - "adding: mem time239, current time 343, horizon 104\n", - "adding: mem time240, current time 343, horizon 103\n", - "adding: mem time241, current time 343, horizon 102\n", - "adding: mem time242, current time 343, horizon 101\n", - "adding: mem time243, current time 343, horizon 100\n", - "adding: mem time244, current time 343, horizon 99\n", - "adding: mem time245, current time 343, horizon 98\n", - "adding: mem time246, current time 343, horizon 97\n", - "adding: mem time247, current time 343, horizon 96\n", - "adding: mem time248, current time 343, horizon 95\n", - "adding: mem time249, current time 343, horizon 94\n", - "adding: mem time250, current time 343, horizon 93\n", - "adding: mem time251, current time 343, horizon 92\n", - "adding: mem time252, current time 343, horizon 91\n", - "adding: mem time253, current time 343, horizon 90\n", - "adding: mem time254, current time 343, horizon 89\n", - "adding: mem time255, current time 343, horizon 88\n", - "adding: mem time256, current time 343, horizon 87\n", - "adding: mem time257, current time 343, horizon 86\n", - "adding: mem time258, current time 343, horizon 85\n", - "adding: mem time259, current time 343, horizon 84\n", - "adding: mem time260, current time 343, horizon 83\n", - "adding: mem time261, current time 343, horizon 82\n", - "adding: mem time262, current time 343, horizon 81\n", - "adding: mem time263, current time 343, horizon 80\n", - "adding: mem time264, current time 343, horizon 79\n", - "adding: mem time265, current time 343, horizon 78\n", - "adding: mem time266, current time 343, horizon 77\n", - "adding: mem time267, current time 343, horizon 76\n", - "adding: mem time268, current time 343, horizon 75\n", - "adding: mem time269, current time 343, horizon 74\n", - "adding: mem time270, current time 343, horizon 73\n", - "adding: mem time271, current time 343, horizon 72\n", - "adding: mem time272, current time 343, horizon 71\n", - "adding: mem time273, current time 343, horizon 70\n", - "adding: mem time274, current time 343, horizon 69\n", - "adding: mem time275, current time 343, horizon 68\n", - "adding: mem time276, current time 343, horizon 67\n", - "adding: mem time277, current time 343, horizon 66\n", - "adding: mem time278, current time 343, horizon 65\n", - "adding: mem time279, current time 343, horizon 64\n", - "adding: mem time280, current time 343, horizon 63\n", - "adding: mem time281, current time 343, horizon 62\n", - "adding: mem time282, current time 343, horizon 61\n", - "adding: mem time283, current time 343, horizon 60\n", - "adding: mem time284, current time 343, horizon 59\n", - "adding: mem time285, current time 343, horizon 58\n", - "adding: mem time286, current time 343, horizon 57\n", - "adding: mem time287, current time 343, horizon 56\n", - "adding: mem time288, current time 343, horizon 55\n", - "adding: mem time289, current time 343, horizon 54\n", - "adding: mem time290, current time 343, horizon 53\n", - "adding: mem time291, current time 343, horizon 52\n", - "adding: mem time292, current time 343, horizon 51\n", - "adding: mem time293, current time 343, horizon 50\n", - "adding: mem time294, current time 343, horizon 49\n", - "adding: mem time295, current time 343, horizon 48\n", - "adding: mem time296, current time 343, horizon 47\n", - "adding: mem time297, current time 343, horizon 46\n", - "adding: mem time298, current time 343, horizon 45\n", - "adding: mem time299, current time 343, horizon 44\n", - "adding: mem time300, current time 343, horizon 43\n", - "adding: mem time301, current time 343, horizon 42\n", - "adding: mem time302, current time 343, horizon 41\n", - "adding: mem time303, current time 343, horizon 40\n", - "adding: mem time304, current time 343, horizon 39\n", - "adding: mem time305, current time 343, horizon 38\n", - "adding: mem time306, current time 343, horizon 37\n", - "adding: mem time307, current time 343, horizon 36\n", - "adding: mem time308, current time 343, horizon 35\n", - "adding: mem time309, current time 343, horizon 34\n", - "adding: mem time310, current time 343, horizon 33\n", - "adding: mem time311, current time 343, horizon 32\n", - "adding: mem time312, current time 343, horizon 31\n", - "adding: mem time313, current time 343, horizon 30\n", - "adding: mem time314, current time 343, horizon 29\n", - "adding: mem time315, current time 343, horizon 28\n", - "adding: mem time316, current time 343, horizon 27\n", - "adding: mem time317, current time 343, horizon 26\n", - "adding: mem time318, current time 343, horizon 25\n", - "adding: mem time319, current time 343, horizon 24\n", - "adding: mem time320, current time 343, horizon 23\n", - "adding: mem time321, current time 343, horizon 22\n", - "adding: mem time322, current time 343, horizon 21\n", - "adding: mem time323, current time 343, horizon 20\n", - "adding: mem time324, current time 343, horizon 19\n", - "adding: mem time325, current time 343, horizon 18\n", - "adding: mem time326, current time 343, horizon 17\n", - "adding: mem time327, current time 343, horizon 16\n", - "adding: mem time328, current time 343, horizon 15\n", - "adding: mem time329, current time 343, horizon 14\n", - "adding: mem time330, current time 343, horizon 13\n", - "adding: mem time331, current time 343, horizon 12\n", - "adding: mem time332, current time 343, horizon 11\n", - "adding: mem time333, current time 343, horizon 10\n", - "adding: mem time334, current time 343, horizon 9\n", - "adding: mem time335, current time 343, horizon 8\n", - "adding: mem time336, current time 343, horizon 7\n", - "adding: mem time337, current time 343, horizon 6\n", - "adding: mem time338, current time 343, horizon 5\n", - "adding: mem time339, current time 343, horizon 4\n", - "adding: mem time340, current time 343, horizon 3\n", - "adding: mem time341, current time 343, horizon 2\n", - "adding: mem time342, current time 343, horizon 1\n", - "adding: mem time200, current time 344, horizon 144\n", - "adding: mem time201, current time 344, horizon 143\n", - "adding: mem time202, current time 344, horizon 142\n", - "adding: mem time203, current time 344, horizon 141\n", - "adding: mem time204, current time 344, horizon 140\n", - "adding: mem time205, current time 344, horizon 139\n", - "adding: mem time206, current time 344, horizon 138\n", - "adding: mem time207, current time 344, horizon 137\n", - "adding: mem time208, current time 344, horizon 136\n", - "adding: mem time209, current time 344, horizon 135\n", - "adding: mem time210, current time 344, horizon 134\n", - "adding: mem time211, current time 344, horizon 133\n", - "adding: mem time212, current time 344, horizon 132\n", - "adding: mem time213, current time 344, horizon 131\n", - "adding: mem time214, current time 344, horizon 130\n", - "adding: mem time215, current time 344, horizon 129\n", - "adding: mem time216, current time 344, horizon 128\n", - "adding: mem time217, current time 344, horizon 127\n", - "adding: mem time218, current time 344, horizon 126\n", - "adding: mem time219, current time 344, horizon 125\n", - "adding: mem time220, current time 344, horizon 124\n", - "adding: mem time221, current time 344, horizon 123\n", - "adding: mem time222, current time 344, horizon 122\n", - "adding: mem time223, current time 344, horizon 121\n", - "adding: mem time224, current time 344, horizon 120\n", - "adding: mem time225, current time 344, horizon 119\n", - "adding: mem time226, current time 344, horizon 118\n", - "adding: mem time227, current time 344, horizon 117\n", - "adding: mem time228, current time 344, horizon 116\n", - "adding: mem time229, current time 344, horizon 115\n", - "adding: mem time230, current time 344, horizon 114\n", - "adding: mem time231, current time 344, horizon 113\n", - "adding: mem time232, current time 344, horizon 112\n", - "adding: mem time233, current time 344, horizon 111\n", - "adding: mem time234, current time 344, horizon 110\n", - "adding: mem time235, current time 344, horizon 109\n", - "adding: mem time236, current time 344, horizon 108\n", - "adding: mem time237, current time 344, horizon 107\n", - "adding: mem time238, current time 344, horizon 106\n", - "adding: mem time239, current time 344, horizon 105\n", - "adding: mem time240, current time 344, horizon 104\n", - "adding: mem time241, current time 344, horizon 103\n", - "adding: mem time242, current time 344, horizon 102\n", - "adding: mem time243, current time 344, horizon 101\n", - "adding: mem time244, current time 344, horizon 100\n", - "adding: mem time245, current time 344, horizon 99\n", - "adding: mem time246, current time 344, horizon 98\n", - "adding: mem time247, current time 344, horizon 97\n", - "adding: mem time248, current time 344, horizon 96\n", - "adding: mem time249, current time 344, horizon 95\n", - "adding: mem time250, current time 344, horizon 94\n", - "adding: mem time251, current time 344, horizon 93\n", - "adding: mem time252, current time 344, horizon 92\n", - "adding: mem time253, current time 344, horizon 91\n", - "adding: mem time254, current time 344, horizon 90\n", - "adding: mem time255, current time 344, horizon 89\n", - "adding: mem time256, current time 344, horizon 88\n", - "adding: mem time257, current time 344, horizon 87\n", - "adding: mem time258, current time 344, horizon 86\n", - "adding: mem time259, current time 344, horizon 85\n", - "adding: mem time260, current time 344, horizon 84\n", - "adding: mem time261, current time 344, horizon 83\n", - "adding: mem time262, current time 344, horizon 82\n", - "adding: mem time263, current time 344, horizon 81\n", - "adding: mem time264, current time 344, horizon 80\n", - "adding: mem time265, current time 344, horizon 79\n", - "adding: mem time266, current time 344, horizon 78\n", - "adding: mem time267, current time 344, horizon 77\n", - "adding: mem time268, current time 344, horizon 76\n", - "adding: mem time269, current time 344, horizon 75\n", - "adding: mem time270, current time 344, horizon 74\n", - "adding: mem time271, current time 344, horizon 73\n", - "adding: mem time272, current time 344, horizon 72\n", - "adding: mem time273, current time 344, horizon 71\n", - "adding: mem time274, current time 344, horizon 70\n", - "adding: mem time275, current time 344, horizon 69\n", - "adding: mem time276, current time 344, horizon 68\n", - "adding: mem time277, current time 344, horizon 67\n", - "adding: mem time278, current time 344, horizon 66\n", - "adding: mem time279, current time 344, horizon 65\n", - "adding: mem time280, current time 344, horizon 64\n", - "adding: mem time281, current time 344, horizon 63\n", - "adding: mem time282, current time 344, horizon 62\n", - "adding: mem time283, current time 344, horizon 61\n", - "adding: mem time284, current time 344, horizon 60\n", - "adding: mem time285, current time 344, horizon 59\n", - "adding: mem time286, current time 344, horizon 58\n", - "adding: mem time287, current time 344, horizon 57\n", - "adding: mem time288, current time 344, horizon 56\n", - "adding: mem time289, current time 344, horizon 55\n", - "adding: mem time290, current time 344, horizon 54\n", - "adding: mem time291, current time 344, horizon 53\n", - "adding: mem time292, current time 344, horizon 52\n", - "adding: mem time293, current time 344, horizon 51\n", - "adding: mem time294, current time 344, horizon 50\n", - "adding: mem time295, current time 344, horizon 49\n", - "adding: mem time296, current time 344, horizon 48\n", - "adding: mem time297, current time 344, horizon 47\n", - "adding: mem time298, current time 344, horizon 46\n", - "adding: mem time299, current time 344, horizon 45\n", - "adding: mem time300, current time 344, horizon 44\n", - "adding: mem time301, current time 344, horizon 43\n", - "adding: mem time302, current time 344, horizon 42\n", - "adding: mem time303, current time 344, horizon 41\n", - "adding: mem time304, current time 344, horizon 40\n", - "adding: mem time305, current time 344, horizon 39\n", - "adding: mem time306, current time 344, horizon 38\n", - "adding: mem time307, current time 344, horizon 37\n", - "adding: mem time308, current time 344, horizon 36\n", - "adding: mem time309, current time 344, horizon 35\n", - "adding: mem time310, current time 344, horizon 34\n", - "adding: mem time311, current time 344, horizon 33\n", - "adding: mem time312, current time 344, horizon 32\n", - "adding: mem time313, current time 344, horizon 31\n", - "adding: mem time314, current time 344, horizon 30\n", - "adding: mem time315, current time 344, horizon 29\n", - "adding: mem time316, current time 344, horizon 28\n", - "adding: mem time317, current time 344, horizon 27\n", - "adding: mem time318, current time 344, horizon 26\n", - "adding: mem time319, current time 344, horizon 25\n", - "adding: mem time320, current time 344, horizon 24\n", - "adding: mem time321, current time 344, horizon 23\n", - "adding: mem time322, current time 344, horizon 22\n", - "adding: mem time323, current time 344, horizon 21\n", - "adding: mem time324, current time 344, horizon 20\n", - "adding: mem time325, current time 344, horizon 19\n", - "adding: mem time326, current time 344, horizon 18\n", - "adding: mem time327, current time 344, horizon 17\n", - "adding: mem time328, current time 344, horizon 16\n", - "adding: mem time329, current time 344, horizon 15\n", - "adding: mem time330, current time 344, horizon 14\n", - "adding: mem time331, current time 344, horizon 13\n", - "adding: mem time332, current time 344, horizon 12\n", - "adding: mem time333, current time 344, horizon 11\n", - "adding: mem time334, current time 344, horizon 10\n", - "adding: mem time335, current time 344, horizon 9\n", - "adding: mem time336, current time 344, horizon 8\n", - "adding: mem time337, current time 344, horizon 7\n", - "adding: mem time338, current time 344, horizon 6\n", - "adding: mem time339, current time 344, horizon 5\n", - "adding: mem time340, current time 344, horizon 4\n", - "adding: mem time341, current time 344, horizon 3\n", - "adding: mem time342, current time 344, horizon 2\n", - "adding: mem time343, current time 344, horizon 1\n", - "adding: mem time200, current time 345, horizon 145\n", - "adding: mem time201, current time 345, horizon 144\n", - "adding: mem time202, current time 345, horizon 143\n", - "adding: mem time203, current time 345, horizon 142\n", - "adding: mem time204, current time 345, horizon 141\n", - "adding: mem time205, current time 345, horizon 140\n", - "adding: mem time206, current time 345, horizon 139\n", - "adding: mem time207, current time 345, horizon 138\n", - "adding: mem time208, current time 345, horizon 137\n", - "adding: mem time209, current time 345, horizon 136\n", - "adding: mem time210, current time 345, horizon 135\n", - "adding: mem time211, current time 345, horizon 134\n", - "adding: mem time212, current time 345, horizon 133\n", - "adding: mem time213, current time 345, horizon 132\n", - "adding: mem time214, current time 345, horizon 131\n", - "adding: mem time215, current time 345, horizon 130\n", - "adding: mem time216, current time 345, horizon 129\n", - "adding: mem time217, current time 345, horizon 128\n", - "adding: mem time218, current time 345, horizon 127\n", - "adding: mem time219, current time 345, horizon 126\n", - "adding: mem time220, current time 345, horizon 125\n", - "adding: mem time221, current time 345, horizon 124\n", - "adding: mem time222, current time 345, horizon 123\n", - "adding: mem time223, current time 345, horizon 122\n", - "adding: mem time224, current time 345, horizon 121\n", - "adding: mem time225, current time 345, horizon 120\n", - "adding: mem time226, current time 345, horizon 119\n", - "adding: mem time227, current time 345, horizon 118\n", - "adding: mem time228, current time 345, horizon 117\n", - "adding: mem time229, current time 345, horizon 116\n", - "adding: mem time230, current time 345, horizon 115\n", - "adding: mem time231, current time 345, horizon 114\n", - "adding: mem time232, current time 345, horizon 113\n", - "adding: mem time233, current time 345, horizon 112\n", - "adding: mem time234, current time 345, horizon 111\n", - "adding: mem time235, current time 345, horizon 110\n", - "adding: mem time236, current time 345, horizon 109\n", - "adding: mem time237, current time 345, horizon 108\n", - "adding: mem time238, current time 345, horizon 107\n", - "adding: mem time239, current time 345, horizon 106\n", - "adding: mem time240, current time 345, horizon 105\n", - "adding: mem time241, current time 345, horizon 104\n", - "adding: mem time242, current time 345, horizon 103\n", - "adding: mem time243, current time 345, horizon 102\n", - "adding: mem time244, current time 345, horizon 101\n", - "adding: mem time245, current time 345, horizon 100\n", - "adding: mem time246, current time 345, horizon 99\n", - "adding: mem time247, current time 345, horizon 98\n", - "adding: mem time248, current time 345, horizon 97\n", - "adding: mem time249, current time 345, horizon 96\n", - "adding: mem time250, current time 345, horizon 95\n", - "adding: mem time251, current time 345, horizon 94\n", - "adding: mem time252, current time 345, horizon 93\n", - "adding: mem time253, current time 345, horizon 92\n", - "adding: mem time254, current time 345, horizon 91\n", - "adding: mem time255, current time 345, horizon 90\n", - "adding: mem time256, current time 345, horizon 89\n", - "adding: mem time257, current time 345, horizon 88\n", - "adding: mem time258, current time 345, horizon 87\n", - "adding: mem time259, current time 345, horizon 86\n", - "adding: mem time260, current time 345, horizon 85\n", - "adding: mem time261, current time 345, horizon 84\n", - "adding: mem time262, current time 345, horizon 83\n", - "adding: mem time263, current time 345, horizon 82\n", - "adding: mem time264, current time 345, horizon 81\n", - "adding: mem time265, current time 345, horizon 80\n", - "adding: mem time266, current time 345, horizon 79\n", - "adding: mem time267, current time 345, horizon 78\n", - "adding: mem time268, current time 345, horizon 77\n", - "adding: mem time269, current time 345, horizon 76\n", - "adding: mem time270, current time 345, horizon 75\n", - "adding: mem time271, current time 345, horizon 74\n", - "adding: mem time272, current time 345, horizon 73\n", - "adding: mem time273, current time 345, horizon 72\n", - "adding: mem time274, current time 345, horizon 71\n", - "adding: mem time275, current time 345, horizon 70\n", - "adding: mem time276, current time 345, horizon 69\n", - "adding: mem time277, current time 345, horizon 68\n", - "adding: mem time278, current time 345, horizon 67\n", - "adding: mem time279, current time 345, horizon 66\n", - "adding: mem time280, current time 345, horizon 65\n", - "adding: mem time281, current time 345, horizon 64\n", - "adding: mem time282, current time 345, horizon 63\n", - "adding: mem time283, current time 345, horizon 62\n", - "adding: mem time284, current time 345, horizon 61\n", - "adding: mem time285, current time 345, horizon 60\n", - "adding: mem time286, current time 345, horizon 59\n", - "adding: mem time287, current time 345, horizon 58\n", - "adding: mem time288, current time 345, horizon 57\n", - "adding: mem time289, current time 345, horizon 56\n", - "adding: mem time290, current time 345, horizon 55\n", - "adding: mem time291, current time 345, horizon 54\n", - "adding: mem time292, current time 345, horizon 53\n", - "adding: mem time293, current time 345, horizon 52\n", - "adding: mem time294, current time 345, horizon 51\n", - "adding: mem time295, current time 345, horizon 50\n", - "adding: mem time296, current time 345, horizon 49\n", - "adding: mem time297, current time 345, horizon 48\n", - "adding: mem time298, current time 345, horizon 47\n", - "adding: mem time299, current time 345, horizon 46\n", - "adding: mem time300, current time 345, horizon 45\n", - "adding: mem time301, current time 345, horizon 44\n", - "adding: mem time302, current time 345, horizon 43\n", - "adding: mem time303, current time 345, horizon 42\n", - "adding: mem time304, current time 345, horizon 41\n", - "adding: mem time305, current time 345, horizon 40\n", - "adding: mem time306, current time 345, horizon 39\n", - "adding: mem time307, current time 345, horizon 38\n", - "adding: mem time308, current time 345, horizon 37\n", - "adding: mem time309, current time 345, horizon 36\n", - "adding: mem time310, current time 345, horizon 35\n", - "adding: mem time311, current time 345, horizon 34\n", - "adding: mem time312, current time 345, horizon 33\n", - "adding: mem time313, current time 345, horizon 32\n", - "adding: mem time314, current time 345, horizon 31\n", - "adding: mem time315, current time 345, horizon 30\n", - "adding: mem time316, current time 345, horizon 29\n", - "adding: mem time317, current time 345, horizon 28\n", - "adding: mem time318, current time 345, horizon 27\n", - "adding: mem time319, current time 345, horizon 26\n", - "adding: mem time320, current time 345, horizon 25\n", - "adding: mem time321, current time 345, horizon 24\n", - "adding: mem time322, current time 345, horizon 23\n", - "adding: mem time323, current time 345, horizon 22\n", - "adding: mem time324, current time 345, horizon 21\n", - "adding: mem time325, current time 345, horizon 20\n", - "adding: mem time326, current time 345, horizon 19\n", - "adding: mem time327, current time 345, horizon 18\n", - "adding: mem time328, current time 345, horizon 17\n", - "adding: mem time329, current time 345, horizon 16\n", - "adding: mem time330, current time 345, horizon 15\n", - "adding: mem time331, current time 345, horizon 14\n", - "adding: mem time332, current time 345, horizon 13\n", - "adding: mem time333, current time 345, horizon 12\n", - "adding: mem time334, current time 345, horizon 11\n", - "adding: mem time335, current time 345, horizon 10\n", - "adding: mem time336, current time 345, horizon 9\n", - "adding: mem time337, current time 345, horizon 8\n", - "adding: mem time338, current time 345, horizon 7\n", - "adding: mem time339, current time 345, horizon 6\n", - "adding: mem time340, current time 345, horizon 5\n", - "adding: mem time341, current time 345, horizon 4\n", - "adding: mem time342, current time 345, horizon 3\n", - "adding: mem time343, current time 345, horizon 2\n", - "adding: mem time344, current time 345, horizon 1\n", - "adding: mem time200, current time 346, horizon 146\n", - "adding: mem time201, current time 346, horizon 145\n", - "adding: mem time202, current time 346, horizon 144\n", - "adding: mem time203, current time 346, horizon 143\n", - "adding: mem time204, current time 346, horizon 142\n", - "adding: mem time205, current time 346, horizon 141\n", - "adding: mem time206, current time 346, horizon 140\n", - "adding: mem time207, current time 346, horizon 139\n", - "adding: mem time208, current time 346, horizon 138\n", - "adding: mem time209, current time 346, horizon 137\n", - "adding: mem time210, current time 346, horizon 136\n", - "adding: mem time211, current time 346, horizon 135\n", - "adding: mem time212, current time 346, horizon 134\n", - "adding: mem time213, current time 346, horizon 133\n", - "adding: mem time214, current time 346, horizon 132\n", - "adding: mem time215, current time 346, horizon 131\n", - "adding: mem time216, current time 346, horizon 130\n", - "adding: mem time217, current time 346, horizon 129\n", - "adding: mem time218, current time 346, horizon 128\n", - "adding: mem time219, current time 346, horizon 127\n", - "adding: mem time220, current time 346, horizon 126\n", - "adding: mem time221, current time 346, horizon 125\n", - "adding: mem time222, current time 346, horizon 124\n", - "adding: mem time223, current time 346, horizon 123\n", - "adding: mem time224, current time 346, horizon 122\n", - "adding: mem time225, current time 346, horizon 121\n", - "adding: mem time226, current time 346, horizon 120\n", - "adding: mem time227, current time 346, horizon 119\n", - "adding: mem time228, current time 346, horizon 118\n", - "adding: mem time229, current time 346, horizon 117\n", - "adding: mem time230, current time 346, horizon 116\n", - "adding: mem time231, current time 346, horizon 115\n", - "adding: mem time232, current time 346, horizon 114\n", - "adding: mem time233, current time 346, horizon 113\n", - "adding: mem time234, current time 346, horizon 112\n", - "adding: mem time235, current time 346, horizon 111\n", - "adding: mem time236, current time 346, horizon 110\n", - "adding: mem time237, current time 346, horizon 109\n", - "adding: mem time238, current time 346, horizon 108\n", - "adding: mem time239, current time 346, horizon 107\n", - "adding: mem time240, current time 346, horizon 106\n", - "adding: mem time241, current time 346, horizon 105\n", - "adding: mem time242, current time 346, horizon 104\n", - "adding: mem time243, current time 346, horizon 103\n", - "adding: mem time244, current time 346, horizon 102\n", - "adding: mem time245, current time 346, horizon 101\n", - "adding: mem time246, current time 346, horizon 100\n", - "adding: mem time247, current time 346, horizon 99\n", - "adding: mem time248, current time 346, horizon 98\n", - "adding: mem time249, current time 346, horizon 97\n", - "adding: mem time250, current time 346, horizon 96\n", - "adding: mem time251, current time 346, horizon 95\n", - "adding: mem time252, current time 346, horizon 94\n", - "adding: mem time253, current time 346, horizon 93\n", - "adding: mem time254, current time 346, horizon 92\n", - "adding: mem time255, current time 346, horizon 91\n", - "adding: mem time256, current time 346, horizon 90\n", - "adding: mem time257, current time 346, horizon 89\n", - "adding: mem time258, current time 346, horizon 88\n", - "adding: mem time259, current time 346, horizon 87\n", - "adding: mem time260, current time 346, horizon 86\n", - "adding: mem time261, current time 346, horizon 85\n", - "adding: mem time262, current time 346, horizon 84\n", - "adding: mem time263, current time 346, horizon 83\n", - "adding: mem time264, current time 346, horizon 82\n", - "adding: mem time265, current time 346, horizon 81\n", - "adding: mem time266, current time 346, horizon 80\n", - "adding: mem time267, current time 346, horizon 79\n", - "adding: mem time268, current time 346, horizon 78\n", - "adding: mem time269, current time 346, horizon 77\n", - "adding: mem time270, current time 346, horizon 76\n", - "adding: mem time271, current time 346, horizon 75\n", - "adding: mem time272, current time 346, horizon 74\n", - "adding: mem time273, current time 346, horizon 73\n", - "adding: mem time274, current time 346, horizon 72\n", - "adding: mem time275, current time 346, horizon 71\n", - "adding: mem time276, current time 346, horizon 70\n", - "adding: mem time277, current time 346, horizon 69\n", - "adding: mem time278, current time 346, horizon 68\n", - "adding: mem time279, current time 346, horizon 67\n", - "adding: mem time280, current time 346, horizon 66\n", - "adding: mem time281, current time 346, horizon 65\n", - "adding: mem time282, current time 346, horizon 64\n", - "adding: mem time283, current time 346, horizon 63\n", - "adding: mem time284, current time 346, horizon 62\n", - "adding: mem time285, current time 346, horizon 61\n", - "adding: mem time286, current time 346, horizon 60\n", - "adding: mem time287, current time 346, horizon 59\n", - "adding: mem time288, current time 346, horizon 58\n", - "adding: mem time289, current time 346, horizon 57\n", - "adding: mem time290, current time 346, horizon 56\n", - "adding: mem time291, current time 346, horizon 55\n", - "adding: mem time292, current time 346, horizon 54\n", - "adding: mem time293, current time 346, horizon 53\n", - "adding: mem time294, current time 346, horizon 52\n", - "adding: mem time295, current time 346, horizon 51\n", - "adding: mem time296, current time 346, horizon 50\n", - "adding: mem time297, current time 346, horizon 49\n", - "adding: mem time298, current time 346, horizon 48\n", - "adding: mem time299, current time 346, horizon 47\n", - "adding: mem time300, current time 346, horizon 46\n", - "adding: mem time301, current time 346, horizon 45\n", - "adding: mem time302, current time 346, horizon 44\n", - "adding: mem time303, current time 346, horizon 43\n", - "adding: mem time304, current time 346, horizon 42\n", - "adding: mem time305, current time 346, horizon 41\n", - "adding: mem time306, current time 346, horizon 40\n", - "adding: mem time307, current time 346, horizon 39\n", - "adding: mem time308, current time 346, horizon 38\n", - "adding: mem time309, current time 346, horizon 37\n", - "adding: mem time310, current time 346, horizon 36\n", - "adding: mem time311, current time 346, horizon 35\n", - "adding: mem time312, current time 346, horizon 34\n", - "adding: mem time313, current time 346, horizon 33\n", - "adding: mem time314, current time 346, horizon 32\n", - "adding: mem time315, current time 346, horizon 31\n", - "adding: mem time316, current time 346, horizon 30\n", - "adding: mem time317, current time 346, horizon 29\n", - "adding: mem time318, current time 346, horizon 28\n", - "adding: mem time319, current time 346, horizon 27\n", - "adding: mem time320, current time 346, horizon 26\n", - "adding: mem time321, current time 346, horizon 25\n", - "adding: mem time322, current time 346, horizon 24\n", - "adding: mem time323, current time 346, horizon 23\n", - "adding: mem time324, current time 346, horizon 22\n", - "adding: mem time325, current time 346, horizon 21\n", - "adding: mem time326, current time 346, horizon 20\n", - "adding: mem time327, current time 346, horizon 19\n", - "adding: mem time328, current time 346, horizon 18\n", - "adding: mem time329, current time 346, horizon 17\n", - "adding: mem time330, current time 346, horizon 16\n", - "adding: mem time331, current time 346, horizon 15\n", - "adding: mem time332, current time 346, horizon 14\n", - "adding: mem time333, current time 346, horizon 13\n", - "adding: mem time334, current time 346, horizon 12\n", - "adding: mem time335, current time 346, horizon 11\n", - "adding: mem time336, current time 346, horizon 10\n", - "adding: mem time337, current time 346, horizon 9\n", - "adding: mem time338, current time 346, horizon 8\n", - "adding: mem time339, current time 346, horizon 7\n", - "adding: mem time340, current time 346, horizon 6\n", - "adding: mem time341, current time 346, horizon 5\n", - "adding: mem time342, current time 346, horizon 4\n", - "adding: mem time343, current time 346, horizon 3\n", - "adding: mem time344, current time 346, horizon 2\n", - "adding: mem time345, current time 346, horizon 1\n", - "adding: mem time200, current time 347, horizon 147\n", - "adding: mem time201, current time 347, horizon 146\n", - "adding: mem time202, current time 347, horizon 145\n", - "adding: mem time203, current time 347, horizon 144\n", - "adding: mem time204, current time 347, horizon 143\n", - "adding: mem time205, current time 347, horizon 142\n", - "adding: mem time206, current time 347, horizon 141\n", - "adding: mem time207, current time 347, horizon 140\n", - "adding: mem time208, current time 347, horizon 139\n", - "adding: mem time209, current time 347, horizon 138\n", - "adding: mem time210, current time 347, horizon 137\n", - "adding: mem time211, current time 347, horizon 136\n", - "adding: mem time212, current time 347, horizon 135\n", - "adding: mem time213, current time 347, horizon 134\n", - "adding: mem time214, current time 347, horizon 133\n", - "adding: mem time215, current time 347, horizon 132\n", - "adding: mem time216, current time 347, horizon 131\n", - "adding: mem time217, current time 347, horizon 130\n", - "adding: mem time218, current time 347, horizon 129\n", - "adding: mem time219, current time 347, horizon 128\n", - "adding: mem time220, current time 347, horizon 127\n", - "adding: mem time221, current time 347, horizon 126\n", - "adding: mem time222, current time 347, horizon 125\n", - "adding: mem time223, current time 347, horizon 124\n", - "adding: mem time224, current time 347, horizon 123\n", - "adding: mem time225, current time 347, horizon 122\n", - "adding: mem time226, current time 347, horizon 121\n", - "adding: mem time227, current time 347, horizon 120\n", - "adding: mem time228, current time 347, horizon 119\n", - "adding: mem time229, current time 347, horizon 118\n", - "adding: mem time230, current time 347, horizon 117\n", - "adding: mem time231, current time 347, horizon 116\n", - "adding: mem time232, current time 347, horizon 115\n", - "adding: mem time233, current time 347, horizon 114\n", - "adding: mem time234, current time 347, horizon 113\n", - "adding: mem time235, current time 347, horizon 112\n", - "adding: mem time236, current time 347, horizon 111\n", - "adding: mem time237, current time 347, horizon 110\n", - "adding: mem time238, current time 347, horizon 109\n", - "adding: mem time239, current time 347, horizon 108\n", - "adding: mem time240, current time 347, horizon 107\n", - "adding: mem time241, current time 347, horizon 106\n", - "adding: mem time242, current time 347, horizon 105\n", - "adding: mem time243, current time 347, horizon 104\n", - "adding: mem time244, current time 347, horizon 103\n", - "adding: mem time245, current time 347, horizon 102\n", - "adding: mem time246, current time 347, horizon 101\n", - "adding: mem time247, current time 347, horizon 100\n", - "adding: mem time248, current time 347, horizon 99\n", - "adding: mem time249, current time 347, horizon 98\n", - "adding: mem time250, current time 347, horizon 97\n", - "adding: mem time251, current time 347, horizon 96\n", - "adding: mem time252, current time 347, horizon 95\n", - "adding: mem time253, current time 347, horizon 94\n", - "adding: mem time254, current time 347, horizon 93\n", - "adding: mem time255, current time 347, horizon 92\n", - "adding: mem time256, current time 347, horizon 91\n", - "adding: mem time257, current time 347, horizon 90\n", - "adding: mem time258, current time 347, horizon 89\n", - "adding: mem time259, current time 347, horizon 88\n", - "adding: mem time260, current time 347, horizon 87\n", - "adding: mem time261, current time 347, horizon 86\n", - "adding: mem time262, current time 347, horizon 85\n", - "adding: mem time263, current time 347, horizon 84\n", - "adding: mem time264, current time 347, horizon 83\n", - "adding: mem time265, current time 347, horizon 82\n", - "adding: mem time266, current time 347, horizon 81\n", - "adding: mem time267, current time 347, horizon 80\n", - "adding: mem time268, current time 347, horizon 79\n", - "adding: mem time269, current time 347, horizon 78\n", - "adding: mem time270, current time 347, horizon 77\n", - "adding: mem time271, current time 347, horizon 76\n", - "adding: mem time272, current time 347, horizon 75\n", - "adding: mem time273, current time 347, horizon 74\n", - "adding: mem time274, current time 347, horizon 73\n", - "adding: mem time275, current time 347, horizon 72\n", - "adding: mem time276, current time 347, horizon 71\n", - "adding: mem time277, current time 347, horizon 70\n", - "adding: mem time278, current time 347, horizon 69\n", - "adding: mem time279, current time 347, horizon 68\n", - "adding: mem time280, current time 347, horizon 67\n", - "adding: mem time281, current time 347, horizon 66\n", - "adding: mem time282, current time 347, horizon 65\n", - "adding: mem time283, current time 347, horizon 64\n", - "adding: mem time284, current time 347, horizon 63\n", - "adding: mem time285, current time 347, horizon 62\n", - "adding: mem time286, current time 347, horizon 61\n", - "adding: mem time287, current time 347, horizon 60\n", - "adding: mem time288, current time 347, horizon 59\n", - "adding: mem time289, current time 347, horizon 58\n", - "adding: mem time290, current time 347, horizon 57\n", - "adding: mem time291, current time 347, horizon 56\n", - "adding: mem time292, current time 347, horizon 55\n", - "adding: mem time293, current time 347, horizon 54\n", - "adding: mem time294, current time 347, horizon 53\n", - "adding: mem time295, current time 347, horizon 52\n", - "adding: mem time296, current time 347, horizon 51\n", - "adding: mem time297, current time 347, horizon 50\n", - "adding: mem time298, current time 347, horizon 49\n", - "adding: mem time299, current time 347, horizon 48\n", - "adding: mem time300, current time 347, horizon 47\n", - "adding: mem time301, current time 347, horizon 46\n", - "adding: mem time302, current time 347, horizon 45\n", - "adding: mem time303, current time 347, horizon 44\n", - "adding: mem time304, current time 347, horizon 43\n", - "adding: mem time305, current time 347, horizon 42\n", - "adding: mem time306, current time 347, horizon 41\n", - "adding: mem time307, current time 347, horizon 40\n", - "adding: mem time308, current time 347, horizon 39\n", - "adding: mem time309, current time 347, horizon 38\n", - "adding: mem time310, current time 347, horizon 37\n", - "adding: mem time311, current time 347, horizon 36\n", - "adding: mem time312, current time 347, horizon 35\n", - "adding: mem time313, current time 347, horizon 34\n", - "adding: mem time314, current time 347, horizon 33\n", - "adding: mem time315, current time 347, horizon 32\n", - "adding: mem time316, current time 347, horizon 31\n", - "adding: mem time317, current time 347, horizon 30\n", - "adding: mem time318, current time 347, horizon 29\n", - "adding: mem time319, current time 347, horizon 28\n", - "adding: mem time320, current time 347, horizon 27\n", - "adding: mem time321, current time 347, horizon 26\n", - "adding: mem time322, current time 347, horizon 25\n", - "adding: mem time323, current time 347, horizon 24\n", - "adding: mem time324, current time 347, horizon 23\n", - "adding: mem time325, current time 347, horizon 22\n", - "adding: mem time326, current time 347, horizon 21\n", - "adding: mem time327, current time 347, horizon 20\n", - "adding: mem time328, current time 347, horizon 19\n", - "adding: mem time329, current time 347, horizon 18\n", - "adding: mem time330, current time 347, horizon 17\n", - "adding: mem time331, current time 347, horizon 16\n", - "adding: mem time332, current time 347, horizon 15\n", - "adding: mem time333, current time 347, horizon 14\n", - "adding: mem time334, current time 347, horizon 13\n", - "adding: mem time335, current time 347, horizon 12\n", - "adding: mem time336, current time 347, horizon 11\n", - "adding: mem time337, current time 347, horizon 10\n", - "adding: mem time338, current time 347, horizon 9\n", - "adding: mem time339, current time 347, horizon 8\n", - "adding: mem time340, current time 347, horizon 7\n", - "adding: mem time341, current time 347, horizon 6\n", - "adding: mem time342, current time 347, horizon 5\n", - "adding: mem time343, current time 347, horizon 4\n", - "adding: mem time344, current time 347, horizon 3\n", - "adding: mem time345, current time 347, horizon 2\n", - "adding: mem time346, current time 347, horizon 1\n", - "adding: mem time200, current time 348, horizon 148\n", - "adding: mem time201, current time 348, horizon 147\n", - "adding: mem time202, current time 348, horizon 146\n", - "adding: mem time203, current time 348, horizon 145\n", - "adding: mem time204, current time 348, horizon 144\n", - "adding: mem time205, current time 348, horizon 143\n", - "adding: mem time206, current time 348, horizon 142\n", - "adding: mem time207, current time 348, horizon 141\n", - "adding: mem time208, current time 348, horizon 140\n", - "adding: mem time209, current time 348, horizon 139\n", - "adding: mem time210, current time 348, horizon 138\n", - "adding: mem time211, current time 348, horizon 137\n", - "adding: mem time212, current time 348, horizon 136\n", - "adding: mem time213, current time 348, horizon 135\n", - "adding: mem time214, current time 348, horizon 134\n", - "adding: mem time215, current time 348, horizon 133\n", - "adding: mem time216, current time 348, horizon 132\n", - "adding: mem time217, current time 348, horizon 131\n", - "adding: mem time218, current time 348, horizon 130\n", - "adding: mem time219, current time 348, horizon 129\n", - "adding: mem time220, current time 348, horizon 128\n", - "adding: mem time221, current time 348, horizon 127\n", - "adding: mem time222, current time 348, horizon 126\n", - "adding: mem time223, current time 348, horizon 125\n", - "adding: mem time224, current time 348, horizon 124\n", - "adding: mem time225, current time 348, horizon 123\n", - "adding: mem time226, current time 348, horizon 122\n", - "adding: mem time227, current time 348, horizon 121\n", - "adding: mem time228, current time 348, horizon 120\n", - "adding: mem time229, current time 348, horizon 119\n", - "adding: mem time230, current time 348, horizon 118\n", - "adding: mem time231, current time 348, horizon 117\n", - "adding: mem time232, current time 348, horizon 116\n", - "adding: mem time233, current time 348, horizon 115\n", - "adding: mem time234, current time 348, horizon 114\n", - "adding: mem time235, current time 348, horizon 113\n", - "adding: mem time236, current time 348, horizon 112\n", - "adding: mem time237, current time 348, horizon 111\n", - "adding: mem time238, current time 348, horizon 110\n", - "adding: mem time239, current time 348, horizon 109\n", - "adding: mem time240, current time 348, horizon 108\n", - "adding: mem time241, current time 348, horizon 107\n", - "adding: mem time242, current time 348, horizon 106\n", - "adding: mem time243, current time 348, horizon 105\n", - "adding: mem time244, current time 348, horizon 104\n", - "adding: mem time245, current time 348, horizon 103\n", - "adding: mem time246, current time 348, horizon 102\n", - "adding: mem time247, current time 348, horizon 101\n", - "adding: mem time248, current time 348, horizon 100\n", - "adding: mem time249, current time 348, horizon 99\n", - "adding: mem time250, current time 348, horizon 98\n", - "adding: mem time251, current time 348, horizon 97\n", - "adding: mem time252, current time 348, horizon 96\n", - "adding: mem time253, current time 348, horizon 95\n", - "adding: mem time254, current time 348, horizon 94\n", - "adding: mem time255, current time 348, horizon 93\n", - "adding: mem time256, current time 348, horizon 92\n", - "adding: mem time257, current time 348, horizon 91\n", - "adding: mem time258, current time 348, horizon 90\n", - "adding: mem time259, current time 348, horizon 89\n", - "adding: mem time260, current time 348, horizon 88\n", - "adding: mem time261, current time 348, horizon 87\n", - "adding: mem time262, current time 348, horizon 86\n", - "adding: mem time263, current time 348, horizon 85\n", - "adding: mem time264, current time 348, horizon 84\n", - "adding: mem time265, current time 348, horizon 83\n", - "adding: mem time266, current time 348, horizon 82\n", - "adding: mem time267, current time 348, horizon 81\n", - "adding: mem time268, current time 348, horizon 80\n", - "adding: mem time269, current time 348, horizon 79\n", - "adding: mem time270, current time 348, horizon 78\n", - "adding: mem time271, current time 348, horizon 77\n", - "adding: mem time272, current time 348, horizon 76\n", - "adding: mem time273, current time 348, horizon 75\n", - "adding: mem time274, current time 348, horizon 74\n", - "adding: mem time275, current time 348, horizon 73\n", - "adding: mem time276, current time 348, horizon 72\n", - "adding: mem time277, current time 348, horizon 71\n", - "adding: mem time278, current time 348, horizon 70\n", - "adding: mem time279, current time 348, horizon 69\n", - "adding: mem time280, current time 348, horizon 68\n", - "adding: mem time281, current time 348, horizon 67\n", - "adding: mem time282, current time 348, horizon 66\n", - "adding: mem time283, current time 348, horizon 65\n", - "adding: mem time284, current time 348, horizon 64\n", - "adding: mem time285, current time 348, horizon 63\n", - "adding: mem time286, current time 348, horizon 62\n", - "adding: mem time287, current time 348, horizon 61\n", - "adding: mem time288, current time 348, horizon 60\n", - "adding: mem time289, current time 348, horizon 59\n", - "adding: mem time290, current time 348, horizon 58\n", - "adding: mem time291, current time 348, horizon 57\n", - "adding: mem time292, current time 348, horizon 56\n", - "adding: mem time293, current time 348, horizon 55\n", - "adding: mem time294, current time 348, horizon 54\n", - "adding: mem time295, current time 348, horizon 53\n", - "adding: mem time296, current time 348, horizon 52\n", - "adding: mem time297, current time 348, horizon 51\n", - "adding: mem time298, current time 348, horizon 50\n", - "adding: mem time299, current time 348, horizon 49\n", - "adding: mem time300, current time 348, horizon 48\n", - "adding: mem time301, current time 348, horizon 47\n", - "adding: mem time302, current time 348, horizon 46\n", - "adding: mem time303, current time 348, horizon 45\n", - "adding: mem time304, current time 348, horizon 44\n", - "adding: mem time305, current time 348, horizon 43\n", - "adding: mem time306, current time 348, horizon 42\n", - "adding: mem time307, current time 348, horizon 41\n", - "adding: mem time308, current time 348, horizon 40\n", - "adding: mem time309, current time 348, horizon 39\n", - "adding: mem time310, current time 348, horizon 38\n", - "adding: mem time311, current time 348, horizon 37\n", - "adding: mem time312, current time 348, horizon 36\n", - "adding: mem time313, current time 348, horizon 35\n", - "adding: mem time314, current time 348, horizon 34\n", - "adding: mem time315, current time 348, horizon 33\n", - "adding: mem time316, current time 348, horizon 32\n", - "adding: mem time317, current time 348, horizon 31\n", - "adding: mem time318, current time 348, horizon 30\n", - "adding: mem time319, current time 348, horizon 29\n", - "adding: mem time320, current time 348, horizon 28\n", - "adding: mem time321, current time 348, horizon 27\n", - "adding: mem time322, current time 348, horizon 26\n", - "adding: mem time323, current time 348, horizon 25\n", - "adding: mem time324, current time 348, horizon 24\n", - "adding: mem time325, current time 348, horizon 23\n", - "adding: mem time326, current time 348, horizon 22\n", - "adding: mem time327, current time 348, horizon 21\n", - "adding: mem time328, current time 348, horizon 20\n", - "adding: mem time329, current time 348, horizon 19\n", - "adding: mem time330, current time 348, horizon 18\n", - "adding: mem time331, current time 348, horizon 17\n", - "adding: mem time332, current time 348, horizon 16\n", - "adding: mem time333, current time 348, horizon 15\n", - "adding: mem time334, current time 348, horizon 14\n", - "adding: mem time335, current time 348, horizon 13\n", - "adding: mem time336, current time 348, horizon 12\n", - "adding: mem time337, current time 348, horizon 11\n", - "adding: mem time338, current time 348, horizon 10\n", - "adding: mem time339, current time 348, horizon 9\n", - "adding: mem time340, current time 348, horizon 8\n", - "adding: mem time341, current time 348, horizon 7\n", - "adding: mem time342, current time 348, horizon 6\n", - "adding: mem time343, current time 348, horizon 5\n", - "adding: mem time344, current time 348, horizon 4\n", - "adding: mem time345, current time 348, horizon 3\n", - "adding: mem time346, current time 348, horizon 2\n", - "adding: mem time347, current time 348, horizon 1\n", - "adding: mem time200, current time 349, horizon 149\n", - "adding: mem time201, current time 349, horizon 148\n", - "adding: mem time202, current time 349, horizon 147\n", - "adding: mem time203, current time 349, horizon 146\n", - "adding: mem time204, current time 349, horizon 145\n", - "adding: mem time205, current time 349, horizon 144\n", - "adding: mem time206, current time 349, horizon 143\n", - "adding: mem time207, current time 349, horizon 142\n", - "adding: mem time208, current time 349, horizon 141\n", - "adding: mem time209, current time 349, horizon 140\n", - "adding: mem time210, current time 349, horizon 139\n", - "adding: mem time211, current time 349, horizon 138\n", - "adding: mem time212, current time 349, horizon 137\n", - "adding: mem time213, current time 349, horizon 136\n", - "adding: mem time214, current time 349, horizon 135\n", - "adding: mem time215, current time 349, horizon 134\n", - "adding: mem time216, current time 349, horizon 133\n", - "adding: mem time217, current time 349, horizon 132\n", - "adding: mem time218, current time 349, horizon 131\n", - "adding: mem time219, current time 349, horizon 130\n", - "adding: mem time220, current time 349, horizon 129\n", - "adding: mem time221, current time 349, horizon 128\n", - "adding: mem time222, current time 349, horizon 127\n", - "adding: mem time223, current time 349, horizon 126\n", - "adding: mem time224, current time 349, horizon 125\n", - "adding: mem time225, current time 349, horizon 124\n", - "adding: mem time226, current time 349, horizon 123\n", - "adding: mem time227, current time 349, horizon 122\n", - "adding: mem time228, current time 349, horizon 121\n", - "adding: mem time229, current time 349, horizon 120\n", - "adding: mem time230, current time 349, horizon 119\n", - "adding: mem time231, current time 349, horizon 118\n", - "adding: mem time232, current time 349, horizon 117\n", - "adding: mem time233, current time 349, horizon 116\n", - "adding: mem time234, current time 349, horizon 115\n", - "adding: mem time235, current time 349, horizon 114\n", - "adding: mem time236, current time 349, horizon 113\n", - "adding: mem time237, current time 349, horizon 112\n", - "adding: mem time238, current time 349, horizon 111\n", - "adding: mem time239, current time 349, horizon 110\n", - "adding: mem time240, current time 349, horizon 109\n", - "adding: mem time241, current time 349, horizon 108\n", - "adding: mem time242, current time 349, horizon 107\n", - "adding: mem time243, current time 349, horizon 106\n", - "adding: mem time244, current time 349, horizon 105\n", - "adding: mem time245, current time 349, horizon 104\n", - "adding: mem time246, current time 349, horizon 103\n", - "adding: mem time247, current time 349, horizon 102\n", - "adding: mem time248, current time 349, horizon 101\n", - "adding: mem time249, current time 349, horizon 100\n", - "adding: mem time250, current time 349, horizon 99\n", - "adding: mem time251, current time 349, horizon 98\n", - "adding: mem time252, current time 349, horizon 97\n", - "adding: mem time253, current time 349, horizon 96\n", - "adding: mem time254, current time 349, horizon 95\n", - "adding: mem time255, current time 349, horizon 94\n", - "adding: mem time256, current time 349, horizon 93\n", - "adding: mem time257, current time 349, horizon 92\n", - "adding: mem time258, current time 349, horizon 91\n", - "adding: mem time259, current time 349, horizon 90\n", - "adding: mem time260, current time 349, horizon 89\n", - "adding: mem time261, current time 349, horizon 88\n", - "adding: mem time262, current time 349, horizon 87\n", - "adding: mem time263, current time 349, horizon 86\n", - "adding: mem time264, current time 349, horizon 85\n", - "adding: mem time265, current time 349, horizon 84\n", - "adding: mem time266, current time 349, horizon 83\n", - "adding: mem time267, current time 349, horizon 82\n", - "adding: mem time268, current time 349, horizon 81\n", - "adding: mem time269, current time 349, horizon 80\n", - "adding: mem time270, current time 349, horizon 79\n", - "adding: mem time271, current time 349, horizon 78\n", - "adding: mem time272, current time 349, horizon 77\n", - "adding: mem time273, current time 349, horizon 76\n", - "adding: mem time274, current time 349, horizon 75\n", - "adding: mem time275, current time 349, horizon 74\n", - "adding: mem time276, current time 349, horizon 73\n", - "adding: mem time277, current time 349, horizon 72\n", - "adding: mem time278, current time 349, horizon 71\n", - "adding: mem time279, current time 349, horizon 70\n", - "adding: mem time280, current time 349, horizon 69\n", - "adding: mem time281, current time 349, horizon 68\n", - "adding: mem time282, current time 349, horizon 67\n", - "adding: mem time283, current time 349, horizon 66\n", - "adding: mem time284, current time 349, horizon 65\n", - "adding: mem time285, current time 349, horizon 64\n", - "adding: mem time286, current time 349, horizon 63\n", - "adding: mem time287, current time 349, horizon 62\n", - "adding: mem time288, current time 349, horizon 61\n", - "adding: mem time289, current time 349, horizon 60\n", - "adding: mem time290, current time 349, horizon 59\n", - "adding: mem time291, current time 349, horizon 58\n", - "adding: mem time292, current time 349, horizon 57\n", - "adding: mem time293, current time 349, horizon 56\n", - "adding: mem time294, current time 349, horizon 55\n", - "adding: mem time295, current time 349, horizon 54\n", - "adding: mem time296, current time 349, horizon 53\n", - "adding: mem time297, current time 349, horizon 52\n", - "adding: mem time298, current time 349, horizon 51\n", - "adding: mem time299, current time 349, horizon 50\n", - "adding: mem time300, current time 349, horizon 49\n", - "adding: mem time301, current time 349, horizon 48\n", - "adding: mem time302, current time 349, horizon 47\n", - "adding: mem time303, current time 349, horizon 46\n", - "adding: mem time304, current time 349, horizon 45\n", - "adding: mem time305, current time 349, horizon 44\n", - "adding: mem time306, current time 349, horizon 43\n", - "adding: mem time307, current time 349, horizon 42\n", - "adding: mem time308, current time 349, horizon 41\n", - "adding: mem time309, current time 349, horizon 40\n", - "adding: mem time310, current time 349, horizon 39\n", - "adding: mem time311, current time 349, horizon 38\n", - "adding: mem time312, current time 349, horizon 37\n", - "adding: mem time313, current time 349, horizon 36\n", - "adding: mem time314, current time 349, horizon 35\n", - "adding: mem time315, current time 349, horizon 34\n", - "adding: mem time316, current time 349, horizon 33\n", - "adding: mem time317, current time 349, horizon 32\n", - "adding: mem time318, current time 349, horizon 31\n", - "adding: mem time319, current time 349, horizon 30\n", - "adding: mem time320, current time 349, horizon 29\n", - "adding: mem time321, current time 349, horizon 28\n", - "adding: mem time322, current time 349, horizon 27\n", - "adding: mem time323, current time 349, horizon 26\n", - "adding: mem time324, current time 349, horizon 25\n", - "adding: mem time325, current time 349, horizon 24\n", - "adding: mem time326, current time 349, horizon 23\n", - "adding: mem time327, current time 349, horizon 22\n", - "adding: mem time328, current time 349, horizon 21\n", - "adding: mem time329, current time 349, horizon 20\n", - "adding: mem time330, current time 349, horizon 19\n", - "adding: mem time331, current time 349, horizon 18\n", - "adding: mem time332, current time 349, horizon 17\n", - "adding: mem time333, current time 349, horizon 16\n", - "adding: mem time334, current time 349, horizon 15\n", - "adding: mem time335, current time 349, horizon 14\n", - "adding: mem time336, current time 349, horizon 13\n", - "adding: mem time337, current time 349, horizon 12\n", - "adding: mem time338, current time 349, horizon 11\n", - "adding: mem time339, current time 349, horizon 10\n", - "adding: mem time340, current time 349, horizon 9\n", - "adding: mem time341, current time 349, horizon 8\n", - "adding: mem time342, current time 349, horizon 7\n", - "adding: mem time343, current time 349, horizon 6\n", - "adding: mem time344, current time 349, horizon 5\n", - "adding: mem time345, current time 349, horizon 4\n", - "adding: mem time346, current time 349, horizon 3\n", - "adding: mem time347, current time 349, horizon 2\n", - "adding: mem time348, current time 349, horizon 1\n", - "adding: mem time200, current time 350, horizon 150\n", - "adding: mem time201, current time 350, horizon 149\n", - "adding: mem time202, current time 350, horizon 148\n", - "adding: mem time203, current time 350, horizon 147\n", - "adding: mem time204, current time 350, horizon 146\n", - "adding: mem time205, current time 350, horizon 145\n", - "adding: mem time206, current time 350, horizon 144\n", - "adding: mem time207, current time 350, horizon 143\n", - "adding: mem time208, current time 350, horizon 142\n", - "adding: mem time209, current time 350, horizon 141\n", - "adding: mem time210, current time 350, horizon 140\n", - "adding: mem time211, current time 350, horizon 139\n", - "adding: mem time212, current time 350, horizon 138\n", - "adding: mem time213, current time 350, horizon 137\n", - "adding: mem time214, current time 350, horizon 136\n", - "adding: mem time215, current time 350, horizon 135\n", - "adding: mem time216, current time 350, horizon 134\n", - "adding: mem time217, current time 350, horizon 133\n", - "adding: mem time218, current time 350, horizon 132\n", - "adding: mem time219, current time 350, horizon 131\n", - "adding: mem time220, current time 350, horizon 130\n", - "adding: mem time221, current time 350, horizon 129\n", - "adding: mem time222, current time 350, horizon 128\n", - "adding: mem time223, current time 350, horizon 127\n", - "adding: mem time224, current time 350, horizon 126\n", - "adding: mem time225, current time 350, horizon 125\n", - "adding: mem time226, current time 350, horizon 124\n", - "adding: mem time227, current time 350, horizon 123\n", - "adding: mem time228, current time 350, horizon 122\n", - "adding: mem time229, current time 350, horizon 121\n", - "adding: mem time230, current time 350, horizon 120\n", - "adding: mem time231, current time 350, horizon 119\n", - "adding: mem time232, current time 350, horizon 118\n", - "adding: mem time233, current time 350, horizon 117\n", - "adding: mem time234, current time 350, horizon 116\n", - "adding: mem time235, current time 350, horizon 115\n", - "adding: mem time236, current time 350, horizon 114\n", - "adding: mem time237, current time 350, horizon 113\n", - "adding: mem time238, current time 350, horizon 112\n", - "adding: mem time239, current time 350, horizon 111\n", - "adding: mem time240, current time 350, horizon 110\n", - "adding: mem time241, current time 350, horizon 109\n", - "adding: mem time242, current time 350, horizon 108\n", - "adding: mem time243, current time 350, horizon 107\n", - "adding: mem time244, current time 350, horizon 106\n", - "adding: mem time245, current time 350, horizon 105\n", - "adding: mem time246, current time 350, horizon 104\n", - "adding: mem time247, current time 350, horizon 103\n", - "adding: mem time248, current time 350, horizon 102\n", - "adding: mem time249, current time 350, horizon 101\n", - "adding: mem time250, current time 350, horizon 100\n", - "adding: mem time251, current time 350, horizon 99\n", - "adding: mem time252, current time 350, horizon 98\n", - "adding: mem time253, current time 350, horizon 97\n", - "adding: mem time254, current time 350, horizon 96\n", - "adding: mem time255, current time 350, horizon 95\n", - "adding: mem time256, current time 350, horizon 94\n", - "adding: mem time257, current time 350, horizon 93\n", - "adding: mem time258, current time 350, horizon 92\n", - "adding: mem time259, current time 350, horizon 91\n", - "adding: mem time260, current time 350, horizon 90\n", - "adding: mem time261, current time 350, horizon 89\n", - "adding: mem time262, current time 350, horizon 88\n", - "adding: mem time263, current time 350, horizon 87\n", - "adding: mem time264, current time 350, horizon 86\n", - "adding: mem time265, current time 350, horizon 85\n", - "adding: mem time266, current time 350, horizon 84\n", - "adding: mem time267, current time 350, horizon 83\n", - "adding: mem time268, current time 350, horizon 82\n", - "adding: mem time269, current time 350, horizon 81\n", - "adding: mem time270, current time 350, horizon 80\n", - "adding: mem time271, current time 350, horizon 79\n", - "adding: mem time272, current time 350, horizon 78\n", - "adding: mem time273, current time 350, horizon 77\n", - "adding: mem time274, current time 350, horizon 76\n", - "adding: mem time275, current time 350, horizon 75\n", - "adding: mem time276, current time 350, horizon 74\n", - "adding: mem time277, current time 350, horizon 73\n", - "adding: mem time278, current time 350, horizon 72\n", - "adding: mem time279, current time 350, horizon 71\n", - "adding: mem time280, current time 350, horizon 70\n", - "adding: mem time281, current time 350, horizon 69\n", - "adding: mem time282, current time 350, horizon 68\n", - "adding: mem time283, current time 350, horizon 67\n", - "adding: mem time284, current time 350, horizon 66\n", - "adding: mem time285, current time 350, horizon 65\n", - "adding: mem time286, current time 350, horizon 64\n", - "adding: mem time287, current time 350, horizon 63\n", - "adding: mem time288, current time 350, horizon 62\n", - "adding: mem time289, current time 350, horizon 61\n", - "adding: mem time290, current time 350, horizon 60\n", - "adding: mem time291, current time 350, horizon 59\n", - "adding: mem time292, current time 350, horizon 58\n", - "adding: mem time293, current time 350, horizon 57\n", - "adding: mem time294, current time 350, horizon 56\n", - "adding: mem time295, current time 350, horizon 55\n", - "adding: mem time296, current time 350, horizon 54\n", - "adding: mem time297, current time 350, horizon 53\n", - "adding: mem time298, current time 350, horizon 52\n", - "adding: mem time299, current time 350, horizon 51\n", - "adding: mem time300, current time 350, horizon 50\n", - "adding: mem time301, current time 350, horizon 49\n", - "adding: mem time302, current time 350, horizon 48\n", - "adding: mem time303, current time 350, horizon 47\n", - "adding: mem time304, current time 350, horizon 46\n", - "adding: mem time305, current time 350, horizon 45\n", - "adding: mem time306, current time 350, horizon 44\n", - "adding: mem time307, current time 350, horizon 43\n", - "adding: mem time308, current time 350, horizon 42\n", - "adding: mem time309, current time 350, horizon 41\n", - "adding: mem time310, current time 350, horizon 40\n", - "adding: mem time311, current time 350, horizon 39\n", - "adding: mem time312, current time 350, horizon 38\n", - "adding: mem time313, current time 350, horizon 37\n", - "adding: mem time314, current time 350, horizon 36\n", - "adding: mem time315, current time 350, horizon 35\n", - "adding: mem time316, current time 350, horizon 34\n", - "adding: mem time317, current time 350, horizon 33\n", - "adding: mem time318, current time 350, horizon 32\n", - "adding: mem time319, current time 350, horizon 31\n", - "adding: mem time320, current time 350, horizon 30\n", - "adding: mem time321, current time 350, horizon 29\n", - "adding: mem time322, current time 350, horizon 28\n", - "adding: mem time323, current time 350, horizon 27\n", - "adding: mem time324, current time 350, horizon 26\n", - "adding: mem time325, current time 350, horizon 25\n", - "adding: mem time326, current time 350, horizon 24\n", - "adding: mem time327, current time 350, horizon 23\n", - "adding: mem time328, current time 350, horizon 22\n", - "adding: mem time329, current time 350, horizon 21\n", - "adding: mem time330, current time 350, horizon 20\n", - "adding: mem time331, current time 350, horizon 19\n", - "adding: mem time332, current time 350, horizon 18\n", - "adding: mem time333, current time 350, horizon 17\n", - "adding: mem time334, current time 350, horizon 16\n", - "adding: mem time335, current time 350, horizon 15\n", - "adding: mem time336, current time 350, horizon 14\n", - "adding: mem time337, current time 350, horizon 13\n", - "adding: mem time338, current time 350, horizon 12\n", - "adding: mem time339, current time 350, horizon 11\n", - "adding: mem time340, current time 350, horizon 10\n", - "adding: mem time341, current time 350, horizon 9\n", - "adding: mem time342, current time 350, horizon 8\n", - "adding: mem time343, current time 350, horizon 7\n", - "adding: mem time344, current time 350, horizon 6\n", - "adding: mem time345, current time 350, horizon 5\n", - "adding: mem time346, current time 350, horizon 4\n", - "adding: mem time347, current time 350, horizon 3\n", - "adding: mem time348, current time 350, horizon 2\n", - "adding: mem time349, current time 350, horizon 1\n", - "adding: mem time200, current time 351, horizon 151\n", - "adding: mem time201, current time 351, horizon 150\n", - "adding: mem time202, current time 351, horizon 149\n", - "adding: mem time203, current time 351, horizon 148\n", - "adding: mem time204, current time 351, horizon 147\n", - "adding: mem time205, current time 351, horizon 146\n", - "adding: mem time206, current time 351, horizon 145\n", - "adding: mem time207, current time 351, horizon 144\n", - "adding: mem time208, current time 351, horizon 143\n", - "adding: mem time209, current time 351, horizon 142\n", - "adding: mem time210, current time 351, horizon 141\n", - "adding: mem time211, current time 351, horizon 140\n", - "adding: mem time212, current time 351, horizon 139\n", - "adding: mem time213, current time 351, horizon 138\n", - "adding: mem time214, current time 351, horizon 137\n", - "adding: mem time215, current time 351, horizon 136\n", - "adding: mem time216, current time 351, horizon 135\n", - "adding: mem time217, current time 351, horizon 134\n", - "adding: mem time218, current time 351, horizon 133\n", - "adding: mem time219, current time 351, horizon 132\n", - "adding: mem time220, current time 351, horizon 131\n", - "adding: mem time221, current time 351, horizon 130\n", - "adding: mem time222, current time 351, horizon 129\n", - "adding: mem time223, current time 351, horizon 128\n", - "adding: mem time224, current time 351, horizon 127\n", - "adding: mem time225, current time 351, horizon 126\n", - "adding: mem time226, current time 351, horizon 125\n", - "adding: mem time227, current time 351, horizon 124\n", - "adding: mem time228, current time 351, horizon 123\n", - "adding: mem time229, current time 351, horizon 122\n", - "adding: mem time230, current time 351, horizon 121\n", - "adding: mem time231, current time 351, horizon 120\n", - "adding: mem time232, current time 351, horizon 119\n", - "adding: mem time233, current time 351, horizon 118\n", - "adding: mem time234, current time 351, horizon 117\n", - "adding: mem time235, current time 351, horizon 116\n", - "adding: mem time236, current time 351, horizon 115\n", - "adding: mem time237, current time 351, horizon 114\n", - "adding: mem time238, current time 351, horizon 113\n", - "adding: mem time239, current time 351, horizon 112\n", - "adding: mem time240, current time 351, horizon 111\n", - "adding: mem time241, current time 351, horizon 110\n", - "adding: mem time242, current time 351, horizon 109\n", - "adding: mem time243, current time 351, horizon 108\n", - "adding: mem time244, current time 351, horizon 107\n", - "adding: mem time245, current time 351, horizon 106\n", - "adding: mem time246, current time 351, horizon 105\n", - "adding: mem time247, current time 351, horizon 104\n", - "adding: mem time248, current time 351, horizon 103\n", - "adding: mem time249, current time 351, horizon 102\n", - "adding: mem time250, current time 351, horizon 101\n", - "adding: mem time251, current time 351, horizon 100\n", - "adding: mem time252, current time 351, horizon 99\n", - "adding: mem time253, current time 351, horizon 98\n", - "adding: mem time254, current time 351, horizon 97\n", - "adding: mem time255, current time 351, horizon 96\n", - "adding: mem time256, current time 351, horizon 95\n", - "adding: mem time257, current time 351, horizon 94\n", - "adding: mem time258, current time 351, horizon 93\n", - "adding: mem time259, current time 351, horizon 92\n", - "adding: mem time260, current time 351, horizon 91\n", - "adding: mem time261, current time 351, horizon 90\n", - "adding: mem time262, current time 351, horizon 89\n", - "adding: mem time263, current time 351, horizon 88\n", - "adding: mem time264, current time 351, horizon 87\n", - "adding: mem time265, current time 351, horizon 86\n", - "adding: mem time266, current time 351, horizon 85\n", - "adding: mem time267, current time 351, horizon 84\n", - "adding: mem time268, current time 351, horizon 83\n", - "adding: mem time269, current time 351, horizon 82\n", - "adding: mem time270, current time 351, horizon 81\n", - "adding: mem time271, current time 351, horizon 80\n", - "adding: mem time272, current time 351, horizon 79\n", - "adding: mem time273, current time 351, horizon 78\n", - "adding: mem time274, current time 351, horizon 77\n", - "adding: mem time275, current time 351, horizon 76\n", - "adding: mem time276, current time 351, horizon 75\n", - "adding: mem time277, current time 351, horizon 74\n", - "adding: mem time278, current time 351, horizon 73\n", - "adding: mem time279, current time 351, horizon 72\n", - "adding: mem time280, current time 351, horizon 71\n", - "adding: mem time281, current time 351, horizon 70\n", - "adding: mem time282, current time 351, horizon 69\n", - "adding: mem time283, current time 351, horizon 68\n", - "adding: mem time284, current time 351, horizon 67\n", - "adding: mem time285, current time 351, horizon 66\n", - "adding: mem time286, current time 351, horizon 65\n", - "adding: mem time287, current time 351, horizon 64\n", - "adding: mem time288, current time 351, horizon 63\n", - "adding: mem time289, current time 351, horizon 62\n", - "adding: mem time290, current time 351, horizon 61\n", - "adding: mem time291, current time 351, horizon 60\n", - "adding: mem time292, current time 351, horizon 59\n", - "adding: mem time293, current time 351, horizon 58\n", - "adding: mem time294, current time 351, horizon 57\n", - "adding: mem time295, current time 351, horizon 56\n", - "adding: mem time296, current time 351, horizon 55\n", - "adding: mem time297, current time 351, horizon 54\n", - "adding: mem time298, current time 351, horizon 53\n", - "adding: mem time299, current time 351, horizon 52\n", - "adding: mem time300, current time 351, horizon 51\n", - "adding: mem time301, current time 351, horizon 50\n", - "adding: mem time302, current time 351, horizon 49\n", - "adding: mem time303, current time 351, horizon 48\n", - "adding: mem time304, current time 351, horizon 47\n", - "adding: mem time305, current time 351, horizon 46\n", - "adding: mem time306, current time 351, horizon 45\n", - "adding: mem time307, current time 351, horizon 44\n", - "adding: mem time308, current time 351, horizon 43\n", - "adding: mem time309, current time 351, horizon 42\n", - "adding: mem time310, current time 351, horizon 41\n", - "adding: mem time311, current time 351, horizon 40\n", - "adding: mem time312, current time 351, horizon 39\n", - "adding: mem time313, current time 351, horizon 38\n", - "adding: mem time314, current time 351, horizon 37\n", - "adding: mem time315, current time 351, horizon 36\n", - "adding: mem time316, current time 351, horizon 35\n", - "adding: mem time317, current time 351, horizon 34\n", - "adding: mem time318, current time 351, horizon 33\n", - "adding: mem time319, current time 351, horizon 32\n", - "adding: mem time320, current time 351, horizon 31\n", - "adding: mem time321, current time 351, horizon 30\n", - "adding: mem time322, current time 351, horizon 29\n", - "adding: mem time323, current time 351, horizon 28\n", - "adding: mem time324, current time 351, horizon 27\n", - "adding: mem time325, current time 351, horizon 26\n", - "adding: mem time326, current time 351, horizon 25\n", - "adding: mem time327, current time 351, horizon 24\n", - "adding: mem time328, current time 351, horizon 23\n", - "adding: mem time329, current time 351, horizon 22\n", - "adding: mem time330, current time 351, horizon 21\n", - "adding: mem time331, current time 351, horizon 20\n", - "adding: mem time332, current time 351, horizon 19\n", - "adding: mem time333, current time 351, horizon 18\n", - "adding: mem time334, current time 351, horizon 17\n", - "adding: mem time335, current time 351, horizon 16\n", - "adding: mem time336, current time 351, horizon 15\n", - "adding: mem time337, current time 351, horizon 14\n", - "adding: mem time338, current time 351, horizon 13\n", - "adding: mem time339, current time 351, horizon 12\n", - "adding: mem time340, current time 351, horizon 11\n", - "adding: mem time341, current time 351, horizon 10\n", - "adding: mem time342, current time 351, horizon 9\n", - "adding: mem time343, current time 351, horizon 8\n", - "adding: mem time344, current time 351, horizon 7\n", - "adding: mem time345, current time 351, horizon 6\n", - "adding: mem time346, current time 351, horizon 5\n", - "adding: mem time347, current time 351, horizon 4\n", - "adding: mem time348, current time 351, horizon 3\n", - "adding: mem time349, current time 351, horizon 2\n", - "adding: mem time350, current time 351, horizon 1\n", - "adding: mem time200, current time 352, horizon 152\n", - "adding: mem time201, current time 352, horizon 151\n", - "adding: mem time202, current time 352, horizon 150\n", - "adding: mem time203, current time 352, horizon 149\n", - "adding: mem time204, current time 352, horizon 148\n", - "adding: mem time205, current time 352, horizon 147\n", - "adding: mem time206, current time 352, horizon 146\n", - "adding: mem time207, current time 352, horizon 145\n", - "adding: mem time208, current time 352, horizon 144\n", - "adding: mem time209, current time 352, horizon 143\n", - "adding: mem time210, current time 352, horizon 142\n", - "adding: mem time211, current time 352, horizon 141\n", - "adding: mem time212, current time 352, horizon 140\n", - "adding: mem time213, current time 352, horizon 139\n", - "adding: mem time214, current time 352, horizon 138\n", - "adding: mem time215, current time 352, horizon 137\n", - "adding: mem time216, current time 352, horizon 136\n", - "adding: mem time217, current time 352, horizon 135\n", - "adding: mem time218, current time 352, horizon 134\n", - "adding: mem time219, current time 352, horizon 133\n", - "adding: mem time220, current time 352, horizon 132\n", - "adding: mem time221, current time 352, horizon 131\n", - "adding: mem time222, current time 352, horizon 130\n", - "adding: mem time223, current time 352, horizon 129\n", - "adding: mem time224, current time 352, horizon 128\n", - "adding: mem time225, current time 352, horizon 127\n", - "adding: mem time226, current time 352, horizon 126\n", - "adding: mem time227, current time 352, horizon 125\n", - "adding: mem time228, current time 352, horizon 124\n", - "adding: mem time229, current time 352, horizon 123\n", - "adding: mem time230, current time 352, horizon 122\n", - "adding: mem time231, current time 352, horizon 121\n", - "adding: mem time232, current time 352, horizon 120\n", - "adding: mem time233, current time 352, horizon 119\n", - "adding: mem time234, current time 352, horizon 118\n", - "adding: mem time235, current time 352, horizon 117\n", - "adding: mem time236, current time 352, horizon 116\n", - "adding: mem time237, current time 352, horizon 115\n", - "adding: mem time238, current time 352, horizon 114\n", - "adding: mem time239, current time 352, horizon 113\n", - "adding: mem time240, current time 352, horizon 112\n", - "adding: mem time241, current time 352, horizon 111\n", - "adding: mem time242, current time 352, horizon 110\n", - "adding: mem time243, current time 352, horizon 109\n", - "adding: mem time244, current time 352, horizon 108\n", - "adding: mem time245, current time 352, horizon 107\n", - "adding: mem time246, current time 352, horizon 106\n", - "adding: mem time247, current time 352, horizon 105\n", - "adding: mem time248, current time 352, horizon 104\n", - "adding: mem time249, current time 352, horizon 103\n", - "adding: mem time250, current time 352, horizon 102\n", - "adding: mem time251, current time 352, horizon 101\n", - "adding: mem time252, current time 352, horizon 100\n", - "adding: mem time253, current time 352, horizon 99\n", - "adding: mem time254, current time 352, horizon 98\n", - "adding: mem time255, current time 352, horizon 97\n", - "adding: mem time256, current time 352, horizon 96\n", - "adding: mem time257, current time 352, horizon 95\n", - "adding: mem time258, current time 352, horizon 94\n", - "adding: mem time259, current time 352, horizon 93\n", - "adding: mem time260, current time 352, horizon 92\n", - "adding: mem time261, current time 352, horizon 91\n", - "adding: mem time262, current time 352, horizon 90\n", - "adding: mem time263, current time 352, horizon 89\n", - "adding: mem time264, current time 352, horizon 88\n", - "adding: mem time265, current time 352, horizon 87\n", - "adding: mem time266, current time 352, horizon 86\n", - "adding: mem time267, current time 352, horizon 85\n", - "adding: mem time268, current time 352, horizon 84\n", - "adding: mem time269, current time 352, horizon 83\n", - "adding: mem time270, current time 352, horizon 82\n", - "adding: mem time271, current time 352, horizon 81\n", - "adding: mem time272, current time 352, horizon 80\n", - "adding: mem time273, current time 352, horizon 79\n", - "adding: mem time274, current time 352, horizon 78\n", - "adding: mem time275, current time 352, horizon 77\n", - "adding: mem time276, current time 352, horizon 76\n", - "adding: mem time277, current time 352, horizon 75\n", - "adding: mem time278, current time 352, horizon 74\n", - "adding: mem time279, current time 352, horizon 73\n", - "adding: mem time280, current time 352, horizon 72\n", - "adding: mem time281, current time 352, horizon 71\n", - "adding: mem time282, current time 352, horizon 70\n", - "adding: mem time283, current time 352, horizon 69\n", - "adding: mem time284, current time 352, horizon 68\n", - "adding: mem time285, current time 352, horizon 67\n", - "adding: mem time286, current time 352, horizon 66\n", - "adding: mem time287, current time 352, horizon 65\n", - "adding: mem time288, current time 352, horizon 64\n", - "adding: mem time289, current time 352, horizon 63\n", - "adding: mem time290, current time 352, horizon 62\n", - "adding: mem time291, current time 352, horizon 61\n", - "adding: mem time292, current time 352, horizon 60\n", - "adding: mem time293, current time 352, horizon 59\n", - "adding: mem time294, current time 352, horizon 58\n", - "adding: mem time295, current time 352, horizon 57\n", - "adding: mem time296, current time 352, horizon 56\n", - "adding: mem time297, current time 352, horizon 55\n", - "adding: mem time298, current time 352, horizon 54\n", - "adding: mem time299, current time 352, horizon 53\n", - "adding: mem time300, current time 352, horizon 52\n", - "adding: mem time301, current time 352, horizon 51\n", - "adding: mem time302, current time 352, horizon 50\n", - "adding: mem time303, current time 352, horizon 49\n", - "adding: mem time304, current time 352, horizon 48\n", - "adding: mem time305, current time 352, horizon 47\n", - "adding: mem time306, current time 352, horizon 46\n", - "adding: mem time307, current time 352, horizon 45\n", - "adding: mem time308, current time 352, horizon 44\n", - "adding: mem time309, current time 352, horizon 43\n", - "adding: mem time310, current time 352, horizon 42\n", - "adding: mem time311, current time 352, horizon 41\n", - "adding: mem time312, current time 352, horizon 40\n", - "adding: mem time313, current time 352, horizon 39\n", - "adding: mem time314, current time 352, horizon 38\n", - "adding: mem time315, current time 352, horizon 37\n", - "adding: mem time316, current time 352, horizon 36\n", - "adding: mem time317, current time 352, horizon 35\n", - "adding: mem time318, current time 352, horizon 34\n", - "adding: mem time319, current time 352, horizon 33\n", - "adding: mem time320, current time 352, horizon 32\n", - "adding: mem time321, current time 352, horizon 31\n", - "adding: mem time322, current time 352, horizon 30\n", - "adding: mem time323, current time 352, horizon 29\n", - "adding: mem time324, current time 352, horizon 28\n", - "adding: mem time325, current time 352, horizon 27\n", - "adding: mem time326, current time 352, horizon 26\n", - "adding: mem time327, current time 352, horizon 25\n", - "adding: mem time328, current time 352, horizon 24\n", - "adding: mem time329, current time 352, horizon 23\n", - "adding: mem time330, current time 352, horizon 22\n", - "adding: mem time331, current time 352, horizon 21\n", - "adding: mem time332, current time 352, horizon 20\n", - "adding: mem time333, current time 352, horizon 19\n", - "adding: mem time334, current time 352, horizon 18\n", - "adding: mem time335, current time 352, horizon 17\n", - "adding: mem time336, current time 352, horizon 16\n", - "adding: mem time337, current time 352, horizon 15\n", - "adding: mem time338, current time 352, horizon 14\n", - "adding: mem time339, current time 352, horizon 13\n", - "adding: mem time340, current time 352, horizon 12\n", - "adding: mem time341, current time 352, horizon 11\n", - "adding: mem time342, current time 352, horizon 10\n", - "adding: mem time343, current time 352, horizon 9\n", - "adding: mem time344, current time 352, horizon 8\n", - "adding: mem time345, current time 352, horizon 7\n", - "adding: mem time346, current time 352, horizon 6\n", - "adding: mem time347, current time 352, horizon 5\n", - "adding: mem time348, current time 352, horizon 4\n", - "adding: mem time349, current time 352, horizon 3\n", - "adding: mem time350, current time 352, horizon 2\n", - "adding: mem time351, current time 352, horizon 1\n", - "adding: mem time200, current time 353, horizon 153\n", - "adding: mem time201, current time 353, horizon 152\n", - "adding: mem time202, current time 353, horizon 151\n", - "adding: mem time203, current time 353, horizon 150\n", - "adding: mem time204, current time 353, horizon 149\n", - "adding: mem time205, current time 353, horizon 148\n", - "adding: mem time206, current time 353, horizon 147\n", - "adding: mem time207, current time 353, horizon 146\n", - "adding: mem time208, current time 353, horizon 145\n", - "adding: mem time209, current time 353, horizon 144\n", - "adding: mem time210, current time 353, horizon 143\n", - "adding: mem time211, current time 353, horizon 142\n", - "adding: mem time212, current time 353, horizon 141\n", - "adding: mem time213, current time 353, horizon 140\n", - "adding: mem time214, current time 353, horizon 139\n", - "adding: mem time215, current time 353, horizon 138\n", - "adding: mem time216, current time 353, horizon 137\n", - "adding: mem time217, current time 353, horizon 136\n", - "adding: mem time218, current time 353, horizon 135\n", - "adding: mem time219, current time 353, horizon 134\n", - "adding: mem time220, current time 353, horizon 133\n", - "adding: mem time221, current time 353, horizon 132\n", - "adding: mem time222, current time 353, horizon 131\n", - "adding: mem time223, current time 353, horizon 130\n", - "adding: mem time224, current time 353, horizon 129\n", - "adding: mem time225, current time 353, horizon 128\n", - "adding: mem time226, current time 353, horizon 127\n", - "adding: mem time227, current time 353, horizon 126\n", - "adding: mem time228, current time 353, horizon 125\n", - "adding: mem time229, current time 353, horizon 124\n", - "adding: mem time230, current time 353, horizon 123\n", - "adding: mem time231, current time 353, horizon 122\n", - "adding: mem time232, current time 353, horizon 121\n", - "adding: mem time233, current time 353, horizon 120\n", - "adding: mem time234, current time 353, horizon 119\n", - "adding: mem time235, current time 353, horizon 118\n", - "adding: mem time236, current time 353, horizon 117\n", - "adding: mem time237, current time 353, horizon 116\n", - "adding: mem time238, current time 353, horizon 115\n", - "adding: mem time239, current time 353, horizon 114\n", - "adding: mem time240, current time 353, horizon 113\n", - "adding: mem time241, current time 353, horizon 112\n", - "adding: mem time242, current time 353, horizon 111\n", - "adding: mem time243, current time 353, horizon 110\n", - "adding: mem time244, current time 353, horizon 109\n", - "adding: mem time245, current time 353, horizon 108\n", - "adding: mem time246, current time 353, horizon 107\n", - "adding: mem time247, current time 353, horizon 106\n", - "adding: mem time248, current time 353, horizon 105\n", - "adding: mem time249, current time 353, horizon 104\n", - "adding: mem time250, current time 353, horizon 103\n", - "adding: mem time251, current time 353, horizon 102\n", - "adding: mem time252, current time 353, horizon 101\n", - "adding: mem time253, current time 353, horizon 100\n", - "adding: mem time254, current time 353, horizon 99\n", - "adding: mem time255, current time 353, horizon 98\n", - "adding: mem time256, current time 353, horizon 97\n", - "adding: mem time257, current time 353, horizon 96\n", - "adding: mem time258, current time 353, horizon 95\n", - "adding: mem time259, current time 353, horizon 94\n", - "adding: mem time260, current time 353, horizon 93\n", - "adding: mem time261, current time 353, horizon 92\n", - "adding: mem time262, current time 353, horizon 91\n", - "adding: mem time263, current time 353, horizon 90\n", - "adding: mem time264, current time 353, horizon 89\n", - "adding: mem time265, current time 353, horizon 88\n", - "adding: mem time266, current time 353, horizon 87\n", - "adding: mem time267, current time 353, horizon 86\n", - "adding: mem time268, current time 353, horizon 85\n", - "adding: mem time269, current time 353, horizon 84\n", - "adding: mem time270, current time 353, horizon 83\n", - "adding: mem time271, current time 353, horizon 82\n", - "adding: mem time272, current time 353, horizon 81\n", - "adding: mem time273, current time 353, horizon 80\n", - "adding: mem time274, current time 353, horizon 79\n", - "adding: mem time275, current time 353, horizon 78\n", - "adding: mem time276, current time 353, horizon 77\n", - "adding: mem time277, current time 353, horizon 76\n", - "adding: mem time278, current time 353, horizon 75\n", - "adding: mem time279, current time 353, horizon 74\n", - "adding: mem time280, current time 353, horizon 73\n", - "adding: mem time281, current time 353, horizon 72\n", - "adding: mem time282, current time 353, horizon 71\n", - "adding: mem time283, current time 353, horizon 70\n", - "adding: mem time284, current time 353, horizon 69\n", - "adding: mem time285, current time 353, horizon 68\n", - "adding: mem time286, current time 353, horizon 67\n", - "adding: mem time287, current time 353, horizon 66\n", - "adding: mem time288, current time 353, horizon 65\n", - "adding: mem time289, current time 353, horizon 64\n", - "adding: mem time290, current time 353, horizon 63\n", - "adding: mem time291, current time 353, horizon 62\n", - "adding: mem time292, current time 353, horizon 61\n", - "adding: mem time293, current time 353, horizon 60\n", - "adding: mem time294, current time 353, horizon 59\n", - "adding: mem time295, current time 353, horizon 58\n", - "adding: mem time296, current time 353, horizon 57\n", - "adding: mem time297, current time 353, horizon 56\n", - "adding: mem time298, current time 353, horizon 55\n", - "adding: mem time299, current time 353, horizon 54\n", - "adding: mem time300, current time 353, horizon 53\n", - "adding: mem time301, current time 353, horizon 52\n", - "adding: mem time302, current time 353, horizon 51\n", - "adding: mem time303, current time 353, horizon 50\n", - "adding: mem time304, current time 353, horizon 49\n", - "adding: mem time305, current time 353, horizon 48\n", - "adding: mem time306, current time 353, horizon 47\n", - "adding: mem time307, current time 353, horizon 46\n", - "adding: mem time308, current time 353, horizon 45\n", - "adding: mem time309, current time 353, horizon 44\n", - "adding: mem time310, current time 353, horizon 43\n", - "adding: mem time311, current time 353, horizon 42\n", - "adding: mem time312, current time 353, horizon 41\n", - "adding: mem time313, current time 353, horizon 40\n", - "adding: mem time314, current time 353, horizon 39\n", - "adding: mem time315, current time 353, horizon 38\n", - "adding: mem time316, current time 353, horizon 37\n", - "adding: mem time317, current time 353, horizon 36\n", - "adding: mem time318, current time 353, horizon 35\n", - "adding: mem time319, current time 353, horizon 34\n", - "adding: mem time320, current time 353, horizon 33\n", - "adding: mem time321, current time 353, horizon 32\n", - "adding: mem time322, current time 353, horizon 31\n", - "adding: mem time323, current time 353, horizon 30\n", - "adding: mem time324, current time 353, horizon 29\n", - "adding: mem time325, current time 353, horizon 28\n", - "adding: mem time326, current time 353, horizon 27\n", - "adding: mem time327, current time 353, horizon 26\n", - "adding: mem time328, current time 353, horizon 25\n", - "adding: mem time329, current time 353, horizon 24\n", - "adding: mem time330, current time 353, horizon 23\n", - "adding: mem time331, current time 353, horizon 22\n", - "adding: mem time332, current time 353, horizon 21\n", - "adding: mem time333, current time 353, horizon 20\n", - "adding: mem time334, current time 353, horizon 19\n", - "adding: mem time335, current time 353, horizon 18\n", - "adding: mem time336, current time 353, horizon 17\n", - "adding: mem time337, current time 353, horizon 16\n", - "adding: mem time338, current time 353, horizon 15\n", - "adding: mem time339, current time 353, horizon 14\n", - "adding: mem time340, current time 353, horizon 13\n", - "adding: mem time341, current time 353, horizon 12\n", - "adding: mem time342, current time 353, horizon 11\n", - "adding: mem time343, current time 353, horizon 10\n", - "adding: mem time344, current time 353, horizon 9\n", - "adding: mem time345, current time 353, horizon 8\n", - "adding: mem time346, current time 353, horizon 7\n", - "adding: mem time347, current time 353, horizon 6\n", - "adding: mem time348, current time 353, horizon 5\n", - "adding: mem time349, current time 353, horizon 4\n", - "adding: mem time350, current time 353, horizon 3\n", - "adding: mem time351, current time 353, horizon 2\n", - "adding: mem time352, current time 353, horizon 1\n", - "adding: mem time200, current time 354, horizon 154\n", - "adding: mem time201, current time 354, horizon 153\n", - "adding: mem time202, current time 354, horizon 152\n", - "adding: mem time203, current time 354, horizon 151\n", - "adding: mem time204, current time 354, horizon 150\n", - "adding: mem time205, current time 354, horizon 149\n", - "adding: mem time206, current time 354, horizon 148\n", - "adding: mem time207, current time 354, horizon 147\n", - "adding: mem time208, current time 354, horizon 146\n", - "adding: mem time209, current time 354, horizon 145\n", - "adding: mem time210, current time 354, horizon 144\n", - "adding: mem time211, current time 354, horizon 143\n", - "adding: mem time212, current time 354, horizon 142\n", - "adding: mem time213, current time 354, horizon 141\n", - "adding: mem time214, current time 354, horizon 140\n", - "adding: mem time215, current time 354, horizon 139\n", - "adding: mem time216, current time 354, horizon 138\n", - "adding: mem time217, current time 354, horizon 137\n", - "adding: mem time218, current time 354, horizon 136\n", - "adding: mem time219, current time 354, horizon 135\n", - "adding: mem time220, current time 354, horizon 134\n", - "adding: mem time221, current time 354, horizon 133\n", - "adding: mem time222, current time 354, horizon 132\n", - "adding: mem time223, current time 354, horizon 131\n", - "adding: mem time224, current time 354, horizon 130\n", - "adding: mem time225, current time 354, horizon 129\n", - "adding: mem time226, current time 354, horizon 128\n", - "adding: mem time227, current time 354, horizon 127\n", - "adding: mem time228, current time 354, horizon 126\n", - "adding: mem time229, current time 354, horizon 125\n", - "adding: mem time230, current time 354, horizon 124\n", - "adding: mem time231, current time 354, horizon 123\n", - "adding: mem time232, current time 354, horizon 122\n", - "adding: mem time233, current time 354, horizon 121\n", - "adding: mem time234, current time 354, horizon 120\n", - "adding: mem time235, current time 354, horizon 119\n", - "adding: mem time236, current time 354, horizon 118\n", - "adding: mem time237, current time 354, horizon 117\n", - "adding: mem time238, current time 354, horizon 116\n", - "adding: mem time239, current time 354, horizon 115\n", - "adding: mem time240, current time 354, horizon 114\n", - "adding: mem time241, current time 354, horizon 113\n", - "adding: mem time242, current time 354, horizon 112\n", - "adding: mem time243, current time 354, horizon 111\n", - "adding: mem time244, current time 354, horizon 110\n", - "adding: mem time245, current time 354, horizon 109\n", - "adding: mem time246, current time 354, horizon 108\n", - "adding: mem time247, current time 354, horizon 107\n", - "adding: mem time248, current time 354, horizon 106\n", - "adding: mem time249, current time 354, horizon 105\n", - "adding: mem time250, current time 354, horizon 104\n", - "adding: mem time251, current time 354, horizon 103\n", - "adding: mem time252, current time 354, horizon 102\n", - "adding: mem time253, current time 354, horizon 101\n", - "adding: mem time254, current time 354, horizon 100\n", - "adding: mem time255, current time 354, horizon 99\n", - "adding: mem time256, current time 354, horizon 98\n", - "adding: mem time257, current time 354, horizon 97\n", - "adding: mem time258, current time 354, horizon 96\n", - "adding: mem time259, current time 354, horizon 95\n", - "adding: mem time260, current time 354, horizon 94\n", - "adding: mem time261, current time 354, horizon 93\n", - "adding: mem time262, current time 354, horizon 92\n", - "adding: mem time263, current time 354, horizon 91\n", - "adding: mem time264, current time 354, horizon 90\n", - "adding: mem time265, current time 354, horizon 89\n", - "adding: mem time266, current time 354, horizon 88\n", - "adding: mem time267, current time 354, horizon 87\n", - "adding: mem time268, current time 354, horizon 86\n", - "adding: mem time269, current time 354, horizon 85\n", - "adding: mem time270, current time 354, horizon 84\n", - "adding: mem time271, current time 354, horizon 83\n", - "adding: mem time272, current time 354, horizon 82\n", - "adding: mem time273, current time 354, horizon 81\n", - "adding: mem time274, current time 354, horizon 80\n", - "adding: mem time275, current time 354, horizon 79\n", - "adding: mem time276, current time 354, horizon 78\n", - "adding: mem time277, current time 354, horizon 77\n", - "adding: mem time278, current time 354, horizon 76\n", - "adding: mem time279, current time 354, horizon 75\n", - "adding: mem time280, current time 354, horizon 74\n", - "adding: mem time281, current time 354, horizon 73\n", - "adding: mem time282, current time 354, horizon 72\n", - "adding: mem time283, current time 354, horizon 71\n", - "adding: mem time284, current time 354, horizon 70\n", - "adding: mem time285, current time 354, horizon 69\n", - "adding: mem time286, current time 354, horizon 68\n", - "adding: mem time287, current time 354, horizon 67\n", - "adding: mem time288, current time 354, horizon 66\n", - "adding: mem time289, current time 354, horizon 65\n", - "adding: mem time290, current time 354, horizon 64\n", - "adding: mem time291, current time 354, horizon 63\n", - "adding: mem time292, current time 354, horizon 62\n", - "adding: mem time293, current time 354, horizon 61\n", - "adding: mem time294, current time 354, horizon 60\n", - "adding: mem time295, current time 354, horizon 59\n", - "adding: mem time296, current time 354, horizon 58\n", - "adding: mem time297, current time 354, horizon 57\n", - "adding: mem time298, current time 354, horizon 56\n", - "adding: mem time299, current time 354, horizon 55\n", - "adding: mem time300, current time 354, horizon 54\n", - "adding: mem time301, current time 354, horizon 53\n", - "adding: mem time302, current time 354, horizon 52\n", - "adding: mem time303, current time 354, horizon 51\n", - "adding: mem time304, current time 354, horizon 50\n", - "adding: mem time305, current time 354, horizon 49\n", - "adding: mem time306, current time 354, horizon 48\n", - "adding: mem time307, current time 354, horizon 47\n", - "adding: mem time308, current time 354, horizon 46\n", - "adding: mem time309, current time 354, horizon 45\n", - "adding: mem time310, current time 354, horizon 44\n", - "adding: mem time311, current time 354, horizon 43\n", - "adding: mem time312, current time 354, horizon 42\n", - "adding: mem time313, current time 354, horizon 41\n", - "adding: mem time314, current time 354, horizon 40\n", - "adding: mem time315, current time 354, horizon 39\n", - "adding: mem time316, current time 354, horizon 38\n", - "adding: mem time317, current time 354, horizon 37\n", - "adding: mem time318, current time 354, horizon 36\n", - "adding: mem time319, current time 354, horizon 35\n", - "adding: mem time320, current time 354, horizon 34\n", - "adding: mem time321, current time 354, horizon 33\n", - "adding: mem time322, current time 354, horizon 32\n", - "adding: mem time323, current time 354, horizon 31\n", - "adding: mem time324, current time 354, horizon 30\n", - "adding: mem time325, current time 354, horizon 29\n", - "adding: mem time326, current time 354, horizon 28\n", - "adding: mem time327, current time 354, horizon 27\n", - "adding: mem time328, current time 354, horizon 26\n", - "adding: mem time329, current time 354, horizon 25\n", - "adding: mem time330, current time 354, horizon 24\n", - "adding: mem time331, current time 354, horizon 23\n", - "adding: mem time332, current time 354, horizon 22\n", - "adding: mem time333, current time 354, horizon 21\n", - "adding: mem time334, current time 354, horizon 20\n", - "adding: mem time335, current time 354, horizon 19\n", - "adding: mem time336, current time 354, horizon 18\n", - "adding: mem time337, current time 354, horizon 17\n", - "adding: mem time338, current time 354, horizon 16\n", - "adding: mem time339, current time 354, horizon 15\n", - "adding: mem time340, current time 354, horizon 14\n", - "adding: mem time341, current time 354, horizon 13\n", - "adding: mem time342, current time 354, horizon 12\n", - "adding: mem time343, current time 354, horizon 11\n", - "adding: mem time344, current time 354, horizon 10\n", - "adding: mem time345, current time 354, horizon 9\n", - "adding: mem time346, current time 354, horizon 8\n", - "adding: mem time347, current time 354, horizon 7\n", - "adding: mem time348, current time 354, horizon 6\n", - "adding: mem time349, current time 354, horizon 5\n", - "adding: mem time350, current time 354, horizon 4\n", - "adding: mem time351, current time 354, horizon 3\n", - "adding: mem time352, current time 354, horizon 2\n", - "adding: mem time353, current time 354, horizon 1\n", - "adding: mem time200, current time 355, horizon 155\n", - "adding: mem time201, current time 355, horizon 154\n", - "adding: mem time202, current time 355, horizon 153\n", - "adding: mem time203, current time 355, horizon 152\n", - "adding: mem time204, current time 355, horizon 151\n", - "adding: mem time205, current time 355, horizon 150\n", - "adding: mem time206, current time 355, horizon 149\n", - "adding: mem time207, current time 355, horizon 148\n", - "adding: mem time208, current time 355, horizon 147\n", - "adding: mem time209, current time 355, horizon 146\n", - "adding: mem time210, current time 355, horizon 145\n", - "adding: mem time211, current time 355, horizon 144\n", - "adding: mem time212, current time 355, horizon 143\n", - "adding: mem time213, current time 355, horizon 142\n", - "adding: mem time214, current time 355, horizon 141\n", - "adding: mem time215, current time 355, horizon 140\n", - "adding: mem time216, current time 355, horizon 139\n", - "adding: mem time217, current time 355, horizon 138\n", - "adding: mem time218, current time 355, horizon 137\n", - "adding: mem time219, current time 355, horizon 136\n", - "adding: mem time220, current time 355, horizon 135\n", - "adding: mem time221, current time 355, horizon 134\n", - "adding: mem time222, current time 355, horizon 133\n", - "adding: mem time223, current time 355, horizon 132\n", - "adding: mem time224, current time 355, horizon 131\n", - "adding: mem time225, current time 355, horizon 130\n", - "adding: mem time226, current time 355, horizon 129\n", - "adding: mem time227, current time 355, horizon 128\n", - "adding: mem time228, current time 355, horizon 127\n", - "adding: mem time229, current time 355, horizon 126\n", - "adding: mem time230, current time 355, horizon 125\n", - "adding: mem time231, current time 355, horizon 124\n", - "adding: mem time232, current time 355, horizon 123\n", - "adding: mem time233, current time 355, horizon 122\n", - "adding: mem time234, current time 355, horizon 121\n", - "adding: mem time235, current time 355, horizon 120\n", - "adding: mem time236, current time 355, horizon 119\n", - "adding: mem time237, current time 355, horizon 118\n", - "adding: mem time238, current time 355, horizon 117\n", - "adding: mem time239, current time 355, horizon 116\n", - "adding: mem time240, current time 355, horizon 115\n", - "adding: mem time241, current time 355, horizon 114\n", - "adding: mem time242, current time 355, horizon 113\n", - "adding: mem time243, current time 355, horizon 112\n", - "adding: mem time244, current time 355, horizon 111\n", - "adding: mem time245, current time 355, horizon 110\n", - "adding: mem time246, current time 355, horizon 109\n", - "adding: mem time247, current time 355, horizon 108\n", - "adding: mem time248, current time 355, horizon 107\n", - "adding: mem time249, current time 355, horizon 106\n", - "adding: mem time250, current time 355, horizon 105\n", - "adding: mem time251, current time 355, horizon 104\n", - "adding: mem time252, current time 355, horizon 103\n", - "adding: mem time253, current time 355, horizon 102\n", - "adding: mem time254, current time 355, horizon 101\n", - "adding: mem time255, current time 355, horizon 100\n", - "adding: mem time256, current time 355, horizon 99\n", - "adding: mem time257, current time 355, horizon 98\n", - "adding: mem time258, current time 355, horizon 97\n", - "adding: mem time259, current time 355, horizon 96\n", - "adding: mem time260, current time 355, horizon 95\n", - "adding: mem time261, current time 355, horizon 94\n", - "adding: mem time262, current time 355, horizon 93\n", - "adding: mem time263, current time 355, horizon 92\n", - "adding: mem time264, current time 355, horizon 91\n", - "adding: mem time265, current time 355, horizon 90\n", - "adding: mem time266, current time 355, horizon 89\n", - "adding: mem time267, current time 355, horizon 88\n", - "adding: mem time268, current time 355, horizon 87\n", - "adding: mem time269, current time 355, horizon 86\n", - "adding: mem time270, current time 355, horizon 85\n", - "adding: mem time271, current time 355, horizon 84\n", - "adding: mem time272, current time 355, horizon 83\n", - "adding: mem time273, current time 355, horizon 82\n", - "adding: mem time274, current time 355, horizon 81\n", - "adding: mem time275, current time 355, horizon 80\n", - "adding: mem time276, current time 355, horizon 79\n", - "adding: mem time277, current time 355, horizon 78\n", - "adding: mem time278, current time 355, horizon 77\n", - "adding: mem time279, current time 355, horizon 76\n", - "adding: mem time280, current time 355, horizon 75\n", - "adding: mem time281, current time 355, horizon 74\n", - "adding: mem time282, current time 355, horizon 73\n", - "adding: mem time283, current time 355, horizon 72\n", - "adding: mem time284, current time 355, horizon 71\n", - "adding: mem time285, current time 355, horizon 70\n", - "adding: mem time286, current time 355, horizon 69\n", - "adding: mem time287, current time 355, horizon 68\n", - "adding: mem time288, current time 355, horizon 67\n", - "adding: mem time289, current time 355, horizon 66\n", - "adding: mem time290, current time 355, horizon 65\n", - "adding: mem time291, current time 355, horizon 64\n", - "adding: mem time292, current time 355, horizon 63\n", - "adding: mem time293, current time 355, horizon 62\n", - "adding: mem time294, current time 355, horizon 61\n", - "adding: mem time295, current time 355, horizon 60\n", - "adding: mem time296, current time 355, horizon 59\n", - "adding: mem time297, current time 355, horizon 58\n", - "adding: mem time298, current time 355, horizon 57\n", - "adding: mem time299, current time 355, horizon 56\n", - "adding: mem time300, current time 355, horizon 55\n", - "adding: mem time301, current time 355, horizon 54\n", - "adding: mem time302, current time 355, horizon 53\n", - "adding: mem time303, current time 355, horizon 52\n", - "adding: mem time304, current time 355, horizon 51\n", - "adding: mem time305, current time 355, horizon 50\n", - "adding: mem time306, current time 355, horizon 49\n", - "adding: mem time307, current time 355, horizon 48\n", - "adding: mem time308, current time 355, horizon 47\n", - "adding: mem time309, current time 355, horizon 46\n", - "adding: mem time310, current time 355, horizon 45\n", - "adding: mem time311, current time 355, horizon 44\n", - "adding: mem time312, current time 355, horizon 43\n", - "adding: mem time313, current time 355, horizon 42\n", - "adding: mem time314, current time 355, horizon 41\n", - "adding: mem time315, current time 355, horizon 40\n", - "adding: mem time316, current time 355, horizon 39\n", - "adding: mem time317, current time 355, horizon 38\n", - "adding: mem time318, current time 355, horizon 37\n", - "adding: mem time319, current time 355, horizon 36\n", - "adding: mem time320, current time 355, horizon 35\n", - "adding: mem time321, current time 355, horizon 34\n", - "adding: mem time322, current time 355, horizon 33\n", - "adding: mem time323, current time 355, horizon 32\n", - "adding: mem time324, current time 355, horizon 31\n", - "adding: mem time325, current time 355, horizon 30\n", - "adding: mem time326, current time 355, horizon 29\n", - "adding: mem time327, current time 355, horizon 28\n", - "adding: mem time328, current time 355, horizon 27\n", - "adding: mem time329, current time 355, horizon 26\n", - "adding: mem time330, current time 355, horizon 25\n", - "adding: mem time331, current time 355, horizon 24\n", - "adding: mem time332, current time 355, horizon 23\n", - "adding: mem time333, current time 355, horizon 22\n", - "adding: mem time334, current time 355, horizon 21\n", - "adding: mem time335, current time 355, horizon 20\n", - "adding: mem time336, current time 355, horizon 19\n", - "adding: mem time337, current time 355, horizon 18\n", - "adding: mem time338, current time 355, horizon 17\n", - "adding: mem time339, current time 355, horizon 16\n", - "adding: mem time340, current time 355, horizon 15\n", - "adding: mem time341, current time 355, horizon 14\n", - "adding: mem time342, current time 355, horizon 13\n", - "adding: mem time343, current time 355, horizon 12\n", - "adding: mem time344, current time 355, horizon 11\n", - "adding: mem time345, current time 355, horizon 10\n", - "adding: mem time346, current time 355, horizon 9\n", - "adding: mem time347, current time 355, horizon 8\n", - "adding: mem time348, current time 355, horizon 7\n", - "adding: mem time349, current time 355, horizon 6\n", - "adding: mem time350, current time 355, horizon 5\n", - "adding: mem time351, current time 355, horizon 4\n", - "adding: mem time352, current time 355, horizon 3\n", - "adding: mem time353, current time 355, horizon 2\n", - "adding: mem time354, current time 355, horizon 1\n", - "adding: mem time200, current time 356, horizon 156\n", - "adding: mem time201, current time 356, horizon 155\n", - "adding: mem time202, current time 356, horizon 154\n", - "adding: mem time203, current time 356, horizon 153\n", - "adding: mem time204, current time 356, horizon 152\n", - "adding: mem time205, current time 356, horizon 151\n", - "adding: mem time206, current time 356, horizon 150\n", - "adding: mem time207, current time 356, horizon 149\n", - "adding: mem time208, current time 356, horizon 148\n", - "adding: mem time209, current time 356, horizon 147\n", - "adding: mem time210, current time 356, horizon 146\n", - "adding: mem time211, current time 356, horizon 145\n", - "adding: mem time212, current time 356, horizon 144\n", - "adding: mem time213, current time 356, horizon 143\n", - "adding: mem time214, current time 356, horizon 142\n", - "adding: mem time215, current time 356, horizon 141\n", - "adding: mem time216, current time 356, horizon 140\n", - "adding: mem time217, current time 356, horizon 139\n", - "adding: mem time218, current time 356, horizon 138\n", - "adding: mem time219, current time 356, horizon 137\n", - "adding: mem time220, current time 356, horizon 136\n", - "adding: mem time221, current time 356, horizon 135\n", - "adding: mem time222, current time 356, horizon 134\n", - "adding: mem time223, current time 356, horizon 133\n", - "adding: mem time224, current time 356, horizon 132\n", - "adding: mem time225, current time 356, horizon 131\n", - "adding: mem time226, current time 356, horizon 130\n", - "adding: mem time227, current time 356, horizon 129\n", - "adding: mem time228, current time 356, horizon 128\n", - "adding: mem time229, current time 356, horizon 127\n", - "adding: mem time230, current time 356, horizon 126\n", - "adding: mem time231, current time 356, horizon 125\n", - "adding: mem time232, current time 356, horizon 124\n", - "adding: mem time233, current time 356, horizon 123\n", - "adding: mem time234, current time 356, horizon 122\n", - "adding: mem time235, current time 356, horizon 121\n", - "adding: mem time236, current time 356, horizon 120\n", - "adding: mem time237, current time 356, horizon 119\n", - "adding: mem time238, current time 356, horizon 118\n", - "adding: mem time239, current time 356, horizon 117\n", - "adding: mem time240, current time 356, horizon 116\n", - "adding: mem time241, current time 356, horizon 115\n", - "adding: mem time242, current time 356, horizon 114\n", - "adding: mem time243, current time 356, horizon 113\n", - "adding: mem time244, current time 356, horizon 112\n", - "adding: mem time245, current time 356, horizon 111\n", - "adding: mem time246, current time 356, horizon 110\n", - "adding: mem time247, current time 356, horizon 109\n", - "adding: mem time248, current time 356, horizon 108\n", - "adding: mem time249, current time 356, horizon 107\n", - "adding: mem time250, current time 356, horizon 106\n", - "adding: mem time251, current time 356, horizon 105\n", - "adding: mem time252, current time 356, horizon 104\n", - "adding: mem time253, current time 356, horizon 103\n", - "adding: mem time254, current time 356, horizon 102\n", - "adding: mem time255, current time 356, horizon 101\n", - "adding: mem time256, current time 356, horizon 100\n", - "adding: mem time257, current time 356, horizon 99\n", - "adding: mem time258, current time 356, horizon 98\n", - "adding: mem time259, current time 356, horizon 97\n", - "adding: mem time260, current time 356, horizon 96\n", - "adding: mem time261, current time 356, horizon 95\n", - "adding: mem time262, current time 356, horizon 94\n", - "adding: mem time263, current time 356, horizon 93\n", - "adding: mem time264, current time 356, horizon 92\n", - "adding: mem time265, current time 356, horizon 91\n", - "adding: mem time266, current time 356, horizon 90\n", - "adding: mem time267, current time 356, horizon 89\n", - "adding: mem time268, current time 356, horizon 88\n", - "adding: mem time269, current time 356, horizon 87\n", - "adding: mem time270, current time 356, horizon 86\n", - "adding: mem time271, current time 356, horizon 85\n", - "adding: mem time272, current time 356, horizon 84\n", - "adding: mem time273, current time 356, horizon 83\n", - "adding: mem time274, current time 356, horizon 82\n", - "adding: mem time275, current time 356, horizon 81\n", - "adding: mem time276, current time 356, horizon 80\n", - "adding: mem time277, current time 356, horizon 79\n", - "adding: mem time278, current time 356, horizon 78\n", - "adding: mem time279, current time 356, horizon 77\n", - "adding: mem time280, current time 356, horizon 76\n", - "adding: mem time281, current time 356, horizon 75\n", - "adding: mem time282, current time 356, horizon 74\n", - "adding: mem time283, current time 356, horizon 73\n", - "adding: mem time284, current time 356, horizon 72\n", - "adding: mem time285, current time 356, horizon 71\n", - "adding: mem time286, current time 356, horizon 70\n", - "adding: mem time287, current time 356, horizon 69\n", - "adding: mem time288, current time 356, horizon 68\n", - "adding: mem time289, current time 356, horizon 67\n", - "adding: mem time290, current time 356, horizon 66\n", - "adding: mem time291, current time 356, horizon 65\n", - "adding: mem time292, current time 356, horizon 64\n", - "adding: mem time293, current time 356, horizon 63\n", - "adding: mem time294, current time 356, horizon 62\n", - "adding: mem time295, current time 356, horizon 61\n", - "adding: mem time296, current time 356, horizon 60\n", - "adding: mem time297, current time 356, horizon 59\n", - "adding: mem time298, current time 356, horizon 58\n", - "adding: mem time299, current time 356, horizon 57\n", - "adding: mem time300, current time 356, horizon 56\n", - "adding: mem time301, current time 356, horizon 55\n", - "adding: mem time302, current time 356, horizon 54\n", - "adding: mem time303, current time 356, horizon 53\n", - "adding: mem time304, current time 356, horizon 52\n", - "adding: mem time305, current time 356, horizon 51\n", - "adding: mem time306, current time 356, horizon 50\n", - "adding: mem time307, current time 356, horizon 49\n", - "adding: mem time308, current time 356, horizon 48\n", - "adding: mem time309, current time 356, horizon 47\n", - "adding: mem time310, current time 356, horizon 46\n", - "adding: mem time311, current time 356, horizon 45\n", - "adding: mem time312, current time 356, horizon 44\n", - "adding: mem time313, current time 356, horizon 43\n", - "adding: mem time314, current time 356, horizon 42\n", - "adding: mem time315, current time 356, horizon 41\n", - "adding: mem time316, current time 356, horizon 40\n", - "adding: mem time317, current time 356, horizon 39\n", - "adding: mem time318, current time 356, horizon 38\n", - "adding: mem time319, current time 356, horizon 37\n", - "adding: mem time320, current time 356, horizon 36\n", - "adding: mem time321, current time 356, horizon 35\n", - "adding: mem time322, current time 356, horizon 34\n", - "adding: mem time323, current time 356, horizon 33\n", - "adding: mem time324, current time 356, horizon 32\n", - "adding: mem time325, current time 356, horizon 31\n", - "adding: mem time326, current time 356, horizon 30\n", - "adding: mem time327, current time 356, horizon 29\n", - "adding: mem time328, current time 356, horizon 28\n", - "adding: mem time329, current time 356, horizon 27\n", - "adding: mem time330, current time 356, horizon 26\n", - "adding: mem time331, current time 356, horizon 25\n", - "adding: mem time332, current time 356, horizon 24\n", - "adding: mem time333, current time 356, horizon 23\n", - "adding: mem time334, current time 356, horizon 22\n", - "adding: mem time335, current time 356, horizon 21\n", - "adding: mem time336, current time 356, horizon 20\n", - "adding: mem time337, current time 356, horizon 19\n", - "adding: mem time338, current time 356, horizon 18\n", - "adding: mem time339, current time 356, horizon 17\n", - "adding: mem time340, current time 356, horizon 16\n", - "adding: mem time341, current time 356, horizon 15\n", - "adding: mem time342, current time 356, horizon 14\n", - "adding: mem time343, current time 356, horizon 13\n", - "adding: mem time344, current time 356, horizon 12\n", - "adding: mem time345, current time 356, horizon 11\n", - "adding: mem time346, current time 356, horizon 10\n", - "adding: mem time347, current time 356, horizon 9\n", - "adding: mem time348, current time 356, horizon 8\n", - "adding: mem time349, current time 356, horizon 7\n", - "adding: mem time350, current time 356, horizon 6\n", - "adding: mem time351, current time 356, horizon 5\n", - "adding: mem time352, current time 356, horizon 4\n", - "adding: mem time353, current time 356, horizon 3\n", - "adding: mem time354, current time 356, horizon 2\n", - "adding: mem time355, current time 356, horizon 1\n", - "adding: mem time200, current time 357, horizon 157\n", - "adding: mem time201, current time 357, horizon 156\n", - "adding: mem time202, current time 357, horizon 155\n", - "adding: mem time203, current time 357, horizon 154\n", - "adding: mem time204, current time 357, horizon 153\n", - "adding: mem time205, current time 357, horizon 152\n", - "adding: mem time206, current time 357, horizon 151\n", - "adding: mem time207, current time 357, horizon 150\n", - "adding: mem time208, current time 357, horizon 149\n", - "adding: mem time209, current time 357, horizon 148\n", - "adding: mem time210, current time 357, horizon 147\n", - "adding: mem time211, current time 357, horizon 146\n", - "adding: mem time212, current time 357, horizon 145\n", - "adding: mem time213, current time 357, horizon 144\n", - "adding: mem time214, current time 357, horizon 143\n", - "adding: mem time215, current time 357, horizon 142\n", - "adding: mem time216, current time 357, horizon 141\n", - "adding: mem time217, current time 357, horizon 140\n", - "adding: mem time218, current time 357, horizon 139\n", - "adding: mem time219, current time 357, horizon 138\n", - "adding: mem time220, current time 357, horizon 137\n", - "adding: mem time221, current time 357, horizon 136\n", - "adding: mem time222, current time 357, horizon 135\n", - "adding: mem time223, current time 357, horizon 134\n", - "adding: mem time224, current time 357, horizon 133\n", - "adding: mem time225, current time 357, horizon 132\n", - "adding: mem time226, current time 357, horizon 131\n", - "adding: mem time227, current time 357, horizon 130\n", - "adding: mem time228, current time 357, horizon 129\n", - "adding: mem time229, current time 357, horizon 128\n", - "adding: mem time230, current time 357, horizon 127\n", - "adding: mem time231, current time 357, horizon 126\n", - "adding: mem time232, current time 357, horizon 125\n", - "adding: mem time233, current time 357, horizon 124\n", - "adding: mem time234, current time 357, horizon 123\n", - "adding: mem time235, current time 357, horizon 122\n", - "adding: mem time236, current time 357, horizon 121\n", - "adding: mem time237, current time 357, horizon 120\n", - "adding: mem time238, current time 357, horizon 119\n", - "adding: mem time239, current time 357, horizon 118\n", - "adding: mem time240, current time 357, horizon 117\n", - "adding: mem time241, current time 357, horizon 116\n", - "adding: mem time242, current time 357, horizon 115\n", - "adding: mem time243, current time 357, horizon 114\n", - "adding: mem time244, current time 357, horizon 113\n", - "adding: mem time245, current time 357, horizon 112\n", - "adding: mem time246, current time 357, horizon 111\n", - "adding: mem time247, current time 357, horizon 110\n", - "adding: mem time248, current time 357, horizon 109\n", - "adding: mem time249, current time 357, horizon 108\n", - "adding: mem time250, current time 357, horizon 107\n", - "adding: mem time251, current time 357, horizon 106\n", - "adding: mem time252, current time 357, horizon 105\n", - "adding: mem time253, current time 357, horizon 104\n", - "adding: mem time254, current time 357, horizon 103\n", - "adding: mem time255, current time 357, horizon 102\n", - "adding: mem time256, current time 357, horizon 101\n", - "adding: mem time257, current time 357, horizon 100\n", - "adding: mem time258, current time 357, horizon 99\n", - "adding: mem time259, current time 357, horizon 98\n", - "adding: mem time260, current time 357, horizon 97\n", - "adding: mem time261, current time 357, horizon 96\n", - "adding: mem time262, current time 357, horizon 95\n", - "adding: mem time263, current time 357, horizon 94\n", - "adding: mem time264, current time 357, horizon 93\n", - "adding: mem time265, current time 357, horizon 92\n", - "adding: mem time266, current time 357, horizon 91\n", - "adding: mem time267, current time 357, horizon 90\n", - "adding: mem time268, current time 357, horizon 89\n", - "adding: mem time269, current time 357, horizon 88\n", - "adding: mem time270, current time 357, horizon 87\n", - "adding: mem time271, current time 357, horizon 86\n", - "adding: mem time272, current time 357, horizon 85\n", - "adding: mem time273, current time 357, horizon 84\n", - "adding: mem time274, current time 357, horizon 83\n", - "adding: mem time275, current time 357, horizon 82\n", - "adding: mem time276, current time 357, horizon 81\n", - "adding: mem time277, current time 357, horizon 80\n", - "adding: mem time278, current time 357, horizon 79\n", - "adding: mem time279, current time 357, horizon 78\n", - "adding: mem time280, current time 357, horizon 77\n", - "adding: mem time281, current time 357, horizon 76\n", - "adding: mem time282, current time 357, horizon 75\n", - "adding: mem time283, current time 357, horizon 74\n", - "adding: mem time284, current time 357, horizon 73\n", - "adding: mem time285, current time 357, horizon 72\n", - "adding: mem time286, current time 357, horizon 71\n", - "adding: mem time287, current time 357, horizon 70\n", - "adding: mem time288, current time 357, horizon 69\n", - "adding: mem time289, current time 357, horizon 68\n", - "adding: mem time290, current time 357, horizon 67\n", - "adding: mem time291, current time 357, horizon 66\n", - "adding: mem time292, current time 357, horizon 65\n", - "adding: mem time293, current time 357, horizon 64\n", - "adding: mem time294, current time 357, horizon 63\n", - "adding: mem time295, current time 357, horizon 62\n", - "adding: mem time296, current time 357, horizon 61\n", - "adding: mem time297, current time 357, horizon 60\n", - "adding: mem time298, current time 357, horizon 59\n", - "adding: mem time299, current time 357, horizon 58\n", - "adding: mem time300, current time 357, horizon 57\n", - "adding: mem time301, current time 357, horizon 56\n", - "adding: mem time302, current time 357, horizon 55\n", - "adding: mem time303, current time 357, horizon 54\n", - "adding: mem time304, current time 357, horizon 53\n", - "adding: mem time305, current time 357, horizon 52\n", - "adding: mem time306, current time 357, horizon 51\n", - "adding: mem time307, current time 357, horizon 50\n", - "adding: mem time308, current time 357, horizon 49\n", - "adding: mem time309, current time 357, horizon 48\n", - "adding: mem time310, current time 357, horizon 47\n", - "adding: mem time311, current time 357, horizon 46\n", - "adding: mem time312, current time 357, horizon 45\n", - "adding: mem time313, current time 357, horizon 44\n", - "adding: mem time314, current time 357, horizon 43\n", - "adding: mem time315, current time 357, horizon 42\n", - "adding: mem time316, current time 357, horizon 41\n", - "adding: mem time317, current time 357, horizon 40\n", - "adding: mem time318, current time 357, horizon 39\n", - "adding: mem time319, current time 357, horizon 38\n", - "adding: mem time320, current time 357, horizon 37\n", - "adding: mem time321, current time 357, horizon 36\n", - "adding: mem time322, current time 357, horizon 35\n", - "adding: mem time323, current time 357, horizon 34\n", - "adding: mem time324, current time 357, horizon 33\n", - "adding: mem time325, current time 357, horizon 32\n", - "adding: mem time326, current time 357, horizon 31\n", - "adding: mem time327, current time 357, horizon 30\n", - "adding: mem time328, current time 357, horizon 29\n", - "adding: mem time329, current time 357, horizon 28\n", - "adding: mem time330, current time 357, horizon 27\n", - "adding: mem time331, current time 357, horizon 26\n", - "adding: mem time332, current time 357, horizon 25\n", - "adding: mem time333, current time 357, horizon 24\n", - "adding: mem time334, current time 357, horizon 23\n", - "adding: mem time335, current time 357, horizon 22\n", - "adding: mem time336, current time 357, horizon 21\n", - "adding: mem time337, current time 357, horizon 20\n", - "adding: mem time338, current time 357, horizon 19\n", - "adding: mem time339, current time 357, horizon 18\n", - "adding: mem time340, current time 357, horizon 17\n", - "adding: mem time341, current time 357, horizon 16\n", - "adding: mem time342, current time 357, horizon 15\n", - "adding: mem time343, current time 357, horizon 14\n", - "adding: mem time344, current time 357, horizon 13\n", - "adding: mem time345, current time 357, horizon 12\n", - "adding: mem time346, current time 357, horizon 11\n", - "adding: mem time347, current time 357, horizon 10\n", - "adding: mem time348, current time 357, horizon 9\n", - "adding: mem time349, current time 357, horizon 8\n", - "adding: mem time350, current time 357, horizon 7\n", - "adding: mem time351, current time 357, horizon 6\n", - "adding: mem time352, current time 357, horizon 5\n", - "adding: mem time353, current time 357, horizon 4\n", - "adding: mem time354, current time 357, horizon 3\n", - "adding: mem time355, current time 357, horizon 2\n", - "adding: mem time356, current time 357, horizon 1\n", - "adding: mem time200, current time 358, horizon 158\n", - "adding: mem time201, current time 358, horizon 157\n", - "adding: mem time202, current time 358, horizon 156\n", - "adding: mem time203, current time 358, horizon 155\n", - "adding: mem time204, current time 358, horizon 154\n", - "adding: mem time205, current time 358, horizon 153\n", - "adding: mem time206, current time 358, horizon 152\n", - "adding: mem time207, current time 358, horizon 151\n", - "adding: mem time208, current time 358, horizon 150\n", - "adding: mem time209, current time 358, horizon 149\n", - "adding: mem time210, current time 358, horizon 148\n", - "adding: mem time211, current time 358, horizon 147\n", - "adding: mem time212, current time 358, horizon 146\n", - "adding: mem time213, current time 358, horizon 145\n", - "adding: mem time214, current time 358, horizon 144\n", - "adding: mem time215, current time 358, horizon 143\n", - "adding: mem time216, current time 358, horizon 142\n", - "adding: mem time217, current time 358, horizon 141\n", - "adding: mem time218, current time 358, horizon 140\n", - "adding: mem time219, current time 358, horizon 139\n", - "adding: mem time220, current time 358, horizon 138\n", - "adding: mem time221, current time 358, horizon 137\n", - "adding: mem time222, current time 358, horizon 136\n", - "adding: mem time223, current time 358, horizon 135\n", - "adding: mem time224, current time 358, horizon 134\n", - "adding: mem time225, current time 358, horizon 133\n", - "adding: mem time226, current time 358, horizon 132\n", - "adding: mem time227, current time 358, horizon 131\n", - "adding: mem time228, current time 358, horizon 130\n", - "adding: mem time229, current time 358, horizon 129\n", - "adding: mem time230, current time 358, horizon 128\n", - "adding: mem time231, current time 358, horizon 127\n", - "adding: mem time232, current time 358, horizon 126\n", - "adding: mem time233, current time 358, horizon 125\n", - "adding: mem time234, current time 358, horizon 124\n", - "adding: mem time235, current time 358, horizon 123\n", - "adding: mem time236, current time 358, horizon 122\n", - "adding: mem time237, current time 358, horizon 121\n", - "adding: mem time238, current time 358, horizon 120\n", - "adding: mem time239, current time 358, horizon 119\n", - "adding: mem time240, current time 358, horizon 118\n", - "adding: mem time241, current time 358, horizon 117\n", - "adding: mem time242, current time 358, horizon 116\n", - "adding: mem time243, current time 358, horizon 115\n", - "adding: mem time244, current time 358, horizon 114\n", - "adding: mem time245, current time 358, horizon 113\n", - "adding: mem time246, current time 358, horizon 112\n", - "adding: mem time247, current time 358, horizon 111\n", - "adding: mem time248, current time 358, horizon 110\n", - "adding: mem time249, current time 358, horizon 109\n", - "adding: mem time250, current time 358, horizon 108\n", - "adding: mem time251, current time 358, horizon 107\n", - "adding: mem time252, current time 358, horizon 106\n", - "adding: mem time253, current time 358, horizon 105\n", - "adding: mem time254, current time 358, horizon 104\n", - "adding: mem time255, current time 358, horizon 103\n", - "adding: mem time256, current time 358, horizon 102\n", - "adding: mem time257, current time 358, horizon 101\n", - "adding: mem time258, current time 358, horizon 100\n", - "adding: mem time259, current time 358, horizon 99\n", - "adding: mem time260, current time 358, horizon 98\n", - "adding: mem time261, current time 358, horizon 97\n", - "adding: mem time262, current time 358, horizon 96\n", - "adding: mem time263, current time 358, horizon 95\n", - "adding: mem time264, current time 358, horizon 94\n", - "adding: mem time265, current time 358, horizon 93\n", - "adding: mem time266, current time 358, horizon 92\n", - "adding: mem time267, current time 358, horizon 91\n", - "adding: mem time268, current time 358, horizon 90\n", - "adding: mem time269, current time 358, horizon 89\n", - "adding: mem time270, current time 358, horizon 88\n", - "adding: mem time271, current time 358, horizon 87\n", - "adding: mem time272, current time 358, horizon 86\n", - "adding: mem time273, current time 358, horizon 85\n", - "adding: mem time274, current time 358, horizon 84\n", - "adding: mem time275, current time 358, horizon 83\n", - "adding: mem time276, current time 358, horizon 82\n", - "adding: mem time277, current time 358, horizon 81\n", - "adding: mem time278, current time 358, horizon 80\n", - "adding: mem time279, current time 358, horizon 79\n", - "adding: mem time280, current time 358, horizon 78\n", - "adding: mem time281, current time 358, horizon 77\n", - "adding: mem time282, current time 358, horizon 76\n", - "adding: mem time283, current time 358, horizon 75\n", - "adding: mem time284, current time 358, horizon 74\n", - "adding: mem time285, current time 358, horizon 73\n", - "adding: mem time286, current time 358, horizon 72\n", - "adding: mem time287, current time 358, horizon 71\n", - "adding: mem time288, current time 358, horizon 70\n", - "adding: mem time289, current time 358, horizon 69\n", - "adding: mem time290, current time 358, horizon 68\n", - "adding: mem time291, current time 358, horizon 67\n", - "adding: mem time292, current time 358, horizon 66\n", - "adding: mem time293, current time 358, horizon 65\n", - "adding: mem time294, current time 358, horizon 64\n", - "adding: mem time295, current time 358, horizon 63\n", - "adding: mem time296, current time 358, horizon 62\n", - "adding: mem time297, current time 358, horizon 61\n", - "adding: mem time298, current time 358, horizon 60\n", - "adding: mem time299, current time 358, horizon 59\n", - "adding: mem time300, current time 358, horizon 58\n", - "adding: mem time301, current time 358, horizon 57\n", - "adding: mem time302, current time 358, horizon 56\n", - "adding: mem time303, current time 358, horizon 55\n", - "adding: mem time304, current time 358, horizon 54\n", - "adding: mem time305, current time 358, horizon 53\n", - "adding: mem time306, current time 358, horizon 52\n", - "adding: mem time307, current time 358, horizon 51\n", - "adding: mem time308, current time 358, horizon 50\n", - "adding: mem time309, current time 358, horizon 49\n", - "adding: mem time310, current time 358, horizon 48\n", - "adding: mem time311, current time 358, horizon 47\n", - "adding: mem time312, current time 358, horizon 46\n", - "adding: mem time313, current time 358, horizon 45\n", - "adding: mem time314, current time 358, horizon 44\n", - "adding: mem time315, current time 358, horizon 43\n", - "adding: mem time316, current time 358, horizon 42\n", - "adding: mem time317, current time 358, horizon 41\n", - "adding: mem time318, current time 358, horizon 40\n", - "adding: mem time319, current time 358, horizon 39\n", - "adding: mem time320, current time 358, horizon 38\n", - "adding: mem time321, current time 358, horizon 37\n", - "adding: mem time322, current time 358, horizon 36\n", - "adding: mem time323, current time 358, horizon 35\n", - "adding: mem time324, current time 358, horizon 34\n", - "adding: mem time325, current time 358, horizon 33\n", - "adding: mem time326, current time 358, horizon 32\n", - "adding: mem time327, current time 358, horizon 31\n", - "adding: mem time328, current time 358, horizon 30\n", - "adding: mem time329, current time 358, horizon 29\n", - "adding: mem time330, current time 358, horizon 28\n", - "adding: mem time331, current time 358, horizon 27\n", - "adding: mem time332, current time 358, horizon 26\n", - "adding: mem time333, current time 358, horizon 25\n", - "adding: mem time334, current time 358, horizon 24\n", - "adding: mem time335, current time 358, horizon 23\n", - "adding: mem time336, current time 358, horizon 22\n", - "adding: mem time337, current time 358, horizon 21\n", - "adding: mem time338, current time 358, horizon 20\n", - "adding: mem time339, current time 358, horizon 19\n", - "adding: mem time340, current time 358, horizon 18\n", - "adding: mem time341, current time 358, horizon 17\n", - "adding: mem time342, current time 358, horizon 16\n", - "adding: mem time343, current time 358, horizon 15\n", - "adding: mem time344, current time 358, horizon 14\n", - "adding: mem time345, current time 358, horizon 13\n", - "adding: mem time346, current time 358, horizon 12\n", - "adding: mem time347, current time 358, horizon 11\n", - "adding: mem time348, current time 358, horizon 10\n", - "adding: mem time349, current time 358, horizon 9\n", - "adding: mem time350, current time 358, horizon 8\n", - "adding: mem time351, current time 358, horizon 7\n", - "adding: mem time352, current time 358, horizon 6\n", - "adding: mem time353, current time 358, horizon 5\n", - "adding: mem time354, current time 358, horizon 4\n", - "adding: mem time355, current time 358, horizon 3\n", - "adding: mem time356, current time 358, horizon 2\n", - "adding: mem time357, current time 358, horizon 1\n", - "adding: mem time200, current time 359, horizon 159\n", - "adding: mem time201, current time 359, horizon 158\n", - "adding: mem time202, current time 359, horizon 157\n", - "adding: mem time203, current time 359, horizon 156\n", - "adding: mem time204, current time 359, horizon 155\n", - "adding: mem time205, current time 359, horizon 154\n", - "adding: mem time206, current time 359, horizon 153\n", - "adding: mem time207, current time 359, horizon 152\n", - "adding: mem time208, current time 359, horizon 151\n", - "adding: mem time209, current time 359, horizon 150\n", - "adding: mem time210, current time 359, horizon 149\n", - "adding: mem time211, current time 359, horizon 148\n", - "adding: mem time212, current time 359, horizon 147\n", - "adding: mem time213, current time 359, horizon 146\n", - "adding: mem time214, current time 359, horizon 145\n", - "adding: mem time215, current time 359, horizon 144\n", - "adding: mem time216, current time 359, horizon 143\n", - "adding: mem time217, current time 359, horizon 142\n", - "adding: mem time218, current time 359, horizon 141\n", - "adding: mem time219, current time 359, horizon 140\n", - "adding: mem time220, current time 359, horizon 139\n", - "adding: mem time221, current time 359, horizon 138\n", - "adding: mem time222, current time 359, horizon 137\n", - "adding: mem time223, current time 359, horizon 136\n", - "adding: mem time224, current time 359, horizon 135\n", - "adding: mem time225, current time 359, horizon 134\n", - "adding: mem time226, current time 359, horizon 133\n", - "adding: mem time227, current time 359, horizon 132\n", - "adding: mem time228, current time 359, horizon 131\n", - "adding: mem time229, current time 359, horizon 130\n", - "adding: mem time230, current time 359, horizon 129\n", - "adding: mem time231, current time 359, horizon 128\n", - "adding: mem time232, current time 359, horizon 127\n", - "adding: mem time233, current time 359, horizon 126\n", - "adding: mem time234, current time 359, horizon 125\n", - "adding: mem time235, current time 359, horizon 124\n", - "adding: mem time236, current time 359, horizon 123\n", - "adding: mem time237, current time 359, horizon 122\n", - "adding: mem time238, current time 359, horizon 121\n", - "adding: mem time239, current time 359, horizon 120\n", - "adding: mem time240, current time 359, horizon 119\n", - "adding: mem time241, current time 359, horizon 118\n", - "adding: mem time242, current time 359, horizon 117\n", - "adding: mem time243, current time 359, horizon 116\n", - "adding: mem time244, current time 359, horizon 115\n", - "adding: mem time245, current time 359, horizon 114\n", - "adding: mem time246, current time 359, horizon 113\n", - "adding: mem time247, current time 359, horizon 112\n", - "adding: mem time248, current time 359, horizon 111\n", - "adding: mem time249, current time 359, horizon 110\n", - "adding: mem time250, current time 359, horizon 109\n", - "adding: mem time251, current time 359, horizon 108\n", - "adding: mem time252, current time 359, horizon 107\n", - "adding: mem time253, current time 359, horizon 106\n", - "adding: mem time254, current time 359, horizon 105\n", - "adding: mem time255, current time 359, horizon 104\n", - "adding: mem time256, current time 359, horizon 103\n", - "adding: mem time257, current time 359, horizon 102\n", - "adding: mem time258, current time 359, horizon 101\n", - "adding: mem time259, current time 359, horizon 100\n", - "adding: mem time260, current time 359, horizon 99\n", - "adding: mem time261, current time 359, horizon 98\n", - "adding: mem time262, current time 359, horizon 97\n", - "adding: mem time263, current time 359, horizon 96\n", - "adding: mem time264, current time 359, horizon 95\n", - "adding: mem time265, current time 359, horizon 94\n", - "adding: mem time266, current time 359, horizon 93\n", - "adding: mem time267, current time 359, horizon 92\n", - "adding: mem time268, current time 359, horizon 91\n", - "adding: mem time269, current time 359, horizon 90\n", - "adding: mem time270, current time 359, horizon 89\n", - "adding: mem time271, current time 359, horizon 88\n", - "adding: mem time272, current time 359, horizon 87\n", - "adding: mem time273, current time 359, horizon 86\n", - "adding: mem time274, current time 359, horizon 85\n", - "adding: mem time275, current time 359, horizon 84\n", - "adding: mem time276, current time 359, horizon 83\n", - "adding: mem time277, current time 359, horizon 82\n", - "adding: mem time278, current time 359, horizon 81\n", - "adding: mem time279, current time 359, horizon 80\n", - "adding: mem time280, current time 359, horizon 79\n", - "adding: mem time281, current time 359, horizon 78\n", - "adding: mem time282, current time 359, horizon 77\n", - "adding: mem time283, current time 359, horizon 76\n", - "adding: mem time284, current time 359, horizon 75\n", - "adding: mem time285, current time 359, horizon 74\n", - "adding: mem time286, current time 359, horizon 73\n", - "adding: mem time287, current time 359, horizon 72\n", - "adding: mem time288, current time 359, horizon 71\n", - "adding: mem time289, current time 359, horizon 70\n", - "adding: mem time290, current time 359, horizon 69\n", - "adding: mem time291, current time 359, horizon 68\n", - "adding: mem time292, current time 359, horizon 67\n", - "adding: mem time293, current time 359, horizon 66\n", - "adding: mem time294, current time 359, horizon 65\n", - "adding: mem time295, current time 359, horizon 64\n", - "adding: mem time296, current time 359, horizon 63\n", - "adding: mem time297, current time 359, horizon 62\n", - "adding: mem time298, current time 359, horizon 61\n", - "adding: mem time299, current time 359, horizon 60\n", - "adding: mem time300, current time 359, horizon 59\n", - "adding: mem time301, current time 359, horizon 58\n", - "adding: mem time302, current time 359, horizon 57\n", - "adding: mem time303, current time 359, horizon 56\n", - "adding: mem time304, current time 359, horizon 55\n", - "adding: mem time305, current time 359, horizon 54\n", - "adding: mem time306, current time 359, horizon 53\n", - "adding: mem time307, current time 359, horizon 52\n", - "adding: mem time308, current time 359, horizon 51\n", - "adding: mem time309, current time 359, horizon 50\n", - "adding: mem time310, current time 359, horizon 49\n", - "adding: mem time311, current time 359, horizon 48\n", - "adding: mem time312, current time 359, horizon 47\n", - "adding: mem time313, current time 359, horizon 46\n", - "adding: mem time314, current time 359, horizon 45\n", - "adding: mem time315, current time 359, horizon 44\n", - "adding: mem time316, current time 359, horizon 43\n", - "adding: mem time317, current time 359, horizon 42\n", - "adding: mem time318, current time 359, horizon 41\n", - "adding: mem time319, current time 359, horizon 40\n", - "adding: mem time320, current time 359, horizon 39\n", - "adding: mem time321, current time 359, horizon 38\n", - "adding: mem time322, current time 359, horizon 37\n", - "adding: mem time323, current time 359, horizon 36\n", - "adding: mem time324, current time 359, horizon 35\n", - "adding: mem time325, current time 359, horizon 34\n", - "adding: mem time326, current time 359, horizon 33\n", - "adding: mem time327, current time 359, horizon 32\n", - "adding: mem time328, current time 359, horizon 31\n", - "adding: mem time329, current time 359, horizon 30\n", - "adding: mem time330, current time 359, horizon 29\n", - "adding: mem time331, current time 359, horizon 28\n", - "adding: mem time332, current time 359, horizon 27\n", - "adding: mem time333, current time 359, horizon 26\n", - "adding: mem time334, current time 359, horizon 25\n", - "adding: mem time335, current time 359, horizon 24\n", - "adding: mem time336, current time 359, horizon 23\n", - "adding: mem time337, current time 359, horizon 22\n", - "adding: mem time338, current time 359, horizon 21\n", - "adding: mem time339, current time 359, horizon 20\n", - "adding: mem time340, current time 359, horizon 19\n", - "adding: mem time341, current time 359, horizon 18\n", - "adding: mem time342, current time 359, horizon 17\n", - "adding: mem time343, current time 359, horizon 16\n", - "adding: mem time344, current time 359, horizon 15\n", - "adding: mem time345, current time 359, horizon 14\n", - "adding: mem time346, current time 359, horizon 13\n", - "adding: mem time347, current time 359, horizon 12\n", - "adding: mem time348, current time 359, horizon 11\n", - "adding: mem time349, current time 359, horizon 10\n", - "adding: mem time350, current time 359, horizon 9\n", - "adding: mem time351, current time 359, horizon 8\n", - "adding: mem time352, current time 359, horizon 7\n", - "adding: mem time353, current time 359, horizon 6\n", - "adding: mem time354, current time 359, horizon 5\n", - "adding: mem time355, current time 359, horizon 4\n", - "adding: mem time356, current time 359, horizon 3\n", - "adding: mem time357, current time 359, horizon 2\n", - "adding: mem time358, current time 359, horizon 1\n", - "adding: mem time200, current time 360, horizon 160\n", - "adding: mem time201, current time 360, horizon 159\n", - "adding: mem time202, current time 360, horizon 158\n", - "adding: mem time203, current time 360, horizon 157\n", - "adding: mem time204, current time 360, horizon 156\n", - "adding: mem time205, current time 360, horizon 155\n", - "adding: mem time206, current time 360, horizon 154\n", - "adding: mem time207, current time 360, horizon 153\n", - "adding: mem time208, current time 360, horizon 152\n", - "adding: mem time209, current time 360, horizon 151\n", - "adding: mem time210, current time 360, horizon 150\n", - "adding: mem time211, current time 360, horizon 149\n", - "adding: mem time212, current time 360, horizon 148\n", - "adding: mem time213, current time 360, horizon 147\n", - "adding: mem time214, current time 360, horizon 146\n", - "adding: mem time215, current time 360, horizon 145\n", - "adding: mem time216, current time 360, horizon 144\n", - "adding: mem time217, current time 360, horizon 143\n", - "adding: mem time218, current time 360, horizon 142\n", - "adding: mem time219, current time 360, horizon 141\n", - "adding: mem time220, current time 360, horizon 140\n", - "adding: mem time221, current time 360, horizon 139\n", - "adding: mem time222, current time 360, horizon 138\n", - "adding: mem time223, current time 360, horizon 137\n", - "adding: mem time224, current time 360, horizon 136\n", - "adding: mem time225, current time 360, horizon 135\n", - "adding: mem time226, current time 360, horizon 134\n", - "adding: mem time227, current time 360, horizon 133\n", - "adding: mem time228, current time 360, horizon 132\n", - "adding: mem time229, current time 360, horizon 131\n", - "adding: mem time230, current time 360, horizon 130\n", - "adding: mem time231, current time 360, horizon 129\n", - "adding: mem time232, current time 360, horizon 128\n", - "adding: mem time233, current time 360, horizon 127\n", - "adding: mem time234, current time 360, horizon 126\n", - "adding: mem time235, current time 360, horizon 125\n", - "adding: mem time236, current time 360, horizon 124\n", - "adding: mem time237, current time 360, horizon 123\n", - "adding: mem time238, current time 360, horizon 122\n", - "adding: mem time239, current time 360, horizon 121\n", - "adding: mem time240, current time 360, horizon 120\n", - "adding: mem time241, current time 360, horizon 119\n", - "adding: mem time242, current time 360, horizon 118\n", - "adding: mem time243, current time 360, horizon 117\n", - "adding: mem time244, current time 360, horizon 116\n", - "adding: mem time245, current time 360, horizon 115\n", - "adding: mem time246, current time 360, horizon 114\n", - "adding: mem time247, current time 360, horizon 113\n", - "adding: mem time248, current time 360, horizon 112\n", - "adding: mem time249, current time 360, horizon 111\n", - "adding: mem time250, current time 360, horizon 110\n", - "adding: mem time251, current time 360, horizon 109\n", - "adding: mem time252, current time 360, horizon 108\n", - "adding: mem time253, current time 360, horizon 107\n", - "adding: mem time254, current time 360, horizon 106\n", - "adding: mem time255, current time 360, horizon 105\n", - "adding: mem time256, current time 360, horizon 104\n", - "adding: mem time257, current time 360, horizon 103\n", - "adding: mem time258, current time 360, horizon 102\n", - "adding: mem time259, current time 360, horizon 101\n", - "adding: mem time260, current time 360, horizon 100\n", - "adding: mem time261, current time 360, horizon 99\n", - "adding: mem time262, current time 360, horizon 98\n", - "adding: mem time263, current time 360, horizon 97\n", - "adding: mem time264, current time 360, horizon 96\n", - "adding: mem time265, current time 360, horizon 95\n", - "adding: mem time266, current time 360, horizon 94\n", - "adding: mem time267, current time 360, horizon 93\n", - "adding: mem time268, current time 360, horizon 92\n", - "adding: mem time269, current time 360, horizon 91\n", - "adding: mem time270, current time 360, horizon 90\n", - "adding: mem time271, current time 360, horizon 89\n", - "adding: mem time272, current time 360, horizon 88\n", - "adding: mem time273, current time 360, horizon 87\n", - "adding: mem time274, current time 360, horizon 86\n", - "adding: mem time275, current time 360, horizon 85\n", - "adding: mem time276, current time 360, horizon 84\n", - "adding: mem time277, current time 360, horizon 83\n", - "adding: mem time278, current time 360, horizon 82\n", - "adding: mem time279, current time 360, horizon 81\n", - "adding: mem time280, current time 360, horizon 80\n", - "adding: mem time281, current time 360, horizon 79\n", - "adding: mem time282, current time 360, horizon 78\n", - "adding: mem time283, current time 360, horizon 77\n", - "adding: mem time284, current time 360, horizon 76\n", - "adding: mem time285, current time 360, horizon 75\n", - "adding: mem time286, current time 360, horizon 74\n", - "adding: mem time287, current time 360, horizon 73\n", - "adding: mem time288, current time 360, horizon 72\n", - "adding: mem time289, current time 360, horizon 71\n", - "adding: mem time290, current time 360, horizon 70\n", - "adding: mem time291, current time 360, horizon 69\n", - "adding: mem time292, current time 360, horizon 68\n", - "adding: mem time293, current time 360, horizon 67\n", - "adding: mem time294, current time 360, horizon 66\n", - "adding: mem time295, current time 360, horizon 65\n", - "adding: mem time296, current time 360, horizon 64\n", - "adding: mem time297, current time 360, horizon 63\n", - "adding: mem time298, current time 360, horizon 62\n", - "adding: mem time299, current time 360, horizon 61\n", - "adding: mem time300, current time 360, horizon 60\n", - "adding: mem time301, current time 360, horizon 59\n", - "adding: mem time302, current time 360, horizon 58\n", - "adding: mem time303, current time 360, horizon 57\n", - "adding: mem time304, current time 360, horizon 56\n", - "adding: mem time305, current time 360, horizon 55\n", - "adding: mem time306, current time 360, horizon 54\n", - "adding: mem time307, current time 360, horizon 53\n", - "adding: mem time308, current time 360, horizon 52\n", - "adding: mem time309, current time 360, horizon 51\n", - "adding: mem time310, current time 360, horizon 50\n", - "adding: mem time311, current time 360, horizon 49\n", - "adding: mem time312, current time 360, horizon 48\n", - "adding: mem time313, current time 360, horizon 47\n", - "adding: mem time314, current time 360, horizon 46\n", - "adding: mem time315, current time 360, horizon 45\n", - "adding: mem time316, current time 360, horizon 44\n", - "adding: mem time317, current time 360, horizon 43\n", - "adding: mem time318, current time 360, horizon 42\n", - "adding: mem time319, current time 360, horizon 41\n", - "adding: mem time320, current time 360, horizon 40\n", - "adding: mem time321, current time 360, horizon 39\n", - "adding: mem time322, current time 360, horizon 38\n", - "adding: mem time323, current time 360, horizon 37\n", - "adding: mem time324, current time 360, horizon 36\n", - "adding: mem time325, current time 360, horizon 35\n", - "adding: mem time326, current time 360, horizon 34\n", - "adding: mem time327, current time 360, horizon 33\n", - "adding: mem time328, current time 360, horizon 32\n", - "adding: mem time329, current time 360, horizon 31\n", - "adding: mem time330, current time 360, horizon 30\n", - "adding: mem time331, current time 360, horizon 29\n", - "adding: mem time332, current time 360, horizon 28\n", - "adding: mem time333, current time 360, horizon 27\n", - "adding: mem time334, current time 360, horizon 26\n", - "adding: mem time335, current time 360, horizon 25\n", - "adding: mem time336, current time 360, horizon 24\n", - "adding: mem time337, current time 360, horizon 23\n", - "adding: mem time338, current time 360, horizon 22\n", - "adding: mem time339, current time 360, horizon 21\n", - "adding: mem time340, current time 360, horizon 20\n", - "adding: mem time341, current time 360, horizon 19\n", - "adding: mem time342, current time 360, horizon 18\n", - "adding: mem time343, current time 360, horizon 17\n", - "adding: mem time344, current time 360, horizon 16\n", - "adding: mem time345, current time 360, horizon 15\n", - "adding: mem time346, current time 360, horizon 14\n", - "adding: mem time347, current time 360, horizon 13\n", - "adding: mem time348, current time 360, horizon 12\n", - "adding: mem time349, current time 360, horizon 11\n", - "adding: mem time350, current time 360, horizon 10\n", - "adding: mem time351, current time 360, horizon 9\n", - "adding: mem time352, current time 360, horizon 8\n", - "adding: mem time353, current time 360, horizon 7\n", - "adding: mem time354, current time 360, horizon 6\n", - "adding: mem time355, current time 360, horizon 5\n", - "adding: mem time356, current time 360, horizon 4\n", - "adding: mem time357, current time 360, horizon 3\n", - "adding: mem time358, current time 360, horizon 2\n", - "adding: mem time359, current time 360, horizon 1\n", - "adding: mem time200, current time 361, horizon 161\n", - "adding: mem time201, current time 361, horizon 160\n", - "adding: mem time202, current time 361, horizon 159\n", - "adding: mem time203, current time 361, horizon 158\n", - "adding: mem time204, current time 361, horizon 157\n", - "adding: mem time205, current time 361, horizon 156\n", - "adding: mem time206, current time 361, horizon 155\n", - "adding: mem time207, current time 361, horizon 154\n", - "adding: mem time208, current time 361, horizon 153\n", - "adding: mem time209, current time 361, horizon 152\n", - "adding: mem time210, current time 361, horizon 151\n", - "adding: mem time211, current time 361, horizon 150\n", - "adding: mem time212, current time 361, horizon 149\n", - "adding: mem time213, current time 361, horizon 148\n", - "adding: mem time214, current time 361, horizon 147\n", - "adding: mem time215, current time 361, horizon 146\n", - "adding: mem time216, current time 361, horizon 145\n", - "adding: mem time217, current time 361, horizon 144\n", - "adding: mem time218, current time 361, horizon 143\n", - "adding: mem time219, current time 361, horizon 142\n", - "adding: mem time220, current time 361, horizon 141\n", - "adding: mem time221, current time 361, horizon 140\n", - "adding: mem time222, current time 361, horizon 139\n", - "adding: mem time223, current time 361, horizon 138\n", - "adding: mem time224, current time 361, horizon 137\n", - "adding: mem time225, current time 361, horizon 136\n", - "adding: mem time226, current time 361, horizon 135\n", - "adding: mem time227, current time 361, horizon 134\n", - "adding: mem time228, current time 361, horizon 133\n", - "adding: mem time229, current time 361, horizon 132\n", - "adding: mem time230, current time 361, horizon 131\n", - "adding: mem time231, current time 361, horizon 130\n", - "adding: mem time232, current time 361, horizon 129\n", - "adding: mem time233, current time 361, horizon 128\n", - "adding: mem time234, current time 361, horizon 127\n", - "adding: mem time235, current time 361, horizon 126\n", - "adding: mem time236, current time 361, horizon 125\n", - "adding: mem time237, current time 361, horizon 124\n", - "adding: mem time238, current time 361, horizon 123\n", - "adding: mem time239, current time 361, horizon 122\n", - "adding: mem time240, current time 361, horizon 121\n", - "adding: mem time241, current time 361, horizon 120\n", - "adding: mem time242, current time 361, horizon 119\n", - "adding: mem time243, current time 361, horizon 118\n", - "adding: mem time244, current time 361, horizon 117\n", - "adding: mem time245, current time 361, horizon 116\n", - "adding: mem time246, current time 361, horizon 115\n", - "adding: mem time247, current time 361, horizon 114\n", - "adding: mem time248, current time 361, horizon 113\n", - "adding: mem time249, current time 361, horizon 112\n", - "adding: mem time250, current time 361, horizon 111\n", - "adding: mem time251, current time 361, horizon 110\n", - "adding: mem time252, current time 361, horizon 109\n", - "adding: mem time253, current time 361, horizon 108\n", - "adding: mem time254, current time 361, horizon 107\n", - "adding: mem time255, current time 361, horizon 106\n", - "adding: mem time256, current time 361, horizon 105\n", - "adding: mem time257, current time 361, horizon 104\n", - "adding: mem time258, current time 361, horizon 103\n", - "adding: mem time259, current time 361, horizon 102\n", - "adding: mem time260, current time 361, horizon 101\n", - "adding: mem time261, current time 361, horizon 100\n", - "adding: mem time262, current time 361, horizon 99\n", - "adding: mem time263, current time 361, horizon 98\n", - "adding: mem time264, current time 361, horizon 97\n", - "adding: mem time265, current time 361, horizon 96\n", - "adding: mem time266, current time 361, horizon 95\n", - "adding: mem time267, current time 361, horizon 94\n", - "adding: mem time268, current time 361, horizon 93\n", - "adding: mem time269, current time 361, horizon 92\n", - "adding: mem time270, current time 361, horizon 91\n", - "adding: mem time271, current time 361, horizon 90\n", - "adding: mem time272, current time 361, horizon 89\n", - "adding: mem time273, current time 361, horizon 88\n", - "adding: mem time274, current time 361, horizon 87\n", - "adding: mem time275, current time 361, horizon 86\n", - "adding: mem time276, current time 361, horizon 85\n", - "adding: mem time277, current time 361, horizon 84\n", - "adding: mem time278, current time 361, horizon 83\n", - "adding: mem time279, current time 361, horizon 82\n", - "adding: mem time280, current time 361, horizon 81\n", - "adding: mem time281, current time 361, horizon 80\n", - "adding: mem time282, current time 361, horizon 79\n", - "adding: mem time283, current time 361, horizon 78\n", - "adding: mem time284, current time 361, horizon 77\n", - "adding: mem time285, current time 361, horizon 76\n", - "adding: mem time286, current time 361, horizon 75\n", - "adding: mem time287, current time 361, horizon 74\n", - "adding: mem time288, current time 361, horizon 73\n", - "adding: mem time289, current time 361, horizon 72\n", - "adding: mem time290, current time 361, horizon 71\n", - "adding: mem time291, current time 361, horizon 70\n", - "adding: mem time292, current time 361, horizon 69\n", - "adding: mem time293, current time 361, horizon 68\n", - "adding: mem time294, current time 361, horizon 67\n", - "adding: mem time295, current time 361, horizon 66\n", - "adding: mem time296, current time 361, horizon 65\n", - "adding: mem time297, current time 361, horizon 64\n", - "adding: mem time298, current time 361, horizon 63\n", - "adding: mem time299, current time 361, horizon 62\n", - "adding: mem time300, current time 361, horizon 61\n", - "adding: mem time301, current time 361, horizon 60\n", - "adding: mem time302, current time 361, horizon 59\n", - "adding: mem time303, current time 361, horizon 58\n", - "adding: mem time304, current time 361, horizon 57\n", - "adding: mem time305, current time 361, horizon 56\n", - "adding: mem time306, current time 361, horizon 55\n", - "adding: mem time307, current time 361, horizon 54\n", - "adding: mem time308, current time 361, horizon 53\n", - "adding: mem time309, current time 361, horizon 52\n", - "adding: mem time310, current time 361, horizon 51\n", - "adding: mem time311, current time 361, horizon 50\n", - "adding: mem time312, current time 361, horizon 49\n", - "adding: mem time313, current time 361, horizon 48\n", - "adding: mem time314, current time 361, horizon 47\n", - "adding: mem time315, current time 361, horizon 46\n", - "adding: mem time316, current time 361, horizon 45\n", - "adding: mem time317, current time 361, horizon 44\n", - "adding: mem time318, current time 361, horizon 43\n", - "adding: mem time319, current time 361, horizon 42\n", - "adding: mem time320, current time 361, horizon 41\n", - "adding: mem time321, current time 361, horizon 40\n", - "adding: mem time322, current time 361, horizon 39\n", - "adding: mem time323, current time 361, horizon 38\n", - "adding: mem time324, current time 361, horizon 37\n", - "adding: mem time325, current time 361, horizon 36\n", - "adding: mem time326, current time 361, horizon 35\n", - "adding: mem time327, current time 361, horizon 34\n", - "adding: mem time328, current time 361, horizon 33\n", - "adding: mem time329, current time 361, horizon 32\n", - "adding: mem time330, current time 361, horizon 31\n", - "adding: mem time331, current time 361, horizon 30\n", - "adding: mem time332, current time 361, horizon 29\n", - "adding: mem time333, current time 361, horizon 28\n", - "adding: mem time334, current time 361, horizon 27\n", - "adding: mem time335, current time 361, horizon 26\n", - "adding: mem time336, current time 361, horizon 25\n", - "adding: mem time337, current time 361, horizon 24\n", - "adding: mem time338, current time 361, horizon 23\n", - "adding: mem time339, current time 361, horizon 22\n", - "adding: mem time340, current time 361, horizon 21\n", - "adding: mem time341, current time 361, horizon 20\n", - "adding: mem time342, current time 361, horizon 19\n", - "adding: mem time343, current time 361, horizon 18\n", - "adding: mem time344, current time 361, horizon 17\n", - "adding: mem time345, current time 361, horizon 16\n", - "adding: mem time346, current time 361, horizon 15\n", - "adding: mem time347, current time 361, horizon 14\n", - "adding: mem time348, current time 361, horizon 13\n", - "adding: mem time349, current time 361, horizon 12\n", - "adding: mem time350, current time 361, horizon 11\n", - "adding: mem time351, current time 361, horizon 10\n", - "adding: mem time352, current time 361, horizon 9\n", - "adding: mem time353, current time 361, horizon 8\n", - "adding: mem time354, current time 361, horizon 7\n", - "adding: mem time355, current time 361, horizon 6\n", - "adding: mem time356, current time 361, horizon 5\n", - "adding: mem time357, current time 361, horizon 4\n", - "adding: mem time358, current time 361, horizon 3\n", - "adding: mem time359, current time 361, horizon 2\n", - "adding: mem time360, current time 361, horizon 1\n", - "adding: mem time200, current time 362, horizon 162\n", - "adding: mem time201, current time 362, horizon 161\n", - "adding: mem time202, current time 362, horizon 160\n", - "adding: mem time203, current time 362, horizon 159\n", - "adding: mem time204, current time 362, horizon 158\n", - "adding: mem time205, current time 362, horizon 157\n", - "adding: mem time206, current time 362, horizon 156\n", - "adding: mem time207, current time 362, horizon 155\n", - "adding: mem time208, current time 362, horizon 154\n", - "adding: mem time209, current time 362, horizon 153\n", - "adding: mem time210, current time 362, horizon 152\n", - "adding: mem time211, current time 362, horizon 151\n", - "adding: mem time212, current time 362, horizon 150\n", - "adding: mem time213, current time 362, horizon 149\n", - "adding: mem time214, current time 362, horizon 148\n", - "adding: mem time215, current time 362, horizon 147\n", - "adding: mem time216, current time 362, horizon 146\n", - "adding: mem time217, current time 362, horizon 145\n", - "adding: mem time218, current time 362, horizon 144\n", - "adding: mem time219, current time 362, horizon 143\n", - "adding: mem time220, current time 362, horizon 142\n", - "adding: mem time221, current time 362, horizon 141\n", - "adding: mem time222, current time 362, horizon 140\n", - "adding: mem time223, current time 362, horizon 139\n", - "adding: mem time224, current time 362, horizon 138\n", - "adding: mem time225, current time 362, horizon 137\n", - "adding: mem time226, current time 362, horizon 136\n", - "adding: mem time227, current time 362, horizon 135\n", - "adding: mem time228, current time 362, horizon 134\n", - "adding: mem time229, current time 362, horizon 133\n", - "adding: mem time230, current time 362, horizon 132\n", - "adding: mem time231, current time 362, horizon 131\n", - "adding: mem time232, current time 362, horizon 130\n", - "adding: mem time233, current time 362, horizon 129\n", - "adding: mem time234, current time 362, horizon 128\n", - "adding: mem time235, current time 362, horizon 127\n", - "adding: mem time236, current time 362, horizon 126\n", - "adding: mem time237, current time 362, horizon 125\n", - "adding: mem time238, current time 362, horizon 124\n", - "adding: mem time239, current time 362, horizon 123\n", - "adding: mem time240, current time 362, horizon 122\n", - "adding: mem time241, current time 362, horizon 121\n", - "adding: mem time242, current time 362, horizon 120\n", - "adding: mem time243, current time 362, horizon 119\n", - "adding: mem time244, current time 362, horizon 118\n", - "adding: mem time245, current time 362, horizon 117\n", - "adding: mem time246, current time 362, horizon 116\n", - "adding: mem time247, current time 362, horizon 115\n", - "adding: mem time248, current time 362, horizon 114\n", - "adding: mem time249, current time 362, horizon 113\n", - "adding: mem time250, current time 362, horizon 112\n", - "adding: mem time251, current time 362, horizon 111\n", - "adding: mem time252, current time 362, horizon 110\n", - "adding: mem time253, current time 362, horizon 109\n", - "adding: mem time254, current time 362, horizon 108\n", - "adding: mem time255, current time 362, horizon 107\n", - "adding: mem time256, current time 362, horizon 106\n", - "adding: mem time257, current time 362, horizon 105\n", - "adding: mem time258, current time 362, horizon 104\n", - "adding: mem time259, current time 362, horizon 103\n", - "adding: mem time260, current time 362, horizon 102\n", - "adding: mem time261, current time 362, horizon 101\n", - "adding: mem time262, current time 362, horizon 100\n", - "adding: mem time263, current time 362, horizon 99\n", - "adding: mem time264, current time 362, horizon 98\n", - "adding: mem time265, current time 362, horizon 97\n", - "adding: mem time266, current time 362, horizon 96\n", - "adding: mem time267, current time 362, horizon 95\n", - "adding: mem time268, current time 362, horizon 94\n", - "adding: mem time269, current time 362, horizon 93\n", - "adding: mem time270, current time 362, horizon 92\n", - "adding: mem time271, current time 362, horizon 91\n", - "adding: mem time272, current time 362, horizon 90\n", - "adding: mem time273, current time 362, horizon 89\n", - "adding: mem time274, current time 362, horizon 88\n", - "adding: mem time275, current time 362, horizon 87\n", - "adding: mem time276, current time 362, horizon 86\n", - "adding: mem time277, current time 362, horizon 85\n", - "adding: mem time278, current time 362, horizon 84\n", - "adding: mem time279, current time 362, horizon 83\n", - "adding: mem time280, current time 362, horizon 82\n", - "adding: mem time281, current time 362, horizon 81\n", - "adding: mem time282, current time 362, horizon 80\n", - "adding: mem time283, current time 362, horizon 79\n", - "adding: mem time284, current time 362, horizon 78\n", - "adding: mem time285, current time 362, horizon 77\n", - "adding: mem time286, current time 362, horizon 76\n", - "adding: mem time287, current time 362, horizon 75\n", - "adding: mem time288, current time 362, horizon 74\n", - "adding: mem time289, current time 362, horizon 73\n", - "adding: mem time290, current time 362, horizon 72\n", - "adding: mem time291, current time 362, horizon 71\n", - "adding: mem time292, current time 362, horizon 70\n", - "adding: mem time293, current time 362, horizon 69\n", - "adding: mem time294, current time 362, horizon 68\n", - "adding: mem time295, current time 362, horizon 67\n", - "adding: mem time296, current time 362, horizon 66\n", - "adding: mem time297, current time 362, horizon 65\n", - "adding: mem time298, current time 362, horizon 64\n", - "adding: mem time299, current time 362, horizon 63\n", - "adding: mem time300, current time 362, horizon 62\n", - "adding: mem time301, current time 362, horizon 61\n", - "adding: mem time302, current time 362, horizon 60\n", - "adding: mem time303, current time 362, horizon 59\n", - "adding: mem time304, current time 362, horizon 58\n", - "adding: mem time305, current time 362, horizon 57\n", - "adding: mem time306, current time 362, horizon 56\n", - "adding: mem time307, current time 362, horizon 55\n", - "adding: mem time308, current time 362, horizon 54\n", - "adding: mem time309, current time 362, horizon 53\n", - "adding: mem time310, current time 362, horizon 52\n", - "adding: mem time311, current time 362, horizon 51\n", - "adding: mem time312, current time 362, horizon 50\n", - "adding: mem time313, current time 362, horizon 49\n", - "adding: mem time314, current time 362, horizon 48\n", - "adding: mem time315, current time 362, horizon 47\n", - "adding: mem time316, current time 362, horizon 46\n", - "adding: mem time317, current time 362, horizon 45\n", - "adding: mem time318, current time 362, horizon 44\n", - "adding: mem time319, current time 362, horizon 43\n", - "adding: mem time320, current time 362, horizon 42\n", - "adding: mem time321, current time 362, horizon 41\n", - "adding: mem time322, current time 362, horizon 40\n", - "adding: mem time323, current time 362, horizon 39\n", - "adding: mem time324, current time 362, horizon 38\n", - "adding: mem time325, current time 362, horizon 37\n", - "adding: mem time326, current time 362, horizon 36\n", - "adding: mem time327, current time 362, horizon 35\n", - "adding: mem time328, current time 362, horizon 34\n", - "adding: mem time329, current time 362, horizon 33\n", - "adding: mem time330, current time 362, horizon 32\n", - "adding: mem time331, current time 362, horizon 31\n", - "adding: mem time332, current time 362, horizon 30\n", - "adding: mem time333, current time 362, horizon 29\n", - "adding: mem time334, current time 362, horizon 28\n", - "adding: mem time335, current time 362, horizon 27\n", - "adding: mem time336, current time 362, horizon 26\n", - "adding: mem time337, current time 362, horizon 25\n", - "adding: mem time338, current time 362, horizon 24\n", - "adding: mem time339, current time 362, horizon 23\n", - "adding: mem time340, current time 362, horizon 22\n", - "adding: mem time341, current time 362, horizon 21\n", - "adding: mem time342, current time 362, horizon 20\n", - "adding: mem time343, current time 362, horizon 19\n", - "adding: mem time344, current time 362, horizon 18\n", - "adding: mem time345, current time 362, horizon 17\n", - "adding: mem time346, current time 362, horizon 16\n", - "adding: mem time347, current time 362, horizon 15\n", - "adding: mem time348, current time 362, horizon 14\n", - "adding: mem time349, current time 362, horizon 13\n", - "adding: mem time350, current time 362, horizon 12\n", - "adding: mem time351, current time 362, horizon 11\n", - "adding: mem time352, current time 362, horizon 10\n", - "adding: mem time353, current time 362, horizon 9\n", - "adding: mem time354, current time 362, horizon 8\n", - "adding: mem time355, current time 362, horizon 7\n", - "adding: mem time356, current time 362, horizon 6\n", - "adding: mem time357, current time 362, horizon 5\n", - "adding: mem time358, current time 362, horizon 4\n", - "adding: mem time359, current time 362, horizon 3\n", - "adding: mem time360, current time 362, horizon 2\n", - "adding: mem time361, current time 362, horizon 1\n", - "adding: mem time200, current time 363, horizon 163\n", - "adding: mem time201, current time 363, horizon 162\n", - "adding: mem time202, current time 363, horizon 161\n", - "adding: mem time203, current time 363, horizon 160\n", - "adding: mem time204, current time 363, horizon 159\n", - "adding: mem time205, current time 363, horizon 158\n", - "adding: mem time206, current time 363, horizon 157\n", - "adding: mem time207, current time 363, horizon 156\n", - "adding: mem time208, current time 363, horizon 155\n", - "adding: mem time209, current time 363, horizon 154\n", - "adding: mem time210, current time 363, horizon 153\n", - "adding: mem time211, current time 363, horizon 152\n", - "adding: mem time212, current time 363, horizon 151\n", - "adding: mem time213, current time 363, horizon 150\n", - "adding: mem time214, current time 363, horizon 149\n", - "adding: mem time215, current time 363, horizon 148\n", - "adding: mem time216, current time 363, horizon 147\n", - "adding: mem time217, current time 363, horizon 146\n", - "adding: mem time218, current time 363, horizon 145\n", - "adding: mem time219, current time 363, horizon 144\n", - "adding: mem time220, current time 363, horizon 143\n", - "adding: mem time221, current time 363, horizon 142\n", - "adding: mem time222, current time 363, horizon 141\n", - "adding: mem time223, current time 363, horizon 140\n", - "adding: mem time224, current time 363, horizon 139\n", - "adding: mem time225, current time 363, horizon 138\n", - "adding: mem time226, current time 363, horizon 137\n", - "adding: mem time227, current time 363, horizon 136\n", - "adding: mem time228, current time 363, horizon 135\n", - "adding: mem time229, current time 363, horizon 134\n", - "adding: mem time230, current time 363, horizon 133\n", - "adding: mem time231, current time 363, horizon 132\n", - "adding: mem time232, current time 363, horizon 131\n", - "adding: mem time233, current time 363, horizon 130\n", - "adding: mem time234, current time 363, horizon 129\n", - "adding: mem time235, current time 363, horizon 128\n", - "adding: mem time236, current time 363, horizon 127\n", - "adding: mem time237, current time 363, horizon 126\n", - "adding: mem time238, current time 363, horizon 125\n", - "adding: mem time239, current time 363, horizon 124\n", - "adding: mem time240, current time 363, horizon 123\n", - "adding: mem time241, current time 363, horizon 122\n", - "adding: mem time242, current time 363, horizon 121\n", - "adding: mem time243, current time 363, horizon 120\n", - "adding: mem time244, current time 363, horizon 119\n", - "adding: mem time245, current time 363, horizon 118\n", - "adding: mem time246, current time 363, horizon 117\n", - "adding: mem time247, current time 363, horizon 116\n", - "adding: mem time248, current time 363, horizon 115\n", - "adding: mem time249, current time 363, horizon 114\n", - "adding: mem time250, current time 363, horizon 113\n", - "adding: mem time251, current time 363, horizon 112\n", - "adding: mem time252, current time 363, horizon 111\n", - "adding: mem time253, current time 363, horizon 110\n", - "adding: mem time254, current time 363, horizon 109\n", - "adding: mem time255, current time 363, horizon 108\n", - "adding: mem time256, current time 363, horizon 107\n", - "adding: mem time257, current time 363, horizon 106\n", - "adding: mem time258, current time 363, horizon 105\n", - "adding: mem time259, current time 363, horizon 104\n", - "adding: mem time260, current time 363, horizon 103\n", - "adding: mem time261, current time 363, horizon 102\n", - "adding: mem time262, current time 363, horizon 101\n", - "adding: mem time263, current time 363, horizon 100\n", - "adding: mem time264, current time 363, horizon 99\n", - "adding: mem time265, current time 363, horizon 98\n", - "adding: mem time266, current time 363, horizon 97\n", - "adding: mem time267, current time 363, horizon 96\n", - "adding: mem time268, current time 363, horizon 95\n", - "adding: mem time269, current time 363, horizon 94\n", - "adding: mem time270, current time 363, horizon 93\n", - "adding: mem time271, current time 363, horizon 92\n", - "adding: mem time272, current time 363, horizon 91\n", - "adding: mem time273, current time 363, horizon 90\n", - "adding: mem time274, current time 363, horizon 89\n", - "adding: mem time275, current time 363, horizon 88\n", - "adding: mem time276, current time 363, horizon 87\n", - "adding: mem time277, current time 363, horizon 86\n", - "adding: mem time278, current time 363, horizon 85\n", - "adding: mem time279, current time 363, horizon 84\n", - "adding: mem time280, current time 363, horizon 83\n", - "adding: mem time281, current time 363, horizon 82\n", - "adding: mem time282, current time 363, horizon 81\n", - "adding: mem time283, current time 363, horizon 80\n", - "adding: mem time284, current time 363, horizon 79\n", - "adding: mem time285, current time 363, horizon 78\n", - "adding: mem time286, current time 363, horizon 77\n", - "adding: mem time287, current time 363, horizon 76\n", - "adding: mem time288, current time 363, horizon 75\n", - "adding: mem time289, current time 363, horizon 74\n", - "adding: mem time290, current time 363, horizon 73\n", - "adding: mem time291, current time 363, horizon 72\n", - "adding: mem time292, current time 363, horizon 71\n", - "adding: mem time293, current time 363, horizon 70\n", - "adding: mem time294, current time 363, horizon 69\n", - "adding: mem time295, current time 363, horizon 68\n", - "adding: mem time296, current time 363, horizon 67\n", - "adding: mem time297, current time 363, horizon 66\n", - "adding: mem time298, current time 363, horizon 65\n", - "adding: mem time299, current time 363, horizon 64\n", - "adding: mem time300, current time 363, horizon 63\n", - "adding: mem time301, current time 363, horizon 62\n", - "adding: mem time302, current time 363, horizon 61\n", - "adding: mem time303, current time 363, horizon 60\n", - "adding: mem time304, current time 363, horizon 59\n", - "adding: mem time305, current time 363, horizon 58\n", - "adding: mem time306, current time 363, horizon 57\n", - "adding: mem time307, current time 363, horizon 56\n", - "adding: mem time308, current time 363, horizon 55\n", - "adding: mem time309, current time 363, horizon 54\n", - "adding: mem time310, current time 363, horizon 53\n", - "adding: mem time311, current time 363, horizon 52\n", - "adding: mem time312, current time 363, horizon 51\n", - "adding: mem time313, current time 363, horizon 50\n", - "adding: mem time314, current time 363, horizon 49\n", - "adding: mem time315, current time 363, horizon 48\n", - "adding: mem time316, current time 363, horizon 47\n", - "adding: mem time317, current time 363, horizon 46\n", - "adding: mem time318, current time 363, horizon 45\n", - "adding: mem time319, current time 363, horizon 44\n", - "adding: mem time320, current time 363, horizon 43\n", - "adding: mem time321, current time 363, horizon 42\n", - "adding: mem time322, current time 363, horizon 41\n", - "adding: mem time323, current time 363, horizon 40\n", - "adding: mem time324, current time 363, horizon 39\n", - "adding: mem time325, current time 363, horizon 38\n", - "adding: mem time326, current time 363, horizon 37\n", - "adding: mem time327, current time 363, horizon 36\n", - "adding: mem time328, current time 363, horizon 35\n", - "adding: mem time329, current time 363, horizon 34\n", - "adding: mem time330, current time 363, horizon 33\n", - "adding: mem time331, current time 363, horizon 32\n", - "adding: mem time332, current time 363, horizon 31\n", - "adding: mem time333, current time 363, horizon 30\n", - "adding: mem time334, current time 363, horizon 29\n", - "adding: mem time335, current time 363, horizon 28\n", - "adding: mem time336, current time 363, horizon 27\n", - "adding: mem time337, current time 363, horizon 26\n", - "adding: mem time338, current time 363, horizon 25\n", - "adding: mem time339, current time 363, horizon 24\n", - "adding: mem time340, current time 363, horizon 23\n", - "adding: mem time341, current time 363, horizon 22\n", - "adding: mem time342, current time 363, horizon 21\n", - "adding: mem time343, current time 363, horizon 20\n", - "adding: mem time344, current time 363, horizon 19\n", - "adding: mem time345, current time 363, horizon 18\n", - "adding: mem time346, current time 363, horizon 17\n", - "adding: mem time347, current time 363, horizon 16\n", - "adding: mem time348, current time 363, horizon 15\n", - "adding: mem time349, current time 363, horizon 14\n", - "adding: mem time350, current time 363, horizon 13\n", - "adding: mem time351, current time 363, horizon 12\n", - "adding: mem time352, current time 363, horizon 11\n", - "adding: mem time353, current time 363, horizon 10\n", - "adding: mem time354, current time 363, horizon 9\n", - "adding: mem time355, current time 363, horizon 8\n", - "adding: mem time356, current time 363, horizon 7\n", - "adding: mem time357, current time 363, horizon 6\n", - "adding: mem time358, current time 363, horizon 5\n", - "adding: mem time359, current time 363, horizon 4\n", - "adding: mem time360, current time 363, horizon 3\n", - "adding: mem time361, current time 363, horizon 2\n", - "adding: mem time362, current time 363, horizon 1\n", - "adding: mem time200, current time 364, horizon 164\n", - "adding: mem time201, current time 364, horizon 163\n", - "adding: mem time202, current time 364, horizon 162\n", - "adding: mem time203, current time 364, horizon 161\n", - "adding: mem time204, current time 364, horizon 160\n", - "adding: mem time205, current time 364, horizon 159\n", - "adding: mem time206, current time 364, horizon 158\n", - "adding: mem time207, current time 364, horizon 157\n", - "adding: mem time208, current time 364, horizon 156\n", - "adding: mem time209, current time 364, horizon 155\n", - "adding: mem time210, current time 364, horizon 154\n", - "adding: mem time211, current time 364, horizon 153\n", - "adding: mem time212, current time 364, horizon 152\n", - "adding: mem time213, current time 364, horizon 151\n", - "adding: mem time214, current time 364, horizon 150\n", - "adding: mem time215, current time 364, horizon 149\n", - "adding: mem time216, current time 364, horizon 148\n", - "adding: mem time217, current time 364, horizon 147\n", - "adding: mem time218, current time 364, horizon 146\n", - "adding: mem time219, current time 364, horizon 145\n", - "adding: mem time220, current time 364, horizon 144\n", - "adding: mem time221, current time 364, horizon 143\n", - "adding: mem time222, current time 364, horizon 142\n", - "adding: mem time223, current time 364, horizon 141\n", - "adding: mem time224, current time 364, horizon 140\n", - "adding: mem time225, current time 364, horizon 139\n", - "adding: mem time226, current time 364, horizon 138\n", - "adding: mem time227, current time 364, horizon 137\n", - "adding: mem time228, current time 364, horizon 136\n", - "adding: mem time229, current time 364, horizon 135\n", - "adding: mem time230, current time 364, horizon 134\n", - "adding: mem time231, current time 364, horizon 133\n", - "adding: mem time232, current time 364, horizon 132\n", - "adding: mem time233, current time 364, horizon 131\n", - "adding: mem time234, current time 364, horizon 130\n", - "adding: mem time235, current time 364, horizon 129\n", - "adding: mem time236, current time 364, horizon 128\n", - "adding: mem time237, current time 364, horizon 127\n", - "adding: mem time238, current time 364, horizon 126\n", - "adding: mem time239, current time 364, horizon 125\n", - "adding: mem time240, current time 364, horizon 124\n", - "adding: mem time241, current time 364, horizon 123\n", - "adding: mem time242, current time 364, horizon 122\n", - "adding: mem time243, current time 364, horizon 121\n", - "adding: mem time244, current time 364, horizon 120\n", - "adding: mem time245, current time 364, horizon 119\n", - "adding: mem time246, current time 364, horizon 118\n", - "adding: mem time247, current time 364, horizon 117\n", - "adding: mem time248, current time 364, horizon 116\n", - "adding: mem time249, current time 364, horizon 115\n", - "adding: mem time250, current time 364, horizon 114\n", - "adding: mem time251, current time 364, horizon 113\n", - "adding: mem time252, current time 364, horizon 112\n", - "adding: mem time253, current time 364, horizon 111\n", - "adding: mem time254, current time 364, horizon 110\n", - "adding: mem time255, current time 364, horizon 109\n", - "adding: mem time256, current time 364, horizon 108\n", - "adding: mem time257, current time 364, horizon 107\n", - "adding: mem time258, current time 364, horizon 106\n", - "adding: mem time259, current time 364, horizon 105\n", - "adding: mem time260, current time 364, horizon 104\n", - "adding: mem time261, current time 364, horizon 103\n", - "adding: mem time262, current time 364, horizon 102\n", - "adding: mem time263, current time 364, horizon 101\n", - "adding: mem time264, current time 364, horizon 100\n", - "adding: mem time265, current time 364, horizon 99\n", - "adding: mem time266, current time 364, horizon 98\n", - "adding: mem time267, current time 364, horizon 97\n", - "adding: mem time268, current time 364, horizon 96\n", - "adding: mem time269, current time 364, horizon 95\n", - "adding: mem time270, current time 364, horizon 94\n", - "adding: mem time271, current time 364, horizon 93\n", - "adding: mem time272, current time 364, horizon 92\n", - "adding: mem time273, current time 364, horizon 91\n", - "adding: mem time274, current time 364, horizon 90\n", - "adding: mem time275, current time 364, horizon 89\n", - "adding: mem time276, current time 364, horizon 88\n", - "adding: mem time277, current time 364, horizon 87\n", - "adding: mem time278, current time 364, horizon 86\n", - "adding: mem time279, current time 364, horizon 85\n", - "adding: mem time280, current time 364, horizon 84\n", - "adding: mem time281, current time 364, horizon 83\n", - "adding: mem time282, current time 364, horizon 82\n", - "adding: mem time283, current time 364, horizon 81\n", - "adding: mem time284, current time 364, horizon 80\n", - "adding: mem time285, current time 364, horizon 79\n", - "adding: mem time286, current time 364, horizon 78\n", - "adding: mem time287, current time 364, horizon 77\n", - "adding: mem time288, current time 364, horizon 76\n", - "adding: mem time289, current time 364, horizon 75\n", - "adding: mem time290, current time 364, horizon 74\n", - "adding: mem time291, current time 364, horizon 73\n", - "adding: mem time292, current time 364, horizon 72\n", - "adding: mem time293, current time 364, horizon 71\n", - "adding: mem time294, current time 364, horizon 70\n", - "adding: mem time295, current time 364, horizon 69\n", - "adding: mem time296, current time 364, horizon 68\n", - "adding: mem time297, current time 364, horizon 67\n", - "adding: mem time298, current time 364, horizon 66\n", - "adding: mem time299, current time 364, horizon 65\n", - "adding: mem time300, current time 364, horizon 64\n", - "adding: mem time301, current time 364, horizon 63\n", - "adding: mem time302, current time 364, horizon 62\n", - "adding: mem time303, current time 364, horizon 61\n", - "adding: mem time304, current time 364, horizon 60\n", - "adding: mem time305, current time 364, horizon 59\n", - "adding: mem time306, current time 364, horizon 58\n", - "adding: mem time307, current time 364, horizon 57\n", - "adding: mem time308, current time 364, horizon 56\n", - "adding: mem time309, current time 364, horizon 55\n", - "adding: mem time310, current time 364, horizon 54\n", - "adding: mem time311, current time 364, horizon 53\n", - "adding: mem time312, current time 364, horizon 52\n", - "adding: mem time313, current time 364, horizon 51\n", - "adding: mem time314, current time 364, horizon 50\n", - "adding: mem time315, current time 364, horizon 49\n", - "adding: mem time316, current time 364, horizon 48\n", - "adding: mem time317, current time 364, horizon 47\n", - "adding: mem time318, current time 364, horizon 46\n", - "adding: mem time319, current time 364, horizon 45\n", - "adding: mem time320, current time 364, horizon 44\n", - "adding: mem time321, current time 364, horizon 43\n", - "adding: mem time322, current time 364, horizon 42\n", - "adding: mem time323, current time 364, horizon 41\n", - "adding: mem time324, current time 364, horizon 40\n", - "adding: mem time325, current time 364, horizon 39\n", - "adding: mem time326, current time 364, horizon 38\n", - "adding: mem time327, current time 364, horizon 37\n", - "adding: mem time328, current time 364, horizon 36\n", - "adding: mem time329, current time 364, horizon 35\n", - "adding: mem time330, current time 364, horizon 34\n", - "adding: mem time331, current time 364, horizon 33\n", - "adding: mem time332, current time 364, horizon 32\n", - "adding: mem time333, current time 364, horizon 31\n", - "adding: mem time334, current time 364, horizon 30\n", - "adding: mem time335, current time 364, horizon 29\n", - "adding: mem time336, current time 364, horizon 28\n", - "adding: mem time337, current time 364, horizon 27\n", - "adding: mem time338, current time 364, horizon 26\n", - "adding: mem time339, current time 364, horizon 25\n", - "adding: mem time340, current time 364, horizon 24\n", - "adding: mem time341, current time 364, horizon 23\n", - "adding: mem time342, current time 364, horizon 22\n", - "adding: mem time343, current time 364, horizon 21\n", - "adding: mem time344, current time 364, horizon 20\n", - "adding: mem time345, current time 364, horizon 19\n", - "adding: mem time346, current time 364, horizon 18\n", - "adding: mem time347, current time 364, horizon 17\n", - "adding: mem time348, current time 364, horizon 16\n", - "adding: mem time349, current time 364, horizon 15\n", - "adding: mem time350, current time 364, horizon 14\n", - "adding: mem time351, current time 364, horizon 13\n", - "adding: mem time352, current time 364, horizon 12\n", - "adding: mem time353, current time 364, horizon 11\n", - "adding: mem time354, current time 364, horizon 10\n", - "adding: mem time355, current time 364, horizon 9\n", - "adding: mem time356, current time 364, horizon 8\n", - "adding: mem time357, current time 364, horizon 7\n", - "adding: mem time358, current time 364, horizon 6\n", - "adding: mem time359, current time 364, horizon 5\n", - "adding: mem time360, current time 364, horizon 4\n", - "adding: mem time361, current time 364, horizon 3\n", - "adding: mem time362, current time 364, horizon 2\n", - "adding: mem time363, current time 364, horizon 1\n", - "adding: mem time200, current time 365, horizon 165\n", - "adding: mem time201, current time 365, horizon 164\n", - "adding: mem time202, current time 365, horizon 163\n", - "adding: mem time203, current time 365, horizon 162\n", - "adding: mem time204, current time 365, horizon 161\n", - "adding: mem time205, current time 365, horizon 160\n", - "adding: mem time206, current time 365, horizon 159\n", - "adding: mem time207, current time 365, horizon 158\n", - "adding: mem time208, current time 365, horizon 157\n", - "adding: mem time209, current time 365, horizon 156\n", - "adding: mem time210, current time 365, horizon 155\n", - "adding: mem time211, current time 365, horizon 154\n", - "adding: mem time212, current time 365, horizon 153\n", - "adding: mem time213, current time 365, horizon 152\n", - "adding: mem time214, current time 365, horizon 151\n", - "adding: mem time215, current time 365, horizon 150\n", - "adding: mem time216, current time 365, horizon 149\n", - "adding: mem time217, current time 365, horizon 148\n", - "adding: mem time218, current time 365, horizon 147\n", - "adding: mem time219, current time 365, horizon 146\n", - "adding: mem time220, current time 365, horizon 145\n", - "adding: mem time221, current time 365, horizon 144\n", - "adding: mem time222, current time 365, horizon 143\n", - "adding: mem time223, current time 365, horizon 142\n", - "adding: mem time224, current time 365, horizon 141\n", - "adding: mem time225, current time 365, horizon 140\n", - "adding: mem time226, current time 365, horizon 139\n", - "adding: mem time227, current time 365, horizon 138\n", - "adding: mem time228, current time 365, horizon 137\n", - "adding: mem time229, current time 365, horizon 136\n", - "adding: mem time230, current time 365, horizon 135\n", - "adding: mem time231, current time 365, horizon 134\n", - "adding: mem time232, current time 365, horizon 133\n", - "adding: mem time233, current time 365, horizon 132\n", - "adding: mem time234, current time 365, horizon 131\n", - "adding: mem time235, current time 365, horizon 130\n", - "adding: mem time236, current time 365, horizon 129\n", - "adding: mem time237, current time 365, horizon 128\n", - "adding: mem time238, current time 365, horizon 127\n", - "adding: mem time239, current time 365, horizon 126\n", - "adding: mem time240, current time 365, horizon 125\n", - "adding: mem time241, current time 365, horizon 124\n", - "adding: mem time242, current time 365, horizon 123\n", - "adding: mem time243, current time 365, horizon 122\n", - "adding: mem time244, current time 365, horizon 121\n", - "adding: mem time245, current time 365, horizon 120\n", - "adding: mem time246, current time 365, horizon 119\n", - "adding: mem time247, current time 365, horizon 118\n", - "adding: mem time248, current time 365, horizon 117\n", - "adding: mem time249, current time 365, horizon 116\n", - "adding: mem time250, current time 365, horizon 115\n", - "adding: mem time251, current time 365, horizon 114\n", - "adding: mem time252, current time 365, horizon 113\n", - "adding: mem time253, current time 365, horizon 112\n", - "adding: mem time254, current time 365, horizon 111\n", - "adding: mem time255, current time 365, horizon 110\n", - "adding: mem time256, current time 365, horizon 109\n", - "adding: mem time257, current time 365, horizon 108\n", - "adding: mem time258, current time 365, horizon 107\n", - "adding: mem time259, current time 365, horizon 106\n", - "adding: mem time260, current time 365, horizon 105\n", - "adding: mem time261, current time 365, horizon 104\n", - "adding: mem time262, current time 365, horizon 103\n", - "adding: mem time263, current time 365, horizon 102\n", - "adding: mem time264, current time 365, horizon 101\n", - "adding: mem time265, current time 365, horizon 100\n", - "adding: mem time266, current time 365, horizon 99\n", - "adding: mem time267, current time 365, horizon 98\n", - "adding: mem time268, current time 365, horizon 97\n", - "adding: mem time269, current time 365, horizon 96\n", - "adding: mem time270, current time 365, horizon 95\n", - "adding: mem time271, current time 365, horizon 94\n", - "adding: mem time272, current time 365, horizon 93\n", - "adding: mem time273, current time 365, horizon 92\n", - "adding: mem time274, current time 365, horizon 91\n", - "adding: mem time275, current time 365, horizon 90\n", - "adding: mem time276, current time 365, horizon 89\n", - "adding: mem time277, current time 365, horizon 88\n", - "adding: mem time278, current time 365, horizon 87\n", - "adding: mem time279, current time 365, horizon 86\n", - "adding: mem time280, current time 365, horizon 85\n", - "adding: mem time281, current time 365, horizon 84\n", - "adding: mem time282, current time 365, horizon 83\n", - "adding: mem time283, current time 365, horizon 82\n", - "adding: mem time284, current time 365, horizon 81\n", - "adding: mem time285, current time 365, horizon 80\n", - "adding: mem time286, current time 365, horizon 79\n", - "adding: mem time287, current time 365, horizon 78\n", - "adding: mem time288, current time 365, horizon 77\n", - "adding: mem time289, current time 365, horizon 76\n", - "adding: mem time290, current time 365, horizon 75\n", - "adding: mem time291, current time 365, horizon 74\n", - "adding: mem time292, current time 365, horizon 73\n", - "adding: mem time293, current time 365, horizon 72\n", - "adding: mem time294, current time 365, horizon 71\n", - "adding: mem time295, current time 365, horizon 70\n", - "adding: mem time296, current time 365, horizon 69\n", - "adding: mem time297, current time 365, horizon 68\n", - "adding: mem time298, current time 365, horizon 67\n", - "adding: mem time299, current time 365, horizon 66\n", - "adding: mem time300, current time 365, horizon 65\n", - "adding: mem time301, current time 365, horizon 64\n", - "adding: mem time302, current time 365, horizon 63\n", - "adding: mem time303, current time 365, horizon 62\n", - "adding: mem time304, current time 365, horizon 61\n", - "adding: mem time305, current time 365, horizon 60\n", - "adding: mem time306, current time 365, horizon 59\n", - "adding: mem time307, current time 365, horizon 58\n", - "adding: mem time308, current time 365, horizon 57\n", - "adding: mem time309, current time 365, horizon 56\n", - "adding: mem time310, current time 365, horizon 55\n", - "adding: mem time311, current time 365, horizon 54\n", - "adding: mem time312, current time 365, horizon 53\n", - "adding: mem time313, current time 365, horizon 52\n", - "adding: mem time314, current time 365, horizon 51\n", - "adding: mem time315, current time 365, horizon 50\n", - "adding: mem time316, current time 365, horizon 49\n", - "adding: mem time317, current time 365, horizon 48\n", - "adding: mem time318, current time 365, horizon 47\n", - "adding: mem time319, current time 365, horizon 46\n", - "adding: mem time320, current time 365, horizon 45\n", - "adding: mem time321, current time 365, horizon 44\n", - "adding: mem time322, current time 365, horizon 43\n", - "adding: mem time323, current time 365, horizon 42\n", - "adding: mem time324, current time 365, horizon 41\n", - "adding: mem time325, current time 365, horizon 40\n", - "adding: mem time326, current time 365, horizon 39\n", - "adding: mem time327, current time 365, horizon 38\n", - "adding: mem time328, current time 365, horizon 37\n", - "adding: mem time329, current time 365, horizon 36\n", - "adding: mem time330, current time 365, horizon 35\n", - "adding: mem time331, current time 365, horizon 34\n", - "adding: mem time332, current time 365, horizon 33\n", - "adding: mem time333, current time 365, horizon 32\n", - "adding: mem time334, current time 365, horizon 31\n", - "adding: mem time335, current time 365, horizon 30\n", - "adding: mem time336, current time 365, horizon 29\n", - "adding: mem time337, current time 365, horizon 28\n", - "adding: mem time338, current time 365, horizon 27\n", - "adding: mem time339, current time 365, horizon 26\n", - "adding: mem time340, current time 365, horizon 25\n", - "adding: mem time341, current time 365, horizon 24\n", - "adding: mem time342, current time 365, horizon 23\n", - "adding: mem time343, current time 365, horizon 22\n", - "adding: mem time344, current time 365, horizon 21\n", - "adding: mem time345, current time 365, horizon 20\n", - "adding: mem time346, current time 365, horizon 19\n", - "adding: mem time347, current time 365, horizon 18\n", - "adding: mem time348, current time 365, horizon 17\n", - "adding: mem time349, current time 365, horizon 16\n", - "adding: mem time350, current time 365, horizon 15\n", - "adding: mem time351, current time 365, horizon 14\n", - "adding: mem time352, current time 365, horizon 13\n", - "adding: mem time353, current time 365, horizon 12\n", - "adding: mem time354, current time 365, horizon 11\n", - "adding: mem time355, current time 365, horizon 10\n", - "adding: mem time356, current time 365, horizon 9\n", - "adding: mem time357, current time 365, horizon 8\n", - "adding: mem time358, current time 365, horizon 7\n", - "adding: mem time359, current time 365, horizon 6\n", - "adding: mem time360, current time 365, horizon 5\n", - "adding: mem time361, current time 365, horizon 4\n", - "adding: mem time362, current time 365, horizon 3\n", - "adding: mem time363, current time 365, horizon 2\n", - "adding: mem time364, current time 365, horizon 1\n", - "adding: mem time200, current time 366, horizon 166\n", - "adding: mem time201, current time 366, horizon 165\n", - "adding: mem time202, current time 366, horizon 164\n", - "adding: mem time203, current time 366, horizon 163\n", - "adding: mem time204, current time 366, horizon 162\n", - "adding: mem time205, current time 366, horizon 161\n", - "adding: mem time206, current time 366, horizon 160\n", - "adding: mem time207, current time 366, horizon 159\n", - "adding: mem time208, current time 366, horizon 158\n", - "adding: mem time209, current time 366, horizon 157\n", - "adding: mem time210, current time 366, horizon 156\n", - "adding: mem time211, current time 366, horizon 155\n", - "adding: mem time212, current time 366, horizon 154\n", - "adding: mem time213, current time 366, horizon 153\n", - "adding: mem time214, current time 366, horizon 152\n", - "adding: mem time215, current time 366, horizon 151\n", - "adding: mem time216, current time 366, horizon 150\n", - "adding: mem time217, current time 366, horizon 149\n", - "adding: mem time218, current time 366, horizon 148\n", - "adding: mem time219, current time 366, horizon 147\n", - "adding: mem time220, current time 366, horizon 146\n", - "adding: mem time221, current time 366, horizon 145\n", - "adding: mem time222, current time 366, horizon 144\n", - "adding: mem time223, current time 366, horizon 143\n", - "adding: mem time224, current time 366, horizon 142\n", - "adding: mem time225, current time 366, horizon 141\n", - "adding: mem time226, current time 366, horizon 140\n", - "adding: mem time227, current time 366, horizon 139\n", - "adding: mem time228, current time 366, horizon 138\n", - "adding: mem time229, current time 366, horizon 137\n", - "adding: mem time230, current time 366, horizon 136\n", - "adding: mem time231, current time 366, horizon 135\n", - "adding: mem time232, current time 366, horizon 134\n", - "adding: mem time233, current time 366, horizon 133\n", - "adding: mem time234, current time 366, horizon 132\n", - "adding: mem time235, current time 366, horizon 131\n", - "adding: mem time236, current time 366, horizon 130\n", - "adding: mem time237, current time 366, horizon 129\n", - "adding: mem time238, current time 366, horizon 128\n", - "adding: mem time239, current time 366, horizon 127\n", - "adding: mem time240, current time 366, horizon 126\n", - "adding: mem time241, current time 366, horizon 125\n", - "adding: mem time242, current time 366, horizon 124\n", - "adding: mem time243, current time 366, horizon 123\n", - "adding: mem time244, current time 366, horizon 122\n", - "adding: mem time245, current time 366, horizon 121\n", - "adding: mem time246, current time 366, horizon 120\n", - "adding: mem time247, current time 366, horizon 119\n", - "adding: mem time248, current time 366, horizon 118\n", - "adding: mem time249, current time 366, horizon 117\n", - "adding: mem time250, current time 366, horizon 116\n", - "adding: mem time251, current time 366, horizon 115\n", - "adding: mem time252, current time 366, horizon 114\n", - "adding: mem time253, current time 366, horizon 113\n", - "adding: mem time254, current time 366, horizon 112\n", - "adding: mem time255, current time 366, horizon 111\n", - "adding: mem time256, current time 366, horizon 110\n", - "adding: mem time257, current time 366, horizon 109\n", - "adding: mem time258, current time 366, horizon 108\n", - "adding: mem time259, current time 366, horizon 107\n", - "adding: mem time260, current time 366, horizon 106\n", - "adding: mem time261, current time 366, horizon 105\n", - "adding: mem time262, current time 366, horizon 104\n", - "adding: mem time263, current time 366, horizon 103\n", - "adding: mem time264, current time 366, horizon 102\n", - "adding: mem time265, current time 366, horizon 101\n", - "adding: mem time266, current time 366, horizon 100\n", - "adding: mem time267, current time 366, horizon 99\n", - "adding: mem time268, current time 366, horizon 98\n", - "adding: mem time269, current time 366, horizon 97\n", - "adding: mem time270, current time 366, horizon 96\n", - "adding: mem time271, current time 366, horizon 95\n", - "adding: mem time272, current time 366, horizon 94\n", - "adding: mem time273, current time 366, horizon 93\n", - "adding: mem time274, current time 366, horizon 92\n", - "adding: mem time275, current time 366, horizon 91\n", - "adding: mem time276, current time 366, horizon 90\n", - "adding: mem time277, current time 366, horizon 89\n", - "adding: mem time278, current time 366, horizon 88\n", - "adding: mem time279, current time 366, horizon 87\n", - "adding: mem time280, current time 366, horizon 86\n", - "adding: mem time281, current time 366, horizon 85\n", - "adding: mem time282, current time 366, horizon 84\n", - "adding: mem time283, current time 366, horizon 83\n", - "adding: mem time284, current time 366, horizon 82\n", - "adding: mem time285, current time 366, horizon 81\n", - "adding: mem time286, current time 366, horizon 80\n", - "adding: mem time287, current time 366, horizon 79\n", - "adding: mem time288, current time 366, horizon 78\n", - "adding: mem time289, current time 366, horizon 77\n", - "adding: mem time290, current time 366, horizon 76\n", - "adding: mem time291, current time 366, horizon 75\n", - "adding: mem time292, current time 366, horizon 74\n", - "adding: mem time293, current time 366, horizon 73\n", - "adding: mem time294, current time 366, horizon 72\n", - "adding: mem time295, current time 366, horizon 71\n", - "adding: mem time296, current time 366, horizon 70\n", - "adding: mem time297, current time 366, horizon 69\n", - "adding: mem time298, current time 366, horizon 68\n", - "adding: mem time299, current time 366, horizon 67\n", - "adding: mem time300, current time 366, horizon 66\n", - "adding: mem time301, current time 366, horizon 65\n", - "adding: mem time302, current time 366, horizon 64\n", - "adding: mem time303, current time 366, horizon 63\n", - "adding: mem time304, current time 366, horizon 62\n", - "adding: mem time305, current time 366, horizon 61\n", - "adding: mem time306, current time 366, horizon 60\n", - "adding: mem time307, current time 366, horizon 59\n", - "adding: mem time308, current time 366, horizon 58\n", - "adding: mem time309, current time 366, horizon 57\n", - "adding: mem time310, current time 366, horizon 56\n", - "adding: mem time311, current time 366, horizon 55\n", - "adding: mem time312, current time 366, horizon 54\n", - "adding: mem time313, current time 366, horizon 53\n", - "adding: mem time314, current time 366, horizon 52\n", - "adding: mem time315, current time 366, horizon 51\n", - "adding: mem time316, current time 366, horizon 50\n", - "adding: mem time317, current time 366, horizon 49\n", - "adding: mem time318, current time 366, horizon 48\n", - "adding: mem time319, current time 366, horizon 47\n", - "adding: mem time320, current time 366, horizon 46\n", - "adding: mem time321, current time 366, horizon 45\n", - "adding: mem time322, current time 366, horizon 44\n", - "adding: mem time323, current time 366, horizon 43\n", - "adding: mem time324, current time 366, horizon 42\n", - "adding: mem time325, current time 366, horizon 41\n", - "adding: mem time326, current time 366, horizon 40\n", - "adding: mem time327, current time 366, horizon 39\n", - "adding: mem time328, current time 366, horizon 38\n", - "adding: mem time329, current time 366, horizon 37\n", - "adding: mem time330, current time 366, horizon 36\n", - "adding: mem time331, current time 366, horizon 35\n", - "adding: mem time332, current time 366, horizon 34\n", - "adding: mem time333, current time 366, horizon 33\n", - "adding: mem time334, current time 366, horizon 32\n", - "adding: mem time335, current time 366, horizon 31\n", - "adding: mem time336, current time 366, horizon 30\n", - "adding: mem time337, current time 366, horizon 29\n", - "adding: mem time338, current time 366, horizon 28\n", - "adding: mem time339, current time 366, horizon 27\n", - "adding: mem time340, current time 366, horizon 26\n", - "adding: mem time341, current time 366, horizon 25\n", - "adding: mem time342, current time 366, horizon 24\n", - "adding: mem time343, current time 366, horizon 23\n", - "adding: mem time344, current time 366, horizon 22\n", - "adding: mem time345, current time 366, horizon 21\n", - "adding: mem time346, current time 366, horizon 20\n", - "adding: mem time347, current time 366, horizon 19\n", - "adding: mem time348, current time 366, horizon 18\n", - "adding: mem time349, current time 366, horizon 17\n", - "adding: mem time350, current time 366, horizon 16\n", - "adding: mem time351, current time 366, horizon 15\n", - "adding: mem time352, current time 366, horizon 14\n", - "adding: mem time353, current time 366, horizon 13\n", - "adding: mem time354, current time 366, horizon 12\n", - "adding: mem time355, current time 366, horizon 11\n", - "adding: mem time356, current time 366, horizon 10\n", - "adding: mem time357, current time 366, horizon 9\n", - "adding: mem time358, current time 366, horizon 8\n", - "adding: mem time359, current time 366, horizon 7\n", - "adding: mem time360, current time 366, horizon 6\n", - "adding: mem time361, current time 366, horizon 5\n", - "adding: mem time362, current time 366, horizon 4\n", - "adding: mem time363, current time 366, horizon 3\n", - "adding: mem time364, current time 366, horizon 2\n", - "adding: mem time365, current time 366, horizon 1\n", - "adding: mem time200, current time 367, horizon 167\n", - "adding: mem time201, current time 367, horizon 166\n", - "adding: mem time202, current time 367, horizon 165\n", - "adding: mem time203, current time 367, horizon 164\n", - "adding: mem time204, current time 367, horizon 163\n", - "adding: mem time205, current time 367, horizon 162\n", - "adding: mem time206, current time 367, horizon 161\n", - "adding: mem time207, current time 367, horizon 160\n", - "adding: mem time208, current time 367, horizon 159\n", - "adding: mem time209, current time 367, horizon 158\n", - "adding: mem time210, current time 367, horizon 157\n", - "adding: mem time211, current time 367, horizon 156\n", - "adding: mem time212, current time 367, horizon 155\n", - "adding: mem time213, current time 367, horizon 154\n", - "adding: mem time214, current time 367, horizon 153\n", - "adding: mem time215, current time 367, horizon 152\n", - "adding: mem time216, current time 367, horizon 151\n", - "adding: mem time217, current time 367, horizon 150\n", - "adding: mem time218, current time 367, horizon 149\n", - "adding: mem time219, current time 367, horizon 148\n", - "adding: mem time220, current time 367, horizon 147\n", - "adding: mem time221, current time 367, horizon 146\n", - "adding: mem time222, current time 367, horizon 145\n", - "adding: mem time223, current time 367, horizon 144\n", - "adding: mem time224, current time 367, horizon 143\n", - "adding: mem time225, current time 367, horizon 142\n", - "adding: mem time226, current time 367, horizon 141\n", - "adding: mem time227, current time 367, horizon 140\n", - "adding: mem time228, current time 367, horizon 139\n", - "adding: mem time229, current time 367, horizon 138\n", - "adding: mem time230, current time 367, horizon 137\n", - "adding: mem time231, current time 367, horizon 136\n", - "adding: mem time232, current time 367, horizon 135\n", - "adding: mem time233, current time 367, horizon 134\n", - "adding: mem time234, current time 367, horizon 133\n", - "adding: mem time235, current time 367, horizon 132\n", - "adding: mem time236, current time 367, horizon 131\n", - "adding: mem time237, current time 367, horizon 130\n", - "adding: mem time238, current time 367, horizon 129\n", - "adding: mem time239, current time 367, horizon 128\n", - "adding: mem time240, current time 367, horizon 127\n", - "adding: mem time241, current time 367, horizon 126\n", - "adding: mem time242, current time 367, horizon 125\n", - "adding: mem time243, current time 367, horizon 124\n", - "adding: mem time244, current time 367, horizon 123\n", - "adding: mem time245, current time 367, horizon 122\n", - "adding: mem time246, current time 367, horizon 121\n", - "adding: mem time247, current time 367, horizon 120\n", - "adding: mem time248, current time 367, horizon 119\n", - "adding: mem time249, current time 367, horizon 118\n", - "adding: mem time250, current time 367, horizon 117\n", - "adding: mem time251, current time 367, horizon 116\n", - "adding: mem time252, current time 367, horizon 115\n", - "adding: mem time253, current time 367, horizon 114\n", - "adding: mem time254, current time 367, horizon 113\n", - "adding: mem time255, current time 367, horizon 112\n", - "adding: mem time256, current time 367, horizon 111\n", - "adding: mem time257, current time 367, horizon 110\n", - "adding: mem time258, current time 367, horizon 109\n", - "adding: mem time259, current time 367, horizon 108\n", - "adding: mem time260, current time 367, horizon 107\n", - "adding: mem time261, current time 367, horizon 106\n", - "adding: mem time262, current time 367, horizon 105\n", - "adding: mem time263, current time 367, horizon 104\n", - "adding: mem time264, current time 367, horizon 103\n", - "adding: mem time265, current time 367, horizon 102\n", - "adding: mem time266, current time 367, horizon 101\n", - "adding: mem time267, current time 367, horizon 100\n", - "adding: mem time268, current time 367, horizon 99\n", - "adding: mem time269, current time 367, horizon 98\n", - "adding: mem time270, current time 367, horizon 97\n", - "adding: mem time271, current time 367, horizon 96\n", - "adding: mem time272, current time 367, horizon 95\n", - "adding: mem time273, current time 367, horizon 94\n", - "adding: mem time274, current time 367, horizon 93\n", - "adding: mem time275, current time 367, horizon 92\n", - "adding: mem time276, current time 367, horizon 91\n", - "adding: mem time277, current time 367, horizon 90\n", - "adding: mem time278, current time 367, horizon 89\n", - "adding: mem time279, current time 367, horizon 88\n", - "adding: mem time280, current time 367, horizon 87\n", - "adding: mem time281, current time 367, horizon 86\n", - "adding: mem time282, current time 367, horizon 85\n", - "adding: mem time283, current time 367, horizon 84\n", - "adding: mem time284, current time 367, horizon 83\n", - "adding: mem time285, current time 367, horizon 82\n", - "adding: mem time286, current time 367, horizon 81\n", - "adding: mem time287, current time 367, horizon 80\n", - "adding: mem time288, current time 367, horizon 79\n", - "adding: mem time289, current time 367, horizon 78\n", - "adding: mem time290, current time 367, horizon 77\n", - "adding: mem time291, current time 367, horizon 76\n", - "adding: mem time292, current time 367, horizon 75\n", - "adding: mem time293, current time 367, horizon 74\n", - "adding: mem time294, current time 367, horizon 73\n", - "adding: mem time295, current time 367, horizon 72\n", - "adding: mem time296, current time 367, horizon 71\n", - "adding: mem time297, current time 367, horizon 70\n", - "adding: mem time298, current time 367, horizon 69\n", - "adding: mem time299, current time 367, horizon 68\n", - "adding: mem time300, current time 367, horizon 67\n", - "adding: mem time301, current time 367, horizon 66\n", - "adding: mem time302, current time 367, horizon 65\n", - "adding: mem time303, current time 367, horizon 64\n", - "adding: mem time304, current time 367, horizon 63\n", - "adding: mem time305, current time 367, horizon 62\n", - "adding: mem time306, current time 367, horizon 61\n", - "adding: mem time307, current time 367, horizon 60\n", - "adding: mem time308, current time 367, horizon 59\n", - "adding: mem time309, current time 367, horizon 58\n", - "adding: mem time310, current time 367, horizon 57\n", - "adding: mem time311, current time 367, horizon 56\n", - "adding: mem time312, current time 367, horizon 55\n", - "adding: mem time313, current time 367, horizon 54\n", - "adding: mem time314, current time 367, horizon 53\n", - "adding: mem time315, current time 367, horizon 52\n", - "adding: mem time316, current time 367, horizon 51\n", - "adding: mem time317, current time 367, horizon 50\n", - "adding: mem time318, current time 367, horizon 49\n", - "adding: mem time319, current time 367, horizon 48\n", - "adding: mem time320, current time 367, horizon 47\n", - "adding: mem time321, current time 367, horizon 46\n", - "adding: mem time322, current time 367, horizon 45\n", - "adding: mem time323, current time 367, horizon 44\n", - "adding: mem time324, current time 367, horizon 43\n", - "adding: mem time325, current time 367, horizon 42\n", - "adding: mem time326, current time 367, horizon 41\n", - "adding: mem time327, current time 367, horizon 40\n", - "adding: mem time328, current time 367, horizon 39\n", - "adding: mem time329, current time 367, horizon 38\n", - "adding: mem time330, current time 367, horizon 37\n", - "adding: mem time331, current time 367, horizon 36\n", - "adding: mem time332, current time 367, horizon 35\n", - "adding: mem time333, current time 367, horizon 34\n", - "adding: mem time334, current time 367, horizon 33\n", - "adding: mem time335, current time 367, horizon 32\n", - "adding: mem time336, current time 367, horizon 31\n", - "adding: mem time337, current time 367, horizon 30\n", - "adding: mem time338, current time 367, horizon 29\n", - "adding: mem time339, current time 367, horizon 28\n", - "adding: mem time340, current time 367, horizon 27\n", - "adding: mem time341, current time 367, horizon 26\n", - "adding: mem time342, current time 367, horizon 25\n", - "adding: mem time343, current time 367, horizon 24\n", - "adding: mem time344, current time 367, horizon 23\n", - "adding: mem time345, current time 367, horizon 22\n", - "adding: mem time346, current time 367, horizon 21\n", - "adding: mem time347, current time 367, horizon 20\n", - "adding: mem time348, current time 367, horizon 19\n", - "adding: mem time349, current time 367, horizon 18\n", - "adding: mem time350, current time 367, horizon 17\n", - "adding: mem time351, current time 367, horizon 16\n", - "adding: mem time352, current time 367, horizon 15\n", - "adding: mem time353, current time 367, horizon 14\n", - "adding: mem time354, current time 367, horizon 13\n", - "adding: mem time355, current time 367, horizon 12\n", - "adding: mem time356, current time 367, horizon 11\n", - "adding: mem time357, current time 367, horizon 10\n", - "adding: mem time358, current time 367, horizon 9\n", - "adding: mem time359, current time 367, horizon 8\n", - "adding: mem time360, current time 367, horizon 7\n", - "adding: mem time361, current time 367, horizon 6\n", - "adding: mem time362, current time 367, horizon 5\n", - "adding: mem time363, current time 367, horizon 4\n", - "adding: mem time364, current time 367, horizon 3\n", - "adding: mem time365, current time 367, horizon 2\n", - "adding: mem time366, current time 367, horizon 1\n", - "adding: mem time200, current time 368, horizon 168\n", - "adding: mem time201, current time 368, horizon 167\n", - "adding: mem time202, current time 368, horizon 166\n", - "adding: mem time203, current time 368, horizon 165\n", - "adding: mem time204, current time 368, horizon 164\n", - "adding: mem time205, current time 368, horizon 163\n", - "adding: mem time206, current time 368, horizon 162\n", - "adding: mem time207, current time 368, horizon 161\n", - "adding: mem time208, current time 368, horizon 160\n", - "adding: mem time209, current time 368, horizon 159\n", - "adding: mem time210, current time 368, horizon 158\n", - "adding: mem time211, current time 368, horizon 157\n", - "adding: mem time212, current time 368, horizon 156\n", - "adding: mem time213, current time 368, horizon 155\n", - "adding: mem time214, current time 368, horizon 154\n", - "adding: mem time215, current time 368, horizon 153\n", - "adding: mem time216, current time 368, horizon 152\n", - "adding: mem time217, current time 368, horizon 151\n", - "adding: mem time218, current time 368, horizon 150\n", - "adding: mem time219, current time 368, horizon 149\n", - "adding: mem time220, current time 368, horizon 148\n", - "adding: mem time221, current time 368, horizon 147\n", - "adding: mem time222, current time 368, horizon 146\n", - "adding: mem time223, current time 368, horizon 145\n", - "adding: mem time224, current time 368, horizon 144\n", - "adding: mem time225, current time 368, horizon 143\n", - "adding: mem time226, current time 368, horizon 142\n", - "adding: mem time227, current time 368, horizon 141\n", - "adding: mem time228, current time 368, horizon 140\n", - "adding: mem time229, current time 368, horizon 139\n", - "adding: mem time230, current time 368, horizon 138\n", - "adding: mem time231, current time 368, horizon 137\n", - "adding: mem time232, current time 368, horizon 136\n", - "adding: mem time233, current time 368, horizon 135\n", - "adding: mem time234, current time 368, horizon 134\n", - "adding: mem time235, current time 368, horizon 133\n", - "adding: mem time236, current time 368, horizon 132\n", - "adding: mem time237, current time 368, horizon 131\n", - "adding: mem time238, current time 368, horizon 130\n", - "adding: mem time239, current time 368, horizon 129\n", - "adding: mem time240, current time 368, horizon 128\n", - "adding: mem time241, current time 368, horizon 127\n", - "adding: mem time242, current time 368, horizon 126\n", - "adding: mem time243, current time 368, horizon 125\n", - "adding: mem time244, current time 368, horizon 124\n", - "adding: mem time245, current time 368, horizon 123\n", - "adding: mem time246, current time 368, horizon 122\n", - "adding: mem time247, current time 368, horizon 121\n", - "adding: mem time248, current time 368, horizon 120\n", - "adding: mem time249, current time 368, horizon 119\n", - "adding: mem time250, current time 368, horizon 118\n", - "adding: mem time251, current time 368, horizon 117\n", - "adding: mem time252, current time 368, horizon 116\n", - "adding: mem time253, current time 368, horizon 115\n", - "adding: mem time254, current time 368, horizon 114\n", - "adding: mem time255, current time 368, horizon 113\n", - "adding: mem time256, current time 368, horizon 112\n", - "adding: mem time257, current time 368, horizon 111\n", - "adding: mem time258, current time 368, horizon 110\n", - "adding: mem time259, current time 368, horizon 109\n", - "adding: mem time260, current time 368, horizon 108\n", - "adding: mem time261, current time 368, horizon 107\n", - "adding: mem time262, current time 368, horizon 106\n", - "adding: mem time263, current time 368, horizon 105\n", - "adding: mem time264, current time 368, horizon 104\n", - "adding: mem time265, current time 368, horizon 103\n", - "adding: mem time266, current time 368, horizon 102\n", - "adding: mem time267, current time 368, horizon 101\n", - "adding: mem time268, current time 368, horizon 100\n", - "adding: mem time269, current time 368, horizon 99\n", - "adding: mem time270, current time 368, horizon 98\n", - "adding: mem time271, current time 368, horizon 97\n", - "adding: mem time272, current time 368, horizon 96\n", - "adding: mem time273, current time 368, horizon 95\n", - "adding: mem time274, current time 368, horizon 94\n", - "adding: mem time275, current time 368, horizon 93\n", - "adding: mem time276, current time 368, horizon 92\n", - "adding: mem time277, current time 368, horizon 91\n", - "adding: mem time278, current time 368, horizon 90\n", - "adding: mem time279, current time 368, horizon 89\n", - "adding: mem time280, current time 368, horizon 88\n", - "adding: mem time281, current time 368, horizon 87\n", - "adding: mem time282, current time 368, horizon 86\n", - "adding: mem time283, current time 368, horizon 85\n", - "adding: mem time284, current time 368, horizon 84\n", - "adding: mem time285, current time 368, horizon 83\n", - "adding: mem time286, current time 368, horizon 82\n", - "adding: mem time287, current time 368, horizon 81\n", - "adding: mem time288, current time 368, horizon 80\n", - "adding: mem time289, current time 368, horizon 79\n", - "adding: mem time290, current time 368, horizon 78\n", - "adding: mem time291, current time 368, horizon 77\n", - "adding: mem time292, current time 368, horizon 76\n", - "adding: mem time293, current time 368, horizon 75\n", - "adding: mem time294, current time 368, horizon 74\n", - "adding: mem time295, current time 368, horizon 73\n", - "adding: mem time296, current time 368, horizon 72\n", - "adding: mem time297, current time 368, horizon 71\n", - "adding: mem time298, current time 368, horizon 70\n", - "adding: mem time299, current time 368, horizon 69\n", - "adding: mem time300, current time 368, horizon 68\n", - "adding: mem time301, current time 368, horizon 67\n", - "adding: mem time302, current time 368, horizon 66\n", - "adding: mem time303, current time 368, horizon 65\n", - "adding: mem time304, current time 368, horizon 64\n", - "adding: mem time305, current time 368, horizon 63\n", - "adding: mem time306, current time 368, horizon 62\n", - "adding: mem time307, current time 368, horizon 61\n", - "adding: mem time308, current time 368, horizon 60\n", - "adding: mem time309, current time 368, horizon 59\n", - "adding: mem time310, current time 368, horizon 58\n", - "adding: mem time311, current time 368, horizon 57\n", - "adding: mem time312, current time 368, horizon 56\n", - "adding: mem time313, current time 368, horizon 55\n", - "adding: mem time314, current time 368, horizon 54\n", - "adding: mem time315, current time 368, horizon 53\n", - "adding: mem time316, current time 368, horizon 52\n", - "adding: mem time317, current time 368, horizon 51\n", - "adding: mem time318, current time 368, horizon 50\n", - "adding: mem time319, current time 368, horizon 49\n", - "adding: mem time320, current time 368, horizon 48\n", - "adding: mem time321, current time 368, horizon 47\n", - "adding: mem time322, current time 368, horizon 46\n", - "adding: mem time323, current time 368, horizon 45\n", - "adding: mem time324, current time 368, horizon 44\n", - "adding: mem time325, current time 368, horizon 43\n", - "adding: mem time326, current time 368, horizon 42\n", - "adding: mem time327, current time 368, horizon 41\n", - "adding: mem time328, current time 368, horizon 40\n", - "adding: mem time329, current time 368, horizon 39\n", - "adding: mem time330, current time 368, horizon 38\n", - "adding: mem time331, current time 368, horizon 37\n", - "adding: mem time332, current time 368, horizon 36\n", - "adding: mem time333, current time 368, horizon 35\n", - "adding: mem time334, current time 368, horizon 34\n", - "adding: mem time335, current time 368, horizon 33\n", - "adding: mem time336, current time 368, horizon 32\n", - "adding: mem time337, current time 368, horizon 31\n", - "adding: mem time338, current time 368, horizon 30\n", - "adding: mem time339, current time 368, horizon 29\n", - "adding: mem time340, current time 368, horizon 28\n", - "adding: mem time341, current time 368, horizon 27\n", - "adding: mem time342, current time 368, horizon 26\n", - "adding: mem time343, current time 368, horizon 25\n", - "adding: mem time344, current time 368, horizon 24\n", - "adding: mem time345, current time 368, horizon 23\n", - "adding: mem time346, current time 368, horizon 22\n", - "adding: mem time347, current time 368, horizon 21\n", - "adding: mem time348, current time 368, horizon 20\n", - "adding: mem time349, current time 368, horizon 19\n", - "adding: mem time350, current time 368, horizon 18\n", - "adding: mem time351, current time 368, horizon 17\n", - "adding: mem time352, current time 368, horizon 16\n", - "adding: mem time353, current time 368, horizon 15\n", - "adding: mem time354, current time 368, horizon 14\n", - "adding: mem time355, current time 368, horizon 13\n", - "adding: mem time356, current time 368, horizon 12\n", - "adding: mem time357, current time 368, horizon 11\n", - "adding: mem time358, current time 368, horizon 10\n", - "adding: mem time359, current time 368, horizon 9\n", - "adding: mem time360, current time 368, horizon 8\n", - "adding: mem time361, current time 368, horizon 7\n", - "adding: mem time362, current time 368, horizon 6\n", - "adding: mem time363, current time 368, horizon 5\n", - "adding: mem time364, current time 368, horizon 4\n", - "adding: mem time365, current time 368, horizon 3\n", - "adding: mem time366, current time 368, horizon 2\n", - "adding: mem time367, current time 368, horizon 1\n", - "adding: mem time200, current time 369, horizon 169\n", - "adding: mem time201, current time 369, horizon 168\n", - "adding: mem time202, current time 369, horizon 167\n", - "adding: mem time203, current time 369, horizon 166\n", - "adding: mem time204, current time 369, horizon 165\n", - "adding: mem time205, current time 369, horizon 164\n", - "adding: mem time206, current time 369, horizon 163\n", - "adding: mem time207, current time 369, horizon 162\n", - "adding: mem time208, current time 369, horizon 161\n", - "adding: mem time209, current time 369, horizon 160\n", - "adding: mem time210, current time 369, horizon 159\n", - "adding: mem time211, current time 369, horizon 158\n", - "adding: mem time212, current time 369, horizon 157\n", - "adding: mem time213, current time 369, horizon 156\n", - "adding: mem time214, current time 369, horizon 155\n", - "adding: mem time215, current time 369, horizon 154\n", - "adding: mem time216, current time 369, horizon 153\n", - "adding: mem time217, current time 369, horizon 152\n", - "adding: mem time218, current time 369, horizon 151\n", - "adding: mem time219, current time 369, horizon 150\n", - "adding: mem time220, current time 369, horizon 149\n", - "adding: mem time221, current time 369, horizon 148\n", - "adding: mem time222, current time 369, horizon 147\n", - "adding: mem time223, current time 369, horizon 146\n", - "adding: mem time224, current time 369, horizon 145\n", - "adding: mem time225, current time 369, horizon 144\n", - "adding: mem time226, current time 369, horizon 143\n", - "adding: mem time227, current time 369, horizon 142\n", - "adding: mem time228, current time 369, horizon 141\n", - "adding: mem time229, current time 369, horizon 140\n", - "adding: mem time230, current time 369, horizon 139\n", - "adding: mem time231, current time 369, horizon 138\n", - "adding: mem time232, current time 369, horizon 137\n", - "adding: mem time233, current time 369, horizon 136\n", - "adding: mem time234, current time 369, horizon 135\n", - "adding: mem time235, current time 369, horizon 134\n", - "adding: mem time236, current time 369, horizon 133\n", - "adding: mem time237, current time 369, horizon 132\n", - "adding: mem time238, current time 369, horizon 131\n", - "adding: mem time239, current time 369, horizon 130\n", - "adding: mem time240, current time 369, horizon 129\n", - "adding: mem time241, current time 369, horizon 128\n", - "adding: mem time242, current time 369, horizon 127\n", - "adding: mem time243, current time 369, horizon 126\n", - "adding: mem time244, current time 369, horizon 125\n", - "adding: mem time245, current time 369, horizon 124\n", - "adding: mem time246, current time 369, horizon 123\n", - "adding: mem time247, current time 369, horizon 122\n", - "adding: mem time248, current time 369, horizon 121\n", - "adding: mem time249, current time 369, horizon 120\n", - "adding: mem time250, current time 369, horizon 119\n", - "adding: mem time251, current time 369, horizon 118\n", - "adding: mem time252, current time 369, horizon 117\n", - "adding: mem time253, current time 369, horizon 116\n", - "adding: mem time254, current time 369, horizon 115\n", - "adding: mem time255, current time 369, horizon 114\n", - "adding: mem time256, current time 369, horizon 113\n", - "adding: mem time257, current time 369, horizon 112\n", - "adding: mem time258, current time 369, horizon 111\n", - "adding: mem time259, current time 369, horizon 110\n", - "adding: mem time260, current time 369, horizon 109\n", - "adding: mem time261, current time 369, horizon 108\n", - "adding: mem time262, current time 369, horizon 107\n", - "adding: mem time263, current time 369, horizon 106\n", - "adding: mem time264, current time 369, horizon 105\n", - "adding: mem time265, current time 369, horizon 104\n", - "adding: mem time266, current time 369, horizon 103\n", - "adding: mem time267, current time 369, horizon 102\n", - "adding: mem time268, current time 369, horizon 101\n", - "adding: mem time269, current time 369, horizon 100\n", - "adding: mem time270, current time 369, horizon 99\n", - "adding: mem time271, current time 369, horizon 98\n", - "adding: mem time272, current time 369, horizon 97\n", - "adding: mem time273, current time 369, horizon 96\n", - "adding: mem time274, current time 369, horizon 95\n", - "adding: mem time275, current time 369, horizon 94\n", - "adding: mem time276, current time 369, horizon 93\n", - "adding: mem time277, current time 369, horizon 92\n", - "adding: mem time278, current time 369, horizon 91\n", - "adding: mem time279, current time 369, horizon 90\n", - "adding: mem time280, current time 369, horizon 89\n", - "adding: mem time281, current time 369, horizon 88\n", - "adding: mem time282, current time 369, horizon 87\n", - "adding: mem time283, current time 369, horizon 86\n", - "adding: mem time284, current time 369, horizon 85\n", - "adding: mem time285, current time 369, horizon 84\n", - "adding: mem time286, current time 369, horizon 83\n", - "adding: mem time287, current time 369, horizon 82\n", - "adding: mem time288, current time 369, horizon 81\n", - "adding: mem time289, current time 369, horizon 80\n", - "adding: mem time290, current time 369, horizon 79\n", - "adding: mem time291, current time 369, horizon 78\n", - "adding: mem time292, current time 369, horizon 77\n", - "adding: mem time293, current time 369, horizon 76\n", - "adding: mem time294, current time 369, horizon 75\n", - "adding: mem time295, current time 369, horizon 74\n", - "adding: mem time296, current time 369, horizon 73\n", - "adding: mem time297, current time 369, horizon 72\n", - "adding: mem time298, current time 369, horizon 71\n", - "adding: mem time299, current time 369, horizon 70\n", - "adding: mem time300, current time 369, horizon 69\n", - "adding: mem time301, current time 369, horizon 68\n", - "adding: mem time302, current time 369, horizon 67\n", - "adding: mem time303, current time 369, horizon 66\n", - "adding: mem time304, current time 369, horizon 65\n", - "adding: mem time305, current time 369, horizon 64\n", - "adding: mem time306, current time 369, horizon 63\n", - "adding: mem time307, current time 369, horizon 62\n", - "adding: mem time308, current time 369, horizon 61\n", - "adding: mem time309, current time 369, horizon 60\n", - "adding: mem time310, current time 369, horizon 59\n", - "adding: mem time311, current time 369, horizon 58\n", - "adding: mem time312, current time 369, horizon 57\n", - "adding: mem time313, current time 369, horizon 56\n", - "adding: mem time314, current time 369, horizon 55\n", - "adding: mem time315, current time 369, horizon 54\n", - "adding: mem time316, current time 369, horizon 53\n", - "adding: mem time317, current time 369, horizon 52\n", - "adding: mem time318, current time 369, horizon 51\n", - "adding: mem time319, current time 369, horizon 50\n", - "adding: mem time320, current time 369, horizon 49\n", - "adding: mem time321, current time 369, horizon 48\n", - "adding: mem time322, current time 369, horizon 47\n", - "adding: mem time323, current time 369, horizon 46\n", - "adding: mem time324, current time 369, horizon 45\n", - "adding: mem time325, current time 369, horizon 44\n", - "adding: mem time326, current time 369, horizon 43\n", - "adding: mem time327, current time 369, horizon 42\n", - "adding: mem time328, current time 369, horizon 41\n", - "adding: mem time329, current time 369, horizon 40\n", - "adding: mem time330, current time 369, horizon 39\n", - "adding: mem time331, current time 369, horizon 38\n", - "adding: mem time332, current time 369, horizon 37\n", - "adding: mem time333, current time 369, horizon 36\n", - "adding: mem time334, current time 369, horizon 35\n", - "adding: mem time335, current time 369, horizon 34\n", - "adding: mem time336, current time 369, horizon 33\n", - "adding: mem time337, current time 369, horizon 32\n", - "adding: mem time338, current time 369, horizon 31\n", - "adding: mem time339, current time 369, horizon 30\n", - "adding: mem time340, current time 369, horizon 29\n", - "adding: mem time341, current time 369, horizon 28\n", - "adding: mem time342, current time 369, horizon 27\n", - "adding: mem time343, current time 369, horizon 26\n", - "adding: mem time344, current time 369, horizon 25\n", - "adding: mem time345, current time 369, horizon 24\n", - "adding: mem time346, current time 369, horizon 23\n", - "adding: mem time347, current time 369, horizon 22\n", - "adding: mem time348, current time 369, horizon 21\n", - "adding: mem time349, current time 369, horizon 20\n", - "adding: mem time350, current time 369, horizon 19\n", - "adding: mem time351, current time 369, horizon 18\n", - "adding: mem time352, current time 369, horizon 17\n", - "adding: mem time353, current time 369, horizon 16\n", - "adding: mem time354, current time 369, horizon 15\n", - "adding: mem time355, current time 369, horizon 14\n", - "adding: mem time356, current time 369, horizon 13\n", - "adding: mem time357, current time 369, horizon 12\n", - "adding: mem time358, current time 369, horizon 11\n", - "adding: mem time359, current time 369, horizon 10\n", - "adding: mem time360, current time 369, horizon 9\n", - "adding: mem time361, current time 369, horizon 8\n", - "adding: mem time362, current time 369, horizon 7\n", - "adding: mem time363, current time 369, horizon 6\n", - "adding: mem time364, current time 369, horizon 5\n", - "adding: mem time365, current time 369, horizon 4\n", - "adding: mem time366, current time 369, horizon 3\n", - "adding: mem time367, current time 369, horizon 2\n", - "adding: mem time368, current time 369, horizon 1\n", - "adding: mem time200, current time 370, horizon 170\n", - "adding: mem time201, current time 370, horizon 169\n", - "adding: mem time202, current time 370, horizon 168\n", - "adding: mem time203, current time 370, horizon 167\n", - "adding: mem time204, current time 370, horizon 166\n", - "adding: mem time205, current time 370, horizon 165\n", - "adding: mem time206, current time 370, horizon 164\n", - "adding: mem time207, current time 370, horizon 163\n", - "adding: mem time208, current time 370, horizon 162\n", - "adding: mem time209, current time 370, horizon 161\n", - "adding: mem time210, current time 370, horizon 160\n", - "adding: mem time211, current time 370, horizon 159\n", - "adding: mem time212, current time 370, horizon 158\n", - "adding: mem time213, current time 370, horizon 157\n", - "adding: mem time214, current time 370, horizon 156\n", - "adding: mem time215, current time 370, horizon 155\n", - "adding: mem time216, current time 370, horizon 154\n", - "adding: mem time217, current time 370, horizon 153\n", - "adding: mem time218, current time 370, horizon 152\n", - "adding: mem time219, current time 370, horizon 151\n", - "adding: mem time220, current time 370, horizon 150\n", - "adding: mem time221, current time 370, horizon 149\n", - "adding: mem time222, current time 370, horizon 148\n", - "adding: mem time223, current time 370, horizon 147\n", - "adding: mem time224, current time 370, horizon 146\n", - "adding: mem time225, current time 370, horizon 145\n", - "adding: mem time226, current time 370, horizon 144\n", - "adding: mem time227, current time 370, horizon 143\n", - "adding: mem time228, current time 370, horizon 142\n", - "adding: mem time229, current time 370, horizon 141\n", - "adding: mem time230, current time 370, horizon 140\n", - "adding: mem time231, current time 370, horizon 139\n", - "adding: mem time232, current time 370, horizon 138\n", - "adding: mem time233, current time 370, horizon 137\n", - "adding: mem time234, current time 370, horizon 136\n", - "adding: mem time235, current time 370, horizon 135\n", - "adding: mem time236, current time 370, horizon 134\n", - "adding: mem time237, current time 370, horizon 133\n", - "adding: mem time238, current time 370, horizon 132\n", - "adding: mem time239, current time 370, horizon 131\n", - "adding: mem time240, current time 370, horizon 130\n", - "adding: mem time241, current time 370, horizon 129\n", - "adding: mem time242, current time 370, horizon 128\n", - "adding: mem time243, current time 370, horizon 127\n", - "adding: mem time244, current time 370, horizon 126\n", - "adding: mem time245, current time 370, horizon 125\n", - "adding: mem time246, current time 370, horizon 124\n", - "adding: mem time247, current time 370, horizon 123\n", - "adding: mem time248, current time 370, horizon 122\n", - "adding: mem time249, current time 370, horizon 121\n", - "adding: mem time250, current time 370, horizon 120\n", - "adding: mem time251, current time 370, horizon 119\n", - "adding: mem time252, current time 370, horizon 118\n", - "adding: mem time253, current time 370, horizon 117\n", - "adding: mem time254, current time 370, horizon 116\n", - "adding: mem time255, current time 370, horizon 115\n", - "adding: mem time256, current time 370, horizon 114\n", - "adding: mem time257, current time 370, horizon 113\n", - "adding: mem time258, current time 370, horizon 112\n", - "adding: mem time259, current time 370, horizon 111\n", - "adding: mem time260, current time 370, horizon 110\n", - "adding: mem time261, current time 370, horizon 109\n", - "adding: mem time262, current time 370, horizon 108\n", - "adding: mem time263, current time 370, horizon 107\n", - "adding: mem time264, current time 370, horizon 106\n", - "adding: mem time265, current time 370, horizon 105\n", - "adding: mem time266, current time 370, horizon 104\n", - "adding: mem time267, current time 370, horizon 103\n", - "adding: mem time268, current time 370, horizon 102\n", - "adding: mem time269, current time 370, horizon 101\n", - "adding: mem time270, current time 370, horizon 100\n", - "adding: mem time271, current time 370, horizon 99\n", - "adding: mem time272, current time 370, horizon 98\n", - "adding: mem time273, current time 370, horizon 97\n", - "adding: mem time274, current time 370, horizon 96\n", - "adding: mem time275, current time 370, horizon 95\n", - "adding: mem time276, current time 370, horizon 94\n", - "adding: mem time277, current time 370, horizon 93\n", - "adding: mem time278, current time 370, horizon 92\n", - "adding: mem time279, current time 370, horizon 91\n", - "adding: mem time280, current time 370, horizon 90\n", - "adding: mem time281, current time 370, horizon 89\n", - "adding: mem time282, current time 370, horizon 88\n", - "adding: mem time283, current time 370, horizon 87\n", - "adding: mem time284, current time 370, horizon 86\n", - "adding: mem time285, current time 370, horizon 85\n", - "adding: mem time286, current time 370, horizon 84\n", - "adding: mem time287, current time 370, horizon 83\n", - "adding: mem time288, current time 370, horizon 82\n", - "adding: mem time289, current time 370, horizon 81\n", - "adding: mem time290, current time 370, horizon 80\n", - "adding: mem time291, current time 370, horizon 79\n", - "adding: mem time292, current time 370, horizon 78\n", - "adding: mem time293, current time 370, horizon 77\n", - "adding: mem time294, current time 370, horizon 76\n", - "adding: mem time295, current time 370, horizon 75\n", - "adding: mem time296, current time 370, horizon 74\n", - "adding: mem time297, current time 370, horizon 73\n", - "adding: mem time298, current time 370, horizon 72\n", - "adding: mem time299, current time 370, horizon 71\n", - "adding: mem time300, current time 370, horizon 70\n", - "adding: mem time301, current time 370, horizon 69\n", - "adding: mem time302, current time 370, horizon 68\n", - "adding: mem time303, current time 370, horizon 67\n", - "adding: mem time304, current time 370, horizon 66\n", - "adding: mem time305, current time 370, horizon 65\n", - "adding: mem time306, current time 370, horizon 64\n", - "adding: mem time307, current time 370, horizon 63\n", - "adding: mem time308, current time 370, horizon 62\n", - "adding: mem time309, current time 370, horizon 61\n", - "adding: mem time310, current time 370, horizon 60\n", - "adding: mem time311, current time 370, horizon 59\n", - "adding: mem time312, current time 370, horizon 58\n", - "adding: mem time313, current time 370, horizon 57\n", - "adding: mem time314, current time 370, horizon 56\n", - "adding: mem time315, current time 370, horizon 55\n", - "adding: mem time316, current time 370, horizon 54\n", - "adding: mem time317, current time 370, horizon 53\n", - "adding: mem time318, current time 370, horizon 52\n", - "adding: mem time319, current time 370, horizon 51\n", - "adding: mem time320, current time 370, horizon 50\n", - "adding: mem time321, current time 370, horizon 49\n", - "adding: mem time322, current time 370, horizon 48\n", - "adding: mem time323, current time 370, horizon 47\n", - "adding: mem time324, current time 370, horizon 46\n", - "adding: mem time325, current time 370, horizon 45\n", - "adding: mem time326, current time 370, horizon 44\n", - "adding: mem time327, current time 370, horizon 43\n", - "adding: mem time328, current time 370, horizon 42\n", - "adding: mem time329, current time 370, horizon 41\n", - "adding: mem time330, current time 370, horizon 40\n", - "adding: mem time331, current time 370, horizon 39\n", - "adding: mem time332, current time 370, horizon 38\n", - "adding: mem time333, current time 370, horizon 37\n", - "adding: mem time334, current time 370, horizon 36\n", - "adding: mem time335, current time 370, horizon 35\n", - "adding: mem time336, current time 370, horizon 34\n", - "adding: mem time337, current time 370, horizon 33\n", - "adding: mem time338, current time 370, horizon 32\n", - "adding: mem time339, current time 370, horizon 31\n", - "adding: mem time340, current time 370, horizon 30\n", - "adding: mem time341, current time 370, horizon 29\n", - "adding: mem time342, current time 370, horizon 28\n", - "adding: mem time343, current time 370, horizon 27\n", - "adding: mem time344, current time 370, horizon 26\n", - "adding: mem time345, current time 370, horizon 25\n", - "adding: mem time346, current time 370, horizon 24\n", - "adding: mem time347, current time 370, horizon 23\n", - "adding: mem time348, current time 370, horizon 22\n", - "adding: mem time349, current time 370, horizon 21\n", - "adding: mem time350, current time 370, horizon 20\n", - "adding: mem time351, current time 370, horizon 19\n", - "adding: mem time352, current time 370, horizon 18\n", - "adding: mem time353, current time 370, horizon 17\n", - "adding: mem time354, current time 370, horizon 16\n", - "adding: mem time355, current time 370, horizon 15\n", - "adding: mem time356, current time 370, horizon 14\n", - "adding: mem time357, current time 370, horizon 13\n", - "adding: mem time358, current time 370, horizon 12\n", - "adding: mem time359, current time 370, horizon 11\n", - "adding: mem time360, current time 370, horizon 10\n", - "adding: mem time361, current time 370, horizon 9\n", - "adding: mem time362, current time 370, horizon 8\n", - "adding: mem time363, current time 370, horizon 7\n", - "adding: mem time364, current time 370, horizon 6\n", - "adding: mem time365, current time 370, horizon 5\n", - "adding: mem time366, current time 370, horizon 4\n", - "adding: mem time367, current time 370, horizon 3\n", - "adding: mem time368, current time 370, horizon 2\n", - "adding: mem time369, current time 370, horizon 1\n", - "adding: mem time200, current time 371, horizon 171\n", - "adding: mem time201, current time 371, horizon 170\n", - "adding: mem time202, current time 371, horizon 169\n", - "adding: mem time203, current time 371, horizon 168\n", - "adding: mem time204, current time 371, horizon 167\n", - "adding: mem time205, current time 371, horizon 166\n", - "adding: mem time206, current time 371, horizon 165\n", - "adding: mem time207, current time 371, horizon 164\n", - "adding: mem time208, current time 371, horizon 163\n", - "adding: mem time209, current time 371, horizon 162\n", - "adding: mem time210, current time 371, horizon 161\n", - "adding: mem time211, current time 371, horizon 160\n", - "adding: mem time212, current time 371, horizon 159\n", - "adding: mem time213, current time 371, horizon 158\n", - "adding: mem time214, current time 371, horizon 157\n", - "adding: mem time215, current time 371, horizon 156\n", - "adding: mem time216, current time 371, horizon 155\n", - "adding: mem time217, current time 371, horizon 154\n", - "adding: mem time218, current time 371, horizon 153\n", - "adding: mem time219, current time 371, horizon 152\n", - "adding: mem time220, current time 371, horizon 151\n", - "adding: mem time221, current time 371, horizon 150\n", - "adding: mem time222, current time 371, horizon 149\n", - "adding: mem time223, current time 371, horizon 148\n", - "adding: mem time224, current time 371, horizon 147\n", - "adding: mem time225, current time 371, horizon 146\n", - "adding: mem time226, current time 371, horizon 145\n", - "adding: mem time227, current time 371, horizon 144\n", - "adding: mem time228, current time 371, horizon 143\n", - "adding: mem time229, current time 371, horizon 142\n", - "adding: mem time230, current time 371, horizon 141\n", - "adding: mem time231, current time 371, horizon 140\n", - "adding: mem time232, current time 371, horizon 139\n", - "adding: mem time233, current time 371, horizon 138\n", - "adding: mem time234, current time 371, horizon 137\n", - "adding: mem time235, current time 371, horizon 136\n", - "adding: mem time236, current time 371, horizon 135\n", - "adding: mem time237, current time 371, horizon 134\n", - "adding: mem time238, current time 371, horizon 133\n", - "adding: mem time239, current time 371, horizon 132\n", - "adding: mem time240, current time 371, horizon 131\n", - "adding: mem time241, current time 371, horizon 130\n", - "adding: mem time242, current time 371, horizon 129\n", - "adding: mem time243, current time 371, horizon 128\n", - "adding: mem time244, current time 371, horizon 127\n", - "adding: mem time245, current time 371, horizon 126\n", - "adding: mem time246, current time 371, horizon 125\n", - "adding: mem time247, current time 371, horizon 124\n", - "adding: mem time248, current time 371, horizon 123\n", - "adding: mem time249, current time 371, horizon 122\n", - "adding: mem time250, current time 371, horizon 121\n", - "adding: mem time251, current time 371, horizon 120\n", - "adding: mem time252, current time 371, horizon 119\n", - "adding: mem time253, current time 371, horizon 118\n", - "adding: mem time254, current time 371, horizon 117\n", - "adding: mem time255, current time 371, horizon 116\n", - "adding: mem time256, current time 371, horizon 115\n", - "adding: mem time257, current time 371, horizon 114\n", - "adding: mem time258, current time 371, horizon 113\n", - "adding: mem time259, current time 371, horizon 112\n", - "adding: mem time260, current time 371, horizon 111\n", - "adding: mem time261, current time 371, horizon 110\n", - "adding: mem time262, current time 371, horizon 109\n", - "adding: mem time263, current time 371, horizon 108\n", - "adding: mem time264, current time 371, horizon 107\n", - "adding: mem time265, current time 371, horizon 106\n", - "adding: mem time266, current time 371, horizon 105\n", - "adding: mem time267, current time 371, horizon 104\n", - "adding: mem time268, current time 371, horizon 103\n", - "adding: mem time269, current time 371, horizon 102\n", - "adding: mem time270, current time 371, horizon 101\n", - "adding: mem time271, current time 371, horizon 100\n", - "adding: mem time272, current time 371, horizon 99\n", - "adding: mem time273, current time 371, horizon 98\n", - "adding: mem time274, current time 371, horizon 97\n", - "adding: mem time275, current time 371, horizon 96\n", - "adding: mem time276, current time 371, horizon 95\n", - "adding: mem time277, current time 371, horizon 94\n", - "adding: mem time278, current time 371, horizon 93\n", - "adding: mem time279, current time 371, horizon 92\n", - "adding: mem time280, current time 371, horizon 91\n", - "adding: mem time281, current time 371, horizon 90\n", - "adding: mem time282, current time 371, horizon 89\n", - "adding: mem time283, current time 371, horizon 88\n", - "adding: mem time284, current time 371, horizon 87\n", - "adding: mem time285, current time 371, horizon 86\n", - "adding: mem time286, current time 371, horizon 85\n", - "adding: mem time287, current time 371, horizon 84\n", - "adding: mem time288, current time 371, horizon 83\n", - "adding: mem time289, current time 371, horizon 82\n", - "adding: mem time290, current time 371, horizon 81\n", - "adding: mem time291, current time 371, horizon 80\n", - "adding: mem time292, current time 371, horizon 79\n", - "adding: mem time293, current time 371, horizon 78\n", - "adding: mem time294, current time 371, horizon 77\n", - "adding: mem time295, current time 371, horizon 76\n", - "adding: mem time296, current time 371, horizon 75\n", - "adding: mem time297, current time 371, horizon 74\n", - "adding: mem time298, current time 371, horizon 73\n", - "adding: mem time299, current time 371, horizon 72\n", - "adding: mem time300, current time 371, horizon 71\n", - "adding: mem time301, current time 371, horizon 70\n", - "adding: mem time302, current time 371, horizon 69\n", - "adding: mem time303, current time 371, horizon 68\n", - "adding: mem time304, current time 371, horizon 67\n", - "adding: mem time305, current time 371, horizon 66\n", - "adding: mem time306, current time 371, horizon 65\n", - "adding: mem time307, current time 371, horizon 64\n", - "adding: mem time308, current time 371, horizon 63\n", - "adding: mem time309, current time 371, horizon 62\n", - "adding: mem time310, current time 371, horizon 61\n", - "adding: mem time311, current time 371, horizon 60\n", - "adding: mem time312, current time 371, horizon 59\n", - "adding: mem time313, current time 371, horizon 58\n", - "adding: mem time314, current time 371, horizon 57\n", - "adding: mem time315, current time 371, horizon 56\n", - "adding: mem time316, current time 371, horizon 55\n", - "adding: mem time317, current time 371, horizon 54\n", - "adding: mem time318, current time 371, horizon 53\n", - "adding: mem time319, current time 371, horizon 52\n", - "adding: mem time320, current time 371, horizon 51\n", - "adding: mem time321, current time 371, horizon 50\n", - "adding: mem time322, current time 371, horizon 49\n", - "adding: mem time323, current time 371, horizon 48\n", - "adding: mem time324, current time 371, horizon 47\n", - "adding: mem time325, current time 371, horizon 46\n", - "adding: mem time326, current time 371, horizon 45\n", - "adding: mem time327, current time 371, horizon 44\n", - "adding: mem time328, current time 371, horizon 43\n", - "adding: mem time329, current time 371, horizon 42\n", - "adding: mem time330, current time 371, horizon 41\n", - "adding: mem time331, current time 371, horizon 40\n", - "adding: mem time332, current time 371, horizon 39\n", - "adding: mem time333, current time 371, horizon 38\n", - "adding: mem time334, current time 371, horizon 37\n", - "adding: mem time335, current time 371, horizon 36\n", - "adding: mem time336, current time 371, horizon 35\n", - "adding: mem time337, current time 371, horizon 34\n", - "adding: mem time338, current time 371, horizon 33\n", - "adding: mem time339, current time 371, horizon 32\n", - "adding: mem time340, current time 371, horizon 31\n", - "adding: mem time341, current time 371, horizon 30\n", - "adding: mem time342, current time 371, horizon 29\n", - "adding: mem time343, current time 371, horizon 28\n", - "adding: mem time344, current time 371, horizon 27\n", - "adding: mem time345, current time 371, horizon 26\n", - "adding: mem time346, current time 371, horizon 25\n", - "adding: mem time347, current time 371, horizon 24\n", - "adding: mem time348, current time 371, horizon 23\n", - "adding: mem time349, current time 371, horizon 22\n", - "adding: mem time350, current time 371, horizon 21\n", - "adding: mem time351, current time 371, horizon 20\n", - "adding: mem time352, current time 371, horizon 19\n", - "adding: mem time353, current time 371, horizon 18\n", - "adding: mem time354, current time 371, horizon 17\n", - "adding: mem time355, current time 371, horizon 16\n", - "adding: mem time356, current time 371, horizon 15\n", - "adding: mem time357, current time 371, horizon 14\n", - "adding: mem time358, current time 371, horizon 13\n", - "adding: mem time359, current time 371, horizon 12\n", - "adding: mem time360, current time 371, horizon 11\n", - "adding: mem time361, current time 371, horizon 10\n", - "adding: mem time362, current time 371, horizon 9\n", - "adding: mem time363, current time 371, horizon 8\n", - "adding: mem time364, current time 371, horizon 7\n", - "adding: mem time365, current time 371, horizon 6\n", - "adding: mem time366, current time 371, horizon 5\n", - "adding: mem time367, current time 371, horizon 4\n", - "adding: mem time368, current time 371, horizon 3\n", - "adding: mem time369, current time 371, horizon 2\n", - "adding: mem time370, current time 371, horizon 1\n", - "adding: mem time200, current time 372, horizon 172\n", - "adding: mem time201, current time 372, horizon 171\n", - "adding: mem time202, current time 372, horizon 170\n", - "adding: mem time203, current time 372, horizon 169\n", - "adding: mem time204, current time 372, horizon 168\n", - "adding: mem time205, current time 372, horizon 167\n", - "adding: mem time206, current time 372, horizon 166\n", - "adding: mem time207, current time 372, horizon 165\n", - "adding: mem time208, current time 372, horizon 164\n", - "adding: mem time209, current time 372, horizon 163\n", - "adding: mem time210, current time 372, horizon 162\n", - "adding: mem time211, current time 372, horizon 161\n", - "adding: mem time212, current time 372, horizon 160\n", - "adding: mem time213, current time 372, horizon 159\n", - "adding: mem time214, current time 372, horizon 158\n", - "adding: mem time215, current time 372, horizon 157\n", - "adding: mem time216, current time 372, horizon 156\n", - "adding: mem time217, current time 372, horizon 155\n", - "adding: mem time218, current time 372, horizon 154\n", - "adding: mem time219, current time 372, horizon 153\n", - "adding: mem time220, current time 372, horizon 152\n", - "adding: mem time221, current time 372, horizon 151\n", - "adding: mem time222, current time 372, horizon 150\n", - "adding: mem time223, current time 372, horizon 149\n", - "adding: mem time224, current time 372, horizon 148\n", - "adding: mem time225, current time 372, horizon 147\n", - "adding: mem time226, current time 372, horizon 146\n", - "adding: mem time227, current time 372, horizon 145\n", - "adding: mem time228, current time 372, horizon 144\n", - "adding: mem time229, current time 372, horizon 143\n", - "adding: mem time230, current time 372, horizon 142\n", - "adding: mem time231, current time 372, horizon 141\n", - "adding: mem time232, current time 372, horizon 140\n", - "adding: mem time233, current time 372, horizon 139\n", - "adding: mem time234, current time 372, horizon 138\n", - "adding: mem time235, current time 372, horizon 137\n", - "adding: mem time236, current time 372, horizon 136\n", - "adding: mem time237, current time 372, horizon 135\n", - "adding: mem time238, current time 372, horizon 134\n", - "adding: mem time239, current time 372, horizon 133\n", - "adding: mem time240, current time 372, horizon 132\n", - "adding: mem time241, current time 372, horizon 131\n", - "adding: mem time242, current time 372, horizon 130\n", - "adding: mem time243, current time 372, horizon 129\n", - "adding: mem time244, current time 372, horizon 128\n", - "adding: mem time245, current time 372, horizon 127\n", - "adding: mem time246, current time 372, horizon 126\n", - "adding: mem time247, current time 372, horizon 125\n", - "adding: mem time248, current time 372, horizon 124\n", - "adding: mem time249, current time 372, horizon 123\n", - "adding: mem time250, current time 372, horizon 122\n", - "adding: mem time251, current time 372, horizon 121\n", - "adding: mem time252, current time 372, horizon 120\n", - "adding: mem time253, current time 372, horizon 119\n", - "adding: mem time254, current time 372, horizon 118\n", - "adding: mem time255, current time 372, horizon 117\n", - "adding: mem time256, current time 372, horizon 116\n", - "adding: mem time257, current time 372, horizon 115\n", - "adding: mem time258, current time 372, horizon 114\n", - "adding: mem time259, current time 372, horizon 113\n", - "adding: mem time260, current time 372, horizon 112\n", - "adding: mem time261, current time 372, horizon 111\n", - "adding: mem time262, current time 372, horizon 110\n", - "adding: mem time263, current time 372, horizon 109\n", - "adding: mem time264, current time 372, horizon 108\n", - "adding: mem time265, current time 372, horizon 107\n", - "adding: mem time266, current time 372, horizon 106\n", - "adding: mem time267, current time 372, horizon 105\n", - "adding: mem time268, current time 372, horizon 104\n", - "adding: mem time269, current time 372, horizon 103\n", - "adding: mem time270, current time 372, horizon 102\n", - "adding: mem time271, current time 372, horizon 101\n", - "adding: mem time272, current time 372, horizon 100\n", - "adding: mem time273, current time 372, horizon 99\n", - "adding: mem time274, current time 372, horizon 98\n", - "adding: mem time275, current time 372, horizon 97\n", - "adding: mem time276, current time 372, horizon 96\n", - "adding: mem time277, current time 372, horizon 95\n", - "adding: mem time278, current time 372, horizon 94\n", - "adding: mem time279, current time 372, horizon 93\n", - "adding: mem time280, current time 372, horizon 92\n", - "adding: mem time281, current time 372, horizon 91\n", - "adding: mem time282, current time 372, horizon 90\n", - "adding: mem time283, current time 372, horizon 89\n", - "adding: mem time284, current time 372, horizon 88\n", - "adding: mem time285, current time 372, horizon 87\n", - "adding: mem time286, current time 372, horizon 86\n", - "adding: mem time287, current time 372, horizon 85\n", - "adding: mem time288, current time 372, horizon 84\n", - "adding: mem time289, current time 372, horizon 83\n", - "adding: mem time290, current time 372, horizon 82\n", - "adding: mem time291, current time 372, horizon 81\n", - "adding: mem time292, current time 372, horizon 80\n", - "adding: mem time293, current time 372, horizon 79\n", - "adding: mem time294, current time 372, horizon 78\n", - "adding: mem time295, current time 372, horizon 77\n", - "adding: mem time296, current time 372, horizon 76\n", - "adding: mem time297, current time 372, horizon 75\n", - "adding: mem time298, current time 372, horizon 74\n", - "adding: mem time299, current time 372, horizon 73\n", - "adding: mem time300, current time 372, horizon 72\n", - "adding: mem time301, current time 372, horizon 71\n", - "adding: mem time302, current time 372, horizon 70\n", - "adding: mem time303, current time 372, horizon 69\n", - "adding: mem time304, current time 372, horizon 68\n", - "adding: mem time305, current time 372, horizon 67\n", - "adding: mem time306, current time 372, horizon 66\n", - "adding: mem time307, current time 372, horizon 65\n", - "adding: mem time308, current time 372, horizon 64\n", - "adding: mem time309, current time 372, horizon 63\n", - "adding: mem time310, current time 372, horizon 62\n", - "adding: mem time311, current time 372, horizon 61\n", - "adding: mem time312, current time 372, horizon 60\n", - "adding: mem time313, current time 372, horizon 59\n", - "adding: mem time314, current time 372, horizon 58\n", - "adding: mem time315, current time 372, horizon 57\n", - "adding: mem time316, current time 372, horizon 56\n", - "adding: mem time317, current time 372, horizon 55\n", - "adding: mem time318, current time 372, horizon 54\n", - "adding: mem time319, current time 372, horizon 53\n", - "adding: mem time320, current time 372, horizon 52\n", - "adding: mem time321, current time 372, horizon 51\n", - "adding: mem time322, current time 372, horizon 50\n", - "adding: mem time323, current time 372, horizon 49\n", - "adding: mem time324, current time 372, horizon 48\n", - "adding: mem time325, current time 372, horizon 47\n", - "adding: mem time326, current time 372, horizon 46\n", - "adding: mem time327, current time 372, horizon 45\n", - "adding: mem time328, current time 372, horizon 44\n", - "adding: mem time329, current time 372, horizon 43\n", - "adding: mem time330, current time 372, horizon 42\n", - "adding: mem time331, current time 372, horizon 41\n", - "adding: mem time332, current time 372, horizon 40\n", - "adding: mem time333, current time 372, horizon 39\n", - "adding: mem time334, current time 372, horizon 38\n", - "adding: mem time335, current time 372, horizon 37\n", - "adding: mem time336, current time 372, horizon 36\n", - "adding: mem time337, current time 372, horizon 35\n", - "adding: mem time338, current time 372, horizon 34\n", - "adding: mem time339, current time 372, horizon 33\n", - "adding: mem time340, current time 372, horizon 32\n", - "adding: mem time341, current time 372, horizon 31\n", - "adding: mem time342, current time 372, horizon 30\n", - "adding: mem time343, current time 372, horizon 29\n", - "adding: mem time344, current time 372, horizon 28\n", - "adding: mem time345, current time 372, horizon 27\n", - "adding: mem time346, current time 372, horizon 26\n", - "adding: mem time347, current time 372, horizon 25\n", - "adding: mem time348, current time 372, horizon 24\n", - "adding: mem time349, current time 372, horizon 23\n", - "adding: mem time350, current time 372, horizon 22\n", - "adding: mem time351, current time 372, horizon 21\n", - "adding: mem time352, current time 372, horizon 20\n", - "adding: mem time353, current time 372, horizon 19\n", - "adding: mem time354, current time 372, horizon 18\n", - "adding: mem time355, current time 372, horizon 17\n", - "adding: mem time356, current time 372, horizon 16\n", - "adding: mem time357, current time 372, horizon 15\n", - "adding: mem time358, current time 372, horizon 14\n", - "adding: mem time359, current time 372, horizon 13\n", - "adding: mem time360, current time 372, horizon 12\n", - "adding: mem time361, current time 372, horizon 11\n", - "adding: mem time362, current time 372, horizon 10\n", - "adding: mem time363, current time 372, horizon 9\n", - "adding: mem time364, current time 372, horizon 8\n", - "adding: mem time365, current time 372, horizon 7\n", - "adding: mem time366, current time 372, horizon 6\n", - "adding: mem time367, current time 372, horizon 5\n", - "adding: mem time368, current time 372, horizon 4\n", - "adding: mem time369, current time 372, horizon 3\n", - "adding: mem time370, current time 372, horizon 2\n", - "adding: mem time371, current time 372, horizon 1\n", - "adding: mem time200, current time 373, horizon 173\n", - "adding: mem time201, current time 373, horizon 172\n", - "adding: mem time202, current time 373, horizon 171\n", - "adding: mem time203, current time 373, horizon 170\n", - "adding: mem time204, current time 373, horizon 169\n", - "adding: mem time205, current time 373, horizon 168\n", - "adding: mem time206, current time 373, horizon 167\n", - "adding: mem time207, current time 373, horizon 166\n", - "adding: mem time208, current time 373, horizon 165\n", - "adding: mem time209, current time 373, horizon 164\n", - "adding: mem time210, current time 373, horizon 163\n", - "adding: mem time211, current time 373, horizon 162\n", - "adding: mem time212, current time 373, horizon 161\n", - "adding: mem time213, current time 373, horizon 160\n", - "adding: mem time214, current time 373, horizon 159\n", - "adding: mem time215, current time 373, horizon 158\n", - "adding: mem time216, current time 373, horizon 157\n", - "adding: mem time217, current time 373, horizon 156\n", - "adding: mem time218, current time 373, horizon 155\n", - "adding: mem time219, current time 373, horizon 154\n", - "adding: mem time220, current time 373, horizon 153\n", - "adding: mem time221, current time 373, horizon 152\n", - "adding: mem time222, current time 373, horizon 151\n", - "adding: mem time223, current time 373, horizon 150\n", - "adding: mem time224, current time 373, horizon 149\n", - "adding: mem time225, current time 373, horizon 148\n", - "adding: mem time226, current time 373, horizon 147\n", - "adding: mem time227, current time 373, horizon 146\n", - "adding: mem time228, current time 373, horizon 145\n", - "adding: mem time229, current time 373, horizon 144\n", - "adding: mem time230, current time 373, horizon 143\n", - "adding: mem time231, current time 373, horizon 142\n", - "adding: mem time232, current time 373, horizon 141\n", - "adding: mem time233, current time 373, horizon 140\n", - "adding: mem time234, current time 373, horizon 139\n", - "adding: mem time235, current time 373, horizon 138\n", - "adding: mem time236, current time 373, horizon 137\n", - "adding: mem time237, current time 373, horizon 136\n", - "adding: mem time238, current time 373, horizon 135\n", - "adding: mem time239, current time 373, horizon 134\n", - "adding: mem time240, current time 373, horizon 133\n", - "adding: mem time241, current time 373, horizon 132\n", - "adding: mem time242, current time 373, horizon 131\n", - "adding: mem time243, current time 373, horizon 130\n", - "adding: mem time244, current time 373, horizon 129\n", - "adding: mem time245, current time 373, horizon 128\n", - "adding: mem time246, current time 373, horizon 127\n", - "adding: mem time247, current time 373, horizon 126\n", - "adding: mem time248, current time 373, horizon 125\n", - "adding: mem time249, current time 373, horizon 124\n", - "adding: mem time250, current time 373, horizon 123\n", - "adding: mem time251, current time 373, horizon 122\n", - "adding: mem time252, current time 373, horizon 121\n", - "adding: mem time253, current time 373, horizon 120\n", - "adding: mem time254, current time 373, horizon 119\n", - "adding: mem time255, current time 373, horizon 118\n", - "adding: mem time256, current time 373, horizon 117\n", - "adding: mem time257, current time 373, horizon 116\n", - "adding: mem time258, current time 373, horizon 115\n", - "adding: mem time259, current time 373, horizon 114\n", - "adding: mem time260, current time 373, horizon 113\n", - "adding: mem time261, current time 373, horizon 112\n", - "adding: mem time262, current time 373, horizon 111\n", - "adding: mem time263, current time 373, horizon 110\n", - "adding: mem time264, current time 373, horizon 109\n", - "adding: mem time265, current time 373, horizon 108\n", - "adding: mem time266, current time 373, horizon 107\n", - "adding: mem time267, current time 373, horizon 106\n", - "adding: mem time268, current time 373, horizon 105\n", - "adding: mem time269, current time 373, horizon 104\n", - "adding: mem time270, current time 373, horizon 103\n", - "adding: mem time271, current time 373, horizon 102\n", - "adding: mem time272, current time 373, horizon 101\n", - "adding: mem time273, current time 373, horizon 100\n", - "adding: mem time274, current time 373, horizon 99\n", - "adding: mem time275, current time 373, horizon 98\n", - "adding: mem time276, current time 373, horizon 97\n", - "adding: mem time277, current time 373, horizon 96\n", - "adding: mem time278, current time 373, horizon 95\n", - "adding: mem time279, current time 373, horizon 94\n", - "adding: mem time280, current time 373, horizon 93\n", - "adding: mem time281, current time 373, horizon 92\n", - "adding: mem time282, current time 373, horizon 91\n", - "adding: mem time283, current time 373, horizon 90\n", - "adding: mem time284, current time 373, horizon 89\n", - "adding: mem time285, current time 373, horizon 88\n", - "adding: mem time286, current time 373, horizon 87\n", - "adding: mem time287, current time 373, horizon 86\n", - "adding: mem time288, current time 373, horizon 85\n", - "adding: mem time289, current time 373, horizon 84\n", - "adding: mem time290, current time 373, horizon 83\n", - "adding: mem time291, current time 373, horizon 82\n", - "adding: mem time292, current time 373, horizon 81\n", - "adding: mem time293, current time 373, horizon 80\n", - "adding: mem time294, current time 373, horizon 79\n", - "adding: mem time295, current time 373, horizon 78\n", - "adding: mem time296, current time 373, horizon 77\n", - "adding: mem time297, current time 373, horizon 76\n", - "adding: mem time298, current time 373, horizon 75\n", - "adding: mem time299, current time 373, horizon 74\n", - "adding: mem time300, current time 373, horizon 73\n", - "adding: mem time301, current time 373, horizon 72\n", - "adding: mem time302, current time 373, horizon 71\n", - "adding: mem time303, current time 373, horizon 70\n", - "adding: mem time304, current time 373, horizon 69\n", - "adding: mem time305, current time 373, horizon 68\n", - "adding: mem time306, current time 373, horizon 67\n", - "adding: mem time307, current time 373, horizon 66\n", - "adding: mem time308, current time 373, horizon 65\n", - "adding: mem time309, current time 373, horizon 64\n", - "adding: mem time310, current time 373, horizon 63\n", - "adding: mem time311, current time 373, horizon 62\n", - "adding: mem time312, current time 373, horizon 61\n", - "adding: mem time313, current time 373, horizon 60\n", - "adding: mem time314, current time 373, horizon 59\n", - "adding: mem time315, current time 373, horizon 58\n", - "adding: mem time316, current time 373, horizon 57\n", - "adding: mem time317, current time 373, horizon 56\n", - "adding: mem time318, current time 373, horizon 55\n", - "adding: mem time319, current time 373, horizon 54\n", - "adding: mem time320, current time 373, horizon 53\n", - "adding: mem time321, current time 373, horizon 52\n", - "adding: mem time322, current time 373, horizon 51\n", - "adding: mem time323, current time 373, horizon 50\n", - "adding: mem time324, current time 373, horizon 49\n", - "adding: mem time325, current time 373, horizon 48\n", - "adding: mem time326, current time 373, horizon 47\n", - "adding: mem time327, current time 373, horizon 46\n", - "adding: mem time328, current time 373, horizon 45\n", - "adding: mem time329, current time 373, horizon 44\n", - "adding: mem time330, current time 373, horizon 43\n", - "adding: mem time331, current time 373, horizon 42\n", - "adding: mem time332, current time 373, horizon 41\n", - "adding: mem time333, current time 373, horizon 40\n", - "adding: mem time334, current time 373, horizon 39\n", - "adding: mem time335, current time 373, horizon 38\n", - "adding: mem time336, current time 373, horizon 37\n", - "adding: mem time337, current time 373, horizon 36\n", - "adding: mem time338, current time 373, horizon 35\n", - "adding: mem time339, current time 373, horizon 34\n", - "adding: mem time340, current time 373, horizon 33\n", - "adding: mem time341, current time 373, horizon 32\n", - "adding: mem time342, current time 373, horizon 31\n", - "adding: mem time343, current time 373, horizon 30\n", - "adding: mem time344, current time 373, horizon 29\n", - "adding: mem time345, current time 373, horizon 28\n", - "adding: mem time346, current time 373, horizon 27\n", - "adding: mem time347, current time 373, horizon 26\n", - "adding: mem time348, current time 373, horizon 25\n", - "adding: mem time349, current time 373, horizon 24\n", - "adding: mem time350, current time 373, horizon 23\n", - "adding: mem time351, current time 373, horizon 22\n", - "adding: mem time352, current time 373, horizon 21\n", - "adding: mem time353, current time 373, horizon 20\n", - "adding: mem time354, current time 373, horizon 19\n", - "adding: mem time355, current time 373, horizon 18\n", - "adding: mem time356, current time 373, horizon 17\n", - "adding: mem time357, current time 373, horizon 16\n", - "adding: mem time358, current time 373, horizon 15\n", - "adding: mem time359, current time 373, horizon 14\n", - "adding: mem time360, current time 373, horizon 13\n", - "adding: mem time361, current time 373, horizon 12\n", - "adding: mem time362, current time 373, horizon 11\n", - "adding: mem time363, current time 373, horizon 10\n", - "adding: mem time364, current time 373, horizon 9\n", - "adding: mem time365, current time 373, horizon 8\n", - "adding: mem time366, current time 373, horizon 7\n", - "adding: mem time367, current time 373, horizon 6\n", - "adding: mem time368, current time 373, horizon 5\n", - "adding: mem time369, current time 373, horizon 4\n", - "adding: mem time370, current time 373, horizon 3\n", - "adding: mem time371, current time 373, horizon 2\n", - "adding: mem time372, current time 373, horizon 1\n", - "adding: mem time200, current time 374, horizon 174\n", - "adding: mem time201, current time 374, horizon 173\n", - "adding: mem time202, current time 374, horizon 172\n", - "adding: mem time203, current time 374, horizon 171\n", - "adding: mem time204, current time 374, horizon 170\n", - "adding: mem time205, current time 374, horizon 169\n", - "adding: mem time206, current time 374, horizon 168\n", - "adding: mem time207, current time 374, horizon 167\n", - "adding: mem time208, current time 374, horizon 166\n", - "adding: mem time209, current time 374, horizon 165\n", - "adding: mem time210, current time 374, horizon 164\n", - "adding: mem time211, current time 374, horizon 163\n", - "adding: mem time212, current time 374, horizon 162\n", - "adding: mem time213, current time 374, horizon 161\n", - "adding: mem time214, current time 374, horizon 160\n", - "adding: mem time215, current time 374, horizon 159\n", - "adding: mem time216, current time 374, horizon 158\n", - "adding: mem time217, current time 374, horizon 157\n", - "adding: mem time218, current time 374, horizon 156\n", - "adding: mem time219, current time 374, horizon 155\n", - "adding: mem time220, current time 374, horizon 154\n", - "adding: mem time221, current time 374, horizon 153\n", - "adding: mem time222, current time 374, horizon 152\n", - "adding: mem time223, current time 374, horizon 151\n", - "adding: mem time224, current time 374, horizon 150\n", - "adding: mem time225, current time 374, horizon 149\n", - "adding: mem time226, current time 374, horizon 148\n", - "adding: mem time227, current time 374, horizon 147\n", - "adding: mem time228, current time 374, horizon 146\n", - "adding: mem time229, current time 374, horizon 145\n", - "adding: mem time230, current time 374, horizon 144\n", - "adding: mem time231, current time 374, horizon 143\n", - "adding: mem time232, current time 374, horizon 142\n", - "adding: mem time233, current time 374, horizon 141\n", - "adding: mem time234, current time 374, horizon 140\n", - "adding: mem time235, current time 374, horizon 139\n", - "adding: mem time236, current time 374, horizon 138\n", - "adding: mem time237, current time 374, horizon 137\n", - "adding: mem time238, current time 374, horizon 136\n", - "adding: mem time239, current time 374, horizon 135\n", - "adding: mem time240, current time 374, horizon 134\n", - "adding: mem time241, current time 374, horizon 133\n", - "adding: mem time242, current time 374, horizon 132\n", - "adding: mem time243, current time 374, horizon 131\n", - "adding: mem time244, current time 374, horizon 130\n", - "adding: mem time245, current time 374, horizon 129\n", - "adding: mem time246, current time 374, horizon 128\n", - "adding: mem time247, current time 374, horizon 127\n", - "adding: mem time248, current time 374, horizon 126\n", - "adding: mem time249, current time 374, horizon 125\n", - "adding: mem time250, current time 374, horizon 124\n", - "adding: mem time251, current time 374, horizon 123\n", - "adding: mem time252, current time 374, horizon 122\n", - "adding: mem time253, current time 374, horizon 121\n", - "adding: mem time254, current time 374, horizon 120\n", - "adding: mem time255, current time 374, horizon 119\n", - "adding: mem time256, current time 374, horizon 118\n", - "adding: mem time257, current time 374, horizon 117\n", - "adding: mem time258, current time 374, horizon 116\n", - "adding: mem time259, current time 374, horizon 115\n", - "adding: mem time260, current time 374, horizon 114\n", - "adding: mem time261, current time 374, horizon 113\n", - "adding: mem time262, current time 374, horizon 112\n", - "adding: mem time263, current time 374, horizon 111\n", - "adding: mem time264, current time 374, horizon 110\n", - "adding: mem time265, current time 374, horizon 109\n", - "adding: mem time266, current time 374, horizon 108\n", - "adding: mem time267, current time 374, horizon 107\n", - "adding: mem time268, current time 374, horizon 106\n", - "adding: mem time269, current time 374, horizon 105\n", - "adding: mem time270, current time 374, horizon 104\n", - "adding: mem time271, current time 374, horizon 103\n", - "adding: mem time272, current time 374, horizon 102\n", - "adding: mem time273, current time 374, horizon 101\n", - "adding: mem time274, current time 374, horizon 100\n", - "adding: mem time275, current time 374, horizon 99\n", - "adding: mem time276, current time 374, horizon 98\n", - "adding: mem time277, current time 374, horizon 97\n", - "adding: mem time278, current time 374, horizon 96\n", - "adding: mem time279, current time 374, horizon 95\n", - "adding: mem time280, current time 374, horizon 94\n", - "adding: mem time281, current time 374, horizon 93\n", - "adding: mem time282, current time 374, horizon 92\n", - "adding: mem time283, current time 374, horizon 91\n", - "adding: mem time284, current time 374, horizon 90\n", - "adding: mem time285, current time 374, horizon 89\n", - "adding: mem time286, current time 374, horizon 88\n", - "adding: mem time287, current time 374, horizon 87\n", - "adding: mem time288, current time 374, horizon 86\n", - "adding: mem time289, current time 374, horizon 85\n", - "adding: mem time290, current time 374, horizon 84\n", - "adding: mem time291, current time 374, horizon 83\n", - "adding: mem time292, current time 374, horizon 82\n", - "adding: mem time293, current time 374, horizon 81\n", - "adding: mem time294, current time 374, horizon 80\n", - "adding: mem time295, current time 374, horizon 79\n", - "adding: mem time296, current time 374, horizon 78\n", - "adding: mem time297, current time 374, horizon 77\n", - "adding: mem time298, current time 374, horizon 76\n", - "adding: mem time299, current time 374, horizon 75\n", - "adding: mem time300, current time 374, horizon 74\n", - "adding: mem time301, current time 374, horizon 73\n", - "adding: mem time302, current time 374, horizon 72\n", - "adding: mem time303, current time 374, horizon 71\n", - "adding: mem time304, current time 374, horizon 70\n", - "adding: mem time305, current time 374, horizon 69\n", - "adding: mem time306, current time 374, horizon 68\n", - "adding: mem time307, current time 374, horizon 67\n", - "adding: mem time308, current time 374, horizon 66\n", - "adding: mem time309, current time 374, horizon 65\n", - "adding: mem time310, current time 374, horizon 64\n", - "adding: mem time311, current time 374, horizon 63\n", - "adding: mem time312, current time 374, horizon 62\n", - "adding: mem time313, current time 374, horizon 61\n", - "adding: mem time314, current time 374, horizon 60\n", - "adding: mem time315, current time 374, horizon 59\n", - "adding: mem time316, current time 374, horizon 58\n", - "adding: mem time317, current time 374, horizon 57\n", - "adding: mem time318, current time 374, horizon 56\n", - "adding: mem time319, current time 374, horizon 55\n", - "adding: mem time320, current time 374, horizon 54\n", - "adding: mem time321, current time 374, horizon 53\n", - "adding: mem time322, current time 374, horizon 52\n", - "adding: mem time323, current time 374, horizon 51\n", - "adding: mem time324, current time 374, horizon 50\n", - "adding: mem time325, current time 374, horizon 49\n", - "adding: mem time326, current time 374, horizon 48\n", - "adding: mem time327, current time 374, horizon 47\n", - "adding: mem time328, current time 374, horizon 46\n", - "adding: mem time329, current time 374, horizon 45\n", - "adding: mem time330, current time 374, horizon 44\n", - "adding: mem time331, current time 374, horizon 43\n", - "adding: mem time332, current time 374, horizon 42\n", - "adding: mem time333, current time 374, horizon 41\n", - "adding: mem time334, current time 374, horizon 40\n", - "adding: mem time335, current time 374, horizon 39\n", - "adding: mem time336, current time 374, horizon 38\n", - "adding: mem time337, current time 374, horizon 37\n", - "adding: mem time338, current time 374, horizon 36\n", - "adding: mem time339, current time 374, horizon 35\n", - "adding: mem time340, current time 374, horizon 34\n", - "adding: mem time341, current time 374, horizon 33\n", - "adding: mem time342, current time 374, horizon 32\n", - "adding: mem time343, current time 374, horizon 31\n", - "adding: mem time344, current time 374, horizon 30\n", - "adding: mem time345, current time 374, horizon 29\n", - "adding: mem time346, current time 374, horizon 28\n", - "adding: mem time347, current time 374, horizon 27\n", - "adding: mem time348, current time 374, horizon 26\n", - "adding: mem time349, current time 374, horizon 25\n", - "adding: mem time350, current time 374, horizon 24\n", - "adding: mem time351, current time 374, horizon 23\n", - "adding: mem time352, current time 374, horizon 22\n", - "adding: mem time353, current time 374, horizon 21\n", - "adding: mem time354, current time 374, horizon 20\n", - "adding: mem time355, current time 374, horizon 19\n", - "adding: mem time356, current time 374, horizon 18\n", - "adding: mem time357, current time 374, horizon 17\n", - "adding: mem time358, current time 374, horizon 16\n", - "adding: mem time359, current time 374, horizon 15\n", - "adding: mem time360, current time 374, horizon 14\n", - "adding: mem time361, current time 374, horizon 13\n", - "adding: mem time362, current time 374, horizon 12\n", - "adding: mem time363, current time 374, horizon 11\n", - "adding: mem time364, current time 374, horizon 10\n", - "adding: mem time365, current time 374, horizon 9\n", - "adding: mem time366, current time 374, horizon 8\n", - "adding: mem time367, current time 374, horizon 7\n", - "adding: mem time368, current time 374, horizon 6\n", - "adding: mem time369, current time 374, horizon 5\n", - "adding: mem time370, current time 374, horizon 4\n", - "adding: mem time371, current time 374, horizon 3\n", - "adding: mem time372, current time 374, horizon 2\n", - "adding: mem time373, current time 374, horizon 1\n", - "adding: mem time200, current time 375, horizon 175\n", - "adding: mem time201, current time 375, horizon 174\n", - "adding: mem time202, current time 375, horizon 173\n", - "adding: mem time203, current time 375, horizon 172\n", - "adding: mem time204, current time 375, horizon 171\n", - "adding: mem time205, current time 375, horizon 170\n", - "adding: mem time206, current time 375, horizon 169\n", - "adding: mem time207, current time 375, horizon 168\n", - "adding: mem time208, current time 375, horizon 167\n", - "adding: mem time209, current time 375, horizon 166\n", - "adding: mem time210, current time 375, horizon 165\n", - "adding: mem time211, current time 375, horizon 164\n", - "adding: mem time212, current time 375, horizon 163\n", - "adding: mem time213, current time 375, horizon 162\n", - "adding: mem time214, current time 375, horizon 161\n", - "adding: mem time215, current time 375, horizon 160\n", - "adding: mem time216, current time 375, horizon 159\n", - "adding: mem time217, current time 375, horizon 158\n", - "adding: mem time218, current time 375, horizon 157\n", - "adding: mem time219, current time 375, horizon 156\n", - "adding: mem time220, current time 375, horizon 155\n", - "adding: mem time221, current time 375, horizon 154\n", - "adding: mem time222, current time 375, horizon 153\n", - "adding: mem time223, current time 375, horizon 152\n", - "adding: mem time224, current time 375, horizon 151\n", - "adding: mem time225, current time 375, horizon 150\n", - "adding: mem time226, current time 375, horizon 149\n", - "adding: mem time227, current time 375, horizon 148\n", - "adding: mem time228, current time 375, horizon 147\n", - "adding: mem time229, current time 375, horizon 146\n", - "adding: mem time230, current time 375, horizon 145\n", - "adding: mem time231, current time 375, horizon 144\n", - "adding: mem time232, current time 375, horizon 143\n", - "adding: mem time233, current time 375, horizon 142\n", - "adding: mem time234, current time 375, horizon 141\n", - "adding: mem time235, current time 375, horizon 140\n", - "adding: mem time236, current time 375, horizon 139\n", - "adding: mem time237, current time 375, horizon 138\n", - "adding: mem time238, current time 375, horizon 137\n", - "adding: mem time239, current time 375, horizon 136\n", - "adding: mem time240, current time 375, horizon 135\n", - "adding: mem time241, current time 375, horizon 134\n", - "adding: mem time242, current time 375, horizon 133\n", - "adding: mem time243, current time 375, horizon 132\n", - "adding: mem time244, current time 375, horizon 131\n", - "adding: mem time245, current time 375, horizon 130\n", - "adding: mem time246, current time 375, horizon 129\n", - "adding: mem time247, current time 375, horizon 128\n", - "adding: mem time248, current time 375, horizon 127\n", - "adding: mem time249, current time 375, horizon 126\n", - "adding: mem time250, current time 375, horizon 125\n", - "adding: mem time251, current time 375, horizon 124\n", - "adding: mem time252, current time 375, horizon 123\n", - "adding: mem time253, current time 375, horizon 122\n", - "adding: mem time254, current time 375, horizon 121\n", - "adding: mem time255, current time 375, horizon 120\n", - "adding: mem time256, current time 375, horizon 119\n", - "adding: mem time257, current time 375, horizon 118\n", - "adding: mem time258, current time 375, horizon 117\n", - "adding: mem time259, current time 375, horizon 116\n", - "adding: mem time260, current time 375, horizon 115\n", - "adding: mem time261, current time 375, horizon 114\n", - "adding: mem time262, current time 375, horizon 113\n", - "adding: mem time263, current time 375, horizon 112\n", - "adding: mem time264, current time 375, horizon 111\n", - "adding: mem time265, current time 375, horizon 110\n", - "adding: mem time266, current time 375, horizon 109\n", - "adding: mem time267, current time 375, horizon 108\n", - "adding: mem time268, current time 375, horizon 107\n", - "adding: mem time269, current time 375, horizon 106\n", - "adding: mem time270, current time 375, horizon 105\n", - "adding: mem time271, current time 375, horizon 104\n", - "adding: mem time272, current time 375, horizon 103\n", - "adding: mem time273, current time 375, horizon 102\n", - "adding: mem time274, current time 375, horizon 101\n", - "adding: mem time275, current time 375, horizon 100\n", - "adding: mem time276, current time 375, horizon 99\n", - "adding: mem time277, current time 375, horizon 98\n", - "adding: mem time278, current time 375, horizon 97\n", - "adding: mem time279, current time 375, horizon 96\n", - "adding: mem time280, current time 375, horizon 95\n", - "adding: mem time281, current time 375, horizon 94\n", - "adding: mem time282, current time 375, horizon 93\n", - "adding: mem time283, current time 375, horizon 92\n", - "adding: mem time284, current time 375, horizon 91\n", - "adding: mem time285, current time 375, horizon 90\n", - "adding: mem time286, current time 375, horizon 89\n", - "adding: mem time287, current time 375, horizon 88\n", - "adding: mem time288, current time 375, horizon 87\n", - "adding: mem time289, current time 375, horizon 86\n", - "adding: mem time290, current time 375, horizon 85\n", - "adding: mem time291, current time 375, horizon 84\n", - "adding: mem time292, current time 375, horizon 83\n", - "adding: mem time293, current time 375, horizon 82\n", - "adding: mem time294, current time 375, horizon 81\n", - "adding: mem time295, current time 375, horizon 80\n", - "adding: mem time296, current time 375, horizon 79\n", - "adding: mem time297, current time 375, horizon 78\n", - "adding: mem time298, current time 375, horizon 77\n", - "adding: mem time299, current time 375, horizon 76\n", - "adding: mem time300, current time 375, horizon 75\n", - "adding: mem time301, current time 375, horizon 74\n", - "adding: mem time302, current time 375, horizon 73\n", - "adding: mem time303, current time 375, horizon 72\n", - "adding: mem time304, current time 375, horizon 71\n", - "adding: mem time305, current time 375, horizon 70\n", - "adding: mem time306, current time 375, horizon 69\n", - "adding: mem time307, current time 375, horizon 68\n", - "adding: mem time308, current time 375, horizon 67\n", - "adding: mem time309, current time 375, horizon 66\n", - "adding: mem time310, current time 375, horizon 65\n", - "adding: mem time311, current time 375, horizon 64\n", - "adding: mem time312, current time 375, horizon 63\n", - "adding: mem time313, current time 375, horizon 62\n", - "adding: mem time314, current time 375, horizon 61\n", - "adding: mem time315, current time 375, horizon 60\n", - "adding: mem time316, current time 375, horizon 59\n", - "adding: mem time317, current time 375, horizon 58\n", - "adding: mem time318, current time 375, horizon 57\n", - "adding: mem time319, current time 375, horizon 56\n", - "adding: mem time320, current time 375, horizon 55\n", - "adding: mem time321, current time 375, horizon 54\n", - "adding: mem time322, current time 375, horizon 53\n", - "adding: mem time323, current time 375, horizon 52\n", - "adding: mem time324, current time 375, horizon 51\n", - "adding: mem time325, current time 375, horizon 50\n", - "adding: mem time326, current time 375, horizon 49\n", - "adding: mem time327, current time 375, horizon 48\n", - "adding: mem time328, current time 375, horizon 47\n", - "adding: mem time329, current time 375, horizon 46\n", - "adding: mem time330, current time 375, horizon 45\n", - "adding: mem time331, current time 375, horizon 44\n", - "adding: mem time332, current time 375, horizon 43\n", - "adding: mem time333, current time 375, horizon 42\n", - "adding: mem time334, current time 375, horizon 41\n", - "adding: mem time335, current time 375, horizon 40\n", - "adding: mem time336, current time 375, horizon 39\n", - "adding: mem time337, current time 375, horizon 38\n", - "adding: mem time338, current time 375, horizon 37\n", - "adding: mem time339, current time 375, horizon 36\n", - "adding: mem time340, current time 375, horizon 35\n", - "adding: mem time341, current time 375, horizon 34\n", - "adding: mem time342, current time 375, horizon 33\n", - "adding: mem time343, current time 375, horizon 32\n", - "adding: mem time344, current time 375, horizon 31\n", - "adding: mem time345, current time 375, horizon 30\n", - "adding: mem time346, current time 375, horizon 29\n", - "adding: mem time347, current time 375, horizon 28\n", - "adding: mem time348, current time 375, horizon 27\n", - "adding: mem time349, current time 375, horizon 26\n", - "adding: mem time350, current time 375, horizon 25\n", - "adding: mem time351, current time 375, horizon 24\n", - "adding: mem time352, current time 375, horizon 23\n", - "adding: mem time353, current time 375, horizon 22\n", - "adding: mem time354, current time 375, horizon 21\n", - "adding: mem time355, current time 375, horizon 20\n", - "adding: mem time356, current time 375, horizon 19\n", - "adding: mem time357, current time 375, horizon 18\n", - "adding: mem time358, current time 375, horizon 17\n", - "adding: mem time359, current time 375, horizon 16\n", - "adding: mem time360, current time 375, horizon 15\n", - "adding: mem time361, current time 375, horizon 14\n", - "adding: mem time362, current time 375, horizon 13\n", - "adding: mem time363, current time 375, horizon 12\n", - "adding: mem time364, current time 375, horizon 11\n", - "adding: mem time365, current time 375, horizon 10\n", - "adding: mem time366, current time 375, horizon 9\n", - "adding: mem time367, current time 375, horizon 8\n", - "adding: mem time368, current time 375, horizon 7\n", - "adding: mem time369, current time 375, horizon 6\n", - "adding: mem time370, current time 375, horizon 5\n", - "adding: mem time371, current time 375, horizon 4\n", - "adding: mem time372, current time 375, horizon 3\n", - "adding: mem time373, current time 375, horizon 2\n", - "adding: mem time374, current time 375, horizon 1\n", - "adding: mem time200, current time 376, horizon 176\n", - "adding: mem time201, current time 376, horizon 175\n", - "adding: mem time202, current time 376, horizon 174\n", - "adding: mem time203, current time 376, horizon 173\n", - "adding: mem time204, current time 376, horizon 172\n", - "adding: mem time205, current time 376, horizon 171\n", - "adding: mem time206, current time 376, horizon 170\n", - "adding: mem time207, current time 376, horizon 169\n", - "adding: mem time208, current time 376, horizon 168\n", - "adding: mem time209, current time 376, horizon 167\n", - "adding: mem time210, current time 376, horizon 166\n", - "adding: mem time211, current time 376, horizon 165\n", - "adding: mem time212, current time 376, horizon 164\n", - "adding: mem time213, current time 376, horizon 163\n", - "adding: mem time214, current time 376, horizon 162\n", - "adding: mem time215, current time 376, horizon 161\n", - "adding: mem time216, current time 376, horizon 160\n", - "adding: mem time217, current time 376, horizon 159\n", - "adding: mem time218, current time 376, horizon 158\n", - "adding: mem time219, current time 376, horizon 157\n", - "adding: mem time220, current time 376, horizon 156\n", - "adding: mem time221, current time 376, horizon 155\n", - "adding: mem time222, current time 376, horizon 154\n", - "adding: mem time223, current time 376, horizon 153\n", - "adding: mem time224, current time 376, horizon 152\n", - "adding: mem time225, current time 376, horizon 151\n", - "adding: mem time226, current time 376, horizon 150\n", - "adding: mem time227, current time 376, horizon 149\n", - "adding: mem time228, current time 376, horizon 148\n", - "adding: mem time229, current time 376, horizon 147\n", - "adding: mem time230, current time 376, horizon 146\n", - "adding: mem time231, current time 376, horizon 145\n", - "adding: mem time232, current time 376, horizon 144\n", - "adding: mem time233, current time 376, horizon 143\n", - "adding: mem time234, current time 376, horizon 142\n", - "adding: mem time235, current time 376, horizon 141\n", - "adding: mem time236, current time 376, horizon 140\n", - "adding: mem time237, current time 376, horizon 139\n", - "adding: mem time238, current time 376, horizon 138\n", - "adding: mem time239, current time 376, horizon 137\n", - "adding: mem time240, current time 376, horizon 136\n", - "adding: mem time241, current time 376, horizon 135\n", - "adding: mem time242, current time 376, horizon 134\n", - "adding: mem time243, current time 376, horizon 133\n", - "adding: mem time244, current time 376, horizon 132\n", - "adding: mem time245, current time 376, horizon 131\n", - "adding: mem time246, current time 376, horizon 130\n", - "adding: mem time247, current time 376, horizon 129\n", - "adding: mem time248, current time 376, horizon 128\n", - "adding: mem time249, current time 376, horizon 127\n", - "adding: mem time250, current time 376, horizon 126\n", - "adding: mem time251, current time 376, horizon 125\n", - "adding: mem time252, current time 376, horizon 124\n", - "adding: mem time253, current time 376, horizon 123\n", - "adding: mem time254, current time 376, horizon 122\n", - "adding: mem time255, current time 376, horizon 121\n", - "adding: mem time256, current time 376, horizon 120\n", - "adding: mem time257, current time 376, horizon 119\n", - "adding: mem time258, current time 376, horizon 118\n", - "adding: mem time259, current time 376, horizon 117\n", - "adding: mem time260, current time 376, horizon 116\n", - "adding: mem time261, current time 376, horizon 115\n", - "adding: mem time262, current time 376, horizon 114\n", - "adding: mem time263, current time 376, horizon 113\n", - "adding: mem time264, current time 376, horizon 112\n", - "adding: mem time265, current time 376, horizon 111\n", - "adding: mem time266, current time 376, horizon 110\n", - "adding: mem time267, current time 376, horizon 109\n", - "adding: mem time268, current time 376, horizon 108\n", - "adding: mem time269, current time 376, horizon 107\n", - "adding: mem time270, current time 376, horizon 106\n", - "adding: mem time271, current time 376, horizon 105\n", - "adding: mem time272, current time 376, horizon 104\n", - "adding: mem time273, current time 376, horizon 103\n", - "adding: mem time274, current time 376, horizon 102\n", - "adding: mem time275, current time 376, horizon 101\n", - "adding: mem time276, current time 376, horizon 100\n", - "adding: mem time277, current time 376, horizon 99\n", - "adding: mem time278, current time 376, horizon 98\n", - "adding: mem time279, current time 376, horizon 97\n", - "adding: mem time280, current time 376, horizon 96\n", - "adding: mem time281, current time 376, horizon 95\n", - "adding: mem time282, current time 376, horizon 94\n", - "adding: mem time283, current time 376, horizon 93\n", - "adding: mem time284, current time 376, horizon 92\n", - "adding: mem time285, current time 376, horizon 91\n", - "adding: mem time286, current time 376, horizon 90\n", - "adding: mem time287, current time 376, horizon 89\n", - "adding: mem time288, current time 376, horizon 88\n", - "adding: mem time289, current time 376, horizon 87\n", - "adding: mem time290, current time 376, horizon 86\n", - "adding: mem time291, current time 376, horizon 85\n", - "adding: mem time292, current time 376, horizon 84\n", - "adding: mem time293, current time 376, horizon 83\n", - "adding: mem time294, current time 376, horizon 82\n", - "adding: mem time295, current time 376, horizon 81\n", - "adding: mem time296, current time 376, horizon 80\n", - "adding: mem time297, current time 376, horizon 79\n", - "adding: mem time298, current time 376, horizon 78\n", - "adding: mem time299, current time 376, horizon 77\n", - "adding: mem time300, current time 376, horizon 76\n", - "adding: mem time301, current time 376, horizon 75\n", - "adding: mem time302, current time 376, horizon 74\n", - "adding: mem time303, current time 376, horizon 73\n", - "adding: mem time304, current time 376, horizon 72\n", - "adding: mem time305, current time 376, horizon 71\n", - "adding: mem time306, current time 376, horizon 70\n", - "adding: mem time307, current time 376, horizon 69\n", - "adding: mem time308, current time 376, horizon 68\n", - "adding: mem time309, current time 376, horizon 67\n", - "adding: mem time310, current time 376, horizon 66\n", - "adding: mem time311, current time 376, horizon 65\n", - "adding: mem time312, current time 376, horizon 64\n", - "adding: mem time313, current time 376, horizon 63\n", - "adding: mem time314, current time 376, horizon 62\n", - "adding: mem time315, current time 376, horizon 61\n", - "adding: mem time316, current time 376, horizon 60\n", - "adding: mem time317, current time 376, horizon 59\n", - "adding: mem time318, current time 376, horizon 58\n", - "adding: mem time319, current time 376, horizon 57\n", - "adding: mem time320, current time 376, horizon 56\n", - "adding: mem time321, current time 376, horizon 55\n", - "adding: mem time322, current time 376, horizon 54\n", - "adding: mem time323, current time 376, horizon 53\n", - "adding: mem time324, current time 376, horizon 52\n", - "adding: mem time325, current time 376, horizon 51\n", - "adding: mem time326, current time 376, horizon 50\n", - "adding: mem time327, current time 376, horizon 49\n", - "adding: mem time328, current time 376, horizon 48\n", - "adding: mem time329, current time 376, horizon 47\n", - "adding: mem time330, current time 376, horizon 46\n", - "adding: mem time331, current time 376, horizon 45\n", - "adding: mem time332, current time 376, horizon 44\n", - "adding: mem time333, current time 376, horizon 43\n", - "adding: mem time334, current time 376, horizon 42\n", - "adding: mem time335, current time 376, horizon 41\n", - "adding: mem time336, current time 376, horizon 40\n", - "adding: mem time337, current time 376, horizon 39\n", - "adding: mem time338, current time 376, horizon 38\n", - "adding: mem time339, current time 376, horizon 37\n", - "adding: mem time340, current time 376, horizon 36\n", - "adding: mem time341, current time 376, horizon 35\n", - "adding: mem time342, current time 376, horizon 34\n", - "adding: mem time343, current time 376, horizon 33\n", - "adding: mem time344, current time 376, horizon 32\n", - "adding: mem time345, current time 376, horizon 31\n", - "adding: mem time346, current time 376, horizon 30\n", - "adding: mem time347, current time 376, horizon 29\n", - "adding: mem time348, current time 376, horizon 28\n", - "adding: mem time349, current time 376, horizon 27\n", - "adding: mem time350, current time 376, horizon 26\n", - "adding: mem time351, current time 376, horizon 25\n", - "adding: mem time352, current time 376, horizon 24\n", - "adding: mem time353, current time 376, horizon 23\n", - "adding: mem time354, current time 376, horizon 22\n", - "adding: mem time355, current time 376, horizon 21\n", - "adding: mem time356, current time 376, horizon 20\n", - "adding: mem time357, current time 376, horizon 19\n", - "adding: mem time358, current time 376, horizon 18\n", - "adding: mem time359, current time 376, horizon 17\n", - "adding: mem time360, current time 376, horizon 16\n", - "adding: mem time361, current time 376, horizon 15\n", - "adding: mem time362, current time 376, horizon 14\n", - "adding: mem time363, current time 376, horizon 13\n", - "adding: mem time364, current time 376, horizon 12\n", - "adding: mem time365, current time 376, horizon 11\n", - "adding: mem time366, current time 376, horizon 10\n", - "adding: mem time367, current time 376, horizon 9\n", - "adding: mem time368, current time 376, horizon 8\n", - "adding: mem time369, current time 376, horizon 7\n", - "adding: mem time370, current time 376, horizon 6\n", - "adding: mem time371, current time 376, horizon 5\n", - "adding: mem time372, current time 376, horizon 4\n", - "adding: mem time373, current time 376, horizon 3\n", - "adding: mem time374, current time 376, horizon 2\n", - "adding: mem time375, current time 376, horizon 1\n", - "adding: mem time200, current time 377, horizon 177\n", - "adding: mem time201, current time 377, horizon 176\n", - "adding: mem time202, current time 377, horizon 175\n", - "adding: mem time203, current time 377, horizon 174\n", - "adding: mem time204, current time 377, horizon 173\n", - "adding: mem time205, current time 377, horizon 172\n", - "adding: mem time206, current time 377, horizon 171\n", - "adding: mem time207, current time 377, horizon 170\n", - "adding: mem time208, current time 377, horizon 169\n", - "adding: mem time209, current time 377, horizon 168\n", - "adding: mem time210, current time 377, horizon 167\n", - "adding: mem time211, current time 377, horizon 166\n", - "adding: mem time212, current time 377, horizon 165\n", - "adding: mem time213, current time 377, horizon 164\n", - "adding: mem time214, current time 377, horizon 163\n", - "adding: mem time215, current time 377, horizon 162\n", - "adding: mem time216, current time 377, horizon 161\n", - "adding: mem time217, current time 377, horizon 160\n", - "adding: mem time218, current time 377, horizon 159\n", - "adding: mem time219, current time 377, horizon 158\n", - "adding: mem time220, current time 377, horizon 157\n", - "adding: mem time221, current time 377, horizon 156\n", - "adding: mem time222, current time 377, horizon 155\n", - "adding: mem time223, current time 377, horizon 154\n", - "adding: mem time224, current time 377, horizon 153\n", - "adding: mem time225, current time 377, horizon 152\n", - "adding: mem time226, current time 377, horizon 151\n", - "adding: mem time227, current time 377, horizon 150\n", - "adding: mem time228, current time 377, horizon 149\n", - "adding: mem time229, current time 377, horizon 148\n", - "adding: mem time230, current time 377, horizon 147\n", - "adding: mem time231, current time 377, horizon 146\n", - "adding: mem time232, current time 377, horizon 145\n", - "adding: mem time233, current time 377, horizon 144\n", - "adding: mem time234, current time 377, horizon 143\n", - "adding: mem time235, current time 377, horizon 142\n", - "adding: mem time236, current time 377, horizon 141\n", - "adding: mem time237, current time 377, horizon 140\n", - "adding: mem time238, current time 377, horizon 139\n", - "adding: mem time239, current time 377, horizon 138\n", - "adding: mem time240, current time 377, horizon 137\n", - "adding: mem time241, current time 377, horizon 136\n", - "adding: mem time242, current time 377, horizon 135\n", - "adding: mem time243, current time 377, horizon 134\n", - "adding: mem time244, current time 377, horizon 133\n", - "adding: mem time245, current time 377, horizon 132\n", - "adding: mem time246, current time 377, horizon 131\n", - "adding: mem time247, current time 377, horizon 130\n", - "adding: mem time248, current time 377, horizon 129\n", - "adding: mem time249, current time 377, horizon 128\n", - "adding: mem time250, current time 377, horizon 127\n", - "adding: mem time251, current time 377, horizon 126\n", - "adding: mem time252, current time 377, horizon 125\n", - "adding: mem time253, current time 377, horizon 124\n", - "adding: mem time254, current time 377, horizon 123\n", - "adding: mem time255, current time 377, horizon 122\n", - "adding: mem time256, current time 377, horizon 121\n", - "adding: mem time257, current time 377, horizon 120\n", - "adding: mem time258, current time 377, horizon 119\n", - "adding: mem time259, current time 377, horizon 118\n", - "adding: mem time260, current time 377, horizon 117\n", - "adding: mem time261, current time 377, horizon 116\n", - "adding: mem time262, current time 377, horizon 115\n", - "adding: mem time263, current time 377, horizon 114\n", - "adding: mem time264, current time 377, horizon 113\n", - "adding: mem time265, current time 377, horizon 112\n", - "adding: mem time266, current time 377, horizon 111\n", - "adding: mem time267, current time 377, horizon 110\n", - "adding: mem time268, current time 377, horizon 109\n", - "adding: mem time269, current time 377, horizon 108\n", - "adding: mem time270, current time 377, horizon 107\n", - "adding: mem time271, current time 377, horizon 106\n", - "adding: mem time272, current time 377, horizon 105\n", - "adding: mem time273, current time 377, horizon 104\n", - "adding: mem time274, current time 377, horizon 103\n", - "adding: mem time275, current time 377, horizon 102\n", - "adding: mem time276, current time 377, horizon 101\n", - "adding: mem time277, current time 377, horizon 100\n", - "adding: mem time278, current time 377, horizon 99\n", - "adding: mem time279, current time 377, horizon 98\n", - "adding: mem time280, current time 377, horizon 97\n", - "adding: mem time281, current time 377, horizon 96\n", - "adding: mem time282, current time 377, horizon 95\n", - "adding: mem time283, current time 377, horizon 94\n", - "adding: mem time284, current time 377, horizon 93\n", - "adding: mem time285, current time 377, horizon 92\n", - "adding: mem time286, current time 377, horizon 91\n", - "adding: mem time287, current time 377, horizon 90\n", - "adding: mem time288, current time 377, horizon 89\n", - "adding: mem time289, current time 377, horizon 88\n", - "adding: mem time290, current time 377, horizon 87\n", - "adding: mem time291, current time 377, horizon 86\n", - "adding: mem time292, current time 377, horizon 85\n", - "adding: mem time293, current time 377, horizon 84\n", - "adding: mem time294, current time 377, horizon 83\n", - "adding: mem time295, current time 377, horizon 82\n", - "adding: mem time296, current time 377, horizon 81\n", - "adding: mem time297, current time 377, horizon 80\n", - "adding: mem time298, current time 377, horizon 79\n", - "adding: mem time299, current time 377, horizon 78\n", - "adding: mem time300, current time 377, horizon 77\n", - "adding: mem time301, current time 377, horizon 76\n", - "adding: mem time302, current time 377, horizon 75\n", - "adding: mem time303, current time 377, horizon 74\n", - "adding: mem time304, current time 377, horizon 73\n", - "adding: mem time305, current time 377, horizon 72\n", - "adding: mem time306, current time 377, horizon 71\n", - "adding: mem time307, current time 377, horizon 70\n", - "adding: mem time308, current time 377, horizon 69\n", - "adding: mem time309, current time 377, horizon 68\n", - "adding: mem time310, current time 377, horizon 67\n", - "adding: mem time311, current time 377, horizon 66\n", - "adding: mem time312, current time 377, horizon 65\n", - "adding: mem time313, current time 377, horizon 64\n", - "adding: mem time314, current time 377, horizon 63\n", - "adding: mem time315, current time 377, horizon 62\n", - "adding: mem time316, current time 377, horizon 61\n", - "adding: mem time317, current time 377, horizon 60\n", - "adding: mem time318, current time 377, horizon 59\n", - "adding: mem time319, current time 377, horizon 58\n", - "adding: mem time320, current time 377, horizon 57\n", - "adding: mem time321, current time 377, horizon 56\n", - "adding: mem time322, current time 377, horizon 55\n", - "adding: mem time323, current time 377, horizon 54\n", - "adding: mem time324, current time 377, horizon 53\n", - "adding: mem time325, current time 377, horizon 52\n", - "adding: mem time326, current time 377, horizon 51\n", - "adding: mem time327, current time 377, horizon 50\n", - "adding: mem time328, current time 377, horizon 49\n", - "adding: mem time329, current time 377, horizon 48\n", - "adding: mem time330, current time 377, horizon 47\n", - "adding: mem time331, current time 377, horizon 46\n", - "adding: mem time332, current time 377, horizon 45\n", - "adding: mem time333, current time 377, horizon 44\n", - "adding: mem time334, current time 377, horizon 43\n", - "adding: mem time335, current time 377, horizon 42\n", - "adding: mem time336, current time 377, horizon 41\n", - "adding: mem time337, current time 377, horizon 40\n", - "adding: mem time338, current time 377, horizon 39\n", - "adding: mem time339, current time 377, horizon 38\n", - "adding: mem time340, current time 377, horizon 37\n", - "adding: mem time341, current time 377, horizon 36\n", - "adding: mem time342, current time 377, horizon 35\n", - "adding: mem time343, current time 377, horizon 34\n", - "adding: mem time344, current time 377, horizon 33\n", - "adding: mem time345, current time 377, horizon 32\n", - "adding: mem time346, current time 377, horizon 31\n", - "adding: mem time347, current time 377, horizon 30\n", - "adding: mem time348, current time 377, horizon 29\n", - "adding: mem time349, current time 377, horizon 28\n", - "adding: mem time350, current time 377, horizon 27\n", - "adding: mem time351, current time 377, horizon 26\n", - "adding: mem time352, current time 377, horizon 25\n", - "adding: mem time353, current time 377, horizon 24\n", - "adding: mem time354, current time 377, horizon 23\n", - "adding: mem time355, current time 377, horizon 22\n", - "adding: mem time356, current time 377, horizon 21\n", - "adding: mem time357, current time 377, horizon 20\n", - "adding: mem time358, current time 377, horizon 19\n", - "adding: mem time359, current time 377, horizon 18\n", - "adding: mem time360, current time 377, horizon 17\n", - "adding: mem time361, current time 377, horizon 16\n", - "adding: mem time362, current time 377, horizon 15\n", - "adding: mem time363, current time 377, horizon 14\n", - "adding: mem time364, current time 377, horizon 13\n", - "adding: mem time365, current time 377, horizon 12\n", - "adding: mem time366, current time 377, horizon 11\n", - "adding: mem time367, current time 377, horizon 10\n", - "adding: mem time368, current time 377, horizon 9\n", - "adding: mem time369, current time 377, horizon 8\n", - "adding: mem time370, current time 377, horizon 7\n", - "adding: mem time371, current time 377, horizon 6\n", - "adding: mem time372, current time 377, horizon 5\n", - "adding: mem time373, current time 377, horizon 4\n", - "adding: mem time374, current time 377, horizon 3\n", - "adding: mem time375, current time 377, horizon 2\n", - "adding: mem time376, current time 377, horizon 1\n", - "adding: mem time200, current time 378, horizon 178\n", - "adding: mem time201, current time 378, horizon 177\n", - "adding: mem time202, current time 378, horizon 176\n", - "adding: mem time203, current time 378, horizon 175\n", - "adding: mem time204, current time 378, horizon 174\n", - "adding: mem time205, current time 378, horizon 173\n", - "adding: mem time206, current time 378, horizon 172\n", - "adding: mem time207, current time 378, horizon 171\n", - "adding: mem time208, current time 378, horizon 170\n", - "adding: mem time209, current time 378, horizon 169\n", - "adding: mem time210, current time 378, horizon 168\n", - "adding: mem time211, current time 378, horizon 167\n", - "adding: mem time212, current time 378, horizon 166\n", - "adding: mem time213, current time 378, horizon 165\n", - "adding: mem time214, current time 378, horizon 164\n", - "adding: mem time215, current time 378, horizon 163\n", - "adding: mem time216, current time 378, horizon 162\n", - "adding: mem time217, current time 378, horizon 161\n", - "adding: mem time218, current time 378, horizon 160\n", - "adding: mem time219, current time 378, horizon 159\n", - "adding: mem time220, current time 378, horizon 158\n", - "adding: mem time221, current time 378, horizon 157\n", - "adding: mem time222, current time 378, horizon 156\n", - "adding: mem time223, current time 378, horizon 155\n", - "adding: mem time224, current time 378, horizon 154\n", - "adding: mem time225, current time 378, horizon 153\n", - "adding: mem time226, current time 378, horizon 152\n", - "adding: mem time227, current time 378, horizon 151\n", - "adding: mem time228, current time 378, horizon 150\n", - "adding: mem time229, current time 378, horizon 149\n", - "adding: mem time230, current time 378, horizon 148\n", - "adding: mem time231, current time 378, horizon 147\n", - "adding: mem time232, current time 378, horizon 146\n", - "adding: mem time233, current time 378, horizon 145\n", - "adding: mem time234, current time 378, horizon 144\n", - "adding: mem time235, current time 378, horizon 143\n", - "adding: mem time236, current time 378, horizon 142\n", - "adding: mem time237, current time 378, horizon 141\n", - "adding: mem time238, current time 378, horizon 140\n", - "adding: mem time239, current time 378, horizon 139\n", - "adding: mem time240, current time 378, horizon 138\n", - "adding: mem time241, current time 378, horizon 137\n", - "adding: mem time242, current time 378, horizon 136\n", - "adding: mem time243, current time 378, horizon 135\n", - "adding: mem time244, current time 378, horizon 134\n", - "adding: mem time245, current time 378, horizon 133\n", - "adding: mem time246, current time 378, horizon 132\n", - "adding: mem time247, current time 378, horizon 131\n", - "adding: mem time248, current time 378, horizon 130\n", - "adding: mem time249, current time 378, horizon 129\n", - "adding: mem time250, current time 378, horizon 128\n", - "adding: mem time251, current time 378, horizon 127\n", - "adding: mem time252, current time 378, horizon 126\n", - "adding: mem time253, current time 378, horizon 125\n", - "adding: mem time254, current time 378, horizon 124\n", - "adding: mem time255, current time 378, horizon 123\n", - "adding: mem time256, current time 378, horizon 122\n", - "adding: mem time257, current time 378, horizon 121\n", - "adding: mem time258, current time 378, horizon 120\n", - "adding: mem time259, current time 378, horizon 119\n", - "adding: mem time260, current time 378, horizon 118\n", - "adding: mem time261, current time 378, horizon 117\n", - "adding: mem time262, current time 378, horizon 116\n", - "adding: mem time263, current time 378, horizon 115\n", - "adding: mem time264, current time 378, horizon 114\n", - "adding: mem time265, current time 378, horizon 113\n", - "adding: mem time266, current time 378, horizon 112\n", - "adding: mem time267, current time 378, horizon 111\n", - "adding: mem time268, current time 378, horizon 110\n", - "adding: mem time269, current time 378, horizon 109\n", - "adding: mem time270, current time 378, horizon 108\n", - "adding: mem time271, current time 378, horizon 107\n", - "adding: mem time272, current time 378, horizon 106\n", - "adding: mem time273, current time 378, horizon 105\n", - "adding: mem time274, current time 378, horizon 104\n", - "adding: mem time275, current time 378, horizon 103\n", - "adding: mem time276, current time 378, horizon 102\n", - "adding: mem time277, current time 378, horizon 101\n", - "adding: mem time278, current time 378, horizon 100\n", - "adding: mem time279, current time 378, horizon 99\n", - "adding: mem time280, current time 378, horizon 98\n", - "adding: mem time281, current time 378, horizon 97\n", - "adding: mem time282, current time 378, horizon 96\n", - "adding: mem time283, current time 378, horizon 95\n", - "adding: mem time284, current time 378, horizon 94\n", - "adding: mem time285, current time 378, horizon 93\n", - "adding: mem time286, current time 378, horizon 92\n", - "adding: mem time287, current time 378, horizon 91\n", - "adding: mem time288, current time 378, horizon 90\n", - "adding: mem time289, current time 378, horizon 89\n", - "adding: mem time290, current time 378, horizon 88\n", - "adding: mem time291, current time 378, horizon 87\n", - "adding: mem time292, current time 378, horizon 86\n", - "adding: mem time293, current time 378, horizon 85\n", - "adding: mem time294, current time 378, horizon 84\n", - "adding: mem time295, current time 378, horizon 83\n", - "adding: mem time296, current time 378, horizon 82\n", - "adding: mem time297, current time 378, horizon 81\n", - "adding: mem time298, current time 378, horizon 80\n", - "adding: mem time299, current time 378, horizon 79\n", - "adding: mem time300, current time 378, horizon 78\n", - "adding: mem time301, current time 378, horizon 77\n", - "adding: mem time302, current time 378, horizon 76\n", - "adding: mem time303, current time 378, horizon 75\n", - "adding: mem time304, current time 378, horizon 74\n", - "adding: mem time305, current time 378, horizon 73\n", - "adding: mem time306, current time 378, horizon 72\n", - "adding: mem time307, current time 378, horizon 71\n", - "adding: mem time308, current time 378, horizon 70\n", - "adding: mem time309, current time 378, horizon 69\n", - "adding: mem time310, current time 378, horizon 68\n", - "adding: mem time311, current time 378, horizon 67\n", - "adding: mem time312, current time 378, horizon 66\n", - "adding: mem time313, current time 378, horizon 65\n", - "adding: mem time314, current time 378, horizon 64\n", - "adding: mem time315, current time 378, horizon 63\n", - "adding: mem time316, current time 378, horizon 62\n", - "adding: mem time317, current time 378, horizon 61\n", - "adding: mem time318, current time 378, horizon 60\n", - "adding: mem time319, current time 378, horizon 59\n", - "adding: mem time320, current time 378, horizon 58\n", - "adding: mem time321, current time 378, horizon 57\n", - "adding: mem time322, current time 378, horizon 56\n", - "adding: mem time323, current time 378, horizon 55\n", - "adding: mem time324, current time 378, horizon 54\n", - "adding: mem time325, current time 378, horizon 53\n", - "adding: mem time326, current time 378, horizon 52\n", - "adding: mem time327, current time 378, horizon 51\n", - "adding: mem time328, current time 378, horizon 50\n", - "adding: mem time329, current time 378, horizon 49\n", - "adding: mem time330, current time 378, horizon 48\n", - "adding: mem time331, current time 378, horizon 47\n", - "adding: mem time332, current time 378, horizon 46\n", - "adding: mem time333, current time 378, horizon 45\n", - "adding: mem time334, current time 378, horizon 44\n", - "adding: mem time335, current time 378, horizon 43\n", - "adding: mem time336, current time 378, horizon 42\n", - "adding: mem time337, current time 378, horizon 41\n", - "adding: mem time338, current time 378, horizon 40\n", - "adding: mem time339, current time 378, horizon 39\n", - "adding: mem time340, current time 378, horizon 38\n", - "adding: mem time341, current time 378, horizon 37\n", - "adding: mem time342, current time 378, horizon 36\n", - "adding: mem time343, current time 378, horizon 35\n", - "adding: mem time344, current time 378, horizon 34\n", - "adding: mem time345, current time 378, horizon 33\n", - "adding: mem time346, current time 378, horizon 32\n", - "adding: mem time347, current time 378, horizon 31\n", - "adding: mem time348, current time 378, horizon 30\n", - "adding: mem time349, current time 378, horizon 29\n", - "adding: mem time350, current time 378, horizon 28\n", - "adding: mem time351, current time 378, horizon 27\n", - "adding: mem time352, current time 378, horizon 26\n", - "adding: mem time353, current time 378, horizon 25\n", - "adding: mem time354, current time 378, horizon 24\n", - "adding: mem time355, current time 378, horizon 23\n", - "adding: mem time356, current time 378, horizon 22\n", - "adding: mem time357, current time 378, horizon 21\n", - "adding: mem time358, current time 378, horizon 20\n", - "adding: mem time359, current time 378, horizon 19\n", - "adding: mem time360, current time 378, horizon 18\n", - "adding: mem time361, current time 378, horizon 17\n", - "adding: mem time362, current time 378, horizon 16\n", - "adding: mem time363, current time 378, horizon 15\n", - "adding: mem time364, current time 378, horizon 14\n", - "adding: mem time365, current time 378, horizon 13\n", - "adding: mem time366, current time 378, horizon 12\n", - "adding: mem time367, current time 378, horizon 11\n", - "adding: mem time368, current time 378, horizon 10\n", - "adding: mem time369, current time 378, horizon 9\n", - "adding: mem time370, current time 378, horizon 8\n", - "adding: mem time371, current time 378, horizon 7\n", - "adding: mem time372, current time 378, horizon 6\n", - "adding: mem time373, current time 378, horizon 5\n", - "adding: mem time374, current time 378, horizon 4\n", - "adding: mem time375, current time 378, horizon 3\n", - "adding: mem time376, current time 378, horizon 2\n", - "adding: mem time377, current time 378, horizon 1\n", - "adding: mem time200, current time 379, horizon 179\n", - "adding: mem time201, current time 379, horizon 178\n", - "adding: mem time202, current time 379, horizon 177\n", - "adding: mem time203, current time 379, horizon 176\n", - "adding: mem time204, current time 379, horizon 175\n", - "adding: mem time205, current time 379, horizon 174\n", - "adding: mem time206, current time 379, horizon 173\n", - "adding: mem time207, current time 379, horizon 172\n", - "adding: mem time208, current time 379, horizon 171\n", - "adding: mem time209, current time 379, horizon 170\n", - "adding: mem time210, current time 379, horizon 169\n", - "adding: mem time211, current time 379, horizon 168\n", - "adding: mem time212, current time 379, horizon 167\n", - "adding: mem time213, current time 379, horizon 166\n", - "adding: mem time214, current time 379, horizon 165\n", - "adding: mem time215, current time 379, horizon 164\n", - "adding: mem time216, current time 379, horizon 163\n", - "adding: mem time217, current time 379, horizon 162\n", - "adding: mem time218, current time 379, horizon 161\n", - "adding: mem time219, current time 379, horizon 160\n", - "adding: mem time220, current time 379, horizon 159\n", - "adding: mem time221, current time 379, horizon 158\n", - "adding: mem time222, current time 379, horizon 157\n", - "adding: mem time223, current time 379, horizon 156\n", - "adding: mem time224, current time 379, horizon 155\n", - "adding: mem time225, current time 379, horizon 154\n", - "adding: mem time226, current time 379, horizon 153\n", - "adding: mem time227, current time 379, horizon 152\n", - "adding: mem time228, current time 379, horizon 151\n", - "adding: mem time229, current time 379, horizon 150\n", - "adding: mem time230, current time 379, horizon 149\n", - "adding: mem time231, current time 379, horizon 148\n", - "adding: mem time232, current time 379, horizon 147\n", - "adding: mem time233, current time 379, horizon 146\n", - "adding: mem time234, current time 379, horizon 145\n", - "adding: mem time235, current time 379, horizon 144\n", - "adding: mem time236, current time 379, horizon 143\n", - "adding: mem time237, current time 379, horizon 142\n", - "adding: mem time238, current time 379, horizon 141\n", - "adding: mem time239, current time 379, horizon 140\n", - "adding: mem time240, current time 379, horizon 139\n", - "adding: mem time241, current time 379, horizon 138\n", - "adding: mem time242, current time 379, horizon 137\n", - "adding: mem time243, current time 379, horizon 136\n", - "adding: mem time244, current time 379, horizon 135\n", - "adding: mem time245, current time 379, horizon 134\n", - "adding: mem time246, current time 379, horizon 133\n", - "adding: mem time247, current time 379, horizon 132\n", - "adding: mem time248, current time 379, horizon 131\n", - "adding: mem time249, current time 379, horizon 130\n", - "adding: mem time250, current time 379, horizon 129\n", - "adding: mem time251, current time 379, horizon 128\n", - "adding: mem time252, current time 379, horizon 127\n", - "adding: mem time253, current time 379, horizon 126\n", - "adding: mem time254, current time 379, horizon 125\n", - "adding: mem time255, current time 379, horizon 124\n", - "adding: mem time256, current time 379, horizon 123\n", - "adding: mem time257, current time 379, horizon 122\n", - "adding: mem time258, current time 379, horizon 121\n", - "adding: mem time259, current time 379, horizon 120\n", - "adding: mem time260, current time 379, horizon 119\n", - "adding: mem time261, current time 379, horizon 118\n", - "adding: mem time262, current time 379, horizon 117\n", - "adding: mem time263, current time 379, horizon 116\n", - "adding: mem time264, current time 379, horizon 115\n", - "adding: mem time265, current time 379, horizon 114\n", - "adding: mem time266, current time 379, horizon 113\n", - "adding: mem time267, current time 379, horizon 112\n", - "adding: mem time268, current time 379, horizon 111\n", - "adding: mem time269, current time 379, horizon 110\n", - "adding: mem time270, current time 379, horizon 109\n", - "adding: mem time271, current time 379, horizon 108\n", - "adding: mem time272, current time 379, horizon 107\n", - "adding: mem time273, current time 379, horizon 106\n", - "adding: mem time274, current time 379, horizon 105\n", - "adding: mem time275, current time 379, horizon 104\n", - "adding: mem time276, current time 379, horizon 103\n", - "adding: mem time277, current time 379, horizon 102\n", - "adding: mem time278, current time 379, horizon 101\n", - "adding: mem time279, current time 379, horizon 100\n", - "adding: mem time280, current time 379, horizon 99\n", - "adding: mem time281, current time 379, horizon 98\n", - "adding: mem time282, current time 379, horizon 97\n", - "adding: mem time283, current time 379, horizon 96\n", - "adding: mem time284, current time 379, horizon 95\n", - "adding: mem time285, current time 379, horizon 94\n", - "adding: mem time286, current time 379, horizon 93\n", - "adding: mem time287, current time 379, horizon 92\n", - "adding: mem time288, current time 379, horizon 91\n", - "adding: mem time289, current time 379, horizon 90\n", - "adding: mem time290, current time 379, horizon 89\n", - "adding: mem time291, current time 379, horizon 88\n", - "adding: mem time292, current time 379, horizon 87\n", - "adding: mem time293, current time 379, horizon 86\n", - "adding: mem time294, current time 379, horizon 85\n", - "adding: mem time295, current time 379, horizon 84\n", - "adding: mem time296, current time 379, horizon 83\n", - "adding: mem time297, current time 379, horizon 82\n", - "adding: mem time298, current time 379, horizon 81\n", - "adding: mem time299, current time 379, horizon 80\n", - "adding: mem time300, current time 379, horizon 79\n", - "adding: mem time301, current time 379, horizon 78\n", - "adding: mem time302, current time 379, horizon 77\n", - "adding: mem time303, current time 379, horizon 76\n", - "adding: mem time304, current time 379, horizon 75\n", - "adding: mem time305, current time 379, horizon 74\n", - "adding: mem time306, current time 379, horizon 73\n", - "adding: mem time307, current time 379, horizon 72\n", - "adding: mem time308, current time 379, horizon 71\n", - "adding: mem time309, current time 379, horizon 70\n", - "adding: mem time310, current time 379, horizon 69\n", - "adding: mem time311, current time 379, horizon 68\n", - "adding: mem time312, current time 379, horizon 67\n", - "adding: mem time313, current time 379, horizon 66\n", - "adding: mem time314, current time 379, horizon 65\n", - "adding: mem time315, current time 379, horizon 64\n", - "adding: mem time316, current time 379, horizon 63\n", - "adding: mem time317, current time 379, horizon 62\n", - "adding: mem time318, current time 379, horizon 61\n", - "adding: mem time319, current time 379, horizon 60\n", - "adding: mem time320, current time 379, horizon 59\n", - "adding: mem time321, current time 379, horizon 58\n", - "adding: mem time322, current time 379, horizon 57\n", - "adding: mem time323, current time 379, horizon 56\n", - "adding: mem time324, current time 379, horizon 55\n", - "adding: mem time325, current time 379, horizon 54\n", - "adding: mem time326, current time 379, horizon 53\n", - "adding: mem time327, current time 379, horizon 52\n", - "adding: mem time328, current time 379, horizon 51\n", - "adding: mem time329, current time 379, horizon 50\n", - "adding: mem time330, current time 379, horizon 49\n", - "adding: mem time331, current time 379, horizon 48\n", - "adding: mem time332, current time 379, horizon 47\n", - "adding: mem time333, current time 379, horizon 46\n", - "adding: mem time334, current time 379, horizon 45\n", - "adding: mem time335, current time 379, horizon 44\n", - "adding: mem time336, current time 379, horizon 43\n", - "adding: mem time337, current time 379, horizon 42\n", - "adding: mem time338, current time 379, horizon 41\n", - "adding: mem time339, current time 379, horizon 40\n", - "adding: mem time340, current time 379, horizon 39\n", - "adding: mem time341, current time 379, horizon 38\n", - "adding: mem time342, current time 379, horizon 37\n", - "adding: mem time343, current time 379, horizon 36\n", - "adding: mem time344, current time 379, horizon 35\n", - "adding: mem time345, current time 379, horizon 34\n", - "adding: mem time346, current time 379, horizon 33\n", - "adding: mem time347, current time 379, horizon 32\n", - "adding: mem time348, current time 379, horizon 31\n", - "adding: mem time349, current time 379, horizon 30\n", - "adding: mem time350, current time 379, horizon 29\n", - "adding: mem time351, current time 379, horizon 28\n", - "adding: mem time352, current time 379, horizon 27\n", - "adding: mem time353, current time 379, horizon 26\n", - "adding: mem time354, current time 379, horizon 25\n", - "adding: mem time355, current time 379, horizon 24\n", - "adding: mem time356, current time 379, horizon 23\n", - "adding: mem time357, current time 379, horizon 22\n", - "adding: mem time358, current time 379, horizon 21\n", - "adding: mem time359, current time 379, horizon 20\n", - "adding: mem time360, current time 379, horizon 19\n", - "adding: mem time361, current time 379, horizon 18\n", - "adding: mem time362, current time 379, horizon 17\n", - "adding: mem time363, current time 379, horizon 16\n", - "adding: mem time364, current time 379, horizon 15\n", - "adding: mem time365, current time 379, horizon 14\n", - "adding: mem time366, current time 379, horizon 13\n", - "adding: mem time367, current time 379, horizon 12\n", - "adding: mem time368, current time 379, horizon 11\n", - "adding: mem time369, current time 379, horizon 10\n", - "adding: mem time370, current time 379, horizon 9\n", - "adding: mem time371, current time 379, horizon 8\n", - "adding: mem time372, current time 379, horizon 7\n", - "adding: mem time373, current time 379, horizon 6\n", - "adding: mem time374, current time 379, horizon 5\n", - "adding: mem time375, current time 379, horizon 4\n", - "adding: mem time376, current time 379, horizon 3\n", - "adding: mem time377, current time 379, horizon 2\n", - "adding: mem time378, current time 379, horizon 1\n", - "adding: mem time200, current time 380, horizon 180\n", - "adding: mem time201, current time 380, horizon 179\n", - "adding: mem time202, current time 380, horizon 178\n", - "adding: mem time203, current time 380, horizon 177\n", - "adding: mem time204, current time 380, horizon 176\n", - "adding: mem time205, current time 380, horizon 175\n", - "adding: mem time206, current time 380, horizon 174\n", - "adding: mem time207, current time 380, horizon 173\n", - "adding: mem time208, current time 380, horizon 172\n", - "adding: mem time209, current time 380, horizon 171\n", - "adding: mem time210, current time 380, horizon 170\n", - "adding: mem time211, current time 380, horizon 169\n", - "adding: mem time212, current time 380, horizon 168\n", - "adding: mem time213, current time 380, horizon 167\n", - "adding: mem time214, current time 380, horizon 166\n", - "adding: mem time215, current time 380, horizon 165\n", - "adding: mem time216, current time 380, horizon 164\n", - "adding: mem time217, current time 380, horizon 163\n", - "adding: mem time218, current time 380, horizon 162\n", - "adding: mem time219, current time 380, horizon 161\n", - "adding: mem time220, current time 380, horizon 160\n", - "adding: mem time221, current time 380, horizon 159\n", - "adding: mem time222, current time 380, horizon 158\n", - "adding: mem time223, current time 380, horizon 157\n", - "adding: mem time224, current time 380, horizon 156\n", - "adding: mem time225, current time 380, horizon 155\n", - "adding: mem time226, current time 380, horizon 154\n", - "adding: mem time227, current time 380, horizon 153\n", - "adding: mem time228, current time 380, horizon 152\n", - "adding: mem time229, current time 380, horizon 151\n", - "adding: mem time230, current time 380, horizon 150\n", - "adding: mem time231, current time 380, horizon 149\n", - "adding: mem time232, current time 380, horizon 148\n", - "adding: mem time233, current time 380, horizon 147\n", - "adding: mem time234, current time 380, horizon 146\n", - "adding: mem time235, current time 380, horizon 145\n", - "adding: mem time236, current time 380, horizon 144\n", - "adding: mem time237, current time 380, horizon 143\n", - "adding: mem time238, current time 380, horizon 142\n", - "adding: mem time239, current time 380, horizon 141\n", - "adding: mem time240, current time 380, horizon 140\n", - "adding: mem time241, current time 380, horizon 139\n", - "adding: mem time242, current time 380, horizon 138\n", - "adding: mem time243, current time 380, horizon 137\n", - "adding: mem time244, current time 380, horizon 136\n", - "adding: mem time245, current time 380, horizon 135\n", - "adding: mem time246, current time 380, horizon 134\n", - "adding: mem time247, current time 380, horizon 133\n", - "adding: mem time248, current time 380, horizon 132\n", - "adding: mem time249, current time 380, horizon 131\n", - "adding: mem time250, current time 380, horizon 130\n", - "adding: mem time251, current time 380, horizon 129\n", - "adding: mem time252, current time 380, horizon 128\n", - "adding: mem time253, current time 380, horizon 127\n", - "adding: mem time254, current time 380, horizon 126\n", - "adding: mem time255, current time 380, horizon 125\n", - "adding: mem time256, current time 380, horizon 124\n", - "adding: mem time257, current time 380, horizon 123\n", - "adding: mem time258, current time 380, horizon 122\n", - "adding: mem time259, current time 380, horizon 121\n", - "adding: mem time260, current time 380, horizon 120\n", - "adding: mem time261, current time 380, horizon 119\n", - "adding: mem time262, current time 380, horizon 118\n", - "adding: mem time263, current time 380, horizon 117\n", - "adding: mem time264, current time 380, horizon 116\n", - "adding: mem time265, current time 380, horizon 115\n", - "adding: mem time266, current time 380, horizon 114\n", - "adding: mem time267, current time 380, horizon 113\n", - "adding: mem time268, current time 380, horizon 112\n", - "adding: mem time269, current time 380, horizon 111\n", - "adding: mem time270, current time 380, horizon 110\n", - "adding: mem time271, current time 380, horizon 109\n", - "adding: mem time272, current time 380, horizon 108\n", - "adding: mem time273, current time 380, horizon 107\n", - "adding: mem time274, current time 380, horizon 106\n", - "adding: mem time275, current time 380, horizon 105\n", - "adding: mem time276, current time 380, horizon 104\n", - "adding: mem time277, current time 380, horizon 103\n", - "adding: mem time278, current time 380, horizon 102\n", - "adding: mem time279, current time 380, horizon 101\n", - "adding: mem time280, current time 380, horizon 100\n", - "adding: mem time281, current time 380, horizon 99\n", - "adding: mem time282, current time 380, horizon 98\n", - "adding: mem time283, current time 380, horizon 97\n", - "adding: mem time284, current time 380, horizon 96\n", - "adding: mem time285, current time 380, horizon 95\n", - "adding: mem time286, current time 380, horizon 94\n", - "adding: mem time287, current time 380, horizon 93\n", - "adding: mem time288, current time 380, horizon 92\n", - "adding: mem time289, current time 380, horizon 91\n", - "adding: mem time290, current time 380, horizon 90\n", - "adding: mem time291, current time 380, horizon 89\n", - "adding: mem time292, current time 380, horizon 88\n", - "adding: mem time293, current time 380, horizon 87\n", - "adding: mem time294, current time 380, horizon 86\n", - "adding: mem time295, current time 380, horizon 85\n", - "adding: mem time296, current time 380, horizon 84\n", - "adding: mem time297, current time 380, horizon 83\n", - "adding: mem time298, current time 380, horizon 82\n", - "adding: mem time299, current time 380, horizon 81\n", - "adding: mem time300, current time 380, horizon 80\n", - "adding: mem time301, current time 380, horizon 79\n", - "adding: mem time302, current time 380, horizon 78\n", - "adding: mem time303, current time 380, horizon 77\n", - "adding: mem time304, current time 380, horizon 76\n", - "adding: mem time305, current time 380, horizon 75\n", - "adding: mem time306, current time 380, horizon 74\n", - "adding: mem time307, current time 380, horizon 73\n", - "adding: mem time308, current time 380, horizon 72\n", - "adding: mem time309, current time 380, horizon 71\n", - "adding: mem time310, current time 380, horizon 70\n", - "adding: mem time311, current time 380, horizon 69\n", - "adding: mem time312, current time 380, horizon 68\n", - "adding: mem time313, current time 380, horizon 67\n", - "adding: mem time314, current time 380, horizon 66\n", - "adding: mem time315, current time 380, horizon 65\n", - "adding: mem time316, current time 380, horizon 64\n", - "adding: mem time317, current time 380, horizon 63\n", - "adding: mem time318, current time 380, horizon 62\n", - "adding: mem time319, current time 380, horizon 61\n", - "adding: mem time320, current time 380, horizon 60\n", - "adding: mem time321, current time 380, horizon 59\n", - "adding: mem time322, current time 380, horizon 58\n", - "adding: mem time323, current time 380, horizon 57\n", - "adding: mem time324, current time 380, horizon 56\n", - "adding: mem time325, current time 380, horizon 55\n", - "adding: mem time326, current time 380, horizon 54\n", - "adding: mem time327, current time 380, horizon 53\n", - "adding: mem time328, current time 380, horizon 52\n", - "adding: mem time329, current time 380, horizon 51\n", - "adding: mem time330, current time 380, horizon 50\n", - "adding: mem time331, current time 380, horizon 49\n", - "adding: mem time332, current time 380, horizon 48\n", - "adding: mem time333, current time 380, horizon 47\n", - "adding: mem time334, current time 380, horizon 46\n", - "adding: mem time335, current time 380, horizon 45\n", - "adding: mem time336, current time 380, horizon 44\n", - "adding: mem time337, current time 380, horizon 43\n", - "adding: mem time338, current time 380, horizon 42\n", - "adding: mem time339, current time 380, horizon 41\n", - "adding: mem time340, current time 380, horizon 40\n", - "adding: mem time341, current time 380, horizon 39\n", - "adding: mem time342, current time 380, horizon 38\n", - "adding: mem time343, current time 380, horizon 37\n", - "adding: mem time344, current time 380, horizon 36\n", - "adding: mem time345, current time 380, horizon 35\n", - "adding: mem time346, current time 380, horizon 34\n", - "adding: mem time347, current time 380, horizon 33\n", - "adding: mem time348, current time 380, horizon 32\n", - "adding: mem time349, current time 380, horizon 31\n", - "adding: mem time350, current time 380, horizon 30\n", - "adding: mem time351, current time 380, horizon 29\n", - "adding: mem time352, current time 380, horizon 28\n", - "adding: mem time353, current time 380, horizon 27\n", - "adding: mem time354, current time 380, horizon 26\n", - "adding: mem time355, current time 380, horizon 25\n", - "adding: mem time356, current time 380, horizon 24\n", - "adding: mem time357, current time 380, horizon 23\n", - "adding: mem time358, current time 380, horizon 22\n", - "adding: mem time359, current time 380, horizon 21\n", - "adding: mem time360, current time 380, horizon 20\n", - "adding: mem time361, current time 380, horizon 19\n", - "adding: mem time362, current time 380, horizon 18\n", - "adding: mem time363, current time 380, horizon 17\n", - "adding: mem time364, current time 380, horizon 16\n", - "adding: mem time365, current time 380, horizon 15\n", - "adding: mem time366, current time 380, horizon 14\n", - "adding: mem time367, current time 380, horizon 13\n", - "adding: mem time368, current time 380, horizon 12\n", - "adding: mem time369, current time 380, horizon 11\n", - "adding: mem time370, current time 380, horizon 10\n", - "adding: mem time371, current time 380, horizon 9\n", - "adding: mem time372, current time 380, horizon 8\n", - "adding: mem time373, current time 380, horizon 7\n", - "adding: mem time374, current time 380, horizon 6\n", - "adding: mem time375, current time 380, horizon 5\n", - "adding: mem time376, current time 380, horizon 4\n", - "adding: mem time377, current time 380, horizon 3\n", - "adding: mem time378, current time 380, horizon 2\n", - "adding: mem time379, current time 380, horizon 1\n", - "adding: mem time200, current time 381, horizon 181\n", - "adding: mem time201, current time 381, horizon 180\n", - "adding: mem time202, current time 381, horizon 179\n", - "adding: mem time203, current time 381, horizon 178\n", - "adding: mem time204, current time 381, horizon 177\n", - "adding: mem time205, current time 381, horizon 176\n", - "adding: mem time206, current time 381, horizon 175\n", - "adding: mem time207, current time 381, horizon 174\n", - "adding: mem time208, current time 381, horizon 173\n", - "adding: mem time209, current time 381, horizon 172\n", - "adding: mem time210, current time 381, horizon 171\n", - "adding: mem time211, current time 381, horizon 170\n", - "adding: mem time212, current time 381, horizon 169\n", - "adding: mem time213, current time 381, horizon 168\n", - "adding: mem time214, current time 381, horizon 167\n", - "adding: mem time215, current time 381, horizon 166\n", - "adding: mem time216, current time 381, horizon 165\n", - "adding: mem time217, current time 381, horizon 164\n", - "adding: mem time218, current time 381, horizon 163\n", - "adding: mem time219, current time 381, horizon 162\n", - "adding: mem time220, current time 381, horizon 161\n", - "adding: mem time221, current time 381, horizon 160\n", - "adding: mem time222, current time 381, horizon 159\n", - "adding: mem time223, current time 381, horizon 158\n", - "adding: mem time224, current time 381, horizon 157\n", - "adding: mem time225, current time 381, horizon 156\n", - "adding: mem time226, current time 381, horizon 155\n", - "adding: mem time227, current time 381, horizon 154\n", - "adding: mem time228, current time 381, horizon 153\n", - "adding: mem time229, current time 381, horizon 152\n", - "adding: mem time230, current time 381, horizon 151\n", - "adding: mem time231, current time 381, horizon 150\n", - "adding: mem time232, current time 381, horizon 149\n", - "adding: mem time233, current time 381, horizon 148\n", - "adding: mem time234, current time 381, horizon 147\n", - "adding: mem time235, current time 381, horizon 146\n", - "adding: mem time236, current time 381, horizon 145\n", - "adding: mem time237, current time 381, horizon 144\n", - "adding: mem time238, current time 381, horizon 143\n", - "adding: mem time239, current time 381, horizon 142\n", - "adding: mem time240, current time 381, horizon 141\n", - "adding: mem time241, current time 381, horizon 140\n", - "adding: mem time242, current time 381, horizon 139\n", - "adding: mem time243, current time 381, horizon 138\n", - "adding: mem time244, current time 381, horizon 137\n", - "adding: mem time245, current time 381, horizon 136\n", - "adding: mem time246, current time 381, horizon 135\n", - "adding: mem time247, current time 381, horizon 134\n", - "adding: mem time248, current time 381, horizon 133\n", - "adding: mem time249, current time 381, horizon 132\n", - "adding: mem time250, current time 381, horizon 131\n", - "adding: mem time251, current time 381, horizon 130\n", - "adding: mem time252, current time 381, horizon 129\n", - "adding: mem time253, current time 381, horizon 128\n", - "adding: mem time254, current time 381, horizon 127\n", - "adding: mem time255, current time 381, horizon 126\n", - "adding: mem time256, current time 381, horizon 125\n", - "adding: mem time257, current time 381, horizon 124\n", - "adding: mem time258, current time 381, horizon 123\n", - "adding: mem time259, current time 381, horizon 122\n", - "adding: mem time260, current time 381, horizon 121\n", - "adding: mem time261, current time 381, horizon 120\n", - "adding: mem time262, current time 381, horizon 119\n", - "adding: mem time263, current time 381, horizon 118\n", - "adding: mem time264, current time 381, horizon 117\n", - "adding: mem time265, current time 381, horizon 116\n", - "adding: mem time266, current time 381, horizon 115\n", - "adding: mem time267, current time 381, horizon 114\n", - "adding: mem time268, current time 381, horizon 113\n", - "adding: mem time269, current time 381, horizon 112\n", - "adding: mem time270, current time 381, horizon 111\n", - "adding: mem time271, current time 381, horizon 110\n", - "adding: mem time272, current time 381, horizon 109\n", - "adding: mem time273, current time 381, horizon 108\n", - "adding: mem time274, current time 381, horizon 107\n", - "adding: mem time275, current time 381, horizon 106\n", - "adding: mem time276, current time 381, horizon 105\n", - "adding: mem time277, current time 381, horizon 104\n", - "adding: mem time278, current time 381, horizon 103\n", - "adding: mem time279, current time 381, horizon 102\n", - "adding: mem time280, current time 381, horizon 101\n", - "adding: mem time281, current time 381, horizon 100\n", - "adding: mem time282, current time 381, horizon 99\n", - "adding: mem time283, current time 381, horizon 98\n", - "adding: mem time284, current time 381, horizon 97\n", - "adding: mem time285, current time 381, horizon 96\n", - "adding: mem time286, current time 381, horizon 95\n", - "adding: mem time287, current time 381, horizon 94\n", - "adding: mem time288, current time 381, horizon 93\n", - "adding: mem time289, current time 381, horizon 92\n", - "adding: mem time290, current time 381, horizon 91\n", - "adding: mem time291, current time 381, horizon 90\n", - "adding: mem time292, current time 381, horizon 89\n", - "adding: mem time293, current time 381, horizon 88\n", - "adding: mem time294, current time 381, horizon 87\n", - "adding: mem time295, current time 381, horizon 86\n", - "adding: mem time296, current time 381, horizon 85\n", - "adding: mem time297, current time 381, horizon 84\n", - "adding: mem time298, current time 381, horizon 83\n", - "adding: mem time299, current time 381, horizon 82\n", - "adding: mem time300, current time 381, horizon 81\n", - "adding: mem time301, current time 381, horizon 80\n", - "adding: mem time302, current time 381, horizon 79\n", - "adding: mem time303, current time 381, horizon 78\n", - "adding: mem time304, current time 381, horizon 77\n", - "adding: mem time305, current time 381, horizon 76\n", - "adding: mem time306, current time 381, horizon 75\n", - "adding: mem time307, current time 381, horizon 74\n", - "adding: mem time308, current time 381, horizon 73\n", - "adding: mem time309, current time 381, horizon 72\n", - "adding: mem time310, current time 381, horizon 71\n", - "adding: mem time311, current time 381, horizon 70\n", - "adding: mem time312, current time 381, horizon 69\n", - "adding: mem time313, current time 381, horizon 68\n", - "adding: mem time314, current time 381, horizon 67\n", - "adding: mem time315, current time 381, horizon 66\n", - "adding: mem time316, current time 381, horizon 65\n", - "adding: mem time317, current time 381, horizon 64\n", - "adding: mem time318, current time 381, horizon 63\n", - "adding: mem time319, current time 381, horizon 62\n", - "adding: mem time320, current time 381, horizon 61\n", - "adding: mem time321, current time 381, horizon 60\n", - "adding: mem time322, current time 381, horizon 59\n", - "adding: mem time323, current time 381, horizon 58\n", - "adding: mem time324, current time 381, horizon 57\n", - "adding: mem time325, current time 381, horizon 56\n", - "adding: mem time326, current time 381, horizon 55\n", - "adding: mem time327, current time 381, horizon 54\n", - "adding: mem time328, current time 381, horizon 53\n", - "adding: mem time329, current time 381, horizon 52\n", - "adding: mem time330, current time 381, horizon 51\n", - "adding: mem time331, current time 381, horizon 50\n", - "adding: mem time332, current time 381, horizon 49\n", - "adding: mem time333, current time 381, horizon 48\n", - "adding: mem time334, current time 381, horizon 47\n", - "adding: mem time335, current time 381, horizon 46\n", - "adding: mem time336, current time 381, horizon 45\n", - "adding: mem time337, current time 381, horizon 44\n", - "adding: mem time338, current time 381, horizon 43\n", - "adding: mem time339, current time 381, horizon 42\n", - "adding: mem time340, current time 381, horizon 41\n", - "adding: mem time341, current time 381, horizon 40\n", - "adding: mem time342, current time 381, horizon 39\n", - "adding: mem time343, current time 381, horizon 38\n", - "adding: mem time344, current time 381, horizon 37\n", - "adding: mem time345, current time 381, horizon 36\n", - "adding: mem time346, current time 381, horizon 35\n", - "adding: mem time347, current time 381, horizon 34\n", - "adding: mem time348, current time 381, horizon 33\n", - "adding: mem time349, current time 381, horizon 32\n", - "adding: mem time350, current time 381, horizon 31\n", - "adding: mem time351, current time 381, horizon 30\n", - "adding: mem time352, current time 381, horizon 29\n", - "adding: mem time353, current time 381, horizon 28\n", - "adding: mem time354, current time 381, horizon 27\n", - "adding: mem time355, current time 381, horizon 26\n", - "adding: mem time356, current time 381, horizon 25\n", - "adding: mem time357, current time 381, horizon 24\n", - "adding: mem time358, current time 381, horizon 23\n", - "adding: mem time359, current time 381, horizon 22\n", - "adding: mem time360, current time 381, horizon 21\n", - "adding: mem time361, current time 381, horizon 20\n", - "adding: mem time362, current time 381, horizon 19\n", - "adding: mem time363, current time 381, horizon 18\n", - "adding: mem time364, current time 381, horizon 17\n", - "adding: mem time365, current time 381, horizon 16\n", - "adding: mem time366, current time 381, horizon 15\n", - "adding: mem time367, current time 381, horizon 14\n", - "adding: mem time368, current time 381, horizon 13\n", - "adding: mem time369, current time 381, horizon 12\n", - "adding: mem time370, current time 381, horizon 11\n", - "adding: mem time371, current time 381, horizon 10\n", - "adding: mem time372, current time 381, horizon 9\n", - "adding: mem time373, current time 381, horizon 8\n", - "adding: mem time374, current time 381, horizon 7\n", - "adding: mem time375, current time 381, horizon 6\n", - "adding: mem time376, current time 381, horizon 5\n", - "adding: mem time377, current time 381, horizon 4\n", - "adding: mem time378, current time 381, horizon 3\n", - "adding: mem time379, current time 381, horizon 2\n", - "adding: mem time380, current time 381, horizon 1\n", - "adding: mem time200, current time 382, horizon 182\n", - "adding: mem time201, current time 382, horizon 181\n", - "adding: mem time202, current time 382, horizon 180\n", - "adding: mem time203, current time 382, horizon 179\n", - "adding: mem time204, current time 382, horizon 178\n", - "adding: mem time205, current time 382, horizon 177\n", - "adding: mem time206, current time 382, horizon 176\n", - "adding: mem time207, current time 382, horizon 175\n", - "adding: mem time208, current time 382, horizon 174\n", - "adding: mem time209, current time 382, horizon 173\n", - "adding: mem time210, current time 382, horizon 172\n", - "adding: mem time211, current time 382, horizon 171\n", - "adding: mem time212, current time 382, horizon 170\n", - "adding: mem time213, current time 382, horizon 169\n", - "adding: mem time214, current time 382, horizon 168\n", - "adding: mem time215, current time 382, horizon 167\n", - "adding: mem time216, current time 382, horizon 166\n", - "adding: mem time217, current time 382, horizon 165\n", - "adding: mem time218, current time 382, horizon 164\n", - "adding: mem time219, current time 382, horizon 163\n", - "adding: mem time220, current time 382, horizon 162\n", - "adding: mem time221, current time 382, horizon 161\n", - "adding: mem time222, current time 382, horizon 160\n", - "adding: mem time223, current time 382, horizon 159\n", - "adding: mem time224, current time 382, horizon 158\n", - "adding: mem time225, current time 382, horizon 157\n", - "adding: mem time226, current time 382, horizon 156\n", - "adding: mem time227, current time 382, horizon 155\n", - "adding: mem time228, current time 382, horizon 154\n", - "adding: mem time229, current time 382, horizon 153\n", - "adding: mem time230, current time 382, horizon 152\n", - "adding: mem time231, current time 382, horizon 151\n", - "adding: mem time232, current time 382, horizon 150\n", - "adding: mem time233, current time 382, horizon 149\n", - "adding: mem time234, current time 382, horizon 148\n", - "adding: mem time235, current time 382, horizon 147\n", - "adding: mem time236, current time 382, horizon 146\n", - "adding: mem time237, current time 382, horizon 145\n", - "adding: mem time238, current time 382, horizon 144\n", - "adding: mem time239, current time 382, horizon 143\n", - "adding: mem time240, current time 382, horizon 142\n", - "adding: mem time241, current time 382, horizon 141\n", - "adding: mem time242, current time 382, horizon 140\n", - "adding: mem time243, current time 382, horizon 139\n", - "adding: mem time244, current time 382, horizon 138\n", - "adding: mem time245, current time 382, horizon 137\n", - "adding: mem time246, current time 382, horizon 136\n", - "adding: mem time247, current time 382, horizon 135\n", - "adding: mem time248, current time 382, horizon 134\n", - "adding: mem time249, current time 382, horizon 133\n", - "adding: mem time250, current time 382, horizon 132\n", - "adding: mem time251, current time 382, horizon 131\n", - "adding: mem time252, current time 382, horizon 130\n", - "adding: mem time253, current time 382, horizon 129\n", - "adding: mem time254, current time 382, horizon 128\n", - "adding: mem time255, current time 382, horizon 127\n", - "adding: mem time256, current time 382, horizon 126\n", - "adding: mem time257, current time 382, horizon 125\n", - "adding: mem time258, current time 382, horizon 124\n", - "adding: mem time259, current time 382, horizon 123\n", - "adding: mem time260, current time 382, horizon 122\n", - "adding: mem time261, current time 382, horizon 121\n", - "adding: mem time262, current time 382, horizon 120\n", - "adding: mem time263, current time 382, horizon 119\n", - "adding: mem time264, current time 382, horizon 118\n", - "adding: mem time265, current time 382, horizon 117\n", - "adding: mem time266, current time 382, horizon 116\n", - "adding: mem time267, current time 382, horizon 115\n", - "adding: mem time268, current time 382, horizon 114\n", - "adding: mem time269, current time 382, horizon 113\n", - "adding: mem time270, current time 382, horizon 112\n", - "adding: mem time271, current time 382, horizon 111\n", - "adding: mem time272, current time 382, horizon 110\n", - "adding: mem time273, current time 382, horizon 109\n", - "adding: mem time274, current time 382, horizon 108\n", - "adding: mem time275, current time 382, horizon 107\n", - "adding: mem time276, current time 382, horizon 106\n", - "adding: mem time277, current time 382, horizon 105\n", - "adding: mem time278, current time 382, horizon 104\n", - "adding: mem time279, current time 382, horizon 103\n", - "adding: mem time280, current time 382, horizon 102\n", - "adding: mem time281, current time 382, horizon 101\n", - "adding: mem time282, current time 382, horizon 100\n", - "adding: mem time283, current time 382, horizon 99\n", - "adding: mem time284, current time 382, horizon 98\n", - "adding: mem time285, current time 382, horizon 97\n", - "adding: mem time286, current time 382, horizon 96\n", - "adding: mem time287, current time 382, horizon 95\n", - "adding: mem time288, current time 382, horizon 94\n", - "adding: mem time289, current time 382, horizon 93\n", - "adding: mem time290, current time 382, horizon 92\n", - "adding: mem time291, current time 382, horizon 91\n", - "adding: mem time292, current time 382, horizon 90\n", - "adding: mem time293, current time 382, horizon 89\n", - "adding: mem time294, current time 382, horizon 88\n", - "adding: mem time295, current time 382, horizon 87\n", - "adding: mem time296, current time 382, horizon 86\n", - "adding: mem time297, current time 382, horizon 85\n", - "adding: mem time298, current time 382, horizon 84\n", - "adding: mem time299, current time 382, horizon 83\n", - "adding: mem time300, current time 382, horizon 82\n", - "adding: mem time301, current time 382, horizon 81\n", - "adding: mem time302, current time 382, horizon 80\n", - "adding: mem time303, current time 382, horizon 79\n", - "adding: mem time304, current time 382, horizon 78\n", - "adding: mem time305, current time 382, horizon 77\n", - "adding: mem time306, current time 382, horizon 76\n", - "adding: mem time307, current time 382, horizon 75\n", - "adding: mem time308, current time 382, horizon 74\n", - "adding: mem time309, current time 382, horizon 73\n", - "adding: mem time310, current time 382, horizon 72\n", - "adding: mem time311, current time 382, horizon 71\n", - "adding: mem time312, current time 382, horizon 70\n", - "adding: mem time313, current time 382, horizon 69\n", - "adding: mem time314, current time 382, horizon 68\n", - "adding: mem time315, current time 382, horizon 67\n", - "adding: mem time316, current time 382, horizon 66\n", - "adding: mem time317, current time 382, horizon 65\n", - "adding: mem time318, current time 382, horizon 64\n", - "adding: mem time319, current time 382, horizon 63\n", - "adding: mem time320, current time 382, horizon 62\n", - "adding: mem time321, current time 382, horizon 61\n", - "adding: mem time322, current time 382, horizon 60\n", - "adding: mem time323, current time 382, horizon 59\n", - "adding: mem time324, current time 382, horizon 58\n", - "adding: mem time325, current time 382, horizon 57\n", - "adding: mem time326, current time 382, horizon 56\n", - "adding: mem time327, current time 382, horizon 55\n", - "adding: mem time328, current time 382, horizon 54\n", - "adding: mem time329, current time 382, horizon 53\n", - "adding: mem time330, current time 382, horizon 52\n", - "adding: mem time331, current time 382, horizon 51\n", - "adding: mem time332, current time 382, horizon 50\n", - "adding: mem time333, current time 382, horizon 49\n", - "adding: mem time334, current time 382, horizon 48\n", - "adding: mem time335, current time 382, horizon 47\n", - "adding: mem time336, current time 382, horizon 46\n", - "adding: mem time337, current time 382, horizon 45\n", - "adding: mem time338, current time 382, horizon 44\n", - "adding: mem time339, current time 382, horizon 43\n", - "adding: mem time340, current time 382, horizon 42\n", - "adding: mem time341, current time 382, horizon 41\n", - "adding: mem time342, current time 382, horizon 40\n", - "adding: mem time343, current time 382, horizon 39\n", - "adding: mem time344, current time 382, horizon 38\n", - "adding: mem time345, current time 382, horizon 37\n", - "adding: mem time346, current time 382, horizon 36\n", - "adding: mem time347, current time 382, horizon 35\n", - "adding: mem time348, current time 382, horizon 34\n", - "adding: mem time349, current time 382, horizon 33\n", - "adding: mem time350, current time 382, horizon 32\n", - "adding: mem time351, current time 382, horizon 31\n", - "adding: mem time352, current time 382, horizon 30\n", - "adding: mem time353, current time 382, horizon 29\n", - "adding: mem time354, current time 382, horizon 28\n", - "adding: mem time355, current time 382, horizon 27\n", - "adding: mem time356, current time 382, horizon 26\n", - "adding: mem time357, current time 382, horizon 25\n", - "adding: mem time358, current time 382, horizon 24\n", - "adding: mem time359, current time 382, horizon 23\n", - "adding: mem time360, current time 382, horizon 22\n", - "adding: mem time361, current time 382, horizon 21\n", - "adding: mem time362, current time 382, horizon 20\n", - "adding: mem time363, current time 382, horizon 19\n", - "adding: mem time364, current time 382, horizon 18\n", - "adding: mem time365, current time 382, horizon 17\n", - "adding: mem time366, current time 382, horizon 16\n", - "adding: mem time367, current time 382, horizon 15\n", - "adding: mem time368, current time 382, horizon 14\n", - "adding: mem time369, current time 382, horizon 13\n", - "adding: mem time370, current time 382, horizon 12\n", - "adding: mem time371, current time 382, horizon 11\n", - "adding: mem time372, current time 382, horizon 10\n", - "adding: mem time373, current time 382, horizon 9\n", - "adding: mem time374, current time 382, horizon 8\n", - "adding: mem time375, current time 382, horizon 7\n", - "adding: mem time376, current time 382, horizon 6\n", - "adding: mem time377, current time 382, horizon 5\n", - "adding: mem time378, current time 382, horizon 4\n", - "adding: mem time379, current time 382, horizon 3\n", - "adding: mem time380, current time 382, horizon 2\n", - "adding: mem time381, current time 382, horizon 1\n", - "adding: mem time200, current time 383, horizon 183\n", - "adding: mem time201, current time 383, horizon 182\n", - "adding: mem time202, current time 383, horizon 181\n", - "adding: mem time203, current time 383, horizon 180\n", - "adding: mem time204, current time 383, horizon 179\n", - "adding: mem time205, current time 383, horizon 178\n", - "adding: mem time206, current time 383, horizon 177\n", - "adding: mem time207, current time 383, horizon 176\n", - "adding: mem time208, current time 383, horizon 175\n", - "adding: mem time209, current time 383, horizon 174\n", - "adding: mem time210, current time 383, horizon 173\n", - "adding: mem time211, current time 383, horizon 172\n", - "adding: mem time212, current time 383, horizon 171\n", - "adding: mem time213, current time 383, horizon 170\n", - "adding: mem time214, current time 383, horizon 169\n", - "adding: mem time215, current time 383, horizon 168\n", - "adding: mem time216, current time 383, horizon 167\n", - "adding: mem time217, current time 383, horizon 166\n", - "adding: mem time218, current time 383, horizon 165\n", - "adding: mem time219, current time 383, horizon 164\n", - "adding: mem time220, current time 383, horizon 163\n", - "adding: mem time221, current time 383, horizon 162\n", - "adding: mem time222, current time 383, horizon 161\n", - "adding: mem time223, current time 383, horizon 160\n", - "adding: mem time224, current time 383, horizon 159\n", - "adding: mem time225, current time 383, horizon 158\n", - "adding: mem time226, current time 383, horizon 157\n", - "adding: mem time227, current time 383, horizon 156\n", - "adding: mem time228, current time 383, horizon 155\n", - "adding: mem time229, current time 383, horizon 154\n", - "adding: mem time230, current time 383, horizon 153\n", - "adding: mem time231, current time 383, horizon 152\n", - "adding: mem time232, current time 383, horizon 151\n", - "adding: mem time233, current time 383, horizon 150\n", - "adding: mem time234, current time 383, horizon 149\n", - "adding: mem time235, current time 383, horizon 148\n", - "adding: mem time236, current time 383, horizon 147\n", - "adding: mem time237, current time 383, horizon 146\n", - "adding: mem time238, current time 383, horizon 145\n", - "adding: mem time239, current time 383, horizon 144\n", - "adding: mem time240, current time 383, horizon 143\n", - "adding: mem time241, current time 383, horizon 142\n", - "adding: mem time242, current time 383, horizon 141\n", - "adding: mem time243, current time 383, horizon 140\n", - "adding: mem time244, current time 383, horizon 139\n", - "adding: mem time245, current time 383, horizon 138\n", - "adding: mem time246, current time 383, horizon 137\n", - "adding: mem time247, current time 383, horizon 136\n", - "adding: mem time248, current time 383, horizon 135\n", - "adding: mem time249, current time 383, horizon 134\n", - "adding: mem time250, current time 383, horizon 133\n", - "adding: mem time251, current time 383, horizon 132\n", - "adding: mem time252, current time 383, horizon 131\n", - "adding: mem time253, current time 383, horizon 130\n", - "adding: mem time254, current time 383, horizon 129\n", - "adding: mem time255, current time 383, horizon 128\n", - "adding: mem time256, current time 383, horizon 127\n", - "adding: mem time257, current time 383, horizon 126\n", - "adding: mem time258, current time 383, horizon 125\n", - "adding: mem time259, current time 383, horizon 124\n", - "adding: mem time260, current time 383, horizon 123\n", - "adding: mem time261, current time 383, horizon 122\n", - "adding: mem time262, current time 383, horizon 121\n", - "adding: mem time263, current time 383, horizon 120\n", - "adding: mem time264, current time 383, horizon 119\n", - "adding: mem time265, current time 383, horizon 118\n", - "adding: mem time266, current time 383, horizon 117\n", - "adding: mem time267, current time 383, horizon 116\n", - "adding: mem time268, current time 383, horizon 115\n", - "adding: mem time269, current time 383, horizon 114\n", - "adding: mem time270, current time 383, horizon 113\n", - "adding: mem time271, current time 383, horizon 112\n", - "adding: mem time272, current time 383, horizon 111\n", - "adding: mem time273, current time 383, horizon 110\n", - "adding: mem time274, current time 383, horizon 109\n", - "adding: mem time275, current time 383, horizon 108\n", - "adding: mem time276, current time 383, horizon 107\n", - "adding: mem time277, current time 383, horizon 106\n", - "adding: mem time278, current time 383, horizon 105\n", - "adding: mem time279, current time 383, horizon 104\n", - "adding: mem time280, current time 383, horizon 103\n", - "adding: mem time281, current time 383, horizon 102\n", - "adding: mem time282, current time 383, horizon 101\n", - "adding: mem time283, current time 383, horizon 100\n", - "adding: mem time284, current time 383, horizon 99\n", - "adding: mem time285, current time 383, horizon 98\n", - "adding: mem time286, current time 383, horizon 97\n", - "adding: mem time287, current time 383, horizon 96\n", - "adding: mem time288, current time 383, horizon 95\n", - "adding: mem time289, current time 383, horizon 94\n", - "adding: mem time290, current time 383, horizon 93\n", - "adding: mem time291, current time 383, horizon 92\n", - "adding: mem time292, current time 383, horizon 91\n", - "adding: mem time293, current time 383, horizon 90\n", - "adding: mem time294, current time 383, horizon 89\n", - "adding: mem time295, current time 383, horizon 88\n", - "adding: mem time296, current time 383, horizon 87\n", - "adding: mem time297, current time 383, horizon 86\n", - "adding: mem time298, current time 383, horizon 85\n", - "adding: mem time299, current time 383, horizon 84\n", - "adding: mem time300, current time 383, horizon 83\n", - "adding: mem time301, current time 383, horizon 82\n", - "adding: mem time302, current time 383, horizon 81\n", - "adding: mem time303, current time 383, horizon 80\n", - "adding: mem time304, current time 383, horizon 79\n", - "adding: mem time305, current time 383, horizon 78\n", - "adding: mem time306, current time 383, horizon 77\n", - "adding: mem time307, current time 383, horizon 76\n", - "adding: mem time308, current time 383, horizon 75\n", - "adding: mem time309, current time 383, horizon 74\n", - "adding: mem time310, current time 383, horizon 73\n", - "adding: mem time311, current time 383, horizon 72\n", - "adding: mem time312, current time 383, horizon 71\n", - "adding: mem time313, current time 383, horizon 70\n", - "adding: mem time314, current time 383, horizon 69\n", - "adding: mem time315, current time 383, horizon 68\n", - "adding: mem time316, current time 383, horizon 67\n", - "adding: mem time317, current time 383, horizon 66\n", - "adding: mem time318, current time 383, horizon 65\n", - "adding: mem time319, current time 383, horizon 64\n", - "adding: mem time320, current time 383, horizon 63\n", - "adding: mem time321, current time 383, horizon 62\n", - "adding: mem time322, current time 383, horizon 61\n", - "adding: mem time323, current time 383, horizon 60\n", - "adding: mem time324, current time 383, horizon 59\n", - "adding: mem time325, current time 383, horizon 58\n", - "adding: mem time326, current time 383, horizon 57\n", - "adding: mem time327, current time 383, horizon 56\n", - "adding: mem time328, current time 383, horizon 55\n", - "adding: mem time329, current time 383, horizon 54\n", - "adding: mem time330, current time 383, horizon 53\n", - "adding: mem time331, current time 383, horizon 52\n", - "adding: mem time332, current time 383, horizon 51\n", - "adding: mem time333, current time 383, horizon 50\n", - "adding: mem time334, current time 383, horizon 49\n", - "adding: mem time335, current time 383, horizon 48\n", - "adding: mem time336, current time 383, horizon 47\n", - "adding: mem time337, current time 383, horizon 46\n", - "adding: mem time338, current time 383, horizon 45\n", - "adding: mem time339, current time 383, horizon 44\n", - "adding: mem time340, current time 383, horizon 43\n", - "adding: mem time341, current time 383, horizon 42\n", - "adding: mem time342, current time 383, horizon 41\n", - "adding: mem time343, current time 383, horizon 40\n", - "adding: mem time344, current time 383, horizon 39\n", - "adding: mem time345, current time 383, horizon 38\n", - "adding: mem time346, current time 383, horizon 37\n", - "adding: mem time347, current time 383, horizon 36\n", - "adding: mem time348, current time 383, horizon 35\n", - "adding: mem time349, current time 383, horizon 34\n", - "adding: mem time350, current time 383, horizon 33\n", - "adding: mem time351, current time 383, horizon 32\n", - "adding: mem time352, current time 383, horizon 31\n", - "adding: mem time353, current time 383, horizon 30\n", - "adding: mem time354, current time 383, horizon 29\n", - "adding: mem time355, current time 383, horizon 28\n", - "adding: mem time356, current time 383, horizon 27\n", - "adding: mem time357, current time 383, horizon 26\n", - "adding: mem time358, current time 383, horizon 25\n", - "adding: mem time359, current time 383, horizon 24\n", - "adding: mem time360, current time 383, horizon 23\n", - "adding: mem time361, current time 383, horizon 22\n", - "adding: mem time362, current time 383, horizon 21\n", - "adding: mem time363, current time 383, horizon 20\n", - "adding: mem time364, current time 383, horizon 19\n", - "adding: mem time365, current time 383, horizon 18\n", - "adding: mem time366, current time 383, horizon 17\n", - "adding: mem time367, current time 383, horizon 16\n", - "adding: mem time368, current time 383, horizon 15\n", - "adding: mem time369, current time 383, horizon 14\n", - "adding: mem time370, current time 383, horizon 13\n", - "adding: mem time371, current time 383, horizon 12\n", - "adding: mem time372, current time 383, horizon 11\n", - "adding: mem time373, current time 383, horizon 10\n", - "adding: mem time374, current time 383, horizon 9\n", - "adding: mem time375, current time 383, horizon 8\n", - "adding: mem time376, current time 383, horizon 7\n", - "adding: mem time377, current time 383, horizon 6\n", - "adding: mem time378, current time 383, horizon 5\n", - "adding: mem time379, current time 383, horizon 4\n", - "adding: mem time380, current time 383, horizon 3\n", - "adding: mem time381, current time 383, horizon 2\n", - "adding: mem time382, current time 383, horizon 1\n", - "adding: mem time200, current time 384, horizon 184\n", - "adding: mem time201, current time 384, horizon 183\n", - "adding: mem time202, current time 384, horizon 182\n", - "adding: mem time203, current time 384, horizon 181\n", - "adding: mem time204, current time 384, horizon 180\n", - "adding: mem time205, current time 384, horizon 179\n", - "adding: mem time206, current time 384, horizon 178\n", - "adding: mem time207, current time 384, horizon 177\n", - "adding: mem time208, current time 384, horizon 176\n", - "adding: mem time209, current time 384, horizon 175\n", - "adding: mem time210, current time 384, horizon 174\n", - "adding: mem time211, current time 384, horizon 173\n", - "adding: mem time212, current time 384, horizon 172\n", - "adding: mem time213, current time 384, horizon 171\n", - "adding: mem time214, current time 384, horizon 170\n", - "adding: mem time215, current time 384, horizon 169\n", - "adding: mem time216, current time 384, horizon 168\n", - "adding: mem time217, current time 384, horizon 167\n", - "adding: mem time218, current time 384, horizon 166\n", - "adding: mem time219, current time 384, horizon 165\n", - "adding: mem time220, current time 384, horizon 164\n", - "adding: mem time221, current time 384, horizon 163\n", - "adding: mem time222, current time 384, horizon 162\n", - "adding: mem time223, current time 384, horizon 161\n", - "adding: mem time224, current time 384, horizon 160\n", - "adding: mem time225, current time 384, horizon 159\n", - "adding: mem time226, current time 384, horizon 158\n", - "adding: mem time227, current time 384, horizon 157\n", - "adding: mem time228, current time 384, horizon 156\n", - "adding: mem time229, current time 384, horizon 155\n", - "adding: mem time230, current time 384, horizon 154\n", - "adding: mem time231, current time 384, horizon 153\n", - "adding: mem time232, current time 384, horizon 152\n", - "adding: mem time233, current time 384, horizon 151\n", - "adding: mem time234, current time 384, horizon 150\n", - "adding: mem time235, current time 384, horizon 149\n", - "adding: mem time236, current time 384, horizon 148\n", - "adding: mem time237, current time 384, horizon 147\n", - "adding: mem time238, current time 384, horizon 146\n", - "adding: mem time239, current time 384, horizon 145\n", - "adding: mem time240, current time 384, horizon 144\n", - "adding: mem time241, current time 384, horizon 143\n", - "adding: mem time242, current time 384, horizon 142\n", - "adding: mem time243, current time 384, horizon 141\n", - "adding: mem time244, current time 384, horizon 140\n", - "adding: mem time245, current time 384, horizon 139\n", - "adding: mem time246, current time 384, horizon 138\n", - "adding: mem time247, current time 384, horizon 137\n", - "adding: mem time248, current time 384, horizon 136\n", - "adding: mem time249, current time 384, horizon 135\n", - "adding: mem time250, current time 384, horizon 134\n", - "adding: mem time251, current time 384, horizon 133\n", - "adding: mem time252, current time 384, horizon 132\n", - "adding: mem time253, current time 384, horizon 131\n", - "adding: mem time254, current time 384, horizon 130\n", - "adding: mem time255, current time 384, horizon 129\n", - "adding: mem time256, current time 384, horizon 128\n", - "adding: mem time257, current time 384, horizon 127\n", - "adding: mem time258, current time 384, horizon 126\n", - "adding: mem time259, current time 384, horizon 125\n", - "adding: mem time260, current time 384, horizon 124\n", - "adding: mem time261, current time 384, horizon 123\n", - "adding: mem time262, current time 384, horizon 122\n", - "adding: mem time263, current time 384, horizon 121\n", - "adding: mem time264, current time 384, horizon 120\n", - "adding: mem time265, current time 384, horizon 119\n", - "adding: mem time266, current time 384, horizon 118\n", - "adding: mem time267, current time 384, horizon 117\n", - "adding: mem time268, current time 384, horizon 116\n", - "adding: mem time269, current time 384, horizon 115\n", - "adding: mem time270, current time 384, horizon 114\n", - "adding: mem time271, current time 384, horizon 113\n", - "adding: mem time272, current time 384, horizon 112\n", - "adding: mem time273, current time 384, horizon 111\n", - "adding: mem time274, current time 384, horizon 110\n", - "adding: mem time275, current time 384, horizon 109\n", - "adding: mem time276, current time 384, horizon 108\n", - "adding: mem time277, current time 384, horizon 107\n", - "adding: mem time278, current time 384, horizon 106\n", - "adding: mem time279, current time 384, horizon 105\n", - "adding: mem time280, current time 384, horizon 104\n", - "adding: mem time281, current time 384, horizon 103\n", - "adding: mem time282, current time 384, horizon 102\n", - "adding: mem time283, current time 384, horizon 101\n", - "adding: mem time284, current time 384, horizon 100\n", - "adding: mem time285, current time 384, horizon 99\n", - "adding: mem time286, current time 384, horizon 98\n", - "adding: mem time287, current time 384, horizon 97\n", - "adding: mem time288, current time 384, horizon 96\n", - "adding: mem time289, current time 384, horizon 95\n", - "adding: mem time290, current time 384, horizon 94\n", - "adding: mem time291, current time 384, horizon 93\n", - "adding: mem time292, current time 384, horizon 92\n", - "adding: mem time293, current time 384, horizon 91\n", - "adding: mem time294, current time 384, horizon 90\n", - "adding: mem time295, current time 384, horizon 89\n", - "adding: mem time296, current time 384, horizon 88\n", - "adding: mem time297, current time 384, horizon 87\n", - "adding: mem time298, current time 384, horizon 86\n", - "adding: mem time299, current time 384, horizon 85\n", - "adding: mem time300, current time 384, horizon 84\n", - "adding: mem time301, current time 384, horizon 83\n", - "adding: mem time302, current time 384, horizon 82\n", - "adding: mem time303, current time 384, horizon 81\n", - "adding: mem time304, current time 384, horizon 80\n", - "adding: mem time305, current time 384, horizon 79\n", - "adding: mem time306, current time 384, horizon 78\n", - "adding: mem time307, current time 384, horizon 77\n", - "adding: mem time308, current time 384, horizon 76\n", - "adding: mem time309, current time 384, horizon 75\n", - "adding: mem time310, current time 384, horizon 74\n", - "adding: mem time311, current time 384, horizon 73\n", - "adding: mem time312, current time 384, horizon 72\n", - "adding: mem time313, current time 384, horizon 71\n", - "adding: mem time314, current time 384, horizon 70\n", - "adding: mem time315, current time 384, horizon 69\n", - "adding: mem time316, current time 384, horizon 68\n", - "adding: mem time317, current time 384, horizon 67\n", - "adding: mem time318, current time 384, horizon 66\n", - "adding: mem time319, current time 384, horizon 65\n", - "adding: mem time320, current time 384, horizon 64\n", - "adding: mem time321, current time 384, horizon 63\n", - "adding: mem time322, current time 384, horizon 62\n", - "adding: mem time323, current time 384, horizon 61\n", - "adding: mem time324, current time 384, horizon 60\n", - "adding: mem time325, current time 384, horizon 59\n", - "adding: mem time326, current time 384, horizon 58\n", - "adding: mem time327, current time 384, horizon 57\n", - "adding: mem time328, current time 384, horizon 56\n", - "adding: mem time329, current time 384, horizon 55\n", - "adding: mem time330, current time 384, horizon 54\n", - "adding: mem time331, current time 384, horizon 53\n", - "adding: mem time332, current time 384, horizon 52\n", - "adding: mem time333, current time 384, horizon 51\n", - "adding: mem time334, current time 384, horizon 50\n", - "adding: mem time335, current time 384, horizon 49\n", - "adding: mem time336, current time 384, horizon 48\n", - "adding: mem time337, current time 384, horizon 47\n", - "adding: mem time338, current time 384, horizon 46\n", - "adding: mem time339, current time 384, horizon 45\n", - "adding: mem time340, current time 384, horizon 44\n", - "adding: mem time341, current time 384, horizon 43\n", - "adding: mem time342, current time 384, horizon 42\n", - "adding: mem time343, current time 384, horizon 41\n", - "adding: mem time344, current time 384, horizon 40\n", - "adding: mem time345, current time 384, horizon 39\n", - "adding: mem time346, current time 384, horizon 38\n", - "adding: mem time347, current time 384, horizon 37\n", - "adding: mem time348, current time 384, horizon 36\n", - "adding: mem time349, current time 384, horizon 35\n", - "adding: mem time350, current time 384, horizon 34\n", - "adding: mem time351, current time 384, horizon 33\n", - "adding: mem time352, current time 384, horizon 32\n", - "adding: mem time353, current time 384, horizon 31\n", - "adding: mem time354, current time 384, horizon 30\n", - "adding: mem time355, current time 384, horizon 29\n", - "adding: mem time356, current time 384, horizon 28\n", - "adding: mem time357, current time 384, horizon 27\n", - "adding: mem time358, current time 384, horizon 26\n", - "adding: mem time359, current time 384, horizon 25\n", - "adding: mem time360, current time 384, horizon 24\n", - "adding: mem time361, current time 384, horizon 23\n", - "adding: mem time362, current time 384, horizon 22\n", - "adding: mem time363, current time 384, horizon 21\n", - "adding: mem time364, current time 384, horizon 20\n", - "adding: mem time365, current time 384, horizon 19\n", - "adding: mem time366, current time 384, horizon 18\n", - "adding: mem time367, current time 384, horizon 17\n", - "adding: mem time368, current time 384, horizon 16\n", - "adding: mem time369, current time 384, horizon 15\n", - "adding: mem time370, current time 384, horizon 14\n", - "adding: mem time371, current time 384, horizon 13\n", - "adding: mem time372, current time 384, horizon 12\n", - "adding: mem time373, current time 384, horizon 11\n", - "adding: mem time374, current time 384, horizon 10\n", - "adding: mem time375, current time 384, horizon 9\n", - "adding: mem time376, current time 384, horizon 8\n", - "adding: mem time377, current time 384, horizon 7\n", - "adding: mem time378, current time 384, horizon 6\n", - "adding: mem time379, current time 384, horizon 5\n", - "adding: mem time380, current time 384, horizon 4\n", - "adding: mem time381, current time 384, horizon 3\n", - "adding: mem time382, current time 384, horizon 2\n", - "adding: mem time383, current time 384, horizon 1\n", - "adding: mem time200, current time 385, horizon 185\n", - "adding: mem time201, current time 385, horizon 184\n", - "adding: mem time202, current time 385, horizon 183\n", - "adding: mem time203, current time 385, horizon 182\n", - "adding: mem time204, current time 385, horizon 181\n", - "adding: mem time205, current time 385, horizon 180\n", - "adding: mem time206, current time 385, horizon 179\n", - "adding: mem time207, current time 385, horizon 178\n", - "adding: mem time208, current time 385, horizon 177\n", - "adding: mem time209, current time 385, horizon 176\n", - "adding: mem time210, current time 385, horizon 175\n", - "adding: mem time211, current time 385, horizon 174\n", - "adding: mem time212, current time 385, horizon 173\n", - "adding: mem time213, current time 385, horizon 172\n", - "adding: mem time214, current time 385, horizon 171\n", - "adding: mem time215, current time 385, horizon 170\n", - "adding: mem time216, current time 385, horizon 169\n", - "adding: mem time217, current time 385, horizon 168\n", - "adding: mem time218, current time 385, horizon 167\n", - "adding: mem time219, current time 385, horizon 166\n", - "adding: mem time220, current time 385, horizon 165\n", - "adding: mem time221, current time 385, horizon 164\n", - "adding: mem time222, current time 385, horizon 163\n", - "adding: mem time223, current time 385, horizon 162\n", - "adding: mem time224, current time 385, horizon 161\n", - "adding: mem time225, current time 385, horizon 160\n", - "adding: mem time226, current time 385, horizon 159\n", - "adding: mem time227, current time 385, horizon 158\n", - "adding: mem time228, current time 385, horizon 157\n", - "adding: mem time229, current time 385, horizon 156\n", - "adding: mem time230, current time 385, horizon 155\n", - "adding: mem time231, current time 385, horizon 154\n", - "adding: mem time232, current time 385, horizon 153\n", - "adding: mem time233, current time 385, horizon 152\n", - "adding: mem time234, current time 385, horizon 151\n", - "adding: mem time235, current time 385, horizon 150\n", - "adding: mem time236, current time 385, horizon 149\n", - "adding: mem time237, current time 385, horizon 148\n", - "adding: mem time238, current time 385, horizon 147\n", - "adding: mem time239, current time 385, horizon 146\n", - "adding: mem time240, current time 385, horizon 145\n", - "adding: mem time241, current time 385, horizon 144\n", - "adding: mem time242, current time 385, horizon 143\n", - "adding: mem time243, current time 385, horizon 142\n", - "adding: mem time244, current time 385, horizon 141\n", - "adding: mem time245, current time 385, horizon 140\n", - "adding: mem time246, current time 385, horizon 139\n", - "adding: mem time247, current time 385, horizon 138\n", - "adding: mem time248, current time 385, horizon 137\n", - "adding: mem time249, current time 385, horizon 136\n", - "adding: mem time250, current time 385, horizon 135\n", - "adding: mem time251, current time 385, horizon 134\n", - "adding: mem time252, current time 385, horizon 133\n", - "adding: mem time253, current time 385, horizon 132\n", - "adding: mem time254, current time 385, horizon 131\n", - "adding: mem time255, current time 385, horizon 130\n", - "adding: mem time256, current time 385, horizon 129\n", - "adding: mem time257, current time 385, horizon 128\n", - "adding: mem time258, current time 385, horizon 127\n", - "adding: mem time259, current time 385, horizon 126\n", - "adding: mem time260, current time 385, horizon 125\n", - "adding: mem time261, current time 385, horizon 124\n", - "adding: mem time262, current time 385, horizon 123\n", - "adding: mem time263, current time 385, horizon 122\n", - "adding: mem time264, current time 385, horizon 121\n", - "adding: mem time265, current time 385, horizon 120\n", - "adding: mem time266, current time 385, horizon 119\n", - "adding: mem time267, current time 385, horizon 118\n", - "adding: mem time268, current time 385, horizon 117\n", - "adding: mem time269, current time 385, horizon 116\n", - "adding: mem time270, current time 385, horizon 115\n", - "adding: mem time271, current time 385, horizon 114\n", - "adding: mem time272, current time 385, horizon 113\n", - "adding: mem time273, current time 385, horizon 112\n", - "adding: mem time274, current time 385, horizon 111\n", - "adding: mem time275, current time 385, horizon 110\n", - "adding: mem time276, current time 385, horizon 109\n", - "adding: mem time277, current time 385, horizon 108\n", - "adding: mem time278, current time 385, horizon 107\n", - "adding: mem time279, current time 385, horizon 106\n", - "adding: mem time280, current time 385, horizon 105\n", - "adding: mem time281, current time 385, horizon 104\n", - "adding: mem time282, current time 385, horizon 103\n", - "adding: mem time283, current time 385, horizon 102\n", - "adding: mem time284, current time 385, horizon 101\n", - "adding: mem time285, current time 385, horizon 100\n", - "adding: mem time286, current time 385, horizon 99\n", - "adding: mem time287, current time 385, horizon 98\n", - "adding: mem time288, current time 385, horizon 97\n", - "adding: mem time289, current time 385, horizon 96\n", - "adding: mem time290, current time 385, horizon 95\n", - "adding: mem time291, current time 385, horizon 94\n", - "adding: mem time292, current time 385, horizon 93\n", - "adding: mem time293, current time 385, horizon 92\n", - "adding: mem time294, current time 385, horizon 91\n", - "adding: mem time295, current time 385, horizon 90\n", - "adding: mem time296, current time 385, horizon 89\n", - "adding: mem time297, current time 385, horizon 88\n", - "adding: mem time298, current time 385, horizon 87\n", - "adding: mem time299, current time 385, horizon 86\n", - "adding: mem time300, current time 385, horizon 85\n", - "adding: mem time301, current time 385, horizon 84\n", - "adding: mem time302, current time 385, horizon 83\n", - "adding: mem time303, current time 385, horizon 82\n", - "adding: mem time304, current time 385, horizon 81\n", - "adding: mem time305, current time 385, horizon 80\n", - "adding: mem time306, current time 385, horizon 79\n", - "adding: mem time307, current time 385, horizon 78\n", - "adding: mem time308, current time 385, horizon 77\n", - "adding: mem time309, current time 385, horizon 76\n", - "adding: mem time310, current time 385, horizon 75\n", - "adding: mem time311, current time 385, horizon 74\n", - "adding: mem time312, current time 385, horizon 73\n", - "adding: mem time313, current time 385, horizon 72\n", - "adding: mem time314, current time 385, horizon 71\n", - "adding: mem time315, current time 385, horizon 70\n", - "adding: mem time316, current time 385, horizon 69\n", - "adding: mem time317, current time 385, horizon 68\n", - "adding: mem time318, current time 385, horizon 67\n", - "adding: mem time319, current time 385, horizon 66\n", - "adding: mem time320, current time 385, horizon 65\n", - "adding: mem time321, current time 385, horizon 64\n", - "adding: mem time322, current time 385, horizon 63\n", - "adding: mem time323, current time 385, horizon 62\n", - "adding: mem time324, current time 385, horizon 61\n", - "adding: mem time325, current time 385, horizon 60\n", - "adding: mem time326, current time 385, horizon 59\n", - "adding: mem time327, current time 385, horizon 58\n", - "adding: mem time328, current time 385, horizon 57\n", - "adding: mem time329, current time 385, horizon 56\n", - "adding: mem time330, current time 385, horizon 55\n", - "adding: mem time331, current time 385, horizon 54\n", - "adding: mem time332, current time 385, horizon 53\n", - "adding: mem time333, current time 385, horizon 52\n", - "adding: mem time334, current time 385, horizon 51\n", - "adding: mem time335, current time 385, horizon 50\n", - "adding: mem time336, current time 385, horizon 49\n", - "adding: mem time337, current time 385, horizon 48\n", - "adding: mem time338, current time 385, horizon 47\n", - "adding: mem time339, current time 385, horizon 46\n", - "adding: mem time340, current time 385, horizon 45\n", - "adding: mem time341, current time 385, horizon 44\n", - "adding: mem time342, current time 385, horizon 43\n", - "adding: mem time343, current time 385, horizon 42\n", - "adding: mem time344, current time 385, horizon 41\n", - "adding: mem time345, current time 385, horizon 40\n", - "adding: mem time346, current time 385, horizon 39\n", - "adding: mem time347, current time 385, horizon 38\n", - "adding: mem time348, current time 385, horizon 37\n", - "adding: mem time349, current time 385, horizon 36\n", - "adding: mem time350, current time 385, horizon 35\n", - "adding: mem time351, current time 385, horizon 34\n", - "adding: mem time352, current time 385, horizon 33\n", - "adding: mem time353, current time 385, horizon 32\n", - "adding: mem time354, current time 385, horizon 31\n", - "adding: mem time355, current time 385, horizon 30\n", - "adding: mem time356, current time 385, horizon 29\n", - "adding: mem time357, current time 385, horizon 28\n", - "adding: mem time358, current time 385, horizon 27\n", - "adding: mem time359, current time 385, horizon 26\n", - "adding: mem time360, current time 385, horizon 25\n", - "adding: mem time361, current time 385, horizon 24\n", - "adding: mem time362, current time 385, horizon 23\n", - "adding: mem time363, current time 385, horizon 22\n", - "adding: mem time364, current time 385, horizon 21\n", - "adding: mem time365, current time 385, horizon 20\n", - "adding: mem time366, current time 385, horizon 19\n", - "adding: mem time367, current time 385, horizon 18\n", - "adding: mem time368, current time 385, horizon 17\n", - "adding: mem time369, current time 385, horizon 16\n", - "adding: mem time370, current time 385, horizon 15\n", - "adding: mem time371, current time 385, horizon 14\n", - "adding: mem time372, current time 385, horizon 13\n", - "adding: mem time373, current time 385, horizon 12\n", - "adding: mem time374, current time 385, horizon 11\n", - "adding: mem time375, current time 385, horizon 10\n", - "adding: mem time376, current time 385, horizon 9\n", - "adding: mem time377, current time 385, horizon 8\n", - "adding: mem time378, current time 385, horizon 7\n", - "adding: mem time379, current time 385, horizon 6\n", - "adding: mem time380, current time 385, horizon 5\n", - "adding: mem time381, current time 385, horizon 4\n", - "adding: mem time382, current time 385, horizon 3\n", - "adding: mem time383, current time 385, horizon 2\n", - "adding: mem time384, current time 385, horizon 1\n", - "adding: mem time200, current time 386, horizon 186\n", - "adding: mem time201, current time 386, horizon 185\n", - "adding: mem time202, current time 386, horizon 184\n", - "adding: mem time203, current time 386, horizon 183\n", - "adding: mem time204, current time 386, horizon 182\n", - "adding: mem time205, current time 386, horizon 181\n", - "adding: mem time206, current time 386, horizon 180\n", - "adding: mem time207, current time 386, horizon 179\n", - "adding: mem time208, current time 386, horizon 178\n", - "adding: mem time209, current time 386, horizon 177\n", - "adding: mem time210, current time 386, horizon 176\n", - "adding: mem time211, current time 386, horizon 175\n", - "adding: mem time212, current time 386, horizon 174\n", - "adding: mem time213, current time 386, horizon 173\n", - "adding: mem time214, current time 386, horizon 172\n", - "adding: mem time215, current time 386, horizon 171\n", - "adding: mem time216, current time 386, horizon 170\n", - "adding: mem time217, current time 386, horizon 169\n", - "adding: mem time218, current time 386, horizon 168\n", - "adding: mem time219, current time 386, horizon 167\n", - "adding: mem time220, current time 386, horizon 166\n", - "adding: mem time221, current time 386, horizon 165\n", - "adding: mem time222, current time 386, horizon 164\n", - "adding: mem time223, current time 386, horizon 163\n", - "adding: mem time224, current time 386, horizon 162\n", - "adding: mem time225, current time 386, horizon 161\n", - "adding: mem time226, current time 386, horizon 160\n", - "adding: mem time227, current time 386, horizon 159\n", - "adding: mem time228, current time 386, horizon 158\n", - "adding: mem time229, current time 386, horizon 157\n", - "adding: mem time230, current time 386, horizon 156\n", - "adding: mem time231, current time 386, horizon 155\n", - "adding: mem time232, current time 386, horizon 154\n", - "adding: mem time233, current time 386, horizon 153\n", - "adding: mem time234, current time 386, horizon 152\n", - "adding: mem time235, current time 386, horizon 151\n", - "adding: mem time236, current time 386, horizon 150\n", - "adding: mem time237, current time 386, horizon 149\n", - "adding: mem time238, current time 386, horizon 148\n", - "adding: mem time239, current time 386, horizon 147\n", - "adding: mem time240, current time 386, horizon 146\n", - "adding: mem time241, current time 386, horizon 145\n", - "adding: mem time242, current time 386, horizon 144\n", - "adding: mem time243, current time 386, horizon 143\n", - "adding: mem time244, current time 386, horizon 142\n", - "adding: mem time245, current time 386, horizon 141\n", - "adding: mem time246, current time 386, horizon 140\n", - "adding: mem time247, current time 386, horizon 139\n", - "adding: mem time248, current time 386, horizon 138\n", - "adding: mem time249, current time 386, horizon 137\n", - "adding: mem time250, current time 386, horizon 136\n", - "adding: mem time251, current time 386, horizon 135\n", - "adding: mem time252, current time 386, horizon 134\n", - "adding: mem time253, current time 386, horizon 133\n", - "adding: mem time254, current time 386, horizon 132\n", - "adding: mem time255, current time 386, horizon 131\n", - "adding: mem time256, current time 386, horizon 130\n", - "adding: mem time257, current time 386, horizon 129\n", - "adding: mem time258, current time 386, horizon 128\n", - "adding: mem time259, current time 386, horizon 127\n", - "adding: mem time260, current time 386, horizon 126\n", - "adding: mem time261, current time 386, horizon 125\n", - "adding: mem time262, current time 386, horizon 124\n", - "adding: mem time263, current time 386, horizon 123\n", - "adding: mem time264, current time 386, horizon 122\n", - "adding: mem time265, current time 386, horizon 121\n", - "adding: mem time266, current time 386, horizon 120\n", - "adding: mem time267, current time 386, horizon 119\n", - "adding: mem time268, current time 386, horizon 118\n", - "adding: mem time269, current time 386, horizon 117\n", - "adding: mem time270, current time 386, horizon 116\n", - "adding: mem time271, current time 386, horizon 115\n", - "adding: mem time272, current time 386, horizon 114\n", - "adding: mem time273, current time 386, horizon 113\n", - "adding: mem time274, current time 386, horizon 112\n", - "adding: mem time275, current time 386, horizon 111\n", - "adding: mem time276, current time 386, horizon 110\n", - "adding: mem time277, current time 386, horizon 109\n", - "adding: mem time278, current time 386, horizon 108\n", - "adding: mem time279, current time 386, horizon 107\n", - "adding: mem time280, current time 386, horizon 106\n", - "adding: mem time281, current time 386, horizon 105\n", - "adding: mem time282, current time 386, horizon 104\n", - "adding: mem time283, current time 386, horizon 103\n", - "adding: mem time284, current time 386, horizon 102\n", - "adding: mem time285, current time 386, horizon 101\n", - "adding: mem time286, current time 386, horizon 100\n", - "adding: mem time287, current time 386, horizon 99\n", - "adding: mem time288, current time 386, horizon 98\n", - "adding: mem time289, current time 386, horizon 97\n", - "adding: mem time290, current time 386, horizon 96\n", - "adding: mem time291, current time 386, horizon 95\n", - "adding: mem time292, current time 386, horizon 94\n", - "adding: mem time293, current time 386, horizon 93\n", - "adding: mem time294, current time 386, horizon 92\n", - "adding: mem time295, current time 386, horizon 91\n", - "adding: mem time296, current time 386, horizon 90\n", - "adding: mem time297, current time 386, horizon 89\n", - "adding: mem time298, current time 386, horizon 88\n", - "adding: mem time299, current time 386, horizon 87\n", - "adding: mem time300, current time 386, horizon 86\n", - "adding: mem time301, current time 386, horizon 85\n", - "adding: mem time302, current time 386, horizon 84\n", - "adding: mem time303, current time 386, horizon 83\n", - "adding: mem time304, current time 386, horizon 82\n", - "adding: mem time305, current time 386, horizon 81\n", - "adding: mem time306, current time 386, horizon 80\n", - "adding: mem time307, current time 386, horizon 79\n", - "adding: mem time308, current time 386, horizon 78\n", - "adding: mem time309, current time 386, horizon 77\n", - "adding: mem time310, current time 386, horizon 76\n", - "adding: mem time311, current time 386, horizon 75\n", - "adding: mem time312, current time 386, horizon 74\n", - "adding: mem time313, current time 386, horizon 73\n", - "adding: mem time314, current time 386, horizon 72\n", - "adding: mem time315, current time 386, horizon 71\n", - "adding: mem time316, current time 386, horizon 70\n", - "adding: mem time317, current time 386, horizon 69\n", - "adding: mem time318, current time 386, horizon 68\n", - "adding: mem time319, current time 386, horizon 67\n", - "adding: mem time320, current time 386, horizon 66\n", - "adding: mem time321, current time 386, horizon 65\n", - "adding: mem time322, current time 386, horizon 64\n", - "adding: mem time323, current time 386, horizon 63\n", - "adding: mem time324, current time 386, horizon 62\n", - "adding: mem time325, current time 386, horizon 61\n", - "adding: mem time326, current time 386, horizon 60\n", - "adding: mem time327, current time 386, horizon 59\n", - "adding: mem time328, current time 386, horizon 58\n", - "adding: mem time329, current time 386, horizon 57\n", - "adding: mem time330, current time 386, horizon 56\n", - "adding: mem time331, current time 386, horizon 55\n", - "adding: mem time332, current time 386, horizon 54\n", - "adding: mem time333, current time 386, horizon 53\n", - "adding: mem time334, current time 386, horizon 52\n", - "adding: mem time335, current time 386, horizon 51\n", - "adding: mem time336, current time 386, horizon 50\n", - "adding: mem time337, current time 386, horizon 49\n", - "adding: mem time338, current time 386, horizon 48\n", - "adding: mem time339, current time 386, horizon 47\n", - "adding: mem time340, current time 386, horizon 46\n", - "adding: mem time341, current time 386, horizon 45\n", - "adding: mem time342, current time 386, horizon 44\n", - "adding: mem time343, current time 386, horizon 43\n", - "adding: mem time344, current time 386, horizon 42\n", - "adding: mem time345, current time 386, horizon 41\n", - "adding: mem time346, current time 386, horizon 40\n", - "adding: mem time347, current time 386, horizon 39\n", - "adding: mem time348, current time 386, horizon 38\n", - "adding: mem time349, current time 386, horizon 37\n", - "adding: mem time350, current time 386, horizon 36\n", - "adding: mem time351, current time 386, horizon 35\n", - "adding: mem time352, current time 386, horizon 34\n", - "adding: mem time353, current time 386, horizon 33\n", - "adding: mem time354, current time 386, horizon 32\n", - "adding: mem time355, current time 386, horizon 31\n", - "adding: mem time356, current time 386, horizon 30\n", - "adding: mem time357, current time 386, horizon 29\n", - "adding: mem time358, current time 386, horizon 28\n", - "adding: mem time359, current time 386, horizon 27\n", - "adding: mem time360, current time 386, horizon 26\n", - "adding: mem time361, current time 386, horizon 25\n", - "adding: mem time362, current time 386, horizon 24\n", - "adding: mem time363, current time 386, horizon 23\n", - "adding: mem time364, current time 386, horizon 22\n", - "adding: mem time365, current time 386, horizon 21\n", - "adding: mem time366, current time 386, horizon 20\n", - "adding: mem time367, current time 386, horizon 19\n", - "adding: mem time368, current time 386, horizon 18\n", - "adding: mem time369, current time 386, horizon 17\n", - "adding: mem time370, current time 386, horizon 16\n", - "adding: mem time371, current time 386, horizon 15\n", - "adding: mem time372, current time 386, horizon 14\n", - "adding: mem time373, current time 386, horizon 13\n", - "adding: mem time374, current time 386, horizon 12\n", - "adding: mem time375, current time 386, horizon 11\n", - "adding: mem time376, current time 386, horizon 10\n", - "adding: mem time377, current time 386, horizon 9\n", - "adding: mem time378, current time 386, horizon 8\n", - "adding: mem time379, current time 386, horizon 7\n", - "adding: mem time380, current time 386, horizon 6\n", - "adding: mem time381, current time 386, horizon 5\n", - "adding: mem time382, current time 386, horizon 4\n", - "adding: mem time383, current time 386, horizon 3\n", - "adding: mem time384, current time 386, horizon 2\n", - "adding: mem time385, current time 386, horizon 1\n", - "adding: mem time200, current time 387, horizon 187\n", - "adding: mem time201, current time 387, horizon 186\n", - "adding: mem time202, current time 387, horizon 185\n", - "adding: mem time203, current time 387, horizon 184\n", - "adding: mem time204, current time 387, horizon 183\n", - "adding: mem time205, current time 387, horizon 182\n", - "adding: mem time206, current time 387, horizon 181\n", - "adding: mem time207, current time 387, horizon 180\n", - "adding: mem time208, current time 387, horizon 179\n", - "adding: mem time209, current time 387, horizon 178\n", - "adding: mem time210, current time 387, horizon 177\n", - "adding: mem time211, current time 387, horizon 176\n", - "adding: mem time212, current time 387, horizon 175\n", - "adding: mem time213, current time 387, horizon 174\n", - "adding: mem time214, current time 387, horizon 173\n", - "adding: mem time215, current time 387, horizon 172\n", - "adding: mem time216, current time 387, horizon 171\n", - "adding: mem time217, current time 387, horizon 170\n", - "adding: mem time218, current time 387, horizon 169\n", - "adding: mem time219, current time 387, horizon 168\n", - "adding: mem time220, current time 387, horizon 167\n", - "adding: mem time221, current time 387, horizon 166\n", - "adding: mem time222, current time 387, horizon 165\n", - "adding: mem time223, current time 387, horizon 164\n", - "adding: mem time224, current time 387, horizon 163\n", - "adding: mem time225, current time 387, horizon 162\n", - "adding: mem time226, current time 387, horizon 161\n", - "adding: mem time227, current time 387, horizon 160\n", - "adding: mem time228, current time 387, horizon 159\n", - "adding: mem time229, current time 387, horizon 158\n", - "adding: mem time230, current time 387, horizon 157\n", - "adding: mem time231, current time 387, horizon 156\n", - "adding: mem time232, current time 387, horizon 155\n", - "adding: mem time233, current time 387, horizon 154\n", - "adding: mem time234, current time 387, horizon 153\n", - "adding: mem time235, current time 387, horizon 152\n", - "adding: mem time236, current time 387, horizon 151\n", - "adding: mem time237, current time 387, horizon 150\n", - "adding: mem time238, current time 387, horizon 149\n", - "adding: mem time239, current time 387, horizon 148\n", - "adding: mem time240, current time 387, horizon 147\n", - "adding: mem time241, current time 387, horizon 146\n", - "adding: mem time242, current time 387, horizon 145\n", - "adding: mem time243, current time 387, horizon 144\n", - "adding: mem time244, current time 387, horizon 143\n", - "adding: mem time245, current time 387, horizon 142\n", - "adding: mem time246, current time 387, horizon 141\n", - "adding: mem time247, current time 387, horizon 140\n", - "adding: mem time248, current time 387, horizon 139\n", - "adding: mem time249, current time 387, horizon 138\n", - "adding: mem time250, current time 387, horizon 137\n", - "adding: mem time251, current time 387, horizon 136\n", - "adding: mem time252, current time 387, horizon 135\n", - "adding: mem time253, current time 387, horizon 134\n", - "adding: mem time254, current time 387, horizon 133\n", - "adding: mem time255, current time 387, horizon 132\n", - "adding: mem time256, current time 387, horizon 131\n", - "adding: mem time257, current time 387, horizon 130\n", - "adding: mem time258, current time 387, horizon 129\n", - "adding: mem time259, current time 387, horizon 128\n", - "adding: mem time260, current time 387, horizon 127\n", - "adding: mem time261, current time 387, horizon 126\n", - "adding: mem time262, current time 387, horizon 125\n", - "adding: mem time263, current time 387, horizon 124\n", - "adding: mem time264, current time 387, horizon 123\n", - "adding: mem time265, current time 387, horizon 122\n", - "adding: mem time266, current time 387, horizon 121\n", - "adding: mem time267, current time 387, horizon 120\n", - "adding: mem time268, current time 387, horizon 119\n", - "adding: mem time269, current time 387, horizon 118\n", - "adding: mem time270, current time 387, horizon 117\n", - "adding: mem time271, current time 387, horizon 116\n", - "adding: mem time272, current time 387, horizon 115\n", - "adding: mem time273, current time 387, horizon 114\n", - "adding: mem time274, current time 387, horizon 113\n", - "adding: mem time275, current time 387, horizon 112\n", - "adding: mem time276, current time 387, horizon 111\n", - "adding: mem time277, current time 387, horizon 110\n", - "adding: mem time278, current time 387, horizon 109\n", - "adding: mem time279, current time 387, horizon 108\n", - "adding: mem time280, current time 387, horizon 107\n", - "adding: mem time281, current time 387, horizon 106\n", - "adding: mem time282, current time 387, horizon 105\n", - "adding: mem time283, current time 387, horizon 104\n", - "adding: mem time284, current time 387, horizon 103\n", - "adding: mem time285, current time 387, horizon 102\n", - "adding: mem time286, current time 387, horizon 101\n", - "adding: mem time287, current time 387, horizon 100\n", - "adding: mem time288, current time 387, horizon 99\n", - "adding: mem time289, current time 387, horizon 98\n", - "adding: mem time290, current time 387, horizon 97\n", - "adding: mem time291, current time 387, horizon 96\n", - "adding: mem time292, current time 387, horizon 95\n", - "adding: mem time293, current time 387, horizon 94\n", - "adding: mem time294, current time 387, horizon 93\n", - "adding: mem time295, current time 387, horizon 92\n", - "adding: mem time296, current time 387, horizon 91\n", - "adding: mem time297, current time 387, horizon 90\n", - "adding: mem time298, current time 387, horizon 89\n", - "adding: mem time299, current time 387, horizon 88\n", - "adding: mem time300, current time 387, horizon 87\n", - "adding: mem time301, current time 387, horizon 86\n", - "adding: mem time302, current time 387, horizon 85\n", - "adding: mem time303, current time 387, horizon 84\n", - "adding: mem time304, current time 387, horizon 83\n", - "adding: mem time305, current time 387, horizon 82\n", - "adding: mem time306, current time 387, horizon 81\n", - "adding: mem time307, current time 387, horizon 80\n", - "adding: mem time308, current time 387, horizon 79\n", - "adding: mem time309, current time 387, horizon 78\n", - "adding: mem time310, current time 387, horizon 77\n", - "adding: mem time311, current time 387, horizon 76\n", - "adding: mem time312, current time 387, horizon 75\n", - "adding: mem time313, current time 387, horizon 74\n", - "adding: mem time314, current time 387, horizon 73\n", - "adding: mem time315, current time 387, horizon 72\n", - "adding: mem time316, current time 387, horizon 71\n", - "adding: mem time317, current time 387, horizon 70\n", - "adding: mem time318, current time 387, horizon 69\n", - "adding: mem time319, current time 387, horizon 68\n", - "adding: mem time320, current time 387, horizon 67\n", - "adding: mem time321, current time 387, horizon 66\n", - "adding: mem time322, current time 387, horizon 65\n", - "adding: mem time323, current time 387, horizon 64\n", - "adding: mem time324, current time 387, horizon 63\n", - "adding: mem time325, current time 387, horizon 62\n", - "adding: mem time326, current time 387, horizon 61\n", - "adding: mem time327, current time 387, horizon 60\n", - "adding: mem time328, current time 387, horizon 59\n", - "adding: mem time329, current time 387, horizon 58\n", - "adding: mem time330, current time 387, horizon 57\n", - "adding: mem time331, current time 387, horizon 56\n", - "adding: mem time332, current time 387, horizon 55\n", - "adding: mem time333, current time 387, horizon 54\n", - "adding: mem time334, current time 387, horizon 53\n", - "adding: mem time335, current time 387, horizon 52\n", - "adding: mem time336, current time 387, horizon 51\n", - "adding: mem time337, current time 387, horizon 50\n", - "adding: mem time338, current time 387, horizon 49\n", - "adding: mem time339, current time 387, horizon 48\n", - "adding: mem time340, current time 387, horizon 47\n", - "adding: mem time341, current time 387, horizon 46\n", - "adding: mem time342, current time 387, horizon 45\n", - "adding: mem time343, current time 387, horizon 44\n", - "adding: mem time344, current time 387, horizon 43\n", - "adding: mem time345, current time 387, horizon 42\n", - "adding: mem time346, current time 387, horizon 41\n", - "adding: mem time347, current time 387, horizon 40\n", - "adding: mem time348, current time 387, horizon 39\n", - "adding: mem time349, current time 387, horizon 38\n", - "adding: mem time350, current time 387, horizon 37\n", - "adding: mem time351, current time 387, horizon 36\n", - "adding: mem time352, current time 387, horizon 35\n", - "adding: mem time353, current time 387, horizon 34\n", - "adding: mem time354, current time 387, horizon 33\n", - "adding: mem time355, current time 387, horizon 32\n", - "adding: mem time356, current time 387, horizon 31\n", - "adding: mem time357, current time 387, horizon 30\n", - "adding: mem time358, current time 387, horizon 29\n", - "adding: mem time359, current time 387, horizon 28\n", - "adding: mem time360, current time 387, horizon 27\n", - "adding: mem time361, current time 387, horizon 26\n", - "adding: mem time362, current time 387, horizon 25\n", - "adding: mem time363, current time 387, horizon 24\n", - "adding: mem time364, current time 387, horizon 23\n", - "adding: mem time365, current time 387, horizon 22\n", - "adding: mem time366, current time 387, horizon 21\n", - "adding: mem time367, current time 387, horizon 20\n", - "adding: mem time368, current time 387, horizon 19\n", - "adding: mem time369, current time 387, horizon 18\n", - "adding: mem time370, current time 387, horizon 17\n", - "adding: mem time371, current time 387, horizon 16\n", - "adding: mem time372, current time 387, horizon 15\n", - "adding: mem time373, current time 387, horizon 14\n", - "adding: mem time374, current time 387, horizon 13\n", - "adding: mem time375, current time 387, horizon 12\n", - "adding: mem time376, current time 387, horizon 11\n", - "adding: mem time377, current time 387, horizon 10\n", - "adding: mem time378, current time 387, horizon 9\n", - "adding: mem time379, current time 387, horizon 8\n", - "adding: mem time380, current time 387, horizon 7\n", - "adding: mem time381, current time 387, horizon 6\n", - "adding: mem time382, current time 387, horizon 5\n", - "adding: mem time383, current time 387, horizon 4\n", - "adding: mem time384, current time 387, horizon 3\n", - "adding: mem time385, current time 387, horizon 2\n", - "adding: mem time386, current time 387, horizon 1\n", - "adding: mem time200, current time 388, horizon 188\n", - "adding: mem time201, current time 388, horizon 187\n", - "adding: mem time202, current time 388, horizon 186\n", - "adding: mem time203, current time 388, horizon 185\n", - "adding: mem time204, current time 388, horizon 184\n", - "adding: mem time205, current time 388, horizon 183\n", - "adding: mem time206, current time 388, horizon 182\n", - "adding: mem time207, current time 388, horizon 181\n", - "adding: mem time208, current time 388, horizon 180\n", - "adding: mem time209, current time 388, horizon 179\n", - "adding: mem time210, current time 388, horizon 178\n", - "adding: mem time211, current time 388, horizon 177\n", - "adding: mem time212, current time 388, horizon 176\n", - "adding: mem time213, current time 388, horizon 175\n", - "adding: mem time214, current time 388, horizon 174\n", - "adding: mem time215, current time 388, horizon 173\n", - "adding: mem time216, current time 388, horizon 172\n", - "adding: mem time217, current time 388, horizon 171\n", - "adding: mem time218, current time 388, horizon 170\n", - "adding: mem time219, current time 388, horizon 169\n", - "adding: mem time220, current time 388, horizon 168\n", - "adding: mem time221, current time 388, horizon 167\n", - "adding: mem time222, current time 388, horizon 166\n", - "adding: mem time223, current time 388, horizon 165\n", - "adding: mem time224, current time 388, horizon 164\n", - "adding: mem time225, current time 388, horizon 163\n", - "adding: mem time226, current time 388, horizon 162\n", - "adding: mem time227, current time 388, horizon 161\n", - "adding: mem time228, current time 388, horizon 160\n", - "adding: mem time229, current time 388, horizon 159\n", - "adding: mem time230, current time 388, horizon 158\n", - "adding: mem time231, current time 388, horizon 157\n", - "adding: mem time232, current time 388, horizon 156\n", - "adding: mem time233, current time 388, horizon 155\n", - "adding: mem time234, current time 388, horizon 154\n", - "adding: mem time235, current time 388, horizon 153\n", - "adding: mem time236, current time 388, horizon 152\n", - "adding: mem time237, current time 388, horizon 151\n", - "adding: mem time238, current time 388, horizon 150\n", - "adding: mem time239, current time 388, horizon 149\n", - "adding: mem time240, current time 388, horizon 148\n", - "adding: mem time241, current time 388, horizon 147\n", - "adding: mem time242, current time 388, horizon 146\n", - "adding: mem time243, current time 388, horizon 145\n", - "adding: mem time244, current time 388, horizon 144\n", - "adding: mem time245, current time 388, horizon 143\n", - "adding: mem time246, current time 388, horizon 142\n", - "adding: mem time247, current time 388, horizon 141\n", - "adding: mem time248, current time 388, horizon 140\n", - "adding: mem time249, current time 388, horizon 139\n", - "adding: mem time250, current time 388, horizon 138\n", - "adding: mem time251, current time 388, horizon 137\n", - "adding: mem time252, current time 388, horizon 136\n", - "adding: mem time253, current time 388, horizon 135\n", - "adding: mem time254, current time 388, horizon 134\n", - "adding: mem time255, current time 388, horizon 133\n", - "adding: mem time256, current time 388, horizon 132\n", - "adding: mem time257, current time 388, horizon 131\n", - "adding: mem time258, current time 388, horizon 130\n", - "adding: mem time259, current time 388, horizon 129\n", - "adding: mem time260, current time 388, horizon 128\n", - "adding: mem time261, current time 388, horizon 127\n", - "adding: mem time262, current time 388, horizon 126\n", - "adding: mem time263, current time 388, horizon 125\n", - "adding: mem time264, current time 388, horizon 124\n", - "adding: mem time265, current time 388, horizon 123\n", - "adding: mem time266, current time 388, horizon 122\n", - "adding: mem time267, current time 388, horizon 121\n", - "adding: mem time268, current time 388, horizon 120\n", - "adding: mem time269, current time 388, horizon 119\n", - "adding: mem time270, current time 388, horizon 118\n", - "adding: mem time271, current time 388, horizon 117\n", - "adding: mem time272, current time 388, horizon 116\n", - "adding: mem time273, current time 388, horizon 115\n", - "adding: mem time274, current time 388, horizon 114\n", - "adding: mem time275, current time 388, horizon 113\n", - "adding: mem time276, current time 388, horizon 112\n", - "adding: mem time277, current time 388, horizon 111\n", - "adding: mem time278, current time 388, horizon 110\n", - "adding: mem time279, current time 388, horizon 109\n", - "adding: mem time280, current time 388, horizon 108\n", - "adding: mem time281, current time 388, horizon 107\n", - "adding: mem time282, current time 388, horizon 106\n", - "adding: mem time283, current time 388, horizon 105\n", - "adding: mem time284, current time 388, horizon 104\n", - "adding: mem time285, current time 388, horizon 103\n", - "adding: mem time286, current time 388, horizon 102\n", - "adding: mem time287, current time 388, horizon 101\n", - "adding: mem time288, current time 388, horizon 100\n", - "adding: mem time289, current time 388, horizon 99\n", - "adding: mem time290, current time 388, horizon 98\n", - "adding: mem time291, current time 388, horizon 97\n", - "adding: mem time292, current time 388, horizon 96\n", - "adding: mem time293, current time 388, horizon 95\n", - "adding: mem time294, current time 388, horizon 94\n", - "adding: mem time295, current time 388, horizon 93\n", - "adding: mem time296, current time 388, horizon 92\n", - "adding: mem time297, current time 388, horizon 91\n", - "adding: mem time298, current time 388, horizon 90\n", - "adding: mem time299, current time 388, horizon 89\n", - "adding: mem time300, current time 388, horizon 88\n", - "adding: mem time301, current time 388, horizon 87\n", - "adding: mem time302, current time 388, horizon 86\n", - "adding: mem time303, current time 388, horizon 85\n", - "adding: mem time304, current time 388, horizon 84\n", - "adding: mem time305, current time 388, horizon 83\n", - "adding: mem time306, current time 388, horizon 82\n", - "adding: mem time307, current time 388, horizon 81\n", - "adding: mem time308, current time 388, horizon 80\n", - "adding: mem time309, current time 388, horizon 79\n", - "adding: mem time310, current time 388, horizon 78\n", - "adding: mem time311, current time 388, horizon 77\n", - "adding: mem time312, current time 388, horizon 76\n", - "adding: mem time313, current time 388, horizon 75\n", - "adding: mem time314, current time 388, horizon 74\n", - "adding: mem time315, current time 388, horizon 73\n", - "adding: mem time316, current time 388, horizon 72\n", - "adding: mem time317, current time 388, horizon 71\n", - "adding: mem time318, current time 388, horizon 70\n", - "adding: mem time319, current time 388, horizon 69\n", - "adding: mem time320, current time 388, horizon 68\n", - "adding: mem time321, current time 388, horizon 67\n", - "adding: mem time322, current time 388, horizon 66\n", - "adding: mem time323, current time 388, horizon 65\n", - "adding: mem time324, current time 388, horizon 64\n", - "adding: mem time325, current time 388, horizon 63\n", - "adding: mem time326, current time 388, horizon 62\n", - "adding: mem time327, current time 388, horizon 61\n", - "adding: mem time328, current time 388, horizon 60\n", - "adding: mem time329, current time 388, horizon 59\n", - "adding: mem time330, current time 388, horizon 58\n", - "adding: mem time331, current time 388, horizon 57\n", - "adding: mem time332, current time 388, horizon 56\n", - "adding: mem time333, current time 388, horizon 55\n", - "adding: mem time334, current time 388, horizon 54\n", - "adding: mem time335, current time 388, horizon 53\n", - "adding: mem time336, current time 388, horizon 52\n", - "adding: mem time337, current time 388, horizon 51\n", - "adding: mem time338, current time 388, horizon 50\n", - "adding: mem time339, current time 388, horizon 49\n", - "adding: mem time340, current time 388, horizon 48\n", - "adding: mem time341, current time 388, horizon 47\n", - "adding: mem time342, current time 388, horizon 46\n", - "adding: mem time343, current time 388, horizon 45\n", - "adding: mem time344, current time 388, horizon 44\n", - "adding: mem time345, current time 388, horizon 43\n", - "adding: mem time346, current time 388, horizon 42\n", - "adding: mem time347, current time 388, horizon 41\n", - "adding: mem time348, current time 388, horizon 40\n", - "adding: mem time349, current time 388, horizon 39\n", - "adding: mem time350, current time 388, horizon 38\n", - "adding: mem time351, current time 388, horizon 37\n", - "adding: mem time352, current time 388, horizon 36\n", - "adding: mem time353, current time 388, horizon 35\n", - "adding: mem time354, current time 388, horizon 34\n", - "adding: mem time355, current time 388, horizon 33\n", - "adding: mem time356, current time 388, horizon 32\n", - "adding: mem time357, current time 388, horizon 31\n", - "adding: mem time358, current time 388, horizon 30\n", - "adding: mem time359, current time 388, horizon 29\n", - "adding: mem time360, current time 388, horizon 28\n", - "adding: mem time361, current time 388, horizon 27\n", - "adding: mem time362, current time 388, horizon 26\n", - "adding: mem time363, current time 388, horizon 25\n", - "adding: mem time364, current time 388, horizon 24\n", - "adding: mem time365, current time 388, horizon 23\n", - "adding: mem time366, current time 388, horizon 22\n", - "adding: mem time367, current time 388, horizon 21\n", - "adding: mem time368, current time 388, horizon 20\n", - "adding: mem time369, current time 388, horizon 19\n", - "adding: mem time370, current time 388, horizon 18\n", - "adding: mem time371, current time 388, horizon 17\n", - "adding: mem time372, current time 388, horizon 16\n", - "adding: mem time373, current time 388, horizon 15\n", - "adding: mem time374, current time 388, horizon 14\n", - "adding: mem time375, current time 388, horizon 13\n", - "adding: mem time376, current time 388, horizon 12\n", - "adding: mem time377, current time 388, horizon 11\n", - "adding: mem time378, current time 388, horizon 10\n", - "adding: mem time379, current time 388, horizon 9\n", - "adding: mem time380, current time 388, horizon 8\n", - "adding: mem time381, current time 388, horizon 7\n", - "adding: mem time382, current time 388, horizon 6\n", - "adding: mem time383, current time 388, horizon 5\n", - "adding: mem time384, current time 388, horizon 4\n", - "adding: mem time385, current time 388, horizon 3\n", - "adding: mem time386, current time 388, horizon 2\n", - "adding: mem time387, current time 388, horizon 1\n", - "adding: mem time200, current time 389, horizon 189\n", - "adding: mem time201, current time 389, horizon 188\n", - "adding: mem time202, current time 389, horizon 187\n", - "adding: mem time203, current time 389, horizon 186\n", - "adding: mem time204, current time 389, horizon 185\n", - "adding: mem time205, current time 389, horizon 184\n", - "adding: mem time206, current time 389, horizon 183\n", - "adding: mem time207, current time 389, horizon 182\n", - "adding: mem time208, current time 389, horizon 181\n", - "adding: mem time209, current time 389, horizon 180\n", - "adding: mem time210, current time 389, horizon 179\n", - "adding: mem time211, current time 389, horizon 178\n", - "adding: mem time212, current time 389, horizon 177\n", - "adding: mem time213, current time 389, horizon 176\n", - "adding: mem time214, current time 389, horizon 175\n", - "adding: mem time215, current time 389, horizon 174\n", - "adding: mem time216, current time 389, horizon 173\n", - "adding: mem time217, current time 389, horizon 172\n", - "adding: mem time218, current time 389, horizon 171\n", - "adding: mem time219, current time 389, horizon 170\n", - "adding: mem time220, current time 389, horizon 169\n", - "adding: mem time221, current time 389, horizon 168\n", - "adding: mem time222, current time 389, horizon 167\n", - "adding: mem time223, current time 389, horizon 166\n", - "adding: mem time224, current time 389, horizon 165\n", - "adding: mem time225, current time 389, horizon 164\n", - "adding: mem time226, current time 389, horizon 163\n", - "adding: mem time227, current time 389, horizon 162\n", - "adding: mem time228, current time 389, horizon 161\n", - "adding: mem time229, current time 389, horizon 160\n", - "adding: mem time230, current time 389, horizon 159\n", - "adding: mem time231, current time 389, horizon 158\n", - "adding: mem time232, current time 389, horizon 157\n", - "adding: mem time233, current time 389, horizon 156\n", - "adding: mem time234, current time 389, horizon 155\n", - "adding: mem time235, current time 389, horizon 154\n", - "adding: mem time236, current time 389, horizon 153\n", - "adding: mem time237, current time 389, horizon 152\n", - "adding: mem time238, current time 389, horizon 151\n", - "adding: mem time239, current time 389, horizon 150\n", - "adding: mem time240, current time 389, horizon 149\n", - "adding: mem time241, current time 389, horizon 148\n", - "adding: mem time242, current time 389, horizon 147\n", - "adding: mem time243, current time 389, horizon 146\n", - "adding: mem time244, current time 389, horizon 145\n", - "adding: mem time245, current time 389, horizon 144\n", - "adding: mem time246, current time 389, horizon 143\n", - "adding: mem time247, current time 389, horizon 142\n", - "adding: mem time248, current time 389, horizon 141\n", - "adding: mem time249, current time 389, horizon 140\n", - "adding: mem time250, current time 389, horizon 139\n", - "adding: mem time251, current time 389, horizon 138\n", - "adding: mem time252, current time 389, horizon 137\n", - "adding: mem time253, current time 389, horizon 136\n", - "adding: mem time254, current time 389, horizon 135\n", - "adding: mem time255, current time 389, horizon 134\n", - "adding: mem time256, current time 389, horizon 133\n", - "adding: mem time257, current time 389, horizon 132\n", - "adding: mem time258, current time 389, horizon 131\n", - "adding: mem time259, current time 389, horizon 130\n", - "adding: mem time260, current time 389, horizon 129\n", - "adding: mem time261, current time 389, horizon 128\n", - "adding: mem time262, current time 389, horizon 127\n", - "adding: mem time263, current time 389, horizon 126\n", - "adding: mem time264, current time 389, horizon 125\n", - "adding: mem time265, current time 389, horizon 124\n", - "adding: mem time266, current time 389, horizon 123\n", - "adding: mem time267, current time 389, horizon 122\n", - "adding: mem time268, current time 389, horizon 121\n", - "adding: mem time269, current time 389, horizon 120\n", - "adding: mem time270, current time 389, horizon 119\n", - "adding: mem time271, current time 389, horizon 118\n", - "adding: mem time272, current time 389, horizon 117\n", - "adding: mem time273, current time 389, horizon 116\n", - "adding: mem time274, current time 389, horizon 115\n", - "adding: mem time275, current time 389, horizon 114\n", - "adding: mem time276, current time 389, horizon 113\n", - "adding: mem time277, current time 389, horizon 112\n", - "adding: mem time278, current time 389, horizon 111\n", - "adding: mem time279, current time 389, horizon 110\n", - "adding: mem time280, current time 389, horizon 109\n", - "adding: mem time281, current time 389, horizon 108\n", - "adding: mem time282, current time 389, horizon 107\n", - "adding: mem time283, current time 389, horizon 106\n", - "adding: mem time284, current time 389, horizon 105\n", - "adding: mem time285, current time 389, horizon 104\n", - "adding: mem time286, current time 389, horizon 103\n", - "adding: mem time287, current time 389, horizon 102\n", - "adding: mem time288, current time 389, horizon 101\n", - "adding: mem time289, current time 389, horizon 100\n", - "adding: mem time290, current time 389, horizon 99\n", - "adding: mem time291, current time 389, horizon 98\n", - "adding: mem time292, current time 389, horizon 97\n", - "adding: mem time293, current time 389, horizon 96\n", - "adding: mem time294, current time 389, horizon 95\n", - "adding: mem time295, current time 389, horizon 94\n", - "adding: mem time296, current time 389, horizon 93\n", - "adding: mem time297, current time 389, horizon 92\n", - "adding: mem time298, current time 389, horizon 91\n", - "adding: mem time299, current time 389, horizon 90\n", - "adding: mem time300, current time 389, horizon 89\n", - "adding: mem time301, current time 389, horizon 88\n", - "adding: mem time302, current time 389, horizon 87\n", - "adding: mem time303, current time 389, horizon 86\n", - "adding: mem time304, current time 389, horizon 85\n", - "adding: mem time305, current time 389, horizon 84\n", - "adding: mem time306, current time 389, horizon 83\n", - "adding: mem time307, current time 389, horizon 82\n", - "adding: mem time308, current time 389, horizon 81\n", - "adding: mem time309, current time 389, horizon 80\n", - "adding: mem time310, current time 389, horizon 79\n", - "adding: mem time311, current time 389, horizon 78\n", - "adding: mem time312, current time 389, horizon 77\n", - "adding: mem time313, current time 389, horizon 76\n", - "adding: mem time314, current time 389, horizon 75\n", - "adding: mem time315, current time 389, horizon 74\n", - "adding: mem time316, current time 389, horizon 73\n", - "adding: mem time317, current time 389, horizon 72\n", - "adding: mem time318, current time 389, horizon 71\n", - "adding: mem time319, current time 389, horizon 70\n", - "adding: mem time320, current time 389, horizon 69\n", - "adding: mem time321, current time 389, horizon 68\n", - "adding: mem time322, current time 389, horizon 67\n", - "adding: mem time323, current time 389, horizon 66\n", - "adding: mem time324, current time 389, horizon 65\n", - "adding: mem time325, current time 389, horizon 64\n", - "adding: mem time326, current time 389, horizon 63\n", - "adding: mem time327, current time 389, horizon 62\n", - "adding: mem time328, current time 389, horizon 61\n", - "adding: mem time329, current time 389, horizon 60\n", - "adding: mem time330, current time 389, horizon 59\n", - "adding: mem time331, current time 389, horizon 58\n", - "adding: mem time332, current time 389, horizon 57\n", - "adding: mem time333, current time 389, horizon 56\n", - "adding: mem time334, current time 389, horizon 55\n", - "adding: mem time335, current time 389, horizon 54\n", - "adding: mem time336, current time 389, horizon 53\n", - "adding: mem time337, current time 389, horizon 52\n", - "adding: mem time338, current time 389, horizon 51\n", - "adding: mem time339, current time 389, horizon 50\n", - "adding: mem time340, current time 389, horizon 49\n", - "adding: mem time341, current time 389, horizon 48\n", - "adding: mem time342, current time 389, horizon 47\n", - "adding: mem time343, current time 389, horizon 46\n", - "adding: mem time344, current time 389, horizon 45\n", - "adding: mem time345, current time 389, horizon 44\n", - "adding: mem time346, current time 389, horizon 43\n", - "adding: mem time347, current time 389, horizon 42\n", - "adding: mem time348, current time 389, horizon 41\n", - "adding: mem time349, current time 389, horizon 40\n", - "adding: mem time350, current time 389, horizon 39\n", - "adding: mem time351, current time 389, horizon 38\n", - "adding: mem time352, current time 389, horizon 37\n", - "adding: mem time353, current time 389, horizon 36\n", - "adding: mem time354, current time 389, horizon 35\n", - "adding: mem time355, current time 389, horizon 34\n", - "adding: mem time356, current time 389, horizon 33\n", - "adding: mem time357, current time 389, horizon 32\n", - "adding: mem time358, current time 389, horizon 31\n", - "adding: mem time359, current time 389, horizon 30\n", - "adding: mem time360, current time 389, horizon 29\n", - "adding: mem time361, current time 389, horizon 28\n", - "adding: mem time362, current time 389, horizon 27\n", - "adding: mem time363, current time 389, horizon 26\n", - "adding: mem time364, current time 389, horizon 25\n", - "adding: mem time365, current time 389, horizon 24\n", - "adding: mem time366, current time 389, horizon 23\n", - "adding: mem time367, current time 389, horizon 22\n", - "adding: mem time368, current time 389, horizon 21\n", - "adding: mem time369, current time 389, horizon 20\n", - "adding: mem time370, current time 389, horizon 19\n", - "adding: mem time371, current time 389, horizon 18\n", - "adding: mem time372, current time 389, horizon 17\n", - "adding: mem time373, current time 389, horizon 16\n", - "adding: mem time374, current time 389, horizon 15\n", - "adding: mem time375, current time 389, horizon 14\n", - "adding: mem time376, current time 389, horizon 13\n", - "adding: mem time377, current time 389, horizon 12\n", - "adding: mem time378, current time 389, horizon 11\n", - "adding: mem time379, current time 389, horizon 10\n", - "adding: mem time380, current time 389, horizon 9\n", - "adding: mem time381, current time 389, horizon 8\n", - "adding: mem time382, current time 389, horizon 7\n", - "adding: mem time383, current time 389, horizon 6\n", - "adding: mem time384, current time 389, horizon 5\n", - "adding: mem time385, current time 389, horizon 4\n", - "adding: mem time386, current time 389, horizon 3\n", - "adding: mem time387, current time 389, horizon 2\n", - "adding: mem time388, current time 389, horizon 1\n", - "adding: mem time200, current time 390, horizon 190\n", - "adding: mem time201, current time 390, horizon 189\n", - "adding: mem time202, current time 390, horizon 188\n", - "adding: mem time203, current time 390, horizon 187\n", - "adding: mem time204, current time 390, horizon 186\n", - "adding: mem time205, current time 390, horizon 185\n", - "adding: mem time206, current time 390, horizon 184\n", - "adding: mem time207, current time 390, horizon 183\n", - "adding: mem time208, current time 390, horizon 182\n", - "adding: mem time209, current time 390, horizon 181\n", - "adding: mem time210, current time 390, horizon 180\n", - "adding: mem time211, current time 390, horizon 179\n", - "adding: mem time212, current time 390, horizon 178\n", - "adding: mem time213, current time 390, horizon 177\n", - "adding: mem time214, current time 390, horizon 176\n", - "adding: mem time215, current time 390, horizon 175\n", - "adding: mem time216, current time 390, horizon 174\n", - "adding: mem time217, current time 390, horizon 173\n", - "adding: mem time218, current time 390, horizon 172\n", - "adding: mem time219, current time 390, horizon 171\n", - "adding: mem time220, current time 390, horizon 170\n", - "adding: mem time221, current time 390, horizon 169\n", - "adding: mem time222, current time 390, horizon 168\n", - "adding: mem time223, current time 390, horizon 167\n", - "adding: mem time224, current time 390, horizon 166\n", - "adding: mem time225, current time 390, horizon 165\n", - "adding: mem time226, current time 390, horizon 164\n", - "adding: mem time227, current time 390, horizon 163\n", - "adding: mem time228, current time 390, horizon 162\n", - "adding: mem time229, current time 390, horizon 161\n", - "adding: mem time230, current time 390, horizon 160\n", - "adding: mem time231, current time 390, horizon 159\n", - "adding: mem time232, current time 390, horizon 158\n", - "adding: mem time233, current time 390, horizon 157\n", - "adding: mem time234, current time 390, horizon 156\n", - "adding: mem time235, current time 390, horizon 155\n", - "adding: mem time236, current time 390, horizon 154\n", - "adding: mem time237, current time 390, horizon 153\n", - "adding: mem time238, current time 390, horizon 152\n", - "adding: mem time239, current time 390, horizon 151\n", - "adding: mem time240, current time 390, horizon 150\n", - "adding: mem time241, current time 390, horizon 149\n", - "adding: mem time242, current time 390, horizon 148\n", - "adding: mem time243, current time 390, horizon 147\n", - "adding: mem time244, current time 390, horizon 146\n", - "adding: mem time245, current time 390, horizon 145\n", - "adding: mem time246, current time 390, horizon 144\n", - "adding: mem time247, current time 390, horizon 143\n", - "adding: mem time248, current time 390, horizon 142\n", - "adding: mem time249, current time 390, horizon 141\n", - "adding: mem time250, current time 390, horizon 140\n", - "adding: mem time251, current time 390, horizon 139\n", - "adding: mem time252, current time 390, horizon 138\n", - "adding: mem time253, current time 390, horizon 137\n", - "adding: mem time254, current time 390, horizon 136\n", - "adding: mem time255, current time 390, horizon 135\n", - "adding: mem time256, current time 390, horizon 134\n", - "adding: mem time257, current time 390, horizon 133\n", - "adding: mem time258, current time 390, horizon 132\n", - "adding: mem time259, current time 390, horizon 131\n", - "adding: mem time260, current time 390, horizon 130\n", - "adding: mem time261, current time 390, horizon 129\n", - "adding: mem time262, current time 390, horizon 128\n", - "adding: mem time263, current time 390, horizon 127\n", - "adding: mem time264, current time 390, horizon 126\n", - "adding: mem time265, current time 390, horizon 125\n", - "adding: mem time266, current time 390, horizon 124\n", - "adding: mem time267, current time 390, horizon 123\n", - "adding: mem time268, current time 390, horizon 122\n", - "adding: mem time269, current time 390, horizon 121\n", - "adding: mem time270, current time 390, horizon 120\n", - "adding: mem time271, current time 390, horizon 119\n", - "adding: mem time272, current time 390, horizon 118\n", - "adding: mem time273, current time 390, horizon 117\n", - "adding: mem time274, current time 390, horizon 116\n", - "adding: mem time275, current time 390, horizon 115\n", - "adding: mem time276, current time 390, horizon 114\n", - "adding: mem time277, current time 390, horizon 113\n", - "adding: mem time278, current time 390, horizon 112\n", - "adding: mem time279, current time 390, horizon 111\n", - "adding: mem time280, current time 390, horizon 110\n", - "adding: mem time281, current time 390, horizon 109\n", - "adding: mem time282, current time 390, horizon 108\n", - "adding: mem time283, current time 390, horizon 107\n", - "adding: mem time284, current time 390, horizon 106\n", - "adding: mem time285, current time 390, horizon 105\n", - "adding: mem time286, current time 390, horizon 104\n", - "adding: mem time287, current time 390, horizon 103\n", - "adding: mem time288, current time 390, horizon 102\n", - "adding: mem time289, current time 390, horizon 101\n", - "adding: mem time290, current time 390, horizon 100\n", - "adding: mem time291, current time 390, horizon 99\n", - "adding: mem time292, current time 390, horizon 98\n", - "adding: mem time293, current time 390, horizon 97\n", - "adding: mem time294, current time 390, horizon 96\n", - "adding: mem time295, current time 390, horizon 95\n", - "adding: mem time296, current time 390, horizon 94\n", - "adding: mem time297, current time 390, horizon 93\n", - "adding: mem time298, current time 390, horizon 92\n", - "adding: mem time299, current time 390, horizon 91\n", - "adding: mem time300, current time 390, horizon 90\n", - "adding: mem time301, current time 390, horizon 89\n", - "adding: mem time302, current time 390, horizon 88\n", - "adding: mem time303, current time 390, horizon 87\n", - "adding: mem time304, current time 390, horizon 86\n", - "adding: mem time305, current time 390, horizon 85\n", - "adding: mem time306, current time 390, horizon 84\n", - "adding: mem time307, current time 390, horizon 83\n", - "adding: mem time308, current time 390, horizon 82\n", - "adding: mem time309, current time 390, horizon 81\n", - "adding: mem time310, current time 390, horizon 80\n", - "adding: mem time311, current time 390, horizon 79\n", - "adding: mem time312, current time 390, horizon 78\n", - "adding: mem time313, current time 390, horizon 77\n", - "adding: mem time314, current time 390, horizon 76\n", - "adding: mem time315, current time 390, horizon 75\n", - "adding: mem time316, current time 390, horizon 74\n", - "adding: mem time317, current time 390, horizon 73\n", - "adding: mem time318, current time 390, horizon 72\n", - "adding: mem time319, current time 390, horizon 71\n", - "adding: mem time320, current time 390, horizon 70\n", - "adding: mem time321, current time 390, horizon 69\n", - "adding: mem time322, current time 390, horizon 68\n", - "adding: mem time323, current time 390, horizon 67\n", - "adding: mem time324, current time 390, horizon 66\n", - "adding: mem time325, current time 390, horizon 65\n", - "adding: mem time326, current time 390, horizon 64\n", - "adding: mem time327, current time 390, horizon 63\n", - "adding: mem time328, current time 390, horizon 62\n", - "adding: mem time329, current time 390, horizon 61\n", - "adding: mem time330, current time 390, horizon 60\n", - "adding: mem time331, current time 390, horizon 59\n", - "adding: mem time332, current time 390, horizon 58\n", - "adding: mem time333, current time 390, horizon 57\n", - "adding: mem time334, current time 390, horizon 56\n", - "adding: mem time335, current time 390, horizon 55\n", - "adding: mem time336, current time 390, horizon 54\n", - "adding: mem time337, current time 390, horizon 53\n", - "adding: mem time338, current time 390, horizon 52\n", - "adding: mem time339, current time 390, horizon 51\n", - "adding: mem time340, current time 390, horizon 50\n", - "adding: mem time341, current time 390, horizon 49\n", - "adding: mem time342, current time 390, horizon 48\n", - "adding: mem time343, current time 390, horizon 47\n", - "adding: mem time344, current time 390, horizon 46\n", - "adding: mem time345, current time 390, horizon 45\n", - "adding: mem time346, current time 390, horizon 44\n", - "adding: mem time347, current time 390, horizon 43\n", - "adding: mem time348, current time 390, horizon 42\n", - "adding: mem time349, current time 390, horizon 41\n", - "adding: mem time350, current time 390, horizon 40\n", - "adding: mem time351, current time 390, horizon 39\n", - "adding: mem time352, current time 390, horizon 38\n", - "adding: mem time353, current time 390, horizon 37\n", - "adding: mem time354, current time 390, horizon 36\n", - "adding: mem time355, current time 390, horizon 35\n", - "adding: mem time356, current time 390, horizon 34\n", - "adding: mem time357, current time 390, horizon 33\n", - "adding: mem time358, current time 390, horizon 32\n", - "adding: mem time359, current time 390, horizon 31\n", - "adding: mem time360, current time 390, horizon 30\n", - "adding: mem time361, current time 390, horizon 29\n", - "adding: mem time362, current time 390, horizon 28\n", - "adding: mem time363, current time 390, horizon 27\n", - "adding: mem time364, current time 390, horizon 26\n", - "adding: mem time365, current time 390, horizon 25\n", - "adding: mem time366, current time 390, horizon 24\n", - "adding: mem time367, current time 390, horizon 23\n", - "adding: mem time368, current time 390, horizon 22\n", - "adding: mem time369, current time 390, horizon 21\n", - "adding: mem time370, current time 390, horizon 20\n", - "adding: mem time371, current time 390, horizon 19\n", - "adding: mem time372, current time 390, horizon 18\n", - "adding: mem time373, current time 390, horizon 17\n", - "adding: mem time374, current time 390, horizon 16\n", - "adding: mem time375, current time 390, horizon 15\n", - "adding: mem time376, current time 390, horizon 14\n", - "adding: mem time377, current time 390, horizon 13\n", - "adding: mem time378, current time 390, horizon 12\n", - "adding: mem time379, current time 390, horizon 11\n", - "adding: mem time380, current time 390, horizon 10\n", - "adding: mem time381, current time 390, horizon 9\n", - "adding: mem time382, current time 390, horizon 8\n", - "adding: mem time383, current time 390, horizon 7\n", - "adding: mem time384, current time 390, horizon 6\n", - "adding: mem time385, current time 390, horizon 5\n", - "adding: mem time386, current time 390, horizon 4\n", - "adding: mem time387, current time 390, horizon 3\n", - "adding: mem time388, current time 390, horizon 2\n", - "adding: mem time389, current time 390, horizon 1\n", - "adding: mem time200, current time 391, horizon 191\n", - "adding: mem time201, current time 391, horizon 190\n", - "adding: mem time202, current time 391, horizon 189\n", - "adding: mem time203, current time 391, horizon 188\n", - "adding: mem time204, current time 391, horizon 187\n", - "adding: mem time205, current time 391, horizon 186\n", - "adding: mem time206, current time 391, horizon 185\n", - "adding: mem time207, current time 391, horizon 184\n", - "adding: mem time208, current time 391, horizon 183\n", - "adding: mem time209, current time 391, horizon 182\n", - "adding: mem time210, current time 391, horizon 181\n", - "adding: mem time211, current time 391, horizon 180\n", - "adding: mem time212, current time 391, horizon 179\n", - "adding: mem time213, current time 391, horizon 178\n", - "adding: mem time214, current time 391, horizon 177\n", - "adding: mem time215, current time 391, horizon 176\n", - "adding: mem time216, current time 391, horizon 175\n", - "adding: mem time217, current time 391, horizon 174\n", - "adding: mem time218, current time 391, horizon 173\n", - "adding: mem time219, current time 391, horizon 172\n", - "adding: mem time220, current time 391, horizon 171\n", - "adding: mem time221, current time 391, horizon 170\n", - "adding: mem time222, current time 391, horizon 169\n", - "adding: mem time223, current time 391, horizon 168\n", - "adding: mem time224, current time 391, horizon 167\n", - "adding: mem time225, current time 391, horizon 166\n", - "adding: mem time226, current time 391, horizon 165\n", - "adding: mem time227, current time 391, horizon 164\n", - "adding: mem time228, current time 391, horizon 163\n", - "adding: mem time229, current time 391, horizon 162\n", - "adding: mem time230, current time 391, horizon 161\n", - "adding: mem time231, current time 391, horizon 160\n", - "adding: mem time232, current time 391, horizon 159\n", - "adding: mem time233, current time 391, horizon 158\n", - "adding: mem time234, current time 391, horizon 157\n", - "adding: mem time235, current time 391, horizon 156\n", - "adding: mem time236, current time 391, horizon 155\n", - "adding: mem time237, current time 391, horizon 154\n", - "adding: mem time238, current time 391, horizon 153\n", - "adding: mem time239, current time 391, horizon 152\n", - "adding: mem time240, current time 391, horizon 151\n", - "adding: mem time241, current time 391, horizon 150\n", - "adding: mem time242, current time 391, horizon 149\n", - "adding: mem time243, current time 391, horizon 148\n", - "adding: mem time244, current time 391, horizon 147\n", - "adding: mem time245, current time 391, horizon 146\n", - "adding: mem time246, current time 391, horizon 145\n", - "adding: mem time247, current time 391, horizon 144\n", - "adding: mem time248, current time 391, horizon 143\n", - "adding: mem time249, current time 391, horizon 142\n", - "adding: mem time250, current time 391, horizon 141\n", - "adding: mem time251, current time 391, horizon 140\n", - "adding: mem time252, current time 391, horizon 139\n", - "adding: mem time253, current time 391, horizon 138\n", - "adding: mem time254, current time 391, horizon 137\n", - "adding: mem time255, current time 391, horizon 136\n", - "adding: mem time256, current time 391, horizon 135\n", - "adding: mem time257, current time 391, horizon 134\n", - "adding: mem time258, current time 391, horizon 133\n", - "adding: mem time259, current time 391, horizon 132\n", - "adding: mem time260, current time 391, horizon 131\n", - "adding: mem time261, current time 391, horizon 130\n", - "adding: mem time262, current time 391, horizon 129\n", - "adding: mem time263, current time 391, horizon 128\n", - "adding: mem time264, current time 391, horizon 127\n", - "adding: mem time265, current time 391, horizon 126\n", - "adding: mem time266, current time 391, horizon 125\n", - "adding: mem time267, current time 391, horizon 124\n", - "adding: mem time268, current time 391, horizon 123\n", - "adding: mem time269, current time 391, horizon 122\n", - "adding: mem time270, current time 391, horizon 121\n", - "adding: mem time271, current time 391, horizon 120\n", - "adding: mem time272, current time 391, horizon 119\n", - "adding: mem time273, current time 391, horizon 118\n", - "adding: mem time274, current time 391, horizon 117\n", - "adding: mem time275, current time 391, horizon 116\n", - "adding: mem time276, current time 391, horizon 115\n", - "adding: mem time277, current time 391, horizon 114\n", - "adding: mem time278, current time 391, horizon 113\n", - "adding: mem time279, current time 391, horizon 112\n", - "adding: mem time280, current time 391, horizon 111\n", - "adding: mem time281, current time 391, horizon 110\n", - "adding: mem time282, current time 391, horizon 109\n", - "adding: mem time283, current time 391, horizon 108\n", - "adding: mem time284, current time 391, horizon 107\n", - "adding: mem time285, current time 391, horizon 106\n", - "adding: mem time286, current time 391, horizon 105\n", - "adding: mem time287, current time 391, horizon 104\n", - "adding: mem time288, current time 391, horizon 103\n", - "adding: mem time289, current time 391, horizon 102\n", - "adding: mem time290, current time 391, horizon 101\n", - "adding: mem time291, current time 391, horizon 100\n", - "adding: mem time292, current time 391, horizon 99\n", - "adding: mem time293, current time 391, horizon 98\n", - "adding: mem time294, current time 391, horizon 97\n", - "adding: mem time295, current time 391, horizon 96\n", - "adding: mem time296, current time 391, horizon 95\n", - "adding: mem time297, current time 391, horizon 94\n", - "adding: mem time298, current time 391, horizon 93\n", - "adding: mem time299, current time 391, horizon 92\n", - "adding: mem time300, current time 391, horizon 91\n", - "adding: mem time301, current time 391, horizon 90\n", - "adding: mem time302, current time 391, horizon 89\n", - "adding: mem time303, current time 391, horizon 88\n", - "adding: mem time304, current time 391, horizon 87\n", - "adding: mem time305, current time 391, horizon 86\n", - "adding: mem time306, current time 391, horizon 85\n", - "adding: mem time307, current time 391, horizon 84\n", - "adding: mem time308, current time 391, horizon 83\n", - "adding: mem time309, current time 391, horizon 82\n", - "adding: mem time310, current time 391, horizon 81\n", - "adding: mem time311, current time 391, horizon 80\n", - "adding: mem time312, current time 391, horizon 79\n", - "adding: mem time313, current time 391, horizon 78\n", - "adding: mem time314, current time 391, horizon 77\n", - "adding: mem time315, current time 391, horizon 76\n", - "adding: mem time316, current time 391, horizon 75\n", - "adding: mem time317, current time 391, horizon 74\n", - "adding: mem time318, current time 391, horizon 73\n", - "adding: mem time319, current time 391, horizon 72\n", - "adding: mem time320, current time 391, horizon 71\n", - "adding: mem time321, current time 391, horizon 70\n", - "adding: mem time322, current time 391, horizon 69\n", - "adding: mem time323, current time 391, horizon 68\n", - "adding: mem time324, current time 391, horizon 67\n", - "adding: mem time325, current time 391, horizon 66\n", - "adding: mem time326, current time 391, horizon 65\n", - "adding: mem time327, current time 391, horizon 64\n", - "adding: mem time328, current time 391, horizon 63\n", - "adding: mem time329, current time 391, horizon 62\n", - "adding: mem time330, current time 391, horizon 61\n", - "adding: mem time331, current time 391, horizon 60\n", - "adding: mem time332, current time 391, horizon 59\n", - "adding: mem time333, current time 391, horizon 58\n", - "adding: mem time334, current time 391, horizon 57\n", - "adding: mem time335, current time 391, horizon 56\n", - "adding: mem time336, current time 391, horizon 55\n", - "adding: mem time337, current time 391, horizon 54\n", - "adding: mem time338, current time 391, horizon 53\n", - "adding: mem time339, current time 391, horizon 52\n", - "adding: mem time340, current time 391, horizon 51\n", - "adding: mem time341, current time 391, horizon 50\n", - "adding: mem time342, current time 391, horizon 49\n", - "adding: mem time343, current time 391, horizon 48\n", - "adding: mem time344, current time 391, horizon 47\n", - "adding: mem time345, current time 391, horizon 46\n", - "adding: mem time346, current time 391, horizon 45\n", - "adding: mem time347, current time 391, horizon 44\n", - "adding: mem time348, current time 391, horizon 43\n", - "adding: mem time349, current time 391, horizon 42\n", - "adding: mem time350, current time 391, horizon 41\n", - "adding: mem time351, current time 391, horizon 40\n", - "adding: mem time352, current time 391, horizon 39\n", - "adding: mem time353, current time 391, horizon 38\n", - "adding: mem time354, current time 391, horizon 37\n", - "adding: mem time355, current time 391, horizon 36\n", - "adding: mem time356, current time 391, horizon 35\n", - "adding: mem time357, current time 391, horizon 34\n", - "adding: mem time358, current time 391, horizon 33\n", - "adding: mem time359, current time 391, horizon 32\n", - "adding: mem time360, current time 391, horizon 31\n", - "adding: mem time361, current time 391, horizon 30\n", - "adding: mem time362, current time 391, horizon 29\n", - "adding: mem time363, current time 391, horizon 28\n", - "adding: mem time364, current time 391, horizon 27\n", - "adding: mem time365, current time 391, horizon 26\n", - "adding: mem time366, current time 391, horizon 25\n", - "adding: mem time367, current time 391, horizon 24\n", - "adding: mem time368, current time 391, horizon 23\n", - "adding: mem time369, current time 391, horizon 22\n", - "adding: mem time370, current time 391, horizon 21\n", - "adding: mem time371, current time 391, horizon 20\n", - "adding: mem time372, current time 391, horizon 19\n", - "adding: mem time373, current time 391, horizon 18\n", - "adding: mem time374, current time 391, horizon 17\n", - "adding: mem time375, current time 391, horizon 16\n", - "adding: mem time376, current time 391, horizon 15\n", - "adding: mem time377, current time 391, horizon 14\n", - "adding: mem time378, current time 391, horizon 13\n", - "adding: mem time379, current time 391, horizon 12\n", - "adding: mem time380, current time 391, horizon 11\n", - "adding: mem time381, current time 391, horizon 10\n", - "adding: mem time382, current time 391, horizon 9\n", - "adding: mem time383, current time 391, horizon 8\n", - "adding: mem time384, current time 391, horizon 7\n", - "adding: mem time385, current time 391, horizon 6\n", - "adding: mem time386, current time 391, horizon 5\n", - "adding: mem time387, current time 391, horizon 4\n", - "adding: mem time388, current time 391, horizon 3\n", - "adding: mem time389, current time 391, horizon 2\n", - "adding: mem time390, current time 391, horizon 1\n", - "adding: mem time200, current time 392, horizon 192\n", - "adding: mem time201, current time 392, horizon 191\n", - "adding: mem time202, current time 392, horizon 190\n", - "adding: mem time203, current time 392, horizon 189\n", - "adding: mem time204, current time 392, horizon 188\n", - "adding: mem time205, current time 392, horizon 187\n", - "adding: mem time206, current time 392, horizon 186\n", - "adding: mem time207, current time 392, horizon 185\n", - "adding: mem time208, current time 392, horizon 184\n", - "adding: mem time209, current time 392, horizon 183\n", - "adding: mem time210, current time 392, horizon 182\n", - "adding: mem time211, current time 392, horizon 181\n", - "adding: mem time212, current time 392, horizon 180\n", - "adding: mem time213, current time 392, horizon 179\n", - "adding: mem time214, current time 392, horizon 178\n", - "adding: mem time215, current time 392, horizon 177\n", - "adding: mem time216, current time 392, horizon 176\n", - "adding: mem time217, current time 392, horizon 175\n", - "adding: mem time218, current time 392, horizon 174\n", - "adding: mem time219, current time 392, horizon 173\n", - "adding: mem time220, current time 392, horizon 172\n", - "adding: mem time221, current time 392, horizon 171\n", - "adding: mem time222, current time 392, horizon 170\n", - "adding: mem time223, current time 392, horizon 169\n", - "adding: mem time224, current time 392, horizon 168\n", - "adding: mem time225, current time 392, horizon 167\n", - "adding: mem time226, current time 392, horizon 166\n", - "adding: mem time227, current time 392, horizon 165\n", - "adding: mem time228, current time 392, horizon 164\n", - "adding: mem time229, current time 392, horizon 163\n", - "adding: mem time230, current time 392, horizon 162\n", - "adding: mem time231, current time 392, horizon 161\n", - "adding: mem time232, current time 392, horizon 160\n", - "adding: mem time233, current time 392, horizon 159\n", - "adding: mem time234, current time 392, horizon 158\n", - "adding: mem time235, current time 392, horizon 157\n", - "adding: mem time236, current time 392, horizon 156\n", - "adding: mem time237, current time 392, horizon 155\n", - "adding: mem time238, current time 392, horizon 154\n", - "adding: mem time239, current time 392, horizon 153\n", - "adding: mem time240, current time 392, horizon 152\n", - "adding: mem time241, current time 392, horizon 151\n", - "adding: mem time242, current time 392, horizon 150\n", - "adding: mem time243, current time 392, horizon 149\n", - "adding: mem time244, current time 392, horizon 148\n", - "adding: mem time245, current time 392, horizon 147\n", - "adding: mem time246, current time 392, horizon 146\n", - "adding: mem time247, current time 392, horizon 145\n", - "adding: mem time248, current time 392, horizon 144\n", - "adding: mem time249, current time 392, horizon 143\n", - "adding: mem time250, current time 392, horizon 142\n", - "adding: mem time251, current time 392, horizon 141\n", - "adding: mem time252, current time 392, horizon 140\n", - "adding: mem time253, current time 392, horizon 139\n", - "adding: mem time254, current time 392, horizon 138\n", - "adding: mem time255, current time 392, horizon 137\n", - "adding: mem time256, current time 392, horizon 136\n", - "adding: mem time257, current time 392, horizon 135\n", - "adding: mem time258, current time 392, horizon 134\n", - "adding: mem time259, current time 392, horizon 133\n", - "adding: mem time260, current time 392, horizon 132\n", - "adding: mem time261, current time 392, horizon 131\n", - "adding: mem time262, current time 392, horizon 130\n", - "adding: mem time263, current time 392, horizon 129\n", - "adding: mem time264, current time 392, horizon 128\n", - "adding: mem time265, current time 392, horizon 127\n", - "adding: mem time266, current time 392, horizon 126\n", - "adding: mem time267, current time 392, horizon 125\n", - "adding: mem time268, current time 392, horizon 124\n", - "adding: mem time269, current time 392, horizon 123\n", - "adding: mem time270, current time 392, horizon 122\n", - "adding: mem time271, current time 392, horizon 121\n", - "adding: mem time272, current time 392, horizon 120\n", - "adding: mem time273, current time 392, horizon 119\n", - "adding: mem time274, current time 392, horizon 118\n", - "adding: mem time275, current time 392, horizon 117\n", - "adding: mem time276, current time 392, horizon 116\n", - "adding: mem time277, current time 392, horizon 115\n", - "adding: mem time278, current time 392, horizon 114\n", - "adding: mem time279, current time 392, horizon 113\n", - "adding: mem time280, current time 392, horizon 112\n", - "adding: mem time281, current time 392, horizon 111\n", - "adding: mem time282, current time 392, horizon 110\n", - "adding: mem time283, current time 392, horizon 109\n", - "adding: mem time284, current time 392, horizon 108\n", - "adding: mem time285, current time 392, horizon 107\n", - "adding: mem time286, current time 392, horizon 106\n", - "adding: mem time287, current time 392, horizon 105\n", - "adding: mem time288, current time 392, horizon 104\n", - "adding: mem time289, current time 392, horizon 103\n", - "adding: mem time290, current time 392, horizon 102\n", - "adding: mem time291, current time 392, horizon 101\n", - "adding: mem time292, current time 392, horizon 100\n", - "adding: mem time293, current time 392, horizon 99\n", - "adding: mem time294, current time 392, horizon 98\n", - "adding: mem time295, current time 392, horizon 97\n", - "adding: mem time296, current time 392, horizon 96\n", - "adding: mem time297, current time 392, horizon 95\n", - "adding: mem time298, current time 392, horizon 94\n", - "adding: mem time299, current time 392, horizon 93\n", - "adding: mem time300, current time 392, horizon 92\n", - "adding: mem time301, current time 392, horizon 91\n", - "adding: mem time302, current time 392, horizon 90\n", - "adding: mem time303, current time 392, horizon 89\n", - "adding: mem time304, current time 392, horizon 88\n", - "adding: mem time305, current time 392, horizon 87\n", - "adding: mem time306, current time 392, horizon 86\n", - "adding: mem time307, current time 392, horizon 85\n", - "adding: mem time308, current time 392, horizon 84\n", - "adding: mem time309, current time 392, horizon 83\n", - "adding: mem time310, current time 392, horizon 82\n", - "adding: mem time311, current time 392, horizon 81\n", - "adding: mem time312, current time 392, horizon 80\n", - "adding: mem time313, current time 392, horizon 79\n", - "adding: mem time314, current time 392, horizon 78\n", - "adding: mem time315, current time 392, horizon 77\n", - "adding: mem time316, current time 392, horizon 76\n", - "adding: mem time317, current time 392, horizon 75\n", - "adding: mem time318, current time 392, horizon 74\n", - "adding: mem time319, current time 392, horizon 73\n", - "adding: mem time320, current time 392, horizon 72\n", - "adding: mem time321, current time 392, horizon 71\n", - "adding: mem time322, current time 392, horizon 70\n", - "adding: mem time323, current time 392, horizon 69\n", - "adding: mem time324, current time 392, horizon 68\n", - "adding: mem time325, current time 392, horizon 67\n", - "adding: mem time326, current time 392, horizon 66\n", - "adding: mem time327, current time 392, horizon 65\n", - "adding: mem time328, current time 392, horizon 64\n", - "adding: mem time329, current time 392, horizon 63\n", - "adding: mem time330, current time 392, horizon 62\n", - "adding: mem time331, current time 392, horizon 61\n", - "adding: mem time332, current time 392, horizon 60\n", - "adding: mem time333, current time 392, horizon 59\n", - "adding: mem time334, current time 392, horizon 58\n", - "adding: mem time335, current time 392, horizon 57\n", - "adding: mem time336, current time 392, horizon 56\n", - "adding: mem time337, current time 392, horizon 55\n", - "adding: mem time338, current time 392, horizon 54\n", - "adding: mem time339, current time 392, horizon 53\n", - "adding: mem time340, current time 392, horizon 52\n", - "adding: mem time341, current time 392, horizon 51\n", - "adding: mem time342, current time 392, horizon 50\n", - "adding: mem time343, current time 392, horizon 49\n", - "adding: mem time344, current time 392, horizon 48\n", - "adding: mem time345, current time 392, horizon 47\n", - "adding: mem time346, current time 392, horizon 46\n", - "adding: mem time347, current time 392, horizon 45\n", - "adding: mem time348, current time 392, horizon 44\n", - "adding: mem time349, current time 392, horizon 43\n", - "adding: mem time350, current time 392, horizon 42\n", - "adding: mem time351, current time 392, horizon 41\n", - "adding: mem time352, current time 392, horizon 40\n", - "adding: mem time353, current time 392, horizon 39\n", - "adding: mem time354, current time 392, horizon 38\n", - "adding: mem time355, current time 392, horizon 37\n", - "adding: mem time356, current time 392, horizon 36\n", - "adding: mem time357, current time 392, horizon 35\n", - "adding: mem time358, current time 392, horizon 34\n", - "adding: mem time359, current time 392, horizon 33\n", - "adding: mem time360, current time 392, horizon 32\n", - "adding: mem time361, current time 392, horizon 31\n", - "adding: mem time362, current time 392, horizon 30\n", - "adding: mem time363, current time 392, horizon 29\n", - "adding: mem time364, current time 392, horizon 28\n", - "adding: mem time365, current time 392, horizon 27\n", - "adding: mem time366, current time 392, horizon 26\n", - "adding: mem time367, current time 392, horizon 25\n", - "adding: mem time368, current time 392, horizon 24\n", - "adding: mem time369, current time 392, horizon 23\n", - "adding: mem time370, current time 392, horizon 22\n", - "adding: mem time371, current time 392, horizon 21\n", - "adding: mem time372, current time 392, horizon 20\n", - "adding: mem time373, current time 392, horizon 19\n", - "adding: mem time374, current time 392, horizon 18\n", - "adding: mem time375, current time 392, horizon 17\n", - "adding: mem time376, current time 392, horizon 16\n", - "adding: mem time377, current time 392, horizon 15\n", - "adding: mem time378, current time 392, horizon 14\n", - "adding: mem time379, current time 392, horizon 13\n", - "adding: mem time380, current time 392, horizon 12\n", - "adding: mem time381, current time 392, horizon 11\n", - "adding: mem time382, current time 392, horizon 10\n", - "adding: mem time383, current time 392, horizon 9\n", - "adding: mem time384, current time 392, horizon 8\n", - "adding: mem time385, current time 392, horizon 7\n", - "adding: mem time386, current time 392, horizon 6\n", - "adding: mem time387, current time 392, horizon 5\n", - "adding: mem time388, current time 392, horizon 4\n", - "adding: mem time389, current time 392, horizon 3\n", - "adding: mem time390, current time 392, horizon 2\n", - "adding: mem time391, current time 392, horizon 1\n", - "adding: mem time200, current time 393, horizon 193\n", - "adding: mem time201, current time 393, horizon 192\n", - "adding: mem time202, current time 393, horizon 191\n", - "adding: mem time203, current time 393, horizon 190\n", - "adding: mem time204, current time 393, horizon 189\n", - "adding: mem time205, current time 393, horizon 188\n", - "adding: mem time206, current time 393, horizon 187\n", - "adding: mem time207, current time 393, horizon 186\n", - "adding: mem time208, current time 393, horizon 185\n", - "adding: mem time209, current time 393, horizon 184\n", - "adding: mem time210, current time 393, horizon 183\n", - "adding: mem time211, current time 393, horizon 182\n", - "adding: mem time212, current time 393, horizon 181\n", - "adding: mem time213, current time 393, horizon 180\n", - "adding: mem time214, current time 393, horizon 179\n", - "adding: mem time215, current time 393, horizon 178\n", - "adding: mem time216, current time 393, horizon 177\n", - "adding: mem time217, current time 393, horizon 176\n", - "adding: mem time218, current time 393, horizon 175\n", - "adding: mem time219, current time 393, horizon 174\n", - "adding: mem time220, current time 393, horizon 173\n", - "adding: mem time221, current time 393, horizon 172\n", - "adding: mem time222, current time 393, horizon 171\n", - "adding: mem time223, current time 393, horizon 170\n", - "adding: mem time224, current time 393, horizon 169\n", - "adding: mem time225, current time 393, horizon 168\n", - "adding: mem time226, current time 393, horizon 167\n", - "adding: mem time227, current time 393, horizon 166\n", - "adding: mem time228, current time 393, horizon 165\n", - "adding: mem time229, current time 393, horizon 164\n", - "adding: mem time230, current time 393, horizon 163\n", - "adding: mem time231, current time 393, horizon 162\n", - "adding: mem time232, current time 393, horizon 161\n", - "adding: mem time233, current time 393, horizon 160\n", - "adding: mem time234, current time 393, horizon 159\n", - "adding: mem time235, current time 393, horizon 158\n", - "adding: mem time236, current time 393, horizon 157\n", - "adding: mem time237, current time 393, horizon 156\n", - "adding: mem time238, current time 393, horizon 155\n", - "adding: mem time239, current time 393, horizon 154\n", - "adding: mem time240, current time 393, horizon 153\n", - "adding: mem time241, current time 393, horizon 152\n", - "adding: mem time242, current time 393, horizon 151\n", - "adding: mem time243, current time 393, horizon 150\n", - "adding: mem time244, current time 393, horizon 149\n", - "adding: mem time245, current time 393, horizon 148\n", - "adding: mem time246, current time 393, horizon 147\n", - "adding: mem time247, current time 393, horizon 146\n", - "adding: mem time248, current time 393, horizon 145\n", - "adding: mem time249, current time 393, horizon 144\n", - "adding: mem time250, current time 393, horizon 143\n", - "adding: mem time251, current time 393, horizon 142\n", - "adding: mem time252, current time 393, horizon 141\n", - "adding: mem time253, current time 393, horizon 140\n", - "adding: mem time254, current time 393, horizon 139\n", - "adding: mem time255, current time 393, horizon 138\n", - "adding: mem time256, current time 393, horizon 137\n", - "adding: mem time257, current time 393, horizon 136\n", - "adding: mem time258, current time 393, horizon 135\n", - "adding: mem time259, current time 393, horizon 134\n", - "adding: mem time260, current time 393, horizon 133\n", - "adding: mem time261, current time 393, horizon 132\n", - "adding: mem time262, current time 393, horizon 131\n", - "adding: mem time263, current time 393, horizon 130\n", - "adding: mem time264, current time 393, horizon 129\n", - "adding: mem time265, current time 393, horizon 128\n", - "adding: mem time266, current time 393, horizon 127\n", - "adding: mem time267, current time 393, horizon 126\n", - "adding: mem time268, current time 393, horizon 125\n", - "adding: mem time269, current time 393, horizon 124\n", - "adding: mem time270, current time 393, horizon 123\n", - "adding: mem time271, current time 393, horizon 122\n", - "adding: mem time272, current time 393, horizon 121\n", - "adding: mem time273, current time 393, horizon 120\n", - "adding: mem time274, current time 393, horizon 119\n", - "adding: mem time275, current time 393, horizon 118\n", - "adding: mem time276, current time 393, horizon 117\n", - "adding: mem time277, current time 393, horizon 116\n", - "adding: mem time278, current time 393, horizon 115\n", - "adding: mem time279, current time 393, horizon 114\n", - "adding: mem time280, current time 393, horizon 113\n", - "adding: mem time281, current time 393, horizon 112\n", - "adding: mem time282, current time 393, horizon 111\n", - "adding: mem time283, current time 393, horizon 110\n", - "adding: mem time284, current time 393, horizon 109\n", - "adding: mem time285, current time 393, horizon 108\n", - "adding: mem time286, current time 393, horizon 107\n", - "adding: mem time287, current time 393, horizon 106\n", - "adding: mem time288, current time 393, horizon 105\n", - "adding: mem time289, current time 393, horizon 104\n", - "adding: mem time290, current time 393, horizon 103\n", - "adding: mem time291, current time 393, horizon 102\n", - "adding: mem time292, current time 393, horizon 101\n", - "adding: mem time293, current time 393, horizon 100\n", - "adding: mem time294, current time 393, horizon 99\n", - "adding: mem time295, current time 393, horizon 98\n", - "adding: mem time296, current time 393, horizon 97\n", - "adding: mem time297, current time 393, horizon 96\n", - "adding: mem time298, current time 393, horizon 95\n", - "adding: mem time299, current time 393, horizon 94\n", - "adding: mem time300, current time 393, horizon 93\n", - "adding: mem time301, current time 393, horizon 92\n", - "adding: mem time302, current time 393, horizon 91\n", - "adding: mem time303, current time 393, horizon 90\n", - "adding: mem time304, current time 393, horizon 89\n", - "adding: mem time305, current time 393, horizon 88\n", - "adding: mem time306, current time 393, horizon 87\n", - "adding: mem time307, current time 393, horizon 86\n", - "adding: mem time308, current time 393, horizon 85\n", - "adding: mem time309, current time 393, horizon 84\n", - "adding: mem time310, current time 393, horizon 83\n", - "adding: mem time311, current time 393, horizon 82\n", - "adding: mem time312, current time 393, horizon 81\n", - "adding: mem time313, current time 393, horizon 80\n", - "adding: mem time314, current time 393, horizon 79\n", - "adding: mem time315, current time 393, horizon 78\n", - "adding: mem time316, current time 393, horizon 77\n", - "adding: mem time317, current time 393, horizon 76\n", - "adding: mem time318, current time 393, horizon 75\n", - "adding: mem time319, current time 393, horizon 74\n", - "adding: mem time320, current time 393, horizon 73\n", - "adding: mem time321, current time 393, horizon 72\n", - "adding: mem time322, current time 393, horizon 71\n", - "adding: mem time323, current time 393, horizon 70\n", - "adding: mem time324, current time 393, horizon 69\n", - "adding: mem time325, current time 393, horizon 68\n", - "adding: mem time326, current time 393, horizon 67\n", - "adding: mem time327, current time 393, horizon 66\n", - "adding: mem time328, current time 393, horizon 65\n", - "adding: mem time329, current time 393, horizon 64\n", - "adding: mem time330, current time 393, horizon 63\n", - "adding: mem time331, current time 393, horizon 62\n", - "adding: mem time332, current time 393, horizon 61\n", - "adding: mem time333, current time 393, horizon 60\n", - "adding: mem time334, current time 393, horizon 59\n", - "adding: mem time335, current time 393, horizon 58\n", - "adding: mem time336, current time 393, horizon 57\n", - "adding: mem time337, current time 393, horizon 56\n", - "adding: mem time338, current time 393, horizon 55\n", - "adding: mem time339, current time 393, horizon 54\n", - "adding: mem time340, current time 393, horizon 53\n", - "adding: mem time341, current time 393, horizon 52\n", - "adding: mem time342, current time 393, horizon 51\n", - "adding: mem time343, current time 393, horizon 50\n", - "adding: mem time344, current time 393, horizon 49\n", - "adding: mem time345, current time 393, horizon 48\n", - "adding: mem time346, current time 393, horizon 47\n", - "adding: mem time347, current time 393, horizon 46\n", - "adding: mem time348, current time 393, horizon 45\n", - "adding: mem time349, current time 393, horizon 44\n", - "adding: mem time350, current time 393, horizon 43\n", - "adding: mem time351, current time 393, horizon 42\n", - "adding: mem time352, current time 393, horizon 41\n", - "adding: mem time353, current time 393, horizon 40\n", - "adding: mem time354, current time 393, horizon 39\n", - "adding: mem time355, current time 393, horizon 38\n", - "adding: mem time356, current time 393, horizon 37\n", - "adding: mem time357, current time 393, horizon 36\n", - "adding: mem time358, current time 393, horizon 35\n", - "adding: mem time359, current time 393, horizon 34\n", - "adding: mem time360, current time 393, horizon 33\n", - "adding: mem time361, current time 393, horizon 32\n", - "adding: mem time362, current time 393, horizon 31\n", - "adding: mem time363, current time 393, horizon 30\n", - "adding: mem time364, current time 393, horizon 29\n", - "adding: mem time365, current time 393, horizon 28\n", - "adding: mem time366, current time 393, horizon 27\n", - "adding: mem time367, current time 393, horizon 26\n", - "adding: mem time368, current time 393, horizon 25\n", - "adding: mem time369, current time 393, horizon 24\n", - "adding: mem time370, current time 393, horizon 23\n", - "adding: mem time371, current time 393, horizon 22\n", - "adding: mem time372, current time 393, horizon 21\n", - "adding: mem time373, current time 393, horizon 20\n", - "adding: mem time374, current time 393, horizon 19\n", - "adding: mem time375, current time 393, horizon 18\n", - "adding: mem time376, current time 393, horizon 17\n", - "adding: mem time377, current time 393, horizon 16\n", - "adding: mem time378, current time 393, horizon 15\n", - "adding: mem time379, current time 393, horizon 14\n", - "adding: mem time380, current time 393, horizon 13\n", - "adding: mem time381, current time 393, horizon 12\n", - "adding: mem time382, current time 393, horizon 11\n", - "adding: mem time383, current time 393, horizon 10\n", - "adding: mem time384, current time 393, horizon 9\n", - "adding: mem time385, current time 393, horizon 8\n", - "adding: mem time386, current time 393, horizon 7\n", - "adding: mem time387, current time 393, horizon 6\n", - "adding: mem time388, current time 393, horizon 5\n", - "adding: mem time389, current time 393, horizon 4\n", - "adding: mem time390, current time 393, horizon 3\n", - "adding: mem time391, current time 393, horizon 2\n", - "adding: mem time392, current time 393, horizon 1\n", - "adding: mem time200, current time 394, horizon 194\n", - "adding: mem time201, current time 394, horizon 193\n", - "adding: mem time202, current time 394, horizon 192\n", - "adding: mem time203, current time 394, horizon 191\n", - "adding: mem time204, current time 394, horizon 190\n", - "adding: mem time205, current time 394, horizon 189\n", - "adding: mem time206, current time 394, horizon 188\n", - "adding: mem time207, current time 394, horizon 187\n", - "adding: mem time208, current time 394, horizon 186\n", - "adding: mem time209, current time 394, horizon 185\n", - "adding: mem time210, current time 394, horizon 184\n", - "adding: mem time211, current time 394, horizon 183\n", - "adding: mem time212, current time 394, horizon 182\n", - "adding: mem time213, current time 394, horizon 181\n", - "adding: mem time214, current time 394, horizon 180\n", - "adding: mem time215, current time 394, horizon 179\n", - "adding: mem time216, current time 394, horizon 178\n", - "adding: mem time217, current time 394, horizon 177\n", - "adding: mem time218, current time 394, horizon 176\n", - "adding: mem time219, current time 394, horizon 175\n", - "adding: mem time220, current time 394, horizon 174\n", - "adding: mem time221, current time 394, horizon 173\n", - "adding: mem time222, current time 394, horizon 172\n", - "adding: mem time223, current time 394, horizon 171\n", - "adding: mem time224, current time 394, horizon 170\n", - "adding: mem time225, current time 394, horizon 169\n", - "adding: mem time226, current time 394, horizon 168\n", - "adding: mem time227, current time 394, horizon 167\n", - "adding: mem time228, current time 394, horizon 166\n", - "adding: mem time229, current time 394, horizon 165\n", - "adding: mem time230, current time 394, horizon 164\n", - "adding: mem time231, current time 394, horizon 163\n", - "adding: mem time232, current time 394, horizon 162\n", - "adding: mem time233, current time 394, horizon 161\n", - "adding: mem time234, current time 394, horizon 160\n", - "adding: mem time235, current time 394, horizon 159\n", - "adding: mem time236, current time 394, horizon 158\n", - "adding: mem time237, current time 394, horizon 157\n", - "adding: mem time238, current time 394, horizon 156\n", - "adding: mem time239, current time 394, horizon 155\n", - "adding: mem time240, current time 394, horizon 154\n", - "adding: mem time241, current time 394, horizon 153\n", - "adding: mem time242, current time 394, horizon 152\n", - "adding: mem time243, current time 394, horizon 151\n", - "adding: mem time244, current time 394, horizon 150\n", - "adding: mem time245, current time 394, horizon 149\n", - "adding: mem time246, current time 394, horizon 148\n", - "adding: mem time247, current time 394, horizon 147\n", - "adding: mem time248, current time 394, horizon 146\n", - "adding: mem time249, current time 394, horizon 145\n", - "adding: mem time250, current time 394, horizon 144\n", - "adding: mem time251, current time 394, horizon 143\n", - "adding: mem time252, current time 394, horizon 142\n", - "adding: mem time253, current time 394, horizon 141\n", - "adding: mem time254, current time 394, horizon 140\n", - "adding: mem time255, current time 394, horizon 139\n", - "adding: mem time256, current time 394, horizon 138\n", - "adding: mem time257, current time 394, horizon 137\n", - "adding: mem time258, current time 394, horizon 136\n", - "adding: mem time259, current time 394, horizon 135\n", - "adding: mem time260, current time 394, horizon 134\n", - "adding: mem time261, current time 394, horizon 133\n", - "adding: mem time262, current time 394, horizon 132\n", - "adding: mem time263, current time 394, horizon 131\n", - "adding: mem time264, current time 394, horizon 130\n", - "adding: mem time265, current time 394, horizon 129\n", - "adding: mem time266, current time 394, horizon 128\n", - "adding: mem time267, current time 394, horizon 127\n", - "adding: mem time268, current time 394, horizon 126\n", - "adding: mem time269, current time 394, horizon 125\n", - "adding: mem time270, current time 394, horizon 124\n", - "adding: mem time271, current time 394, horizon 123\n", - "adding: mem time272, current time 394, horizon 122\n", - "adding: mem time273, current time 394, horizon 121\n", - "adding: mem time274, current time 394, horizon 120\n", - "adding: mem time275, current time 394, horizon 119\n", - "adding: mem time276, current time 394, horizon 118\n", - "adding: mem time277, current time 394, horizon 117\n", - "adding: mem time278, current time 394, horizon 116\n", - "adding: mem time279, current time 394, horizon 115\n", - "adding: mem time280, current time 394, horizon 114\n", - "adding: mem time281, current time 394, horizon 113\n", - "adding: mem time282, current time 394, horizon 112\n", - "adding: mem time283, current time 394, horizon 111\n", - "adding: mem time284, current time 394, horizon 110\n", - "adding: mem time285, current time 394, horizon 109\n", - "adding: mem time286, current time 394, horizon 108\n", - "adding: mem time287, current time 394, horizon 107\n", - "adding: mem time288, current time 394, horizon 106\n", - "adding: mem time289, current time 394, horizon 105\n", - "adding: mem time290, current time 394, horizon 104\n", - "adding: mem time291, current time 394, horizon 103\n", - "adding: mem time292, current time 394, horizon 102\n", - "adding: mem time293, current time 394, horizon 101\n", - "adding: mem time294, current time 394, horizon 100\n", - "adding: mem time295, current time 394, horizon 99\n", - "adding: mem time296, current time 394, horizon 98\n", - "adding: mem time297, current time 394, horizon 97\n", - "adding: mem time298, current time 394, horizon 96\n", - "adding: mem time299, current time 394, horizon 95\n", - "adding: mem time300, current time 394, horizon 94\n", - "adding: mem time301, current time 394, horizon 93\n", - "adding: mem time302, current time 394, horizon 92\n", - "adding: mem time303, current time 394, horizon 91\n", - "adding: mem time304, current time 394, horizon 90\n", - "adding: mem time305, current time 394, horizon 89\n", - "adding: mem time306, current time 394, horizon 88\n", - "adding: mem time307, current time 394, horizon 87\n", - "adding: mem time308, current time 394, horizon 86\n", - "adding: mem time309, current time 394, horizon 85\n", - "adding: mem time310, current time 394, horizon 84\n", - "adding: mem time311, current time 394, horizon 83\n", - "adding: mem time312, current time 394, horizon 82\n", - "adding: mem time313, current time 394, horizon 81\n", - "adding: mem time314, current time 394, horizon 80\n", - "adding: mem time315, current time 394, horizon 79\n", - "adding: mem time316, current time 394, horizon 78\n", - "adding: mem time317, current time 394, horizon 77\n", - "adding: mem time318, current time 394, horizon 76\n", - "adding: mem time319, current time 394, horizon 75\n", - "adding: mem time320, current time 394, horizon 74\n", - "adding: mem time321, current time 394, horizon 73\n", - "adding: mem time322, current time 394, horizon 72\n", - "adding: mem time323, current time 394, horizon 71\n", - "adding: mem time324, current time 394, horizon 70\n", - "adding: mem time325, current time 394, horizon 69\n", - "adding: mem time326, current time 394, horizon 68\n", - "adding: mem time327, current time 394, horizon 67\n", - "adding: mem time328, current time 394, horizon 66\n", - "adding: mem time329, current time 394, horizon 65\n", - "adding: mem time330, current time 394, horizon 64\n", - "adding: mem time331, current time 394, horizon 63\n", - "adding: mem time332, current time 394, horizon 62\n", - "adding: mem time333, current time 394, horizon 61\n", - "adding: mem time334, current time 394, horizon 60\n", - "adding: mem time335, current time 394, horizon 59\n", - "adding: mem time336, current time 394, horizon 58\n", - "adding: mem time337, current time 394, horizon 57\n", - "adding: mem time338, current time 394, horizon 56\n", - "adding: mem time339, current time 394, horizon 55\n", - "adding: mem time340, current time 394, horizon 54\n", - "adding: mem time341, current time 394, horizon 53\n", - "adding: mem time342, current time 394, horizon 52\n", - "adding: mem time343, current time 394, horizon 51\n", - "adding: mem time344, current time 394, horizon 50\n", - "adding: mem time345, current time 394, horizon 49\n", - "adding: mem time346, current time 394, horizon 48\n", - "adding: mem time347, current time 394, horizon 47\n", - "adding: mem time348, current time 394, horizon 46\n", - "adding: mem time349, current time 394, horizon 45\n", - "adding: mem time350, current time 394, horizon 44\n", - "adding: mem time351, current time 394, horizon 43\n", - "adding: mem time352, current time 394, horizon 42\n", - "adding: mem time353, current time 394, horizon 41\n", - "adding: mem time354, current time 394, horizon 40\n", - "adding: mem time355, current time 394, horizon 39\n", - "adding: mem time356, current time 394, horizon 38\n", - "adding: mem time357, current time 394, horizon 37\n", - "adding: mem time358, current time 394, horizon 36\n", - "adding: mem time359, current time 394, horizon 35\n", - "adding: mem time360, current time 394, horizon 34\n", - "adding: mem time361, current time 394, horizon 33\n", - "adding: mem time362, current time 394, horizon 32\n", - "adding: mem time363, current time 394, horizon 31\n", - "adding: mem time364, current time 394, horizon 30\n", - "adding: mem time365, current time 394, horizon 29\n", - "adding: mem time366, current time 394, horizon 28\n", - "adding: mem time367, current time 394, horizon 27\n", - "adding: mem time368, current time 394, horizon 26\n", - "adding: mem time369, current time 394, horizon 25\n", - "adding: mem time370, current time 394, horizon 24\n", - "adding: mem time371, current time 394, horizon 23\n", - "adding: mem time372, current time 394, horizon 22\n", - "adding: mem time373, current time 394, horizon 21\n", - "adding: mem time374, current time 394, horizon 20\n", - "adding: mem time375, current time 394, horizon 19\n", - "adding: mem time376, current time 394, horizon 18\n", - "adding: mem time377, current time 394, horizon 17\n", - "adding: mem time378, current time 394, horizon 16\n", - "adding: mem time379, current time 394, horizon 15\n", - "adding: mem time380, current time 394, horizon 14\n", - "adding: mem time381, current time 394, horizon 13\n", - "adding: mem time382, current time 394, horizon 12\n", - "adding: mem time383, current time 394, horizon 11\n", - "adding: mem time384, current time 394, horizon 10\n", - "adding: mem time385, current time 394, horizon 9\n", - "adding: mem time386, current time 394, horizon 8\n", - "adding: mem time387, current time 394, horizon 7\n", - "adding: mem time388, current time 394, horizon 6\n", - "adding: mem time389, current time 394, horizon 5\n", - "adding: mem time390, current time 394, horizon 4\n", - "adding: mem time391, current time 394, horizon 3\n", - "adding: mem time392, current time 394, horizon 2\n", - "adding: mem time393, current time 394, horizon 1\n", - "adding: mem time200, current time 395, horizon 195\n", - "adding: mem time201, current time 395, horizon 194\n", - "adding: mem time202, current time 395, horizon 193\n", - "adding: mem time203, current time 395, horizon 192\n", - "adding: mem time204, current time 395, horizon 191\n", - "adding: mem time205, current time 395, horizon 190\n", - "adding: mem time206, current time 395, horizon 189\n", - "adding: mem time207, current time 395, horizon 188\n", - "adding: mem time208, current time 395, horizon 187\n", - "adding: mem time209, current time 395, horizon 186\n", - "adding: mem time210, current time 395, horizon 185\n", - "adding: mem time211, current time 395, horizon 184\n", - "adding: mem time212, current time 395, horizon 183\n", - "adding: mem time213, current time 395, horizon 182\n", - "adding: mem time214, current time 395, horizon 181\n", - "adding: mem time215, current time 395, horizon 180\n", - "adding: mem time216, current time 395, horizon 179\n", - "adding: mem time217, current time 395, horizon 178\n", - "adding: mem time218, current time 395, horizon 177\n", - "adding: mem time219, current time 395, horizon 176\n", - "adding: mem time220, current time 395, horizon 175\n", - "adding: mem time221, current time 395, horizon 174\n", - "adding: mem time222, current time 395, horizon 173\n", - "adding: mem time223, current time 395, horizon 172\n", - "adding: mem time224, current time 395, horizon 171\n", - "adding: mem time225, current time 395, horizon 170\n", - "adding: mem time226, current time 395, horizon 169\n", - "adding: mem time227, current time 395, horizon 168\n", - "adding: mem time228, current time 395, horizon 167\n", - "adding: mem time229, current time 395, horizon 166\n", - "adding: mem time230, current time 395, horizon 165\n", - "adding: mem time231, current time 395, horizon 164\n", - "adding: mem time232, current time 395, horizon 163\n", - "adding: mem time233, current time 395, horizon 162\n", - "adding: mem time234, current time 395, horizon 161\n", - "adding: mem time235, current time 395, horizon 160\n", - "adding: mem time236, current time 395, horizon 159\n", - "adding: mem time237, current time 395, horizon 158\n", - "adding: mem time238, current time 395, horizon 157\n", - "adding: mem time239, current time 395, horizon 156\n", - "adding: mem time240, current time 395, horizon 155\n", - "adding: mem time241, current time 395, horizon 154\n", - "adding: mem time242, current time 395, horizon 153\n", - "adding: mem time243, current time 395, horizon 152\n", - "adding: mem time244, current time 395, horizon 151\n", - "adding: mem time245, current time 395, horizon 150\n", - "adding: mem time246, current time 395, horizon 149\n", - "adding: mem time247, current time 395, horizon 148\n", - "adding: mem time248, current time 395, horizon 147\n", - "adding: mem time249, current time 395, horizon 146\n", - "adding: mem time250, current time 395, horizon 145\n", - "adding: mem time251, current time 395, horizon 144\n", - "adding: mem time252, current time 395, horizon 143\n", - "adding: mem time253, current time 395, horizon 142\n", - "adding: mem time254, current time 395, horizon 141\n", - "adding: mem time255, current time 395, horizon 140\n", - "adding: mem time256, current time 395, horizon 139\n", - "adding: mem time257, current time 395, horizon 138\n", - "adding: mem time258, current time 395, horizon 137\n", - "adding: mem time259, current time 395, horizon 136\n", - "adding: mem time260, current time 395, horizon 135\n", - "adding: mem time261, current time 395, horizon 134\n", - "adding: mem time262, current time 395, horizon 133\n", - "adding: mem time263, current time 395, horizon 132\n", - "adding: mem time264, current time 395, horizon 131\n", - "adding: mem time265, current time 395, horizon 130\n", - "adding: mem time266, current time 395, horizon 129\n", - "adding: mem time267, current time 395, horizon 128\n", - "adding: mem time268, current time 395, horizon 127\n", - "adding: mem time269, current time 395, horizon 126\n", - "adding: mem time270, current time 395, horizon 125\n", - "adding: mem time271, current time 395, horizon 124\n", - "adding: mem time272, current time 395, horizon 123\n", - "adding: mem time273, current time 395, horizon 122\n", - "adding: mem time274, current time 395, horizon 121\n", - "adding: mem time275, current time 395, horizon 120\n", - "adding: mem time276, current time 395, horizon 119\n", - "adding: mem time277, current time 395, horizon 118\n", - "adding: mem time278, current time 395, horizon 117\n", - "adding: mem time279, current time 395, horizon 116\n", - "adding: mem time280, current time 395, horizon 115\n", - "adding: mem time281, current time 395, horizon 114\n", - "adding: mem time282, current time 395, horizon 113\n", - "adding: mem time283, current time 395, horizon 112\n", - "adding: mem time284, current time 395, horizon 111\n", - "adding: mem time285, current time 395, horizon 110\n", - "adding: mem time286, current time 395, horizon 109\n", - "adding: mem time287, current time 395, horizon 108\n", - "adding: mem time288, current time 395, horizon 107\n", - "adding: mem time289, current time 395, horizon 106\n", - "adding: mem time290, current time 395, horizon 105\n", - "adding: mem time291, current time 395, horizon 104\n", - "adding: mem time292, current time 395, horizon 103\n", - "adding: mem time293, current time 395, horizon 102\n", - "adding: mem time294, current time 395, horizon 101\n", - "adding: mem time295, current time 395, horizon 100\n", - "adding: mem time296, current time 395, horizon 99\n", - "adding: mem time297, current time 395, horizon 98\n", - "adding: mem time298, current time 395, horizon 97\n", - "adding: mem time299, current time 395, horizon 96\n", - "adding: mem time300, current time 395, horizon 95\n", - "adding: mem time301, current time 395, horizon 94\n", - "adding: mem time302, current time 395, horizon 93\n", - "adding: mem time303, current time 395, horizon 92\n", - "adding: mem time304, current time 395, horizon 91\n", - "adding: mem time305, current time 395, horizon 90\n", - "adding: mem time306, current time 395, horizon 89\n", - "adding: mem time307, current time 395, horizon 88\n", - "adding: mem time308, current time 395, horizon 87\n", - "adding: mem time309, current time 395, horizon 86\n", - "adding: mem time310, current time 395, horizon 85\n", - "adding: mem time311, current time 395, horizon 84\n", - "adding: mem time312, current time 395, horizon 83\n", - "adding: mem time313, current time 395, horizon 82\n", - "adding: mem time314, current time 395, horizon 81\n", - "adding: mem time315, current time 395, horizon 80\n", - "adding: mem time316, current time 395, horizon 79\n", - "adding: mem time317, current time 395, horizon 78\n", - "adding: mem time318, current time 395, horizon 77\n", - "adding: mem time319, current time 395, horizon 76\n", - "adding: mem time320, current time 395, horizon 75\n", - "adding: mem time321, current time 395, horizon 74\n", - "adding: mem time322, current time 395, horizon 73\n", - "adding: mem time323, current time 395, horizon 72\n", - "adding: mem time324, current time 395, horizon 71\n", - "adding: mem time325, current time 395, horizon 70\n", - "adding: mem time326, current time 395, horizon 69\n", - "adding: mem time327, current time 395, horizon 68\n", - "adding: mem time328, current time 395, horizon 67\n", - "adding: mem time329, current time 395, horizon 66\n", - "adding: mem time330, current time 395, horizon 65\n", - "adding: mem time331, current time 395, horizon 64\n", - "adding: mem time332, current time 395, horizon 63\n", - "adding: mem time333, current time 395, horizon 62\n", - "adding: mem time334, current time 395, horizon 61\n", - "adding: mem time335, current time 395, horizon 60\n", - "adding: mem time336, current time 395, horizon 59\n", - "adding: mem time337, current time 395, horizon 58\n", - "adding: mem time338, current time 395, horizon 57\n", - "adding: mem time339, current time 395, horizon 56\n", - "adding: mem time340, current time 395, horizon 55\n", - "adding: mem time341, current time 395, horizon 54\n", - "adding: mem time342, current time 395, horizon 53\n", - "adding: mem time343, current time 395, horizon 52\n", - "adding: mem time344, current time 395, horizon 51\n", - "adding: mem time345, current time 395, horizon 50\n", - "adding: mem time346, current time 395, horizon 49\n", - "adding: mem time347, current time 395, horizon 48\n", - "adding: mem time348, current time 395, horizon 47\n", - "adding: mem time349, current time 395, horizon 46\n", - "adding: mem time350, current time 395, horizon 45\n", - "adding: mem time351, current time 395, horizon 44\n", - "adding: mem time352, current time 395, horizon 43\n", - "adding: mem time353, current time 395, horizon 42\n", - "adding: mem time354, current time 395, horizon 41\n", - "adding: mem time355, current time 395, horizon 40\n", - "adding: mem time356, current time 395, horizon 39\n", - "adding: mem time357, current time 395, horizon 38\n", - "adding: mem time358, current time 395, horizon 37\n", - "adding: mem time359, current time 395, horizon 36\n", - "adding: mem time360, current time 395, horizon 35\n", - "adding: mem time361, current time 395, horizon 34\n", - "adding: mem time362, current time 395, horizon 33\n", - "adding: mem time363, current time 395, horizon 32\n", - "adding: mem time364, current time 395, horizon 31\n", - "adding: mem time365, current time 395, horizon 30\n", - "adding: mem time366, current time 395, horizon 29\n", - "adding: mem time367, current time 395, horizon 28\n", - "adding: mem time368, current time 395, horizon 27\n", - "adding: mem time369, current time 395, horizon 26\n", - "adding: mem time370, current time 395, horizon 25\n", - "adding: mem time371, current time 395, horizon 24\n", - "adding: mem time372, current time 395, horizon 23\n", - "adding: mem time373, current time 395, horizon 22\n", - "adding: mem time374, current time 395, horizon 21\n", - "adding: mem time375, current time 395, horizon 20\n", - "adding: mem time376, current time 395, horizon 19\n", - "adding: mem time377, current time 395, horizon 18\n", - "adding: mem time378, current time 395, horizon 17\n", - "adding: mem time379, current time 395, horizon 16\n", - "adding: mem time380, current time 395, horizon 15\n", - "adding: mem time381, current time 395, horizon 14\n", - "adding: mem time382, current time 395, horizon 13\n", - "adding: mem time383, current time 395, horizon 12\n", - "adding: mem time384, current time 395, horizon 11\n", - "adding: mem time385, current time 395, horizon 10\n", - "adding: mem time386, current time 395, horizon 9\n", - "adding: mem time387, current time 395, horizon 8\n", - "adding: mem time388, current time 395, horizon 7\n", - "adding: mem time389, current time 395, horizon 6\n", - "adding: mem time390, current time 395, horizon 5\n", - "adding: mem time391, current time 395, horizon 4\n", - "adding: mem time392, current time 395, horizon 3\n", - "adding: mem time393, current time 395, horizon 2\n", - "adding: mem time394, current time 395, horizon 1\n", - "adding: mem time200, current time 396, horizon 196\n", - "adding: mem time201, current time 396, horizon 195\n", - "adding: mem time202, current time 396, horizon 194\n", - "adding: mem time203, current time 396, horizon 193\n", - "adding: mem time204, current time 396, horizon 192\n", - "adding: mem time205, current time 396, horizon 191\n", - "adding: mem time206, current time 396, horizon 190\n", - "adding: mem time207, current time 396, horizon 189\n", - "adding: mem time208, current time 396, horizon 188\n", - "adding: mem time209, current time 396, horizon 187\n", - "adding: mem time210, current time 396, horizon 186\n", - "adding: mem time211, current time 396, horizon 185\n", - "adding: mem time212, current time 396, horizon 184\n", - "adding: mem time213, current time 396, horizon 183\n", - "adding: mem time214, current time 396, horizon 182\n", - "adding: mem time215, current time 396, horizon 181\n", - "adding: mem time216, current time 396, horizon 180\n", - "adding: mem time217, current time 396, horizon 179\n", - "adding: mem time218, current time 396, horizon 178\n", - "adding: mem time219, current time 396, horizon 177\n", - "adding: mem time220, current time 396, horizon 176\n", - "adding: mem time221, current time 396, horizon 175\n", - "adding: mem time222, current time 396, horizon 174\n", - "adding: mem time223, current time 396, horizon 173\n", - "adding: mem time224, current time 396, horizon 172\n", - "adding: mem time225, current time 396, horizon 171\n", - "adding: mem time226, current time 396, horizon 170\n", - "adding: mem time227, current time 396, horizon 169\n", - "adding: mem time228, current time 396, horizon 168\n", - "adding: mem time229, current time 396, horizon 167\n", - "adding: mem time230, current time 396, horizon 166\n", - "adding: mem time231, current time 396, horizon 165\n", - "adding: mem time232, current time 396, horizon 164\n", - "adding: mem time233, current time 396, horizon 163\n", - "adding: mem time234, current time 396, horizon 162\n", - "adding: mem time235, current time 396, horizon 161\n", - "adding: mem time236, current time 396, horizon 160\n", - "adding: mem time237, current time 396, horizon 159\n", - "adding: mem time238, current time 396, horizon 158\n", - "adding: mem time239, current time 396, horizon 157\n", - "adding: mem time240, current time 396, horizon 156\n", - "adding: mem time241, current time 396, horizon 155\n", - "adding: mem time242, current time 396, horizon 154\n", - "adding: mem time243, current time 396, horizon 153\n", - "adding: mem time244, current time 396, horizon 152\n", - "adding: mem time245, current time 396, horizon 151\n", - "adding: mem time246, current time 396, horizon 150\n", - "adding: mem time247, current time 396, horizon 149\n", - "adding: mem time248, current time 396, horizon 148\n", - "adding: mem time249, current time 396, horizon 147\n", - "adding: mem time250, current time 396, horizon 146\n", - "adding: mem time251, current time 396, horizon 145\n", - "adding: mem time252, current time 396, horizon 144\n", - "adding: mem time253, current time 396, horizon 143\n", - "adding: mem time254, current time 396, horizon 142\n", - "adding: mem time255, current time 396, horizon 141\n", - "adding: mem time256, current time 396, horizon 140\n", - "adding: mem time257, current time 396, horizon 139\n", - "adding: mem time258, current time 396, horizon 138\n", - "adding: mem time259, current time 396, horizon 137\n", - "adding: mem time260, current time 396, horizon 136\n", - "adding: mem time261, current time 396, horizon 135\n", - "adding: mem time262, current time 396, horizon 134\n", - "adding: mem time263, current time 396, horizon 133\n", - "adding: mem time264, current time 396, horizon 132\n", - "adding: mem time265, current time 396, horizon 131\n", - "adding: mem time266, current time 396, horizon 130\n", - "adding: mem time267, current time 396, horizon 129\n", - "adding: mem time268, current time 396, horizon 128\n", - "adding: mem time269, current time 396, horizon 127\n", - "adding: mem time270, current time 396, horizon 126\n", - "adding: mem time271, current time 396, horizon 125\n", - "adding: mem time272, current time 396, horizon 124\n", - "adding: mem time273, current time 396, horizon 123\n", - "adding: mem time274, current time 396, horizon 122\n", - "adding: mem time275, current time 396, horizon 121\n", - "adding: mem time276, current time 396, horizon 120\n", - "adding: mem time277, current time 396, horizon 119\n", - "adding: mem time278, current time 396, horizon 118\n", - "adding: mem time279, current time 396, horizon 117\n", - "adding: mem time280, current time 396, horizon 116\n", - "adding: mem time281, current time 396, horizon 115\n", - "adding: mem time282, current time 396, horizon 114\n", - "adding: mem time283, current time 396, horizon 113\n", - "adding: mem time284, current time 396, horizon 112\n", - "adding: mem time285, current time 396, horizon 111\n", - "adding: mem time286, current time 396, horizon 110\n", - "adding: mem time287, current time 396, horizon 109\n", - "adding: mem time288, current time 396, horizon 108\n", - "adding: mem time289, current time 396, horizon 107\n", - "adding: mem time290, current time 396, horizon 106\n", - "adding: mem time291, current time 396, horizon 105\n", - "adding: mem time292, current time 396, horizon 104\n", - "adding: mem time293, current time 396, horizon 103\n", - "adding: mem time294, current time 396, horizon 102\n", - "adding: mem time295, current time 396, horizon 101\n", - "adding: mem time296, current time 396, horizon 100\n", - "adding: mem time297, current time 396, horizon 99\n", - "adding: mem time298, current time 396, horizon 98\n", - "adding: mem time299, current time 396, horizon 97\n", - "adding: mem time300, current time 396, horizon 96\n", - "adding: mem time301, current time 396, horizon 95\n", - "adding: mem time302, current time 396, horizon 94\n", - "adding: mem time303, current time 396, horizon 93\n", - "adding: mem time304, current time 396, horizon 92\n", - "adding: mem time305, current time 396, horizon 91\n", - "adding: mem time306, current time 396, horizon 90\n", - "adding: mem time307, current time 396, horizon 89\n", - "adding: mem time308, current time 396, horizon 88\n", - "adding: mem time309, current time 396, horizon 87\n", - "adding: mem time310, current time 396, horizon 86\n", - "adding: mem time311, current time 396, horizon 85\n", - "adding: mem time312, current time 396, horizon 84\n", - "adding: mem time313, current time 396, horizon 83\n", - "adding: mem time314, current time 396, horizon 82\n", - "adding: mem time315, current time 396, horizon 81\n", - "adding: mem time316, current time 396, horizon 80\n", - "adding: mem time317, current time 396, horizon 79\n", - "adding: mem time318, current time 396, horizon 78\n", - "adding: mem time319, current time 396, horizon 77\n", - "adding: mem time320, current time 396, horizon 76\n", - "adding: mem time321, current time 396, horizon 75\n", - "adding: mem time322, current time 396, horizon 74\n", - "adding: mem time323, current time 396, horizon 73\n", - "adding: mem time324, current time 396, horizon 72\n", - "adding: mem time325, current time 396, horizon 71\n", - "adding: mem time326, current time 396, horizon 70\n", - "adding: mem time327, current time 396, horizon 69\n", - "adding: mem time328, current time 396, horizon 68\n", - "adding: mem time329, current time 396, horizon 67\n", - "adding: mem time330, current time 396, horizon 66\n", - "adding: mem time331, current time 396, horizon 65\n", - "adding: mem time332, current time 396, horizon 64\n", - "adding: mem time333, current time 396, horizon 63\n", - "adding: mem time334, current time 396, horizon 62\n", - "adding: mem time335, current time 396, horizon 61\n", - "adding: mem time336, current time 396, horizon 60\n", - "adding: mem time337, current time 396, horizon 59\n", - "adding: mem time338, current time 396, horizon 58\n", - "adding: mem time339, current time 396, horizon 57\n", - "adding: mem time340, current time 396, horizon 56\n", - "adding: mem time341, current time 396, horizon 55\n", - "adding: mem time342, current time 396, horizon 54\n", - "adding: mem time343, current time 396, horizon 53\n", - "adding: mem time344, current time 396, horizon 52\n", - "adding: mem time345, current time 396, horizon 51\n", - "adding: mem time346, current time 396, horizon 50\n", - "adding: mem time347, current time 396, horizon 49\n", - "adding: mem time348, current time 396, horizon 48\n", - "adding: mem time349, current time 396, horizon 47\n", - "adding: mem time350, current time 396, horizon 46\n", - "adding: mem time351, current time 396, horizon 45\n", - "adding: mem time352, current time 396, horizon 44\n", - "adding: mem time353, current time 396, horizon 43\n", - "adding: mem time354, current time 396, horizon 42\n", - "adding: mem time355, current time 396, horizon 41\n", - "adding: mem time356, current time 396, horizon 40\n", - "adding: mem time357, current time 396, horizon 39\n", - "adding: mem time358, current time 396, horizon 38\n", - "adding: mem time359, current time 396, horizon 37\n", - "adding: mem time360, current time 396, horizon 36\n", - "adding: mem time361, current time 396, horizon 35\n", - "adding: mem time362, current time 396, horizon 34\n", - "adding: mem time363, current time 396, horizon 33\n", - "adding: mem time364, current time 396, horizon 32\n", - "adding: mem time365, current time 396, horizon 31\n", - "adding: mem time366, current time 396, horizon 30\n", - "adding: mem time367, current time 396, horizon 29\n", - "adding: mem time368, current time 396, horizon 28\n", - "adding: mem time369, current time 396, horizon 27\n", - "adding: mem time370, current time 396, horizon 26\n", - "adding: mem time371, current time 396, horizon 25\n", - "adding: mem time372, current time 396, horizon 24\n", - "adding: mem time373, current time 396, horizon 23\n", - "adding: mem time374, current time 396, horizon 22\n", - "adding: mem time375, current time 396, horizon 21\n", - "adding: mem time376, current time 396, horizon 20\n", - "adding: mem time377, current time 396, horizon 19\n", - "adding: mem time378, current time 396, horizon 18\n", - "adding: mem time379, current time 396, horizon 17\n", - "adding: mem time380, current time 396, horizon 16\n", - "adding: mem time381, current time 396, horizon 15\n", - "adding: mem time382, current time 396, horizon 14\n", - "adding: mem time383, current time 396, horizon 13\n", - "adding: mem time384, current time 396, horizon 12\n", - "adding: mem time385, current time 396, horizon 11\n", - "adding: mem time386, current time 396, horizon 10\n", - "adding: mem time387, current time 396, horizon 9\n", - "adding: mem time388, current time 396, horizon 8\n", - "adding: mem time389, current time 396, horizon 7\n", - "adding: mem time390, current time 396, horizon 6\n", - "adding: mem time391, current time 396, horizon 5\n", - "adding: mem time392, current time 396, horizon 4\n", - "adding: mem time393, current time 396, horizon 3\n", - "adding: mem time394, current time 396, horizon 2\n", - "adding: mem time395, current time 396, horizon 1\n", - "adding: mem time200, current time 397, horizon 197\n", - "adding: mem time201, current time 397, horizon 196\n", - "adding: mem time202, current time 397, horizon 195\n", - "adding: mem time203, current time 397, horizon 194\n", - "adding: mem time204, current time 397, horizon 193\n", - "adding: mem time205, current time 397, horizon 192\n", - "adding: mem time206, current time 397, horizon 191\n", - "adding: mem time207, current time 397, horizon 190\n", - "adding: mem time208, current time 397, horizon 189\n", - "adding: mem time209, current time 397, horizon 188\n", - "adding: mem time210, current time 397, horizon 187\n", - "adding: mem time211, current time 397, horizon 186\n", - "adding: mem time212, current time 397, horizon 185\n", - "adding: mem time213, current time 397, horizon 184\n", - "adding: mem time214, current time 397, horizon 183\n", - "adding: mem time215, current time 397, horizon 182\n", - "adding: mem time216, current time 397, horizon 181\n", - "adding: mem time217, current time 397, horizon 180\n", - "adding: mem time218, current time 397, horizon 179\n", - "adding: mem time219, current time 397, horizon 178\n", - "adding: mem time220, current time 397, horizon 177\n", - "adding: mem time221, current time 397, horizon 176\n", - "adding: mem time222, current time 397, horizon 175\n", - "adding: mem time223, current time 397, horizon 174\n", - "adding: mem time224, current time 397, horizon 173\n", - "adding: mem time225, current time 397, horizon 172\n", - "adding: mem time226, current time 397, horizon 171\n", - "adding: mem time227, current time 397, horizon 170\n", - "adding: mem time228, current time 397, horizon 169\n", - "adding: mem time229, current time 397, horizon 168\n", - "adding: mem time230, current time 397, horizon 167\n", - "adding: mem time231, current time 397, horizon 166\n", - "adding: mem time232, current time 397, horizon 165\n", - "adding: mem time233, current time 397, horizon 164\n", - "adding: mem time234, current time 397, horizon 163\n", - "adding: mem time235, current time 397, horizon 162\n", - "adding: mem time236, current time 397, horizon 161\n", - "adding: mem time237, current time 397, horizon 160\n", - "adding: mem time238, current time 397, horizon 159\n", - "adding: mem time239, current time 397, horizon 158\n", - "adding: mem time240, current time 397, horizon 157\n", - "adding: mem time241, current time 397, horizon 156\n", - "adding: mem time242, current time 397, horizon 155\n", - "adding: mem time243, current time 397, horizon 154\n", - "adding: mem time244, current time 397, horizon 153\n", - "adding: mem time245, current time 397, horizon 152\n", - "adding: mem time246, current time 397, horizon 151\n", - "adding: mem time247, current time 397, horizon 150\n", - "adding: mem time248, current time 397, horizon 149\n", - "adding: mem time249, current time 397, horizon 148\n", - "adding: mem time250, current time 397, horizon 147\n", - "adding: mem time251, current time 397, horizon 146\n", - "adding: mem time252, current time 397, horizon 145\n", - "adding: mem time253, current time 397, horizon 144\n", - "adding: mem time254, current time 397, horizon 143\n", - "adding: mem time255, current time 397, horizon 142\n", - "adding: mem time256, current time 397, horizon 141\n", - "adding: mem time257, current time 397, horizon 140\n", - "adding: mem time258, current time 397, horizon 139\n", - "adding: mem time259, current time 397, horizon 138\n", - "adding: mem time260, current time 397, horizon 137\n", - "adding: mem time261, current time 397, horizon 136\n", - "adding: mem time262, current time 397, horizon 135\n", - "adding: mem time263, current time 397, horizon 134\n", - "adding: mem time264, current time 397, horizon 133\n", - "adding: mem time265, current time 397, horizon 132\n", - "adding: mem time266, current time 397, horizon 131\n", - "adding: mem time267, current time 397, horizon 130\n", - "adding: mem time268, current time 397, horizon 129\n", - "adding: mem time269, current time 397, horizon 128\n", - "adding: mem time270, current time 397, horizon 127\n", - "adding: mem time271, current time 397, horizon 126\n", - "adding: mem time272, current time 397, horizon 125\n", - "adding: mem time273, current time 397, horizon 124\n", - "adding: mem time274, current time 397, horizon 123\n", - "adding: mem time275, current time 397, horizon 122\n", - "adding: mem time276, current time 397, horizon 121\n", - "adding: mem time277, current time 397, horizon 120\n", - "adding: mem time278, current time 397, horizon 119\n", - "adding: mem time279, current time 397, horizon 118\n", - "adding: mem time280, current time 397, horizon 117\n", - "adding: mem time281, current time 397, horizon 116\n", - "adding: mem time282, current time 397, horizon 115\n", - "adding: mem time283, current time 397, horizon 114\n", - "adding: mem time284, current time 397, horizon 113\n", - "adding: mem time285, current time 397, horizon 112\n", - "adding: mem time286, current time 397, horizon 111\n", - "adding: mem time287, current time 397, horizon 110\n", - "adding: mem time288, current time 397, horizon 109\n", - "adding: mem time289, current time 397, horizon 108\n", - "adding: mem time290, current time 397, horizon 107\n", - "adding: mem time291, current time 397, horizon 106\n", - "adding: mem time292, current time 397, horizon 105\n", - "adding: mem time293, current time 397, horizon 104\n", - "adding: mem time294, current time 397, horizon 103\n", - "adding: mem time295, current time 397, horizon 102\n", - "adding: mem time296, current time 397, horizon 101\n", - "adding: mem time297, current time 397, horizon 100\n", - "adding: mem time298, current time 397, horizon 99\n", - "adding: mem time299, current time 397, horizon 98\n", - "adding: mem time300, current time 397, horizon 97\n", - "adding: mem time301, current time 397, horizon 96\n", - "adding: mem time302, current time 397, horizon 95\n", - "adding: mem time303, current time 397, horizon 94\n", - "adding: mem time304, current time 397, horizon 93\n", - "adding: mem time305, current time 397, horizon 92\n", - "adding: mem time306, current time 397, horizon 91\n", - "adding: mem time307, current time 397, horizon 90\n", - "adding: mem time308, current time 397, horizon 89\n", - "adding: mem time309, current time 397, horizon 88\n", - "adding: mem time310, current time 397, horizon 87\n", - "adding: mem time311, current time 397, horizon 86\n", - "adding: mem time312, current time 397, horizon 85\n", - "adding: mem time313, current time 397, horizon 84\n", - "adding: mem time314, current time 397, horizon 83\n", - "adding: mem time315, current time 397, horizon 82\n", - "adding: mem time316, current time 397, horizon 81\n", - "adding: mem time317, current time 397, horizon 80\n", - "adding: mem time318, current time 397, horizon 79\n", - "adding: mem time319, current time 397, horizon 78\n", - "adding: mem time320, current time 397, horizon 77\n", - "adding: mem time321, current time 397, horizon 76\n", - "adding: mem time322, current time 397, horizon 75\n", - "adding: mem time323, current time 397, horizon 74\n", - "adding: mem time324, current time 397, horizon 73\n", - "adding: mem time325, current time 397, horizon 72\n", - "adding: mem time326, current time 397, horizon 71\n", - "adding: mem time327, current time 397, horizon 70\n", - "adding: mem time328, current time 397, horizon 69\n", - "adding: mem time329, current time 397, horizon 68\n", - "adding: mem time330, current time 397, horizon 67\n", - "adding: mem time331, current time 397, horizon 66\n", - "adding: mem time332, current time 397, horizon 65\n", - "adding: mem time333, current time 397, horizon 64\n", - "adding: mem time334, current time 397, horizon 63\n", - "adding: mem time335, current time 397, horizon 62\n", - "adding: mem time336, current time 397, horizon 61\n", - "adding: mem time337, current time 397, horizon 60\n", - "adding: mem time338, current time 397, horizon 59\n", - "adding: mem time339, current time 397, horizon 58\n", - "adding: mem time340, current time 397, horizon 57\n", - "adding: mem time341, current time 397, horizon 56\n", - "adding: mem time342, current time 397, horizon 55\n", - "adding: mem time343, current time 397, horizon 54\n", - "adding: mem time344, current time 397, horizon 53\n", - "adding: mem time345, current time 397, horizon 52\n", - "adding: mem time346, current time 397, horizon 51\n", - "adding: mem time347, current time 397, horizon 50\n", - "adding: mem time348, current time 397, horizon 49\n", - "adding: mem time349, current time 397, horizon 48\n", - "adding: mem time350, current time 397, horizon 47\n", - "adding: mem time351, current time 397, horizon 46\n", - "adding: mem time352, current time 397, horizon 45\n", - "adding: mem time353, current time 397, horizon 44\n", - "adding: mem time354, current time 397, horizon 43\n", - "adding: mem time355, current time 397, horizon 42\n", - "adding: mem time356, current time 397, horizon 41\n", - "adding: mem time357, current time 397, horizon 40\n", - "adding: mem time358, current time 397, horizon 39\n", - "adding: mem time359, current time 397, horizon 38\n", - "adding: mem time360, current time 397, horizon 37\n", - "adding: mem time361, current time 397, horizon 36\n", - "adding: mem time362, current time 397, horizon 35\n", - "adding: mem time363, current time 397, horizon 34\n", - "adding: mem time364, current time 397, horizon 33\n", - "adding: mem time365, current time 397, horizon 32\n", - "adding: mem time366, current time 397, horizon 31\n", - "adding: mem time367, current time 397, horizon 30\n", - "adding: mem time368, current time 397, horizon 29\n", - "adding: mem time369, current time 397, horizon 28\n", - "adding: mem time370, current time 397, horizon 27\n", - "adding: mem time371, current time 397, horizon 26\n", - "adding: mem time372, current time 397, horizon 25\n", - "adding: mem time373, current time 397, horizon 24\n", - "adding: mem time374, current time 397, horizon 23\n", - "adding: mem time375, current time 397, horizon 22\n", - "adding: mem time376, current time 397, horizon 21\n", - "adding: mem time377, current time 397, horizon 20\n", - "adding: mem time378, current time 397, horizon 19\n", - "adding: mem time379, current time 397, horizon 18\n", - "adding: mem time380, current time 397, horizon 17\n", - "adding: mem time381, current time 397, horizon 16\n", - "adding: mem time382, current time 397, horizon 15\n", - "adding: mem time383, current time 397, horizon 14\n", - "adding: mem time384, current time 397, horizon 13\n", - "adding: mem time385, current time 397, horizon 12\n", - "adding: mem time386, current time 397, horizon 11\n", - "adding: mem time387, current time 397, horizon 10\n", - "adding: mem time388, current time 397, horizon 9\n", - "adding: mem time389, current time 397, horizon 8\n", - "adding: mem time390, current time 397, horizon 7\n", - "adding: mem time391, current time 397, horizon 6\n", - "adding: mem time392, current time 397, horizon 5\n", - "adding: mem time393, current time 397, horizon 4\n", - "adding: mem time394, current time 397, horizon 3\n", - "adding: mem time395, current time 397, horizon 2\n", - "adding: mem time396, current time 397, horizon 1\n", - "adding: mem time200, current time 398, horizon 198\n", - "adding: mem time201, current time 398, horizon 197\n", - "adding: mem time202, current time 398, horizon 196\n", - "adding: mem time203, current time 398, horizon 195\n", - "adding: mem time204, current time 398, horizon 194\n", - "adding: mem time205, current time 398, horizon 193\n", - "adding: mem time206, current time 398, horizon 192\n", - "adding: mem time207, current time 398, horizon 191\n", - "adding: mem time208, current time 398, horizon 190\n", - "adding: mem time209, current time 398, horizon 189\n", - "adding: mem time210, current time 398, horizon 188\n", - "adding: mem time211, current time 398, horizon 187\n", - "adding: mem time212, current time 398, horizon 186\n", - "adding: mem time213, current time 398, horizon 185\n", - "adding: mem time214, current time 398, horizon 184\n", - "adding: mem time215, current time 398, horizon 183\n", - "adding: mem time216, current time 398, horizon 182\n", - "adding: mem time217, current time 398, horizon 181\n", - "adding: mem time218, current time 398, horizon 180\n", - "adding: mem time219, current time 398, horizon 179\n", - "adding: mem time220, current time 398, horizon 178\n", - "adding: mem time221, current time 398, horizon 177\n", - "adding: mem time222, current time 398, horizon 176\n", - "adding: mem time223, current time 398, horizon 175\n", - "adding: mem time224, current time 398, horizon 174\n", - "adding: mem time225, current time 398, horizon 173\n", - "adding: mem time226, current time 398, horizon 172\n", - "adding: mem time227, current time 398, horizon 171\n", - "adding: mem time228, current time 398, horizon 170\n", - "adding: mem time229, current time 398, horizon 169\n", - "adding: mem time230, current time 398, horizon 168\n", - "adding: mem time231, current time 398, horizon 167\n", - "adding: mem time232, current time 398, horizon 166\n", - "adding: mem time233, current time 398, horizon 165\n", - "adding: mem time234, current time 398, horizon 164\n", - "adding: mem time235, current time 398, horizon 163\n", - "adding: mem time236, current time 398, horizon 162\n", - "adding: mem time237, current time 398, horizon 161\n", - "adding: mem time238, current time 398, horizon 160\n", - "adding: mem time239, current time 398, horizon 159\n", - "adding: mem time240, current time 398, horizon 158\n", - "adding: mem time241, current time 398, horizon 157\n", - "adding: mem time242, current time 398, horizon 156\n", - "adding: mem time243, current time 398, horizon 155\n", - "adding: mem time244, current time 398, horizon 154\n", - "adding: mem time245, current time 398, horizon 153\n", - "adding: mem time246, current time 398, horizon 152\n", - "adding: mem time247, current time 398, horizon 151\n", - "adding: mem time248, current time 398, horizon 150\n", - "adding: mem time249, current time 398, horizon 149\n", - "adding: mem time250, current time 398, horizon 148\n", - "adding: mem time251, current time 398, horizon 147\n", - "adding: mem time252, current time 398, horizon 146\n", - "adding: mem time253, current time 398, horizon 145\n", - "adding: mem time254, current time 398, horizon 144\n", - "adding: mem time255, current time 398, horizon 143\n", - "adding: mem time256, current time 398, horizon 142\n", - "adding: mem time257, current time 398, horizon 141\n", - "adding: mem time258, current time 398, horizon 140\n", - "adding: mem time259, current time 398, horizon 139\n", - "adding: mem time260, current time 398, horizon 138\n", - "adding: mem time261, current time 398, horizon 137\n", - "adding: mem time262, current time 398, horizon 136\n", - "adding: mem time263, current time 398, horizon 135\n", - "adding: mem time264, current time 398, horizon 134\n", - "adding: mem time265, current time 398, horizon 133\n", - "adding: mem time266, current time 398, horizon 132\n", - "adding: mem time267, current time 398, horizon 131\n", - "adding: mem time268, current time 398, horizon 130\n", - "adding: mem time269, current time 398, horizon 129\n", - "adding: mem time270, current time 398, horizon 128\n", - "adding: mem time271, current time 398, horizon 127\n", - "adding: mem time272, current time 398, horizon 126\n", - "adding: mem time273, current time 398, horizon 125\n", - "adding: mem time274, current time 398, horizon 124\n", - "adding: mem time275, current time 398, horizon 123\n", - "adding: mem time276, current time 398, horizon 122\n", - "adding: mem time277, current time 398, horizon 121\n", - "adding: mem time278, current time 398, horizon 120\n", - "adding: mem time279, current time 398, horizon 119\n", - "adding: mem time280, current time 398, horizon 118\n", - "adding: mem time281, current time 398, horizon 117\n", - "adding: mem time282, current time 398, horizon 116\n", - "adding: mem time283, current time 398, horizon 115\n", - "adding: mem time284, current time 398, horizon 114\n", - "adding: mem time285, current time 398, horizon 113\n", - "adding: mem time286, current time 398, horizon 112\n", - "adding: mem time287, current time 398, horizon 111\n", - "adding: mem time288, current time 398, horizon 110\n", - "adding: mem time289, current time 398, horizon 109\n", - "adding: mem time290, current time 398, horizon 108\n", - "adding: mem time291, current time 398, horizon 107\n", - "adding: mem time292, current time 398, horizon 106\n", - "adding: mem time293, current time 398, horizon 105\n", - "adding: mem time294, current time 398, horizon 104\n", - "adding: mem time295, current time 398, horizon 103\n", - "adding: mem time296, current time 398, horizon 102\n", - "adding: mem time297, current time 398, horizon 101\n", - "adding: mem time298, current time 398, horizon 100\n", - "adding: mem time299, current time 398, horizon 99\n", - "adding: mem time300, current time 398, horizon 98\n", - "adding: mem time301, current time 398, horizon 97\n", - "adding: mem time302, current time 398, horizon 96\n", - "adding: mem time303, current time 398, horizon 95\n", - "adding: mem time304, current time 398, horizon 94\n", - "adding: mem time305, current time 398, horizon 93\n", - "adding: mem time306, current time 398, horizon 92\n", - "adding: mem time307, current time 398, horizon 91\n", - "adding: mem time308, current time 398, horizon 90\n", - "adding: mem time309, current time 398, horizon 89\n", - "adding: mem time310, current time 398, horizon 88\n", - "adding: mem time311, current time 398, horizon 87\n", - "adding: mem time312, current time 398, horizon 86\n", - "adding: mem time313, current time 398, horizon 85\n", - "adding: mem time314, current time 398, horizon 84\n", - "adding: mem time315, current time 398, horizon 83\n", - "adding: mem time316, current time 398, horizon 82\n", - "adding: mem time317, current time 398, horizon 81\n", - "adding: mem time318, current time 398, horizon 80\n", - "adding: mem time319, current time 398, horizon 79\n", - "adding: mem time320, current time 398, horizon 78\n", - "adding: mem time321, current time 398, horizon 77\n", - "adding: mem time322, current time 398, horizon 76\n", - "adding: mem time323, current time 398, horizon 75\n", - "adding: mem time324, current time 398, horizon 74\n", - "adding: mem time325, current time 398, horizon 73\n", - "adding: mem time326, current time 398, horizon 72\n", - "adding: mem time327, current time 398, horizon 71\n", - "adding: mem time328, current time 398, horizon 70\n", - "adding: mem time329, current time 398, horizon 69\n", - "adding: mem time330, current time 398, horizon 68\n", - "adding: mem time331, current time 398, horizon 67\n", - "adding: mem time332, current time 398, horizon 66\n", - "adding: mem time333, current time 398, horizon 65\n", - "adding: mem time334, current time 398, horizon 64\n", - "adding: mem time335, current time 398, horizon 63\n", - "adding: mem time336, current time 398, horizon 62\n", - "adding: mem time337, current time 398, horizon 61\n", - "adding: mem time338, current time 398, horizon 60\n", - "adding: mem time339, current time 398, horizon 59\n", - "adding: mem time340, current time 398, horizon 58\n", - "adding: mem time341, current time 398, horizon 57\n", - "adding: mem time342, current time 398, horizon 56\n", - "adding: mem time343, current time 398, horizon 55\n", - "adding: mem time344, current time 398, horizon 54\n", - "adding: mem time345, current time 398, horizon 53\n", - "adding: mem time346, current time 398, horizon 52\n", - "adding: mem time347, current time 398, horizon 51\n", - "adding: mem time348, current time 398, horizon 50\n", - "adding: mem time349, current time 398, horizon 49\n", - "adding: mem time350, current time 398, horizon 48\n", - "adding: mem time351, current time 398, horizon 47\n", - "adding: mem time352, current time 398, horizon 46\n", - "adding: mem time353, current time 398, horizon 45\n", - "adding: mem time354, current time 398, horizon 44\n", - "adding: mem time355, current time 398, horizon 43\n", - "adding: mem time356, current time 398, horizon 42\n", - "adding: mem time357, current time 398, horizon 41\n", - "adding: mem time358, current time 398, horizon 40\n", - "adding: mem time359, current time 398, horizon 39\n", - "adding: mem time360, current time 398, horizon 38\n", - "adding: mem time361, current time 398, horizon 37\n", - "adding: mem time362, current time 398, horizon 36\n", - "adding: mem time363, current time 398, horizon 35\n", - "adding: mem time364, current time 398, horizon 34\n", - "adding: mem time365, current time 398, horizon 33\n", - "adding: mem time366, current time 398, horizon 32\n", - "adding: mem time367, current time 398, horizon 31\n", - "adding: mem time368, current time 398, horizon 30\n", - "adding: mem time369, current time 398, horizon 29\n", - "adding: mem time370, current time 398, horizon 28\n", - "adding: mem time371, current time 398, horizon 27\n", - "adding: mem time372, current time 398, horizon 26\n", - "adding: mem time373, current time 398, horizon 25\n", - "adding: mem time374, current time 398, horizon 24\n", - "adding: mem time375, current time 398, horizon 23\n", - "adding: mem time376, current time 398, horizon 22\n", - "adding: mem time377, current time 398, horizon 21\n", - "adding: mem time378, current time 398, horizon 20\n", - "adding: mem time379, current time 398, horizon 19\n", - "adding: mem time380, current time 398, horizon 18\n", - "adding: mem time381, current time 398, horizon 17\n", - "adding: mem time382, current time 398, horizon 16\n", - "adding: mem time383, current time 398, horizon 15\n", - "adding: mem time384, current time 398, horizon 14\n", - "adding: mem time385, current time 398, horizon 13\n", - "adding: mem time386, current time 398, horizon 12\n", - "adding: mem time387, current time 398, horizon 11\n", - "adding: mem time388, current time 398, horizon 10\n", - "adding: mem time389, current time 398, horizon 9\n", - "adding: mem time390, current time 398, horizon 8\n", - "adding: mem time391, current time 398, horizon 7\n", - "adding: mem time392, current time 398, horizon 6\n", - "adding: mem time393, current time 398, horizon 5\n", - "adding: mem time394, current time 398, horizon 4\n", - "adding: mem time395, current time 398, horizon 3\n", - "adding: mem time396, current time 398, horizon 2\n", - "adding: mem time397, current time 398, horizon 1\n", - "adding: mem time200, current time 399, horizon 199\n", - "adding: mem time201, current time 399, horizon 198\n", - "adding: mem time202, current time 399, horizon 197\n", - "adding: mem time203, current time 399, horizon 196\n", - "adding: mem time204, current time 399, horizon 195\n", - "adding: mem time205, current time 399, horizon 194\n", - "adding: mem time206, current time 399, horizon 193\n", - "adding: mem time207, current time 399, horizon 192\n", - "adding: mem time208, current time 399, horizon 191\n", - "adding: mem time209, current time 399, horizon 190\n", - "adding: mem time210, current time 399, horizon 189\n", - "adding: mem time211, current time 399, horizon 188\n", - "adding: mem time212, current time 399, horizon 187\n", - "adding: mem time213, current time 399, horizon 186\n", - "adding: mem time214, current time 399, horizon 185\n", - "adding: mem time215, current time 399, horizon 184\n", - "adding: mem time216, current time 399, horizon 183\n", - "adding: mem time217, current time 399, horizon 182\n", - "adding: mem time218, current time 399, horizon 181\n", - "adding: mem time219, current time 399, horizon 180\n", - "adding: mem time220, current time 399, horizon 179\n", - "adding: mem time221, current time 399, horizon 178\n", - "adding: mem time222, current time 399, horizon 177\n", - "adding: mem time223, current time 399, horizon 176\n", - "adding: mem time224, current time 399, horizon 175\n", - "adding: mem time225, current time 399, horizon 174\n", - "adding: mem time226, current time 399, horizon 173\n", - "adding: mem time227, current time 399, horizon 172\n", - "adding: mem time228, current time 399, horizon 171\n", - "adding: mem time229, current time 399, horizon 170\n", - "adding: mem time230, current time 399, horizon 169\n", - "adding: mem time231, current time 399, horizon 168\n", - "adding: mem time232, current time 399, horizon 167\n", - "adding: mem time233, current time 399, horizon 166\n", - "adding: mem time234, current time 399, horizon 165\n", - "adding: mem time235, current time 399, horizon 164\n", - "adding: mem time236, current time 399, horizon 163\n", - "adding: mem time237, current time 399, horizon 162\n", - "adding: mem time238, current time 399, horizon 161\n", - "adding: mem time239, current time 399, horizon 160\n", - "adding: mem time240, current time 399, horizon 159\n", - "adding: mem time241, current time 399, horizon 158\n", - "adding: mem time242, current time 399, horizon 157\n", - "adding: mem time243, current time 399, horizon 156\n", - "adding: mem time244, current time 399, horizon 155\n", - "adding: mem time245, current time 399, horizon 154\n", - "adding: mem time246, current time 399, horizon 153\n", - "adding: mem time247, current time 399, horizon 152\n", - "adding: mem time248, current time 399, horizon 151\n", - "adding: mem time249, current time 399, horizon 150\n", - "adding: mem time250, current time 399, horizon 149\n", - "adding: mem time251, current time 399, horizon 148\n", - "adding: mem time252, current time 399, horizon 147\n", - "adding: mem time253, current time 399, horizon 146\n", - "adding: mem time254, current time 399, horizon 145\n", - "adding: mem time255, current time 399, horizon 144\n", - "adding: mem time256, current time 399, horizon 143\n", - "adding: mem time257, current time 399, horizon 142\n", - "adding: mem time258, current time 399, horizon 141\n", - "adding: mem time259, current time 399, horizon 140\n", - "adding: mem time260, current time 399, horizon 139\n", - "adding: mem time261, current time 399, horizon 138\n", - "adding: mem time262, current time 399, horizon 137\n", - "adding: mem time263, current time 399, horizon 136\n", - "adding: mem time264, current time 399, horizon 135\n", - "adding: mem time265, current time 399, horizon 134\n", - "adding: mem time266, current time 399, horizon 133\n", - "adding: mem time267, current time 399, horizon 132\n", - "adding: mem time268, current time 399, horizon 131\n", - "adding: mem time269, current time 399, horizon 130\n", - "adding: mem time270, current time 399, horizon 129\n", - "adding: mem time271, current time 399, horizon 128\n", - "adding: mem time272, current time 399, horizon 127\n", - "adding: mem time273, current time 399, horizon 126\n", - "adding: mem time274, current time 399, horizon 125\n", - "adding: mem time275, current time 399, horizon 124\n", - "adding: mem time276, current time 399, horizon 123\n", - "adding: mem time277, current time 399, horizon 122\n", - "adding: mem time278, current time 399, horizon 121\n", - "adding: mem time279, current time 399, horizon 120\n", - "adding: mem time280, current time 399, horizon 119\n", - "adding: mem time281, current time 399, horizon 118\n", - "adding: mem time282, current time 399, horizon 117\n", - "adding: mem time283, current time 399, horizon 116\n", - "adding: mem time284, current time 399, horizon 115\n", - "adding: mem time285, current time 399, horizon 114\n", - "adding: mem time286, current time 399, horizon 113\n", - "adding: mem time287, current time 399, horizon 112\n", - "adding: mem time288, current time 399, horizon 111\n", - "adding: mem time289, current time 399, horizon 110\n", - "adding: mem time290, current time 399, horizon 109\n", - "adding: mem time291, current time 399, horizon 108\n", - "adding: mem time292, current time 399, horizon 107\n", - "adding: mem time293, current time 399, horizon 106\n", - "adding: mem time294, current time 399, horizon 105\n", - "adding: mem time295, current time 399, horizon 104\n", - "adding: mem time296, current time 399, horizon 103\n", - "adding: mem time297, current time 399, horizon 102\n", - "adding: mem time298, current time 399, horizon 101\n", - "adding: mem time299, current time 399, horizon 100\n", - "adding: mem time300, current time 399, horizon 99\n", - "adding: mem time301, current time 399, horizon 98\n", - "adding: mem time302, current time 399, horizon 97\n", - "adding: mem time303, current time 399, horizon 96\n", - "adding: mem time304, current time 399, horizon 95\n", - "adding: mem time305, current time 399, horizon 94\n", - "adding: mem time306, current time 399, horizon 93\n", - "adding: mem time307, current time 399, horizon 92\n", - "adding: mem time308, current time 399, horizon 91\n", - "adding: mem time309, current time 399, horizon 90\n", - "adding: mem time310, current time 399, horizon 89\n", - "adding: mem time311, current time 399, horizon 88\n", - "adding: mem time312, current time 399, horizon 87\n", - "adding: mem time313, current time 399, horizon 86\n", - "adding: mem time314, current time 399, horizon 85\n", - "adding: mem time315, current time 399, horizon 84\n", - "adding: mem time316, current time 399, horizon 83\n", - "adding: mem time317, current time 399, horizon 82\n", - "adding: mem time318, current time 399, horizon 81\n", - "adding: mem time319, current time 399, horizon 80\n", - "adding: mem time320, current time 399, horizon 79\n", - "adding: mem time321, current time 399, horizon 78\n", - "adding: mem time322, current time 399, horizon 77\n", - "adding: mem time323, current time 399, horizon 76\n", - "adding: mem time324, current time 399, horizon 75\n", - "adding: mem time325, current time 399, horizon 74\n", - "adding: mem time326, current time 399, horizon 73\n", - "adding: mem time327, current time 399, horizon 72\n", - "adding: mem time328, current time 399, horizon 71\n", - "adding: mem time329, current time 399, horizon 70\n", - "adding: mem time330, current time 399, horizon 69\n", - "adding: mem time331, current time 399, horizon 68\n", - "adding: mem time332, current time 399, horizon 67\n", - "adding: mem time333, current time 399, horizon 66\n", - "adding: mem time334, current time 399, horizon 65\n", - "adding: mem time335, current time 399, horizon 64\n", - "adding: mem time336, current time 399, horizon 63\n", - "adding: mem time337, current time 399, horizon 62\n", - "adding: mem time338, current time 399, horizon 61\n", - "adding: mem time339, current time 399, horizon 60\n", - "adding: mem time340, current time 399, horizon 59\n", - "adding: mem time341, current time 399, horizon 58\n", - "adding: mem time342, current time 399, horizon 57\n", - "adding: mem time343, current time 399, horizon 56\n", - "adding: mem time344, current time 399, horizon 55\n", - "adding: mem time345, current time 399, horizon 54\n", - "adding: mem time346, current time 399, horizon 53\n", - "adding: mem time347, current time 399, horizon 52\n", - "adding: mem time348, current time 399, horizon 51\n", - "adding: mem time349, current time 399, horizon 50\n", - "adding: mem time350, current time 399, horizon 49\n", - "adding: mem time351, current time 399, horizon 48\n", - "adding: mem time352, current time 399, horizon 47\n", - "adding: mem time353, current time 399, horizon 46\n", - "adding: mem time354, current time 399, horizon 45\n", - "adding: mem time355, current time 399, horizon 44\n", - "adding: mem time356, current time 399, horizon 43\n", - "adding: mem time357, current time 399, horizon 42\n", - "adding: mem time358, current time 399, horizon 41\n", - "adding: mem time359, current time 399, horizon 40\n", - "adding: mem time360, current time 399, horizon 39\n", - "adding: mem time361, current time 399, horizon 38\n", - "adding: mem time362, current time 399, horizon 37\n", - "adding: mem time363, current time 399, horizon 36\n", - "adding: mem time364, current time 399, horizon 35\n", - "adding: mem time365, current time 399, horizon 34\n", - "adding: mem time366, current time 399, horizon 33\n", - "adding: mem time367, current time 399, horizon 32\n", - "adding: mem time368, current time 399, horizon 31\n", - "adding: mem time369, current time 399, horizon 30\n", - "adding: mem time370, current time 399, horizon 29\n", - "adding: mem time371, current time 399, horizon 28\n", - "adding: mem time372, current time 399, horizon 27\n", - "adding: mem time373, current time 399, horizon 26\n", - "adding: mem time374, current time 399, horizon 25\n", - "adding: mem time375, current time 399, horizon 24\n", - "adding: mem time376, current time 399, horizon 23\n", - "adding: mem time377, current time 399, horizon 22\n", - "adding: mem time378, current time 399, horizon 21\n", - "adding: mem time379, current time 399, horizon 20\n", - "adding: mem time380, current time 399, horizon 19\n", - "adding: mem time381, current time 399, horizon 18\n", - "adding: mem time382, current time 399, horizon 17\n", - "adding: mem time383, current time 399, horizon 16\n", - "adding: mem time384, current time 399, horizon 15\n", - "adding: mem time385, current time 399, horizon 14\n", - "adding: mem time386, current time 399, horizon 13\n", - "adding: mem time387, current time 399, horizon 12\n", - "adding: mem time388, current time 399, horizon 11\n", - "adding: mem time389, current time 399, horizon 10\n", - "adding: mem time390, current time 399, horizon 9\n", - "adding: mem time391, current time 399, horizon 8\n", - "adding: mem time392, current time 399, horizon 7\n", - "adding: mem time393, current time 399, horizon 6\n", - "adding: mem time394, current time 399, horizon 5\n", - "adding: mem time395, current time 399, horizon 4\n", - "adding: mem time396, current time 399, horizon 3\n", - "adding: mem time397, current time 399, horizon 2\n", - "adding: mem time398, current time 399, horizon 1\n", - "adding: mem time400, current time 401, horizon 1\n", - "adding: mem time400, current time 402, horizon 2\n", - "adding: mem time401, current time 402, horizon 1\n", - "adding: mem time400, current time 403, horizon 3\n", - "adding: mem time401, current time 403, horizon 2\n", - "adding: mem time402, current time 403, horizon 1\n", - "adding: mem time400, current time 404, horizon 4\n", - "adding: mem time401, current time 404, horizon 3\n", - "adding: mem time402, current time 404, horizon 2\n", - "adding: mem time403, current time 404, horizon 1\n", - "adding: mem time400, current time 405, horizon 5\n", - "adding: mem time401, current time 405, horizon 4\n", - "adding: mem time402, current time 405, horizon 3\n", - "adding: mem time403, current time 405, horizon 2\n", - "adding: mem time404, current time 405, horizon 1\n", - "adding: mem time400, current time 406, horizon 6\n", - "adding: mem time401, current time 406, horizon 5\n", - "adding: mem time402, current time 406, horizon 4\n", - "adding: mem time403, current time 406, horizon 3\n", - "adding: mem time404, current time 406, horizon 2\n", - "adding: mem time405, current time 406, horizon 1\n", - "adding: mem time400, current time 407, horizon 7\n", - "adding: mem time401, current time 407, horizon 6\n", - "adding: mem time402, current time 407, horizon 5\n", - "adding: mem time403, current time 407, horizon 4\n", - "adding: mem time404, current time 407, horizon 3\n", - "adding: mem time405, current time 407, horizon 2\n", - "adding: mem time406, current time 407, horizon 1\n", - "adding: mem time400, current time 408, horizon 8\n", - "adding: mem time401, current time 408, horizon 7\n", - "adding: mem time402, current time 408, horizon 6\n", - "adding: mem time403, current time 408, horizon 5\n", - "adding: mem time404, current time 408, horizon 4\n", - "adding: mem time405, current time 408, horizon 3\n", - "adding: mem time406, current time 408, horizon 2\n", - "adding: mem time407, current time 408, horizon 1\n", - "adding: mem time400, current time 409, horizon 9\n", - "adding: mem time401, current time 409, horizon 8\n", - "adding: mem time402, current time 409, horizon 7\n", - "adding: mem time403, current time 409, horizon 6\n", - "adding: mem time404, current time 409, horizon 5\n", - "adding: mem time405, current time 409, horizon 4\n", - "adding: mem time406, current time 409, horizon 3\n", - "adding: mem time407, current time 409, horizon 2\n", - "adding: mem time408, current time 409, horizon 1\n", - "adding: mem time400, current time 410, horizon 10\n", - "adding: mem time401, current time 410, horizon 9\n", - "adding: mem time402, current time 410, horizon 8\n", - "adding: mem time403, current time 410, horizon 7\n", - "adding: mem time404, current time 410, horizon 6\n", - "adding: mem time405, current time 410, horizon 5\n", - "adding: mem time406, current time 410, horizon 4\n", - "adding: mem time407, current time 410, horizon 3\n", - "adding: mem time408, current time 410, horizon 2\n", - "adding: mem time409, current time 410, horizon 1\n", - "adding: mem time400, current time 411, horizon 11\n", - "adding: mem time401, current time 411, horizon 10\n", - "adding: mem time402, current time 411, horizon 9\n", - "adding: mem time403, current time 411, horizon 8\n", - "adding: mem time404, current time 411, horizon 7\n", - "adding: mem time405, current time 411, horizon 6\n", - "adding: mem time406, current time 411, horizon 5\n", - "adding: mem time407, current time 411, horizon 4\n", - "adding: mem time408, current time 411, horizon 3\n", - "adding: mem time409, current time 411, horizon 2\n", - "adding: mem time410, current time 411, horizon 1\n", - "adding: mem time400, current time 412, horizon 12\n", - "adding: mem time401, current time 412, horizon 11\n", - "adding: mem time402, current time 412, horizon 10\n", - "adding: mem time403, current time 412, horizon 9\n", - "adding: mem time404, current time 412, horizon 8\n", - "adding: mem time405, current time 412, horizon 7\n", - "adding: mem time406, current time 412, horizon 6\n", - "adding: mem time407, current time 412, horizon 5\n", - "adding: mem time408, current time 412, horizon 4\n", - "adding: mem time409, current time 412, horizon 3\n", - "adding: mem time410, current time 412, horizon 2\n", - "adding: mem time411, current time 412, horizon 1\n", - "adding: mem time400, current time 413, horizon 13\n", - "adding: mem time401, current time 413, horizon 12\n", - "adding: mem time402, current time 413, horizon 11\n", - "adding: mem time403, current time 413, horizon 10\n", - "adding: mem time404, current time 413, horizon 9\n", - "adding: mem time405, current time 413, horizon 8\n", - "adding: mem time406, current time 413, horizon 7\n", - "adding: mem time407, current time 413, horizon 6\n", - "adding: mem time408, current time 413, horizon 5\n", - "adding: mem time409, current time 413, horizon 4\n", - "adding: mem time410, current time 413, horizon 3\n", - "adding: mem time411, current time 413, horizon 2\n", - "adding: mem time412, current time 413, horizon 1\n", - "adding: mem time400, current time 414, horizon 14\n", - "adding: mem time401, current time 414, horizon 13\n", - "adding: mem time402, current time 414, horizon 12\n", - "adding: mem time403, current time 414, horizon 11\n", - "adding: mem time404, current time 414, horizon 10\n", - "adding: mem time405, current time 414, horizon 9\n", - "adding: mem time406, current time 414, horizon 8\n", - "adding: mem time407, current time 414, horizon 7\n", - "adding: mem time408, current time 414, horizon 6\n", - "adding: mem time409, current time 414, horizon 5\n", - "adding: mem time410, current time 414, horizon 4\n", - "adding: mem time411, current time 414, horizon 3\n", - "adding: mem time412, current time 414, horizon 2\n", - "adding: mem time413, current time 414, horizon 1\n", - "adding: mem time400, current time 415, horizon 15\n", - "adding: mem time401, current time 415, horizon 14\n", - "adding: mem time402, current time 415, horizon 13\n", - "adding: mem time403, current time 415, horizon 12\n", - "adding: mem time404, current time 415, horizon 11\n", - "adding: mem time405, current time 415, horizon 10\n", - "adding: mem time406, current time 415, horizon 9\n", - "adding: mem time407, current time 415, horizon 8\n", - "adding: mem time408, current time 415, horizon 7\n", - "adding: mem time409, current time 415, horizon 6\n", - "adding: mem time410, current time 415, horizon 5\n", - "adding: mem time411, current time 415, horizon 4\n", - "adding: mem time412, current time 415, horizon 3\n", - "adding: mem time413, current time 415, horizon 2\n", - "adding: mem time414, current time 415, horizon 1\n", - "adding: mem time400, current time 416, horizon 16\n", - "adding: mem time401, current time 416, horizon 15\n", - "adding: mem time402, current time 416, horizon 14\n", - "adding: mem time403, current time 416, horizon 13\n", - "adding: mem time404, current time 416, horizon 12\n", - "adding: mem time405, current time 416, horizon 11\n", - "adding: mem time406, current time 416, horizon 10\n", - "adding: mem time407, current time 416, horizon 9\n", - "adding: mem time408, current time 416, horizon 8\n", - "adding: mem time409, current time 416, horizon 7\n", - "adding: mem time410, current time 416, horizon 6\n", - "adding: mem time411, current time 416, horizon 5\n", - "adding: mem time412, current time 416, horizon 4\n", - "adding: mem time413, current time 416, horizon 3\n", - "adding: mem time414, current time 416, horizon 2\n", - "adding: mem time415, current time 416, horizon 1\n", - "adding: mem time400, current time 417, horizon 17\n", - "adding: mem time401, current time 417, horizon 16\n", - "adding: mem time402, current time 417, horizon 15\n", - "adding: mem time403, current time 417, horizon 14\n", - "adding: mem time404, current time 417, horizon 13\n", - "adding: mem time405, current time 417, horizon 12\n", - "adding: mem time406, current time 417, horizon 11\n", - "adding: mem time407, current time 417, horizon 10\n", - "adding: mem time408, current time 417, horizon 9\n", - "adding: mem time409, current time 417, horizon 8\n", - "adding: mem time410, current time 417, horizon 7\n", - "adding: mem time411, current time 417, horizon 6\n", - "adding: mem time412, current time 417, horizon 5\n", - "adding: mem time413, current time 417, horizon 4\n", - "adding: mem time414, current time 417, horizon 3\n", - "adding: mem time415, current time 417, horizon 2\n", - "adding: mem time416, current time 417, horizon 1\n", - "adding: mem time400, current time 418, horizon 18\n", - "adding: mem time401, current time 418, horizon 17\n", - "adding: mem time402, current time 418, horizon 16\n", - "adding: mem time403, current time 418, horizon 15\n", - "adding: mem time404, current time 418, horizon 14\n", - "adding: mem time405, current time 418, horizon 13\n", - "adding: mem time406, current time 418, horizon 12\n", - "adding: mem time407, current time 418, horizon 11\n", - "adding: mem time408, current time 418, horizon 10\n", - "adding: mem time409, current time 418, horizon 9\n", - "adding: mem time410, current time 418, horizon 8\n", - "adding: mem time411, current time 418, horizon 7\n", - "adding: mem time412, current time 418, horizon 6\n", - "adding: mem time413, current time 418, horizon 5\n", - "adding: mem time414, current time 418, horizon 4\n", - "adding: mem time415, current time 418, horizon 3\n", - "adding: mem time416, current time 418, horizon 2\n", - "adding: mem time417, current time 418, horizon 1\n", - "adding: mem time400, current time 419, horizon 19\n", - "adding: mem time401, current time 419, horizon 18\n", - "adding: mem time402, current time 419, horizon 17\n", - "adding: mem time403, current time 419, horizon 16\n", - "adding: mem time404, current time 419, horizon 15\n", - "adding: mem time405, current time 419, horizon 14\n", - "adding: mem time406, current time 419, horizon 13\n", - "adding: mem time407, current time 419, horizon 12\n", - "adding: mem time408, current time 419, horizon 11\n", - "adding: mem time409, current time 419, horizon 10\n", - "adding: mem time410, current time 419, horizon 9\n", - "adding: mem time411, current time 419, horizon 8\n", - "adding: mem time412, current time 419, horizon 7\n", - "adding: mem time413, current time 419, horizon 6\n", - "adding: mem time414, current time 419, horizon 5\n", - "adding: mem time415, current time 419, horizon 4\n", - "adding: mem time416, current time 419, horizon 3\n", - "adding: mem time417, current time 419, horizon 2\n", - "adding: mem time418, current time 419, horizon 1\n", - "adding: mem time400, current time 420, horizon 20\n", - "adding: mem time401, current time 420, horizon 19\n", - "adding: mem time402, current time 420, horizon 18\n", - "adding: mem time403, current time 420, horizon 17\n", - "adding: mem time404, current time 420, horizon 16\n", - "adding: mem time405, current time 420, horizon 15\n", - "adding: mem time406, current time 420, horizon 14\n", - "adding: mem time407, current time 420, horizon 13\n", - "adding: mem time408, current time 420, horizon 12\n", - "adding: mem time409, current time 420, horizon 11\n", - "adding: mem time410, current time 420, horizon 10\n", - "adding: mem time411, current time 420, horizon 9\n", - "adding: mem time412, current time 420, horizon 8\n", - "adding: mem time413, current time 420, horizon 7\n", - "adding: mem time414, current time 420, horizon 6\n", - "adding: mem time415, current time 420, horizon 5\n", - "adding: mem time416, current time 420, horizon 4\n", - "adding: mem time417, current time 420, horizon 3\n", - "adding: mem time418, current time 420, horizon 2\n", - "adding: mem time419, current time 420, horizon 1\n", - "adding: mem time400, current time 421, horizon 21\n", - "adding: mem time401, current time 421, horizon 20\n", - "adding: mem time402, current time 421, horizon 19\n", - "adding: mem time403, current time 421, horizon 18\n", - "adding: mem time404, current time 421, horizon 17\n", - "adding: mem time405, current time 421, horizon 16\n", - "adding: mem time406, current time 421, horizon 15\n", - "adding: mem time407, current time 421, horizon 14\n", - "adding: mem time408, current time 421, horizon 13\n", - "adding: mem time409, current time 421, horizon 12\n", - "adding: mem time410, current time 421, horizon 11\n", - "adding: mem time411, current time 421, horizon 10\n", - "adding: mem time412, current time 421, horizon 9\n", - "adding: mem time413, current time 421, horizon 8\n", - "adding: mem time414, current time 421, horizon 7\n", - "adding: mem time415, current time 421, horizon 6\n", - "adding: mem time416, current time 421, horizon 5\n", - "adding: mem time417, current time 421, horizon 4\n", - "adding: mem time418, current time 421, horizon 3\n", - "adding: mem time419, current time 421, horizon 2\n", - "adding: mem time420, current time 421, horizon 1\n", - "adding: mem time400, current time 422, horizon 22\n", - "adding: mem time401, current time 422, horizon 21\n", - "adding: mem time402, current time 422, horizon 20\n", - "adding: mem time403, current time 422, horizon 19\n", - "adding: mem time404, current time 422, horizon 18\n", - "adding: mem time405, current time 422, horizon 17\n", - "adding: mem time406, current time 422, horizon 16\n", - "adding: mem time407, current time 422, horizon 15\n", - "adding: mem time408, current time 422, horizon 14\n", - "adding: mem time409, current time 422, horizon 13\n", - "adding: mem time410, current time 422, horizon 12\n", - "adding: mem time411, current time 422, horizon 11\n", - "adding: mem time412, current time 422, horizon 10\n", - "adding: mem time413, current time 422, horizon 9\n", - "adding: mem time414, current time 422, horizon 8\n", - "adding: mem time415, current time 422, horizon 7\n", - "adding: mem time416, current time 422, horizon 6\n", - "adding: mem time417, current time 422, horizon 5\n", - "adding: mem time418, current time 422, horizon 4\n", - "adding: mem time419, current time 422, horizon 3\n", - "adding: mem time420, current time 422, horizon 2\n", - "adding: mem time421, current time 422, horizon 1\n", - "adding: mem time400, current time 423, horizon 23\n", - "adding: mem time401, current time 423, horizon 22\n", - "adding: mem time402, current time 423, horizon 21\n", - "adding: mem time403, current time 423, horizon 20\n", - "adding: mem time404, current time 423, horizon 19\n", - "adding: mem time405, current time 423, horizon 18\n", - "adding: mem time406, current time 423, horizon 17\n", - "adding: mem time407, current time 423, horizon 16\n", - "adding: mem time408, current time 423, horizon 15\n", - "adding: mem time409, current time 423, horizon 14\n", - "adding: mem time410, current time 423, horizon 13\n", - "adding: mem time411, current time 423, horizon 12\n", - "adding: mem time412, current time 423, horizon 11\n", - "adding: mem time413, current time 423, horizon 10\n", - "adding: mem time414, current time 423, horizon 9\n", - "adding: mem time415, current time 423, horizon 8\n", - "adding: mem time416, current time 423, horizon 7\n", - "adding: mem time417, current time 423, horizon 6\n", - "adding: mem time418, current time 423, horizon 5\n", - "adding: mem time419, current time 423, horizon 4\n", - "adding: mem time420, current time 423, horizon 3\n", - "adding: mem time421, current time 423, horizon 2\n", - "adding: mem time422, current time 423, horizon 1\n", - "adding: mem time400, current time 424, horizon 24\n", - "adding: mem time401, current time 424, horizon 23\n", - "adding: mem time402, current time 424, horizon 22\n", - "adding: mem time403, current time 424, horizon 21\n", - "adding: mem time404, current time 424, horizon 20\n", - "adding: mem time405, current time 424, horizon 19\n", - "adding: mem time406, current time 424, horizon 18\n", - "adding: mem time407, current time 424, horizon 17\n", - "adding: mem time408, current time 424, horizon 16\n", - "adding: mem time409, current time 424, horizon 15\n", - "adding: mem time410, current time 424, horizon 14\n", - "adding: mem time411, current time 424, horizon 13\n", - "adding: mem time412, current time 424, horizon 12\n", - "adding: mem time413, current time 424, horizon 11\n", - "adding: mem time414, current time 424, horizon 10\n", - "adding: mem time415, current time 424, horizon 9\n", - "adding: mem time416, current time 424, horizon 8\n", - "adding: mem time417, current time 424, horizon 7\n", - "adding: mem time418, current time 424, horizon 6\n", - "adding: mem time419, current time 424, horizon 5\n", - "adding: mem time420, current time 424, horizon 4\n", - "adding: mem time421, current time 424, horizon 3\n", - "adding: mem time422, current time 424, horizon 2\n", - "adding: mem time423, current time 424, horizon 1\n", - "adding: mem time400, current time 425, horizon 25\n", - "adding: mem time401, current time 425, horizon 24\n", - "adding: mem time402, current time 425, horizon 23\n", - "adding: mem time403, current time 425, horizon 22\n", - "adding: mem time404, current time 425, horizon 21\n", - "adding: mem time405, current time 425, horizon 20\n", - "adding: mem time406, current time 425, horizon 19\n", - "adding: mem time407, current time 425, horizon 18\n", - "adding: mem time408, current time 425, horizon 17\n", - "adding: mem time409, current time 425, horizon 16\n", - "adding: mem time410, current time 425, horizon 15\n", - "adding: mem time411, current time 425, horizon 14\n", - "adding: mem time412, current time 425, horizon 13\n", - "adding: mem time413, current time 425, horizon 12\n", - "adding: mem time414, current time 425, horizon 11\n", - "adding: mem time415, current time 425, horizon 10\n", - "adding: mem time416, current time 425, horizon 9\n", - "adding: mem time417, current time 425, horizon 8\n", - "adding: mem time418, current time 425, horizon 7\n", - "adding: mem time419, current time 425, horizon 6\n", - "adding: mem time420, current time 425, horizon 5\n", - "adding: mem time421, current time 425, horizon 4\n", - "adding: mem time422, current time 425, horizon 3\n", - "adding: mem time423, current time 425, horizon 2\n", - "adding: mem time424, current time 425, horizon 1\n", - "adding: mem time400, current time 426, horizon 26\n", - "adding: mem time401, current time 426, horizon 25\n", - "adding: mem time402, current time 426, horizon 24\n", - "adding: mem time403, current time 426, horizon 23\n", - "adding: mem time404, current time 426, horizon 22\n", - "adding: mem time405, current time 426, horizon 21\n", - "adding: mem time406, current time 426, horizon 20\n", - "adding: mem time407, current time 426, horizon 19\n", - "adding: mem time408, current time 426, horizon 18\n", - "adding: mem time409, current time 426, horizon 17\n", - "adding: mem time410, current time 426, horizon 16\n", - "adding: mem time411, current time 426, horizon 15\n", - "adding: mem time412, current time 426, horizon 14\n", - "adding: mem time413, current time 426, horizon 13\n", - "adding: mem time414, current time 426, horizon 12\n", - "adding: mem time415, current time 426, horizon 11\n", - "adding: mem time416, current time 426, horizon 10\n", - "adding: mem time417, current time 426, horizon 9\n", - "adding: mem time418, current time 426, horizon 8\n", - "adding: mem time419, current time 426, horizon 7\n", - "adding: mem time420, current time 426, horizon 6\n", - "adding: mem time421, current time 426, horizon 5\n", - "adding: mem time422, current time 426, horizon 4\n", - "adding: mem time423, current time 426, horizon 3\n", - "adding: mem time424, current time 426, horizon 2\n", - "adding: mem time425, current time 426, horizon 1\n", - "adding: mem time400, current time 427, horizon 27\n", - "adding: mem time401, current time 427, horizon 26\n", - "adding: mem time402, current time 427, horizon 25\n", - "adding: mem time403, current time 427, horizon 24\n", - "adding: mem time404, current time 427, horizon 23\n", - "adding: mem time405, current time 427, horizon 22\n", - "adding: mem time406, current time 427, horizon 21\n", - "adding: mem time407, current time 427, horizon 20\n", - "adding: mem time408, current time 427, horizon 19\n", - "adding: mem time409, current time 427, horizon 18\n", - "adding: mem time410, current time 427, horizon 17\n", - "adding: mem time411, current time 427, horizon 16\n", - "adding: mem time412, current time 427, horizon 15\n", - "adding: mem time413, current time 427, horizon 14\n", - "adding: mem time414, current time 427, horizon 13\n", - "adding: mem time415, current time 427, horizon 12\n", - "adding: mem time416, current time 427, horizon 11\n", - "adding: mem time417, current time 427, horizon 10\n", - "adding: mem time418, current time 427, horizon 9\n", - "adding: mem time419, current time 427, horizon 8\n", - "adding: mem time420, current time 427, horizon 7\n", - "adding: mem time421, current time 427, horizon 6\n", - "adding: mem time422, current time 427, horizon 5\n", - "adding: mem time423, current time 427, horizon 4\n", - "adding: mem time424, current time 427, horizon 3\n", - "adding: mem time425, current time 427, horizon 2\n", - "adding: mem time426, current time 427, horizon 1\n", - "adding: mem time400, current time 428, horizon 28\n", - "adding: mem time401, current time 428, horizon 27\n", - "adding: mem time402, current time 428, horizon 26\n", - "adding: mem time403, current time 428, horizon 25\n", - "adding: mem time404, current time 428, horizon 24\n", - "adding: mem time405, current time 428, horizon 23\n", - "adding: mem time406, current time 428, horizon 22\n", - "adding: mem time407, current time 428, horizon 21\n", - "adding: mem time408, current time 428, horizon 20\n", - "adding: mem time409, current time 428, horizon 19\n", - "adding: mem time410, current time 428, horizon 18\n", - "adding: mem time411, current time 428, horizon 17\n", - "adding: mem time412, current time 428, horizon 16\n", - "adding: mem time413, current time 428, horizon 15\n", - "adding: mem time414, current time 428, horizon 14\n", - "adding: mem time415, current time 428, horizon 13\n", - "adding: mem time416, current time 428, horizon 12\n", - "adding: mem time417, current time 428, horizon 11\n", - "adding: mem time418, current time 428, horizon 10\n", - "adding: mem time419, current time 428, horizon 9\n", - "adding: mem time420, current time 428, horizon 8\n", - "adding: mem time421, current time 428, horizon 7\n", - "adding: mem time422, current time 428, horizon 6\n", - "adding: mem time423, current time 428, horizon 5\n", - "adding: mem time424, current time 428, horizon 4\n", - "adding: mem time425, current time 428, horizon 3\n", - "adding: mem time426, current time 428, horizon 2\n", - "adding: mem time427, current time 428, horizon 1\n", - "adding: mem time400, current time 429, horizon 29\n", - "adding: mem time401, current time 429, horizon 28\n", - "adding: mem time402, current time 429, horizon 27\n", - "adding: mem time403, current time 429, horizon 26\n", - "adding: mem time404, current time 429, horizon 25\n", - "adding: mem time405, current time 429, horizon 24\n", - "adding: mem time406, current time 429, horizon 23\n", - "adding: mem time407, current time 429, horizon 22\n", - "adding: mem time408, current time 429, horizon 21\n", - "adding: mem time409, current time 429, horizon 20\n", - "adding: mem time410, current time 429, horizon 19\n", - "adding: mem time411, current time 429, horizon 18\n", - "adding: mem time412, current time 429, horizon 17\n", - "adding: mem time413, current time 429, horizon 16\n", - "adding: mem time414, current time 429, horizon 15\n", - "adding: mem time415, current time 429, horizon 14\n", - "adding: mem time416, current time 429, horizon 13\n", - "adding: mem time417, current time 429, horizon 12\n", - "adding: mem time418, current time 429, horizon 11\n", - "adding: mem time419, current time 429, horizon 10\n", - "adding: mem time420, current time 429, horizon 9\n", - "adding: mem time421, current time 429, horizon 8\n", - "adding: mem time422, current time 429, horizon 7\n", - "adding: mem time423, current time 429, horizon 6\n", - "adding: mem time424, current time 429, horizon 5\n", - "adding: mem time425, current time 429, horizon 4\n", - "adding: mem time426, current time 429, horizon 3\n", - "adding: mem time427, current time 429, horizon 2\n", - "adding: mem time428, current time 429, horizon 1\n", - "adding: mem time400, current time 430, horizon 30\n", - "adding: mem time401, current time 430, horizon 29\n", - "adding: mem time402, current time 430, horizon 28\n", - "adding: mem time403, current time 430, horizon 27\n", - "adding: mem time404, current time 430, horizon 26\n", - "adding: mem time405, current time 430, horizon 25\n", - "adding: mem time406, current time 430, horizon 24\n", - "adding: mem time407, current time 430, horizon 23\n", - "adding: mem time408, current time 430, horizon 22\n", - "adding: mem time409, current time 430, horizon 21\n", - "adding: mem time410, current time 430, horizon 20\n", - "adding: mem time411, current time 430, horizon 19\n", - "adding: mem time412, current time 430, horizon 18\n", - "adding: mem time413, current time 430, horizon 17\n", - "adding: mem time414, current time 430, horizon 16\n", - "adding: mem time415, current time 430, horizon 15\n", - "adding: mem time416, current time 430, horizon 14\n", - "adding: mem time417, current time 430, horizon 13\n", - "adding: mem time418, current time 430, horizon 12\n", - "adding: mem time419, current time 430, horizon 11\n", - "adding: mem time420, current time 430, horizon 10\n", - "adding: mem time421, current time 430, horizon 9\n", - "adding: mem time422, current time 430, horizon 8\n", - "adding: mem time423, current time 430, horizon 7\n", - "adding: mem time424, current time 430, horizon 6\n", - "adding: mem time425, current time 430, horizon 5\n", - "adding: mem time426, current time 430, horizon 4\n", - "adding: mem time427, current time 430, horizon 3\n", - "adding: mem time428, current time 430, horizon 2\n", - "adding: mem time429, current time 430, horizon 1\n", - "adding: mem time400, current time 431, horizon 31\n", - "adding: mem time401, current time 431, horizon 30\n", - "adding: mem time402, current time 431, horizon 29\n", - "adding: mem time403, current time 431, horizon 28\n", - "adding: mem time404, current time 431, horizon 27\n", - "adding: mem time405, current time 431, horizon 26\n", - "adding: mem time406, current time 431, horizon 25\n", - "adding: mem time407, current time 431, horizon 24\n", - "adding: mem time408, current time 431, horizon 23\n", - "adding: mem time409, current time 431, horizon 22\n", - "adding: mem time410, current time 431, horizon 21\n", - "adding: mem time411, current time 431, horizon 20\n", - "adding: mem time412, current time 431, horizon 19\n", - "adding: mem time413, current time 431, horizon 18\n", - "adding: mem time414, current time 431, horizon 17\n", - "adding: mem time415, current time 431, horizon 16\n", - "adding: mem time416, current time 431, horizon 15\n", - "adding: mem time417, current time 431, horizon 14\n", - "adding: mem time418, current time 431, horizon 13\n", - "adding: mem time419, current time 431, horizon 12\n", - "adding: mem time420, current time 431, horizon 11\n", - "adding: mem time421, current time 431, horizon 10\n", - "adding: mem time422, current time 431, horizon 9\n", - "adding: mem time423, current time 431, horizon 8\n", - "adding: mem time424, current time 431, horizon 7\n", - "adding: mem time425, current time 431, horizon 6\n", - "adding: mem time426, current time 431, horizon 5\n", - "adding: mem time427, current time 431, horizon 4\n", - "adding: mem time428, current time 431, horizon 3\n", - "adding: mem time429, current time 431, horizon 2\n", - "adding: mem time430, current time 431, horizon 1\n", - "adding: mem time400, current time 432, horizon 32\n", - "adding: mem time401, current time 432, horizon 31\n", - "adding: mem time402, current time 432, horizon 30\n", - "adding: mem time403, current time 432, horizon 29\n", - "adding: mem time404, current time 432, horizon 28\n", - "adding: mem time405, current time 432, horizon 27\n", - "adding: mem time406, current time 432, horizon 26\n", - "adding: mem time407, current time 432, horizon 25\n", - "adding: mem time408, current time 432, horizon 24\n", - "adding: mem time409, current time 432, horizon 23\n", - "adding: mem time410, current time 432, horizon 22\n", - "adding: mem time411, current time 432, horizon 21\n", - "adding: mem time412, current time 432, horizon 20\n", - "adding: mem time413, current time 432, horizon 19\n", - "adding: mem time414, current time 432, horizon 18\n", - "adding: mem time415, current time 432, horizon 17\n", - "adding: mem time416, current time 432, horizon 16\n", - "adding: mem time417, current time 432, horizon 15\n", - "adding: mem time418, current time 432, horizon 14\n", - "adding: mem time419, current time 432, horizon 13\n", - "adding: mem time420, current time 432, horizon 12\n", - "adding: mem time421, current time 432, horizon 11\n", - "adding: mem time422, current time 432, horizon 10\n", - "adding: mem time423, current time 432, horizon 9\n", - "adding: mem time424, current time 432, horizon 8\n", - "adding: mem time425, current time 432, horizon 7\n", - "adding: mem time426, current time 432, horizon 6\n", - "adding: mem time427, current time 432, horizon 5\n", - "adding: mem time428, current time 432, horizon 4\n", - "adding: mem time429, current time 432, horizon 3\n", - "adding: mem time430, current time 432, horizon 2\n", - "adding: mem time431, current time 432, horizon 1\n", - "adding: mem time400, current time 433, horizon 33\n", - "adding: mem time401, current time 433, horizon 32\n", - "adding: mem time402, current time 433, horizon 31\n", - "adding: mem time403, current time 433, horizon 30\n", - "adding: mem time404, current time 433, horizon 29\n", - "adding: mem time405, current time 433, horizon 28\n", - "adding: mem time406, current time 433, horizon 27\n", - "adding: mem time407, current time 433, horizon 26\n", - "adding: mem time408, current time 433, horizon 25\n", - "adding: mem time409, current time 433, horizon 24\n", - "adding: mem time410, current time 433, horizon 23\n", - "adding: mem time411, current time 433, horizon 22\n", - "adding: mem time412, current time 433, horizon 21\n", - "adding: mem time413, current time 433, horizon 20\n", - "adding: mem time414, current time 433, horizon 19\n", - "adding: mem time415, current time 433, horizon 18\n", - "adding: mem time416, current time 433, horizon 17\n", - "adding: mem time417, current time 433, horizon 16\n", - "adding: mem time418, current time 433, horizon 15\n", - "adding: mem time419, current time 433, horizon 14\n", - "adding: mem time420, current time 433, horizon 13\n", - "adding: mem time421, current time 433, horizon 12\n", - "adding: mem time422, current time 433, horizon 11\n", - "adding: mem time423, current time 433, horizon 10\n", - "adding: mem time424, current time 433, horizon 9\n", - "adding: mem time425, current time 433, horizon 8\n", - "adding: mem time426, current time 433, horizon 7\n", - "adding: mem time427, current time 433, horizon 6\n", - "adding: mem time428, current time 433, horizon 5\n", - "adding: mem time429, current time 433, horizon 4\n", - "adding: mem time430, current time 433, horizon 3\n", - "adding: mem time431, current time 433, horizon 2\n", - "adding: mem time432, current time 433, horizon 1\n", - "adding: mem time400, current time 434, horizon 34\n", - "adding: mem time401, current time 434, horizon 33\n", - "adding: mem time402, current time 434, horizon 32\n", - "adding: mem time403, current time 434, horizon 31\n", - "adding: mem time404, current time 434, horizon 30\n", - "adding: mem time405, current time 434, horizon 29\n", - "adding: mem time406, current time 434, horizon 28\n", - "adding: mem time407, current time 434, horizon 27\n", - "adding: mem time408, current time 434, horizon 26\n", - "adding: mem time409, current time 434, horizon 25\n", - "adding: mem time410, current time 434, horizon 24\n", - "adding: mem time411, current time 434, horizon 23\n", - "adding: mem time412, current time 434, horizon 22\n", - "adding: mem time413, current time 434, horizon 21\n", - "adding: mem time414, current time 434, horizon 20\n", - "adding: mem time415, current time 434, horizon 19\n", - "adding: mem time416, current time 434, horizon 18\n", - "adding: mem time417, current time 434, horizon 17\n", - "adding: mem time418, current time 434, horizon 16\n", - "adding: mem time419, current time 434, horizon 15\n", - "adding: mem time420, current time 434, horizon 14\n", - "adding: mem time421, current time 434, horizon 13\n", - "adding: mem time422, current time 434, horizon 12\n", - "adding: mem time423, current time 434, horizon 11\n", - "adding: mem time424, current time 434, horizon 10\n", - "adding: mem time425, current time 434, horizon 9\n", - "adding: mem time426, current time 434, horizon 8\n", - "adding: mem time427, current time 434, horizon 7\n", - "adding: mem time428, current time 434, horizon 6\n", - "adding: mem time429, current time 434, horizon 5\n", - "adding: mem time430, current time 434, horizon 4\n", - "adding: mem time431, current time 434, horizon 3\n", - "adding: mem time432, current time 434, horizon 2\n", - "adding: mem time433, current time 434, horizon 1\n", - "adding: mem time400, current time 435, horizon 35\n", - "adding: mem time401, current time 435, horizon 34\n", - "adding: mem time402, current time 435, horizon 33\n", - "adding: mem time403, current time 435, horizon 32\n", - "adding: mem time404, current time 435, horizon 31\n", - "adding: mem time405, current time 435, horizon 30\n", - "adding: mem time406, current time 435, horizon 29\n", - "adding: mem time407, current time 435, horizon 28\n", - "adding: mem time408, current time 435, horizon 27\n", - "adding: mem time409, current time 435, horizon 26\n", - "adding: mem time410, current time 435, horizon 25\n", - "adding: mem time411, current time 435, horizon 24\n", - "adding: mem time412, current time 435, horizon 23\n", - "adding: mem time413, current time 435, horizon 22\n", - "adding: mem time414, current time 435, horizon 21\n", - "adding: mem time415, current time 435, horizon 20\n", - "adding: mem time416, current time 435, horizon 19\n", - "adding: mem time417, current time 435, horizon 18\n", - "adding: mem time418, current time 435, horizon 17\n", - "adding: mem time419, current time 435, horizon 16\n", - "adding: mem time420, current time 435, horizon 15\n", - "adding: mem time421, current time 435, horizon 14\n", - "adding: mem time422, current time 435, horizon 13\n", - "adding: mem time423, current time 435, horizon 12\n", - "adding: mem time424, current time 435, horizon 11\n", - "adding: mem time425, current time 435, horizon 10\n", - "adding: mem time426, current time 435, horizon 9\n", - "adding: mem time427, current time 435, horizon 8\n", - "adding: mem time428, current time 435, horizon 7\n", - "adding: mem time429, current time 435, horizon 6\n", - "adding: mem time430, current time 435, horizon 5\n", - "adding: mem time431, current time 435, horizon 4\n", - "adding: mem time432, current time 435, horizon 3\n", - "adding: mem time433, current time 435, horizon 2\n", - "adding: mem time434, current time 435, horizon 1\n", - "adding: mem time400, current time 436, horizon 36\n", - "adding: mem time401, current time 436, horizon 35\n", - "adding: mem time402, current time 436, horizon 34\n", - "adding: mem time403, current time 436, horizon 33\n", - "adding: mem time404, current time 436, horizon 32\n", - "adding: mem time405, current time 436, horizon 31\n", - "adding: mem time406, current time 436, horizon 30\n", - "adding: mem time407, current time 436, horizon 29\n", - "adding: mem time408, current time 436, horizon 28\n", - "adding: mem time409, current time 436, horizon 27\n", - "adding: mem time410, current time 436, horizon 26\n", - "adding: mem time411, current time 436, horizon 25\n", - "adding: mem time412, current time 436, horizon 24\n", - "adding: mem time413, current time 436, horizon 23\n", - "adding: mem time414, current time 436, horizon 22\n", - "adding: mem time415, current time 436, horizon 21\n", - "adding: mem time416, current time 436, horizon 20\n", - "adding: mem time417, current time 436, horizon 19\n", - "adding: mem time418, current time 436, horizon 18\n", - "adding: mem time419, current time 436, horizon 17\n", - "adding: mem time420, current time 436, horizon 16\n", - "adding: mem time421, current time 436, horizon 15\n", - "adding: mem time422, current time 436, horizon 14\n", - "adding: mem time423, current time 436, horizon 13\n", - "adding: mem time424, current time 436, horizon 12\n", - "adding: mem time425, current time 436, horizon 11\n", - "adding: mem time426, current time 436, horizon 10\n", - "adding: mem time427, current time 436, horizon 9\n", - "adding: mem time428, current time 436, horizon 8\n", - "adding: mem time429, current time 436, horizon 7\n", - "adding: mem time430, current time 436, horizon 6\n", - "adding: mem time431, current time 436, horizon 5\n", - "adding: mem time432, current time 436, horizon 4\n", - "adding: mem time433, current time 436, horizon 3\n", - "adding: mem time434, current time 436, horizon 2\n", - "adding: mem time435, current time 436, horizon 1\n", - "adding: mem time400, current time 437, horizon 37\n", - "adding: mem time401, current time 437, horizon 36\n", - "adding: mem time402, current time 437, horizon 35\n", - "adding: mem time403, current time 437, horizon 34\n", - "adding: mem time404, current time 437, horizon 33\n", - "adding: mem time405, current time 437, horizon 32\n", - "adding: mem time406, current time 437, horizon 31\n", - "adding: mem time407, current time 437, horizon 30\n", - "adding: mem time408, current time 437, horizon 29\n", - "adding: mem time409, current time 437, horizon 28\n", - "adding: mem time410, current time 437, horizon 27\n", - "adding: mem time411, current time 437, horizon 26\n", - "adding: mem time412, current time 437, horizon 25\n", - "adding: mem time413, current time 437, horizon 24\n", - "adding: mem time414, current time 437, horizon 23\n", - "adding: mem time415, current time 437, horizon 22\n", - "adding: mem time416, current time 437, horizon 21\n", - "adding: mem time417, current time 437, horizon 20\n", - "adding: mem time418, current time 437, horizon 19\n", - "adding: mem time419, current time 437, horizon 18\n", - "adding: mem time420, current time 437, horizon 17\n", - "adding: mem time421, current time 437, horizon 16\n", - "adding: mem time422, current time 437, horizon 15\n", - "adding: mem time423, current time 437, horizon 14\n", - "adding: mem time424, current time 437, horizon 13\n", - "adding: mem time425, current time 437, horizon 12\n", - "adding: mem time426, current time 437, horizon 11\n", - "adding: mem time427, current time 437, horizon 10\n", - "adding: mem time428, current time 437, horizon 9\n", - "adding: mem time429, current time 437, horizon 8\n", - "adding: mem time430, current time 437, horizon 7\n", - "adding: mem time431, current time 437, horizon 6\n", - "adding: mem time432, current time 437, horizon 5\n", - "adding: mem time433, current time 437, horizon 4\n", - "adding: mem time434, current time 437, horizon 3\n", - "adding: mem time435, current time 437, horizon 2\n", - "adding: mem time436, current time 437, horizon 1\n", - "adding: mem time400, current time 438, horizon 38\n", - "adding: mem time401, current time 438, horizon 37\n", - "adding: mem time402, current time 438, horizon 36\n", - "adding: mem time403, current time 438, horizon 35\n", - "adding: mem time404, current time 438, horizon 34\n", - "adding: mem time405, current time 438, horizon 33\n", - "adding: mem time406, current time 438, horizon 32\n", - "adding: mem time407, current time 438, horizon 31\n", - "adding: mem time408, current time 438, horizon 30\n", - "adding: mem time409, current time 438, horizon 29\n", - "adding: mem time410, current time 438, horizon 28\n", - "adding: mem time411, current time 438, horizon 27\n", - "adding: mem time412, current time 438, horizon 26\n", - "adding: mem time413, current time 438, horizon 25\n", - "adding: mem time414, current time 438, horizon 24\n", - "adding: mem time415, current time 438, horizon 23\n", - "adding: mem time416, current time 438, horizon 22\n", - "adding: mem time417, current time 438, horizon 21\n", - "adding: mem time418, current time 438, horizon 20\n", - "adding: mem time419, current time 438, horizon 19\n", - "adding: mem time420, current time 438, horizon 18\n", - "adding: mem time421, current time 438, horizon 17\n", - "adding: mem time422, current time 438, horizon 16\n", - "adding: mem time423, current time 438, horizon 15\n", - "adding: mem time424, current time 438, horizon 14\n", - "adding: mem time425, current time 438, horizon 13\n", - "adding: mem time426, current time 438, horizon 12\n", - "adding: mem time427, current time 438, horizon 11\n", - "adding: mem time428, current time 438, horizon 10\n", - "adding: mem time429, current time 438, horizon 9\n", - "adding: mem time430, current time 438, horizon 8\n", - "adding: mem time431, current time 438, horizon 7\n", - "adding: mem time432, current time 438, horizon 6\n", - "adding: mem time433, current time 438, horizon 5\n", - "adding: mem time434, current time 438, horizon 4\n", - "adding: mem time435, current time 438, horizon 3\n", - "adding: mem time436, current time 438, horizon 2\n", - "adding: mem time437, current time 438, horizon 1\n", - "adding: mem time400, current time 439, horizon 39\n", - "adding: mem time401, current time 439, horizon 38\n", - "adding: mem time402, current time 439, horizon 37\n", - "adding: mem time403, current time 439, horizon 36\n", - "adding: mem time404, current time 439, horizon 35\n", - "adding: mem time405, current time 439, horizon 34\n", - "adding: mem time406, current time 439, horizon 33\n", - "adding: mem time407, current time 439, horizon 32\n", - "adding: mem time408, current time 439, horizon 31\n", - "adding: mem time409, current time 439, horizon 30\n", - "adding: mem time410, current time 439, horizon 29\n", - "adding: mem time411, current time 439, horizon 28\n", - "adding: mem time412, current time 439, horizon 27\n", - "adding: mem time413, current time 439, horizon 26\n", - "adding: mem time414, current time 439, horizon 25\n", - "adding: mem time415, current time 439, horizon 24\n", - "adding: mem time416, current time 439, horizon 23\n", - "adding: mem time417, current time 439, horizon 22\n", - "adding: mem time418, current time 439, horizon 21\n", - "adding: mem time419, current time 439, horizon 20\n", - "adding: mem time420, current time 439, horizon 19\n", - "adding: mem time421, current time 439, horizon 18\n", - "adding: mem time422, current time 439, horizon 17\n", - "adding: mem time423, current time 439, horizon 16\n", - "adding: mem time424, current time 439, horizon 15\n", - "adding: mem time425, current time 439, horizon 14\n", - "adding: mem time426, current time 439, horizon 13\n", - "adding: mem time427, current time 439, horizon 12\n", - "adding: mem time428, current time 439, horizon 11\n", - "adding: mem time429, current time 439, horizon 10\n", - "adding: mem time430, current time 439, horizon 9\n", - "adding: mem time431, current time 439, horizon 8\n", - "adding: mem time432, current time 439, horizon 7\n", - "adding: mem time433, current time 439, horizon 6\n", - "adding: mem time434, current time 439, horizon 5\n", - "adding: mem time435, current time 439, horizon 4\n", - "adding: mem time436, current time 439, horizon 3\n", - "adding: mem time437, current time 439, horizon 2\n", - "adding: mem time438, current time 439, horizon 1\n", - "adding: mem time400, current time 440, horizon 40\n", - "adding: mem time401, current time 440, horizon 39\n", - "adding: mem time402, current time 440, horizon 38\n", - "adding: mem time403, current time 440, horizon 37\n", - "adding: mem time404, current time 440, horizon 36\n", - "adding: mem time405, current time 440, horizon 35\n", - "adding: mem time406, current time 440, horizon 34\n", - "adding: mem time407, current time 440, horizon 33\n", - "adding: mem time408, current time 440, horizon 32\n", - "adding: mem time409, current time 440, horizon 31\n", - "adding: mem time410, current time 440, horizon 30\n", - "adding: mem time411, current time 440, horizon 29\n", - "adding: mem time412, current time 440, horizon 28\n", - "adding: mem time413, current time 440, horizon 27\n", - "adding: mem time414, current time 440, horizon 26\n", - "adding: mem time415, current time 440, horizon 25\n", - "adding: mem time416, current time 440, horizon 24\n", - "adding: mem time417, current time 440, horizon 23\n", - "adding: mem time418, current time 440, horizon 22\n", - "adding: mem time419, current time 440, horizon 21\n", - "adding: mem time420, current time 440, horizon 20\n", - "adding: mem time421, current time 440, horizon 19\n", - "adding: mem time422, current time 440, horizon 18\n", - "adding: mem time423, current time 440, horizon 17\n", - "adding: mem time424, current time 440, horizon 16\n", - "adding: mem time425, current time 440, horizon 15\n", - "adding: mem time426, current time 440, horizon 14\n", - "adding: mem time427, current time 440, horizon 13\n", - "adding: mem time428, current time 440, horizon 12\n", - "adding: mem time429, current time 440, horizon 11\n", - "adding: mem time430, current time 440, horizon 10\n", - "adding: mem time431, current time 440, horizon 9\n", - "adding: mem time432, current time 440, horizon 8\n", - "adding: mem time433, current time 440, horizon 7\n", - "adding: mem time434, current time 440, horizon 6\n", - "adding: mem time435, current time 440, horizon 5\n", - "adding: mem time436, current time 440, horizon 4\n", - "adding: mem time437, current time 440, horizon 3\n", - "adding: mem time438, current time 440, horizon 2\n", - "adding: mem time439, current time 440, horizon 1\n", - "adding: mem time400, current time 441, horizon 41\n", - "adding: mem time401, current time 441, horizon 40\n", - "adding: mem time402, current time 441, horizon 39\n", - "adding: mem time403, current time 441, horizon 38\n", - "adding: mem time404, current time 441, horizon 37\n", - "adding: mem time405, current time 441, horizon 36\n", - "adding: mem time406, current time 441, horizon 35\n", - "adding: mem time407, current time 441, horizon 34\n", - "adding: mem time408, current time 441, horizon 33\n", - "adding: mem time409, current time 441, horizon 32\n", - "adding: mem time410, current time 441, horizon 31\n", - "adding: mem time411, current time 441, horizon 30\n", - "adding: mem time412, current time 441, horizon 29\n", - "adding: mem time413, current time 441, horizon 28\n", - "adding: mem time414, current time 441, horizon 27\n", - "adding: mem time415, current time 441, horizon 26\n", - "adding: mem time416, current time 441, horizon 25\n", - "adding: mem time417, current time 441, horizon 24\n", - "adding: mem time418, current time 441, horizon 23\n", - "adding: mem time419, current time 441, horizon 22\n", - "adding: mem time420, current time 441, horizon 21\n", - "adding: mem time421, current time 441, horizon 20\n", - "adding: mem time422, current time 441, horizon 19\n", - "adding: mem time423, current time 441, horizon 18\n", - "adding: mem time424, current time 441, horizon 17\n", - "adding: mem time425, current time 441, horizon 16\n", - "adding: mem time426, current time 441, horizon 15\n", - "adding: mem time427, current time 441, horizon 14\n", - "adding: mem time428, current time 441, horizon 13\n", - "adding: mem time429, current time 441, horizon 12\n", - "adding: mem time430, current time 441, horizon 11\n", - "adding: mem time431, current time 441, horizon 10\n", - "adding: mem time432, current time 441, horizon 9\n", - "adding: mem time433, current time 441, horizon 8\n", - "adding: mem time434, current time 441, horizon 7\n", - "adding: mem time435, current time 441, horizon 6\n", - "adding: mem time436, current time 441, horizon 5\n", - "adding: mem time437, current time 441, horizon 4\n", - "adding: mem time438, current time 441, horizon 3\n", - "adding: mem time439, current time 441, horizon 2\n", - "adding: mem time440, current time 441, horizon 1\n", - "adding: mem time400, current time 442, horizon 42\n", - "adding: mem time401, current time 442, horizon 41\n", - "adding: mem time402, current time 442, horizon 40\n", - "adding: mem time403, current time 442, horizon 39\n", - "adding: mem time404, current time 442, horizon 38\n", - "adding: mem time405, current time 442, horizon 37\n", - "adding: mem time406, current time 442, horizon 36\n", - "adding: mem time407, current time 442, horizon 35\n", - "adding: mem time408, current time 442, horizon 34\n", - "adding: mem time409, current time 442, horizon 33\n", - "adding: mem time410, current time 442, horizon 32\n", - "adding: mem time411, current time 442, horizon 31\n", - "adding: mem time412, current time 442, horizon 30\n", - "adding: mem time413, current time 442, horizon 29\n", - "adding: mem time414, current time 442, horizon 28\n", - "adding: mem time415, current time 442, horizon 27\n", - "adding: mem time416, current time 442, horizon 26\n", - "adding: mem time417, current time 442, horizon 25\n", - "adding: mem time418, current time 442, horizon 24\n", - "adding: mem time419, current time 442, horizon 23\n", - "adding: mem time420, current time 442, horizon 22\n", - "adding: mem time421, current time 442, horizon 21\n", - "adding: mem time422, current time 442, horizon 20\n", - "adding: mem time423, current time 442, horizon 19\n", - "adding: mem time424, current time 442, horizon 18\n", - "adding: mem time425, current time 442, horizon 17\n", - "adding: mem time426, current time 442, horizon 16\n", - "adding: mem time427, current time 442, horizon 15\n", - "adding: mem time428, current time 442, horizon 14\n", - "adding: mem time429, current time 442, horizon 13\n", - "adding: mem time430, current time 442, horizon 12\n", - "adding: mem time431, current time 442, horizon 11\n", - "adding: mem time432, current time 442, horizon 10\n", - "adding: mem time433, current time 442, horizon 9\n", - "adding: mem time434, current time 442, horizon 8\n", - "adding: mem time435, current time 442, horizon 7\n", - "adding: mem time436, current time 442, horizon 6\n", - "adding: mem time437, current time 442, horizon 5\n", - "adding: mem time438, current time 442, horizon 4\n", - "adding: mem time439, current time 442, horizon 3\n", - "adding: mem time440, current time 442, horizon 2\n", - "adding: mem time441, current time 442, horizon 1\n", - "adding: mem time400, current time 443, horizon 43\n", - "adding: mem time401, current time 443, horizon 42\n", - "adding: mem time402, current time 443, horizon 41\n", - "adding: mem time403, current time 443, horizon 40\n", - "adding: mem time404, current time 443, horizon 39\n", - "adding: mem time405, current time 443, horizon 38\n", - "adding: mem time406, current time 443, horizon 37\n", - "adding: mem time407, current time 443, horizon 36\n", - "adding: mem time408, current time 443, horizon 35\n", - "adding: mem time409, current time 443, horizon 34\n", - "adding: mem time410, current time 443, horizon 33\n", - "adding: mem time411, current time 443, horizon 32\n", - "adding: mem time412, current time 443, horizon 31\n", - "adding: mem time413, current time 443, horizon 30\n", - "adding: mem time414, current time 443, horizon 29\n", - "adding: mem time415, current time 443, horizon 28\n", - "adding: mem time416, current time 443, horizon 27\n", - "adding: mem time417, current time 443, horizon 26\n", - "adding: mem time418, current time 443, horizon 25\n", - "adding: mem time419, current time 443, horizon 24\n", - "adding: mem time420, current time 443, horizon 23\n", - "adding: mem time421, current time 443, horizon 22\n", - "adding: mem time422, current time 443, horizon 21\n", - "adding: mem time423, current time 443, horizon 20\n", - "adding: mem time424, current time 443, horizon 19\n", - "adding: mem time425, current time 443, horizon 18\n", - "adding: mem time426, current time 443, horizon 17\n", - "adding: mem time427, current time 443, horizon 16\n", - "adding: mem time428, current time 443, horizon 15\n", - "adding: mem time429, current time 443, horizon 14\n", - "adding: mem time430, current time 443, horizon 13\n", - "adding: mem time431, current time 443, horizon 12\n", - "adding: mem time432, current time 443, horizon 11\n", - "adding: mem time433, current time 443, horizon 10\n", - "adding: mem time434, current time 443, horizon 9\n", - "adding: mem time435, current time 443, horizon 8\n", - "adding: mem time436, current time 443, horizon 7\n", - "adding: mem time437, current time 443, horizon 6\n", - "adding: mem time438, current time 443, horizon 5\n", - "adding: mem time439, current time 443, horizon 4\n", - "adding: mem time440, current time 443, horizon 3\n", - "adding: mem time441, current time 443, horizon 2\n", - "adding: mem time442, current time 443, horizon 1\n", - "adding: mem time400, current time 444, horizon 44\n", - "adding: mem time401, current time 444, horizon 43\n", - "adding: mem time402, current time 444, horizon 42\n", - "adding: mem time403, current time 444, horizon 41\n", - "adding: mem time404, current time 444, horizon 40\n", - "adding: mem time405, current time 444, horizon 39\n", - "adding: mem time406, current time 444, horizon 38\n", - "adding: mem time407, current time 444, horizon 37\n", - "adding: mem time408, current time 444, horizon 36\n", - "adding: mem time409, current time 444, horizon 35\n", - "adding: mem time410, current time 444, horizon 34\n", - "adding: mem time411, current time 444, horizon 33\n", - "adding: mem time412, current time 444, horizon 32\n", - "adding: mem time413, current time 444, horizon 31\n", - "adding: mem time414, current time 444, horizon 30\n", - "adding: mem time415, current time 444, horizon 29\n", - "adding: mem time416, current time 444, horizon 28\n", - "adding: mem time417, current time 444, horizon 27\n", - "adding: mem time418, current time 444, horizon 26\n", - "adding: mem time419, current time 444, horizon 25\n", - "adding: mem time420, current time 444, horizon 24\n", - "adding: mem time421, current time 444, horizon 23\n", - "adding: mem time422, current time 444, horizon 22\n", - "adding: mem time423, current time 444, horizon 21\n", - "adding: mem time424, current time 444, horizon 20\n", - "adding: mem time425, current time 444, horizon 19\n", - "adding: mem time426, current time 444, horizon 18\n", - "adding: mem time427, current time 444, horizon 17\n", - "adding: mem time428, current time 444, horizon 16\n", - "adding: mem time429, current time 444, horizon 15\n", - "adding: mem time430, current time 444, horizon 14\n", - "adding: mem time431, current time 444, horizon 13\n", - "adding: mem time432, current time 444, horizon 12\n", - "adding: mem time433, current time 444, horizon 11\n", - "adding: mem time434, current time 444, horizon 10\n", - "adding: mem time435, current time 444, horizon 9\n", - "adding: mem time436, current time 444, horizon 8\n", - "adding: mem time437, current time 444, horizon 7\n", - "adding: mem time438, current time 444, horizon 6\n", - "adding: mem time439, current time 444, horizon 5\n", - "adding: mem time440, current time 444, horizon 4\n", - "adding: mem time441, current time 444, horizon 3\n", - "adding: mem time442, current time 444, horizon 2\n", - "adding: mem time443, current time 444, horizon 1\n", - "adding: mem time400, current time 445, horizon 45\n", - "adding: mem time401, current time 445, horizon 44\n", - "adding: mem time402, current time 445, horizon 43\n", - "adding: mem time403, current time 445, horizon 42\n", - "adding: mem time404, current time 445, horizon 41\n", - "adding: mem time405, current time 445, horizon 40\n", - "adding: mem time406, current time 445, horizon 39\n", - "adding: mem time407, current time 445, horizon 38\n", - "adding: mem time408, current time 445, horizon 37\n", - "adding: mem time409, current time 445, horizon 36\n", - "adding: mem time410, current time 445, horizon 35\n", - "adding: mem time411, current time 445, horizon 34\n", - "adding: mem time412, current time 445, horizon 33\n", - "adding: mem time413, current time 445, horizon 32\n", - "adding: mem time414, current time 445, horizon 31\n", - "adding: mem time415, current time 445, horizon 30\n", - "adding: mem time416, current time 445, horizon 29\n", - "adding: mem time417, current time 445, horizon 28\n", - "adding: mem time418, current time 445, horizon 27\n", - "adding: mem time419, current time 445, horizon 26\n", - "adding: mem time420, current time 445, horizon 25\n", - "adding: mem time421, current time 445, horizon 24\n", - "adding: mem time422, current time 445, horizon 23\n", - "adding: mem time423, current time 445, horizon 22\n", - "adding: mem time424, current time 445, horizon 21\n", - "adding: mem time425, current time 445, horizon 20\n", - "adding: mem time426, current time 445, horizon 19\n", - "adding: mem time427, current time 445, horizon 18\n", - "adding: mem time428, current time 445, horizon 17\n", - "adding: mem time429, current time 445, horizon 16\n", - "adding: mem time430, current time 445, horizon 15\n", - "adding: mem time431, current time 445, horizon 14\n", - "adding: mem time432, current time 445, horizon 13\n", - "adding: mem time433, current time 445, horizon 12\n", - "adding: mem time434, current time 445, horizon 11\n", - "adding: mem time435, current time 445, horizon 10\n", - "adding: mem time436, current time 445, horizon 9\n", - "adding: mem time437, current time 445, horizon 8\n", - "adding: mem time438, current time 445, horizon 7\n", - "adding: mem time439, current time 445, horizon 6\n", - "adding: mem time440, current time 445, horizon 5\n", - "adding: mem time441, current time 445, horizon 4\n", - "adding: mem time442, current time 445, horizon 3\n", - "adding: mem time443, current time 445, horizon 2\n", - "adding: mem time444, current time 445, horizon 1\n", - "adding: mem time400, current time 446, horizon 46\n", - "adding: mem time401, current time 446, horizon 45\n", - "adding: mem time402, current time 446, horizon 44\n", - "adding: mem time403, current time 446, horizon 43\n", - "adding: mem time404, current time 446, horizon 42\n", - "adding: mem time405, current time 446, horizon 41\n", - "adding: mem time406, current time 446, horizon 40\n", - "adding: mem time407, current time 446, horizon 39\n", - "adding: mem time408, current time 446, horizon 38\n", - "adding: mem time409, current time 446, horizon 37\n", - "adding: mem time410, current time 446, horizon 36\n", - "adding: mem time411, current time 446, horizon 35\n", - "adding: mem time412, current time 446, horizon 34\n", - "adding: mem time413, current time 446, horizon 33\n", - "adding: mem time414, current time 446, horizon 32\n", - "adding: mem time415, current time 446, horizon 31\n", - "adding: mem time416, current time 446, horizon 30\n", - "adding: mem time417, current time 446, horizon 29\n", - "adding: mem time418, current time 446, horizon 28\n", - "adding: mem time419, current time 446, horizon 27\n", - "adding: mem time420, current time 446, horizon 26\n", - "adding: mem time421, current time 446, horizon 25\n", - "adding: mem time422, current time 446, horizon 24\n", - "adding: mem time423, current time 446, horizon 23\n", - "adding: mem time424, current time 446, horizon 22\n", - "adding: mem time425, current time 446, horizon 21\n", - "adding: mem time426, current time 446, horizon 20\n", - "adding: mem time427, current time 446, horizon 19\n", - "adding: mem time428, current time 446, horizon 18\n", - "adding: mem time429, current time 446, horizon 17\n", - "adding: mem time430, current time 446, horizon 16\n", - "adding: mem time431, current time 446, horizon 15\n", - "adding: mem time432, current time 446, horizon 14\n", - "adding: mem time433, current time 446, horizon 13\n", - "adding: mem time434, current time 446, horizon 12\n", - "adding: mem time435, current time 446, horizon 11\n", - "adding: mem time436, current time 446, horizon 10\n", - "adding: mem time437, current time 446, horizon 9\n", - "adding: mem time438, current time 446, horizon 8\n", - "adding: mem time439, current time 446, horizon 7\n", - "adding: mem time440, current time 446, horizon 6\n", - "adding: mem time441, current time 446, horizon 5\n", - "adding: mem time442, current time 446, horizon 4\n", - "adding: mem time443, current time 446, horizon 3\n", - "adding: mem time444, current time 446, horizon 2\n", - "adding: mem time445, current time 446, horizon 1\n", - "adding: mem time400, current time 447, horizon 47\n", - "adding: mem time401, current time 447, horizon 46\n", - "adding: mem time402, current time 447, horizon 45\n", - "adding: mem time403, current time 447, horizon 44\n", - "adding: mem time404, current time 447, horizon 43\n", - "adding: mem time405, current time 447, horizon 42\n", - "adding: mem time406, current time 447, horizon 41\n", - "adding: mem time407, current time 447, horizon 40\n", - "adding: mem time408, current time 447, horizon 39\n", - "adding: mem time409, current time 447, horizon 38\n", - "adding: mem time410, current time 447, horizon 37\n", - "adding: mem time411, current time 447, horizon 36\n", - "adding: mem time412, current time 447, horizon 35\n", - "adding: mem time413, current time 447, horizon 34\n", - "adding: mem time414, current time 447, horizon 33\n", - "adding: mem time415, current time 447, horizon 32\n", - "adding: mem time416, current time 447, horizon 31\n", - "adding: mem time417, current time 447, horizon 30\n", - "adding: mem time418, current time 447, horizon 29\n", - "adding: mem time419, current time 447, horizon 28\n", - "adding: mem time420, current time 447, horizon 27\n", - "adding: mem time421, current time 447, horizon 26\n", - "adding: mem time422, current time 447, horizon 25\n", - "adding: mem time423, current time 447, horizon 24\n", - "adding: mem time424, current time 447, horizon 23\n", - "adding: mem time425, current time 447, horizon 22\n", - "adding: mem time426, current time 447, horizon 21\n", - "adding: mem time427, current time 447, horizon 20\n", - "adding: mem time428, current time 447, horizon 19\n", - "adding: mem time429, current time 447, horizon 18\n", - "adding: mem time430, current time 447, horizon 17\n", - "adding: mem time431, current time 447, horizon 16\n", - "adding: mem time432, current time 447, horizon 15\n", - "adding: mem time433, current time 447, horizon 14\n", - "adding: mem time434, current time 447, horizon 13\n", - "adding: mem time435, current time 447, horizon 12\n", - "adding: mem time436, current time 447, horizon 11\n", - "adding: mem time437, current time 447, horizon 10\n", - "adding: mem time438, current time 447, horizon 9\n", - "adding: mem time439, current time 447, horizon 8\n", - "adding: mem time440, current time 447, horizon 7\n", - "adding: mem time441, current time 447, horizon 6\n", - "adding: mem time442, current time 447, horizon 5\n", - "adding: mem time443, current time 447, horizon 4\n", - "adding: mem time444, current time 447, horizon 3\n", - "adding: mem time445, current time 447, horizon 2\n", - "adding: mem time446, current time 447, horizon 1\n", - "adding: mem time400, current time 448, horizon 48\n", - "adding: mem time401, current time 448, horizon 47\n", - "adding: mem time402, current time 448, horizon 46\n", - "adding: mem time403, current time 448, horizon 45\n", - "adding: mem time404, current time 448, horizon 44\n", - "adding: mem time405, current time 448, horizon 43\n", - "adding: mem time406, current time 448, horizon 42\n", - "adding: mem time407, current time 448, horizon 41\n", - "adding: mem time408, current time 448, horizon 40\n", - "adding: mem time409, current time 448, horizon 39\n", - "adding: mem time410, current time 448, horizon 38\n", - "adding: mem time411, current time 448, horizon 37\n", - "adding: mem time412, current time 448, horizon 36\n", - "adding: mem time413, current time 448, horizon 35\n", - "adding: mem time414, current time 448, horizon 34\n", - "adding: mem time415, current time 448, horizon 33\n", - "adding: mem time416, current time 448, horizon 32\n", - "adding: mem time417, current time 448, horizon 31\n", - "adding: mem time418, current time 448, horizon 30\n", - "adding: mem time419, current time 448, horizon 29\n", - "adding: mem time420, current time 448, horizon 28\n", - "adding: mem time421, current time 448, horizon 27\n", - "adding: mem time422, current time 448, horizon 26\n", - "adding: mem time423, current time 448, horizon 25\n", - "adding: mem time424, current time 448, horizon 24\n", - "adding: mem time425, current time 448, horizon 23\n", - "adding: mem time426, current time 448, horizon 22\n", - "adding: mem time427, current time 448, horizon 21\n", - "adding: mem time428, current time 448, horizon 20\n", - "adding: mem time429, current time 448, horizon 19\n", - "adding: mem time430, current time 448, horizon 18\n", - "adding: mem time431, current time 448, horizon 17\n", - "adding: mem time432, current time 448, horizon 16\n", - "adding: mem time433, current time 448, horizon 15\n", - "adding: mem time434, current time 448, horizon 14\n", - "adding: mem time435, current time 448, horizon 13\n", - "adding: mem time436, current time 448, horizon 12\n", - "adding: mem time437, current time 448, horizon 11\n", - "adding: mem time438, current time 448, horizon 10\n", - "adding: mem time439, current time 448, horizon 9\n", - "adding: mem time440, current time 448, horizon 8\n", - "adding: mem time441, current time 448, horizon 7\n", - "adding: mem time442, current time 448, horizon 6\n", - "adding: mem time443, current time 448, horizon 5\n", - "adding: mem time444, current time 448, horizon 4\n", - "adding: mem time445, current time 448, horizon 3\n", - "adding: mem time446, current time 448, horizon 2\n", - "adding: mem time447, current time 448, horizon 1\n", - "adding: mem time400, current time 449, horizon 49\n", - "adding: mem time401, current time 449, horizon 48\n", - "adding: mem time402, current time 449, horizon 47\n", - "adding: mem time403, current time 449, horizon 46\n", - "adding: mem time404, current time 449, horizon 45\n", - "adding: mem time405, current time 449, horizon 44\n", - "adding: mem time406, current time 449, horizon 43\n", - "adding: mem time407, current time 449, horizon 42\n", - "adding: mem time408, current time 449, horizon 41\n", - "adding: mem time409, current time 449, horizon 40\n", - "adding: mem time410, current time 449, horizon 39\n", - "adding: mem time411, current time 449, horizon 38\n", - "adding: mem time412, current time 449, horizon 37\n", - "adding: mem time413, current time 449, horizon 36\n", - "adding: mem time414, current time 449, horizon 35\n", - "adding: mem time415, current time 449, horizon 34\n", - "adding: mem time416, current time 449, horizon 33\n", - "adding: mem time417, current time 449, horizon 32\n", - "adding: mem time418, current time 449, horizon 31\n", - "adding: mem time419, current time 449, horizon 30\n", - "adding: mem time420, current time 449, horizon 29\n", - "adding: mem time421, current time 449, horizon 28\n", - "adding: mem time422, current time 449, horizon 27\n", - "adding: mem time423, current time 449, horizon 26\n", - "adding: mem time424, current time 449, horizon 25\n", - "adding: mem time425, current time 449, horizon 24\n", - "adding: mem time426, current time 449, horizon 23\n", - "adding: mem time427, current time 449, horizon 22\n", - "adding: mem time428, current time 449, horizon 21\n", - "adding: mem time429, current time 449, horizon 20\n", - "adding: mem time430, current time 449, horizon 19\n", - "adding: mem time431, current time 449, horizon 18\n", - "adding: mem time432, current time 449, horizon 17\n", - "adding: mem time433, current time 449, horizon 16\n", - "adding: mem time434, current time 449, horizon 15\n", - "adding: mem time435, current time 449, horizon 14\n", - "adding: mem time436, current time 449, horizon 13\n", - "adding: mem time437, current time 449, horizon 12\n", - "adding: mem time438, current time 449, horizon 11\n", - "adding: mem time439, current time 449, horizon 10\n", - "adding: mem time440, current time 449, horizon 9\n", - "adding: mem time441, current time 449, horizon 8\n", - "adding: mem time442, current time 449, horizon 7\n", - "adding: mem time443, current time 449, horizon 6\n", - "adding: mem time444, current time 449, horizon 5\n", - "adding: mem time445, current time 449, horizon 4\n", - "adding: mem time446, current time 449, horizon 3\n", - "adding: mem time447, current time 449, horizon 2\n", - "adding: mem time448, current time 449, horizon 1\n", - "adding: mem time400, current time 450, horizon 50\n", - "adding: mem time401, current time 450, horizon 49\n", - "adding: mem time402, current time 450, horizon 48\n", - "adding: mem time403, current time 450, horizon 47\n", - "adding: mem time404, current time 450, horizon 46\n", - "adding: mem time405, current time 450, horizon 45\n", - "adding: mem time406, current time 450, horizon 44\n", - "adding: mem time407, current time 450, horizon 43\n", - "adding: mem time408, current time 450, horizon 42\n", - "adding: mem time409, current time 450, horizon 41\n", - "adding: mem time410, current time 450, horizon 40\n", - "adding: mem time411, current time 450, horizon 39\n", - "adding: mem time412, current time 450, horizon 38\n", - "adding: mem time413, current time 450, horizon 37\n", - "adding: mem time414, current time 450, horizon 36\n", - "adding: mem time415, current time 450, horizon 35\n", - "adding: mem time416, current time 450, horizon 34\n", - "adding: mem time417, current time 450, horizon 33\n", - "adding: mem time418, current time 450, horizon 32\n", - "adding: mem time419, current time 450, horizon 31\n", - "adding: mem time420, current time 450, horizon 30\n", - "adding: mem time421, current time 450, horizon 29\n", - "adding: mem time422, current time 450, horizon 28\n", - "adding: mem time423, current time 450, horizon 27\n", - "adding: mem time424, current time 450, horizon 26\n", - "adding: mem time425, current time 450, horizon 25\n", - "adding: mem time426, current time 450, horizon 24\n", - "adding: mem time427, current time 450, horizon 23\n", - "adding: mem time428, current time 450, horizon 22\n", - "adding: mem time429, current time 450, horizon 21\n", - "adding: mem time430, current time 450, horizon 20\n", - "adding: mem time431, current time 450, horizon 19\n", - "adding: mem time432, current time 450, horizon 18\n", - "adding: mem time433, current time 450, horizon 17\n", - "adding: mem time434, current time 450, horizon 16\n", - "adding: mem time435, current time 450, horizon 15\n", - "adding: mem time436, current time 450, horizon 14\n", - "adding: mem time437, current time 450, horizon 13\n", - "adding: mem time438, current time 450, horizon 12\n", - "adding: mem time439, current time 450, horizon 11\n", - "adding: mem time440, current time 450, horizon 10\n", - "adding: mem time441, current time 450, horizon 9\n", - "adding: mem time442, current time 450, horizon 8\n", - "adding: mem time443, current time 450, horizon 7\n", - "adding: mem time444, current time 450, horizon 6\n", - "adding: mem time445, current time 450, horizon 5\n", - "adding: mem time446, current time 450, horizon 4\n", - "adding: mem time447, current time 450, horizon 3\n", - "adding: mem time448, current time 450, horizon 2\n", - "adding: mem time449, current time 450, horizon 1\n", - "adding: mem time400, current time 451, horizon 51\n", - "adding: mem time401, current time 451, horizon 50\n", - "adding: mem time402, current time 451, horizon 49\n", - "adding: mem time403, current time 451, horizon 48\n", - "adding: mem time404, current time 451, horizon 47\n", - "adding: mem time405, current time 451, horizon 46\n", - "adding: mem time406, current time 451, horizon 45\n", - "adding: mem time407, current time 451, horizon 44\n", - "adding: mem time408, current time 451, horizon 43\n", - "adding: mem time409, current time 451, horizon 42\n", - "adding: mem time410, current time 451, horizon 41\n", - "adding: mem time411, current time 451, horizon 40\n", - "adding: mem time412, current time 451, horizon 39\n", - "adding: mem time413, current time 451, horizon 38\n", - "adding: mem time414, current time 451, horizon 37\n", - "adding: mem time415, current time 451, horizon 36\n", - "adding: mem time416, current time 451, horizon 35\n", - "adding: mem time417, current time 451, horizon 34\n", - "adding: mem time418, current time 451, horizon 33\n", - "adding: mem time419, current time 451, horizon 32\n", - "adding: mem time420, current time 451, horizon 31\n", - "adding: mem time421, current time 451, horizon 30\n", - "adding: mem time422, current time 451, horizon 29\n", - "adding: mem time423, current time 451, horizon 28\n", - "adding: mem time424, current time 451, horizon 27\n", - "adding: mem time425, current time 451, horizon 26\n", - "adding: mem time426, current time 451, horizon 25\n", - "adding: mem time427, current time 451, horizon 24\n", - "adding: mem time428, current time 451, horizon 23\n", - "adding: mem time429, current time 451, horizon 22\n", - "adding: mem time430, current time 451, horizon 21\n", - "adding: mem time431, current time 451, horizon 20\n", - "adding: mem time432, current time 451, horizon 19\n", - "adding: mem time433, current time 451, horizon 18\n", - "adding: mem time434, current time 451, horizon 17\n", - "adding: mem time435, current time 451, horizon 16\n", - "adding: mem time436, current time 451, horizon 15\n", - "adding: mem time437, current time 451, horizon 14\n", - "adding: mem time438, current time 451, horizon 13\n", - "adding: mem time439, current time 451, horizon 12\n", - "adding: mem time440, current time 451, horizon 11\n", - "adding: mem time441, current time 451, horizon 10\n", - "adding: mem time442, current time 451, horizon 9\n", - "adding: mem time443, current time 451, horizon 8\n", - "adding: mem time444, current time 451, horizon 7\n", - "adding: mem time445, current time 451, horizon 6\n", - "adding: mem time446, current time 451, horizon 5\n", - "adding: mem time447, current time 451, horizon 4\n", - "adding: mem time448, current time 451, horizon 3\n", - "adding: mem time449, current time 451, horizon 2\n", - "adding: mem time450, current time 451, horizon 1\n", - "adding: mem time400, current time 452, horizon 52\n", - "adding: mem time401, current time 452, horizon 51\n", - "adding: mem time402, current time 452, horizon 50\n", - "adding: mem time403, current time 452, horizon 49\n", - "adding: mem time404, current time 452, horizon 48\n", - "adding: mem time405, current time 452, horizon 47\n", - "adding: mem time406, current time 452, horizon 46\n", - "adding: mem time407, current time 452, horizon 45\n", - "adding: mem time408, current time 452, horizon 44\n", - "adding: mem time409, current time 452, horizon 43\n", - "adding: mem time410, current time 452, horizon 42\n", - "adding: mem time411, current time 452, horizon 41\n", - "adding: mem time412, current time 452, horizon 40\n", - "adding: mem time413, current time 452, horizon 39\n", - "adding: mem time414, current time 452, horizon 38\n", - "adding: mem time415, current time 452, horizon 37\n", - "adding: mem time416, current time 452, horizon 36\n", - "adding: mem time417, current time 452, horizon 35\n", - "adding: mem time418, current time 452, horizon 34\n", - "adding: mem time419, current time 452, horizon 33\n", - "adding: mem time420, current time 452, horizon 32\n", - "adding: mem time421, current time 452, horizon 31\n", - "adding: mem time422, current time 452, horizon 30\n", - "adding: mem time423, current time 452, horizon 29\n", - "adding: mem time424, current time 452, horizon 28\n", - "adding: mem time425, current time 452, horizon 27\n", - "adding: mem time426, current time 452, horizon 26\n", - "adding: mem time427, current time 452, horizon 25\n", - "adding: mem time428, current time 452, horizon 24\n", - "adding: mem time429, current time 452, horizon 23\n", - "adding: mem time430, current time 452, horizon 22\n", - "adding: mem time431, current time 452, horizon 21\n", - "adding: mem time432, current time 452, horizon 20\n", - "adding: mem time433, current time 452, horizon 19\n", - "adding: mem time434, current time 452, horizon 18\n", - "adding: mem time435, current time 452, horizon 17\n", - "adding: mem time436, current time 452, horizon 16\n", - "adding: mem time437, current time 452, horizon 15\n", - "adding: mem time438, current time 452, horizon 14\n", - "adding: mem time439, current time 452, horizon 13\n", - "adding: mem time440, current time 452, horizon 12\n", - "adding: mem time441, current time 452, horizon 11\n", - "adding: mem time442, current time 452, horizon 10\n", - "adding: mem time443, current time 452, horizon 9\n", - "adding: mem time444, current time 452, horizon 8\n", - "adding: mem time445, current time 452, horizon 7\n", - "adding: mem time446, current time 452, horizon 6\n", - "adding: mem time447, current time 452, horizon 5\n", - "adding: mem time448, current time 452, horizon 4\n", - "adding: mem time449, current time 452, horizon 3\n", - "adding: mem time450, current time 452, horizon 2\n", - "adding: mem time451, current time 452, horizon 1\n", - "adding: mem time400, current time 453, horizon 53\n", - "adding: mem time401, current time 453, horizon 52\n", - "adding: mem time402, current time 453, horizon 51\n", - "adding: mem time403, current time 453, horizon 50\n", - "adding: mem time404, current time 453, horizon 49\n", - "adding: mem time405, current time 453, horizon 48\n", - "adding: mem time406, current time 453, horizon 47\n", - "adding: mem time407, current time 453, horizon 46\n", - "adding: mem time408, current time 453, horizon 45\n", - "adding: mem time409, current time 453, horizon 44\n", - "adding: mem time410, current time 453, horizon 43\n", - "adding: mem time411, current time 453, horizon 42\n", - "adding: mem time412, current time 453, horizon 41\n", - "adding: mem time413, current time 453, horizon 40\n", - "adding: mem time414, current time 453, horizon 39\n", - "adding: mem time415, current time 453, horizon 38\n", - "adding: mem time416, current time 453, horizon 37\n", - "adding: mem time417, current time 453, horizon 36\n", - "adding: mem time418, current time 453, horizon 35\n", - "adding: mem time419, current time 453, horizon 34\n", - "adding: mem time420, current time 453, horizon 33\n", - "adding: mem time421, current time 453, horizon 32\n", - "adding: mem time422, current time 453, horizon 31\n", - "adding: mem time423, current time 453, horizon 30\n", - "adding: mem time424, current time 453, horizon 29\n", - "adding: mem time425, current time 453, horizon 28\n", - "adding: mem time426, current time 453, horizon 27\n", - "adding: mem time427, current time 453, horizon 26\n", - "adding: mem time428, current time 453, horizon 25\n", - "adding: mem time429, current time 453, horizon 24\n", - "adding: mem time430, current time 453, horizon 23\n", - "adding: mem time431, current time 453, horizon 22\n", - "adding: mem time432, current time 453, horizon 21\n", - "adding: mem time433, current time 453, horizon 20\n", - "adding: mem time434, current time 453, horizon 19\n", - "adding: mem time435, current time 453, horizon 18\n", - "adding: mem time436, current time 453, horizon 17\n", - "adding: mem time437, current time 453, horizon 16\n", - "adding: mem time438, current time 453, horizon 15\n", - "adding: mem time439, current time 453, horizon 14\n", - "adding: mem time440, current time 453, horizon 13\n", - "adding: mem time441, current time 453, horizon 12\n", - "adding: mem time442, current time 453, horizon 11\n", - "adding: mem time443, current time 453, horizon 10\n", - "adding: mem time444, current time 453, horizon 9\n", - "adding: mem time445, current time 453, horizon 8\n", - "adding: mem time446, current time 453, horizon 7\n", - "adding: mem time447, current time 453, horizon 6\n", - "adding: mem time448, current time 453, horizon 5\n", - "adding: mem time449, current time 453, horizon 4\n", - "adding: mem time450, current time 453, horizon 3\n", - "adding: mem time451, current time 453, horizon 2\n", - "adding: mem time452, current time 453, horizon 1\n", - "adding: mem time400, current time 454, horizon 54\n", - "adding: mem time401, current time 454, horizon 53\n", - "adding: mem time402, current time 454, horizon 52\n", - "adding: mem time403, current time 454, horizon 51\n", - "adding: mem time404, current time 454, horizon 50\n", - "adding: mem time405, current time 454, horizon 49\n", - "adding: mem time406, current time 454, horizon 48\n", - "adding: mem time407, current time 454, horizon 47\n", - "adding: mem time408, current time 454, horizon 46\n", - "adding: mem time409, current time 454, horizon 45\n", - "adding: mem time410, current time 454, horizon 44\n", - "adding: mem time411, current time 454, horizon 43\n", - "adding: mem time412, current time 454, horizon 42\n", - "adding: mem time413, current time 454, horizon 41\n", - "adding: mem time414, current time 454, horizon 40\n", - "adding: mem time415, current time 454, horizon 39\n", - "adding: mem time416, current time 454, horizon 38\n", - "adding: mem time417, current time 454, horizon 37\n", - "adding: mem time418, current time 454, horizon 36\n", - "adding: mem time419, current time 454, horizon 35\n", - "adding: mem time420, current time 454, horizon 34\n", - "adding: mem time421, current time 454, horizon 33\n", - "adding: mem time422, current time 454, horizon 32\n", - "adding: mem time423, current time 454, horizon 31\n", - "adding: mem time424, current time 454, horizon 30\n", - "adding: mem time425, current time 454, horizon 29\n", - "adding: mem time426, current time 454, horizon 28\n", - "adding: mem time427, current time 454, horizon 27\n", - "adding: mem time428, current time 454, horizon 26\n", - "adding: mem time429, current time 454, horizon 25\n", - "adding: mem time430, current time 454, horizon 24\n", - "adding: mem time431, current time 454, horizon 23\n", - "adding: mem time432, current time 454, horizon 22\n", - "adding: mem time433, current time 454, horizon 21\n", - "adding: mem time434, current time 454, horizon 20\n", - "adding: mem time435, current time 454, horizon 19\n", - "adding: mem time436, current time 454, horizon 18\n", - "adding: mem time437, current time 454, horizon 17\n", - "adding: mem time438, current time 454, horizon 16\n", - "adding: mem time439, current time 454, horizon 15\n", - "adding: mem time440, current time 454, horizon 14\n", - "adding: mem time441, current time 454, horizon 13\n", - "adding: mem time442, current time 454, horizon 12\n", - "adding: mem time443, current time 454, horizon 11\n", - "adding: mem time444, current time 454, horizon 10\n", - "adding: mem time445, current time 454, horizon 9\n", - "adding: mem time446, current time 454, horizon 8\n", - "adding: mem time447, current time 454, horizon 7\n", - "adding: mem time448, current time 454, horizon 6\n", - "adding: mem time449, current time 454, horizon 5\n", - "adding: mem time450, current time 454, horizon 4\n", - "adding: mem time451, current time 454, horizon 3\n", - "adding: mem time452, current time 454, horizon 2\n", - "adding: mem time453, current time 454, horizon 1\n", - "adding: mem time400, current time 455, horizon 55\n", - "adding: mem time401, current time 455, horizon 54\n", - "adding: mem time402, current time 455, horizon 53\n", - "adding: mem time403, current time 455, horizon 52\n", - "adding: mem time404, current time 455, horizon 51\n", - "adding: mem time405, current time 455, horizon 50\n", - "adding: mem time406, current time 455, horizon 49\n", - "adding: mem time407, current time 455, horizon 48\n", - "adding: mem time408, current time 455, horizon 47\n", - "adding: mem time409, current time 455, horizon 46\n", - "adding: mem time410, current time 455, horizon 45\n", - "adding: mem time411, current time 455, horizon 44\n", - "adding: mem time412, current time 455, horizon 43\n", - "adding: mem time413, current time 455, horizon 42\n", - "adding: mem time414, current time 455, horizon 41\n", - "adding: mem time415, current time 455, horizon 40\n", - "adding: mem time416, current time 455, horizon 39\n", - "adding: mem time417, current time 455, horizon 38\n", - "adding: mem time418, current time 455, horizon 37\n", - "adding: mem time419, current time 455, horizon 36\n", - "adding: mem time420, current time 455, horizon 35\n", - "adding: mem time421, current time 455, horizon 34\n", - "adding: mem time422, current time 455, horizon 33\n", - "adding: mem time423, current time 455, horizon 32\n", - "adding: mem time424, current time 455, horizon 31\n", - "adding: mem time425, current time 455, horizon 30\n", - "adding: mem time426, current time 455, horizon 29\n", - "adding: mem time427, current time 455, horizon 28\n", - "adding: mem time428, current time 455, horizon 27\n", - "adding: mem time429, current time 455, horizon 26\n", - "adding: mem time430, current time 455, horizon 25\n", - "adding: mem time431, current time 455, horizon 24\n", - "adding: mem time432, current time 455, horizon 23\n", - "adding: mem time433, current time 455, horizon 22\n", - "adding: mem time434, current time 455, horizon 21\n", - "adding: mem time435, current time 455, horizon 20\n", - "adding: mem time436, current time 455, horizon 19\n", - "adding: mem time437, current time 455, horizon 18\n", - "adding: mem time438, current time 455, horizon 17\n", - "adding: mem time439, current time 455, horizon 16\n", - "adding: mem time440, current time 455, horizon 15\n", - "adding: mem time441, current time 455, horizon 14\n", - "adding: mem time442, current time 455, horizon 13\n", - "adding: mem time443, current time 455, horizon 12\n", - "adding: mem time444, current time 455, horizon 11\n", - "adding: mem time445, current time 455, horizon 10\n", - "adding: mem time446, current time 455, horizon 9\n", - "adding: mem time447, current time 455, horizon 8\n", - "adding: mem time448, current time 455, horizon 7\n", - "adding: mem time449, current time 455, horizon 6\n", - "adding: mem time450, current time 455, horizon 5\n", - "adding: mem time451, current time 455, horizon 4\n", - "adding: mem time452, current time 455, horizon 3\n", - "adding: mem time453, current time 455, horizon 2\n", - "adding: mem time454, current time 455, horizon 1\n", - "adding: mem time400, current time 456, horizon 56\n", - "adding: mem time401, current time 456, horizon 55\n", - "adding: mem time402, current time 456, horizon 54\n", - "adding: mem time403, current time 456, horizon 53\n", - "adding: mem time404, current time 456, horizon 52\n", - "adding: mem time405, current time 456, horizon 51\n", - "adding: mem time406, current time 456, horizon 50\n", - "adding: mem time407, current time 456, horizon 49\n", - "adding: mem time408, current time 456, horizon 48\n", - "adding: mem time409, current time 456, horizon 47\n", - "adding: mem time410, current time 456, horizon 46\n", - "adding: mem time411, current time 456, horizon 45\n", - "adding: mem time412, current time 456, horizon 44\n", - "adding: mem time413, current time 456, horizon 43\n", - "adding: mem time414, current time 456, horizon 42\n", - "adding: mem time415, current time 456, horizon 41\n", - "adding: mem time416, current time 456, horizon 40\n", - "adding: mem time417, current time 456, horizon 39\n", - "adding: mem time418, current time 456, horizon 38\n", - "adding: mem time419, current time 456, horizon 37\n", - "adding: mem time420, current time 456, horizon 36\n", - "adding: mem time421, current time 456, horizon 35\n", - "adding: mem time422, current time 456, horizon 34\n", - "adding: mem time423, current time 456, horizon 33\n", - "adding: mem time424, current time 456, horizon 32\n", - "adding: mem time425, current time 456, horizon 31\n", - "adding: mem time426, current time 456, horizon 30\n", - "adding: mem time427, current time 456, horizon 29\n", - "adding: mem time428, current time 456, horizon 28\n", - "adding: mem time429, current time 456, horizon 27\n", - "adding: mem time430, current time 456, horizon 26\n", - "adding: mem time431, current time 456, horizon 25\n", - "adding: mem time432, current time 456, horizon 24\n", - "adding: mem time433, current time 456, horizon 23\n", - "adding: mem time434, current time 456, horizon 22\n", - "adding: mem time435, current time 456, horizon 21\n", - "adding: mem time436, current time 456, horizon 20\n", - "adding: mem time437, current time 456, horizon 19\n", - "adding: mem time438, current time 456, horizon 18\n", - "adding: mem time439, current time 456, horizon 17\n", - "adding: mem time440, current time 456, horizon 16\n", - "adding: mem time441, current time 456, horizon 15\n", - "adding: mem time442, current time 456, horizon 14\n", - "adding: mem time443, current time 456, horizon 13\n", - "adding: mem time444, current time 456, horizon 12\n", - "adding: mem time445, current time 456, horizon 11\n", - "adding: mem time446, current time 456, horizon 10\n", - "adding: mem time447, current time 456, horizon 9\n", - "adding: mem time448, current time 456, horizon 8\n", - "adding: mem time449, current time 456, horizon 7\n", - "adding: mem time450, current time 456, horizon 6\n", - "adding: mem time451, current time 456, horizon 5\n", - "adding: mem time452, current time 456, horizon 4\n", - "adding: mem time453, current time 456, horizon 3\n", - "adding: mem time454, current time 456, horizon 2\n", - "adding: mem time455, current time 456, horizon 1\n", - "adding: mem time400, current time 457, horizon 57\n", - "adding: mem time401, current time 457, horizon 56\n", - "adding: mem time402, current time 457, horizon 55\n", - "adding: mem time403, current time 457, horizon 54\n", - "adding: mem time404, current time 457, horizon 53\n", - "adding: mem time405, current time 457, horizon 52\n", - "adding: mem time406, current time 457, horizon 51\n", - "adding: mem time407, current time 457, horizon 50\n", - "adding: mem time408, current time 457, horizon 49\n", - "adding: mem time409, current time 457, horizon 48\n", - "adding: mem time410, current time 457, horizon 47\n", - "adding: mem time411, current time 457, horizon 46\n", - "adding: mem time412, current time 457, horizon 45\n", - "adding: mem time413, current time 457, horizon 44\n", - "adding: mem time414, current time 457, horizon 43\n", - "adding: mem time415, current time 457, horizon 42\n", - "adding: mem time416, current time 457, horizon 41\n", - "adding: mem time417, current time 457, horizon 40\n", - "adding: mem time418, current time 457, horizon 39\n", - "adding: mem time419, current time 457, horizon 38\n", - "adding: mem time420, current time 457, horizon 37\n", - "adding: mem time421, current time 457, horizon 36\n", - "adding: mem time422, current time 457, horizon 35\n", - "adding: mem time423, current time 457, horizon 34\n", - "adding: mem time424, current time 457, horizon 33\n", - "adding: mem time425, current time 457, horizon 32\n", - "adding: mem time426, current time 457, horizon 31\n", - "adding: mem time427, current time 457, horizon 30\n", - "adding: mem time428, current time 457, horizon 29\n", - "adding: mem time429, current time 457, horizon 28\n", - "adding: mem time430, current time 457, horizon 27\n", - "adding: mem time431, current time 457, horizon 26\n", - "adding: mem time432, current time 457, horizon 25\n", - "adding: mem time433, current time 457, horizon 24\n", - "adding: mem time434, current time 457, horizon 23\n", - "adding: mem time435, current time 457, horizon 22\n", - "adding: mem time436, current time 457, horizon 21\n", - "adding: mem time437, current time 457, horizon 20\n", - "adding: mem time438, current time 457, horizon 19\n", - "adding: mem time439, current time 457, horizon 18\n", - "adding: mem time440, current time 457, horizon 17\n", - "adding: mem time441, current time 457, horizon 16\n", - "adding: mem time442, current time 457, horizon 15\n", - "adding: mem time443, current time 457, horizon 14\n", - "adding: mem time444, current time 457, horizon 13\n", - "adding: mem time445, current time 457, horizon 12\n", - "adding: mem time446, current time 457, horizon 11\n", - "adding: mem time447, current time 457, horizon 10\n", - "adding: mem time448, current time 457, horizon 9\n", - "adding: mem time449, current time 457, horizon 8\n", - "adding: mem time450, current time 457, horizon 7\n", - "adding: mem time451, current time 457, horizon 6\n", - "adding: mem time452, current time 457, horizon 5\n", - "adding: mem time453, current time 457, horizon 4\n", - "adding: mem time454, current time 457, horizon 3\n", - "adding: mem time455, current time 457, horizon 2\n", - "adding: mem time456, current time 457, horizon 1\n", - "adding: mem time400, current time 458, horizon 58\n", - "adding: mem time401, current time 458, horizon 57\n", - "adding: mem time402, current time 458, horizon 56\n", - "adding: mem time403, current time 458, horizon 55\n", - "adding: mem time404, current time 458, horizon 54\n", - "adding: mem time405, current time 458, horizon 53\n", - "adding: mem time406, current time 458, horizon 52\n", - "adding: mem time407, current time 458, horizon 51\n", - "adding: mem time408, current time 458, horizon 50\n", - "adding: mem time409, current time 458, horizon 49\n", - "adding: mem time410, current time 458, horizon 48\n", - "adding: mem time411, current time 458, horizon 47\n", - "adding: mem time412, current time 458, horizon 46\n", - "adding: mem time413, current time 458, horizon 45\n", - "adding: mem time414, current time 458, horizon 44\n", - "adding: mem time415, current time 458, horizon 43\n", - "adding: mem time416, current time 458, horizon 42\n", - "adding: mem time417, current time 458, horizon 41\n", - "adding: mem time418, current time 458, horizon 40\n", - "adding: mem time419, current time 458, horizon 39\n", - "adding: mem time420, current time 458, horizon 38\n", - "adding: mem time421, current time 458, horizon 37\n", - "adding: mem time422, current time 458, horizon 36\n", - "adding: mem time423, current time 458, horizon 35\n", - "adding: mem time424, current time 458, horizon 34\n", - "adding: mem time425, current time 458, horizon 33\n", - "adding: mem time426, current time 458, horizon 32\n", - "adding: mem time427, current time 458, horizon 31\n", - "adding: mem time428, current time 458, horizon 30\n", - "adding: mem time429, current time 458, horizon 29\n", - "adding: mem time430, current time 458, horizon 28\n", - "adding: mem time431, current time 458, horizon 27\n", - "adding: mem time432, current time 458, horizon 26\n", - "adding: mem time433, current time 458, horizon 25\n", - "adding: mem time434, current time 458, horizon 24\n", - "adding: mem time435, current time 458, horizon 23\n", - "adding: mem time436, current time 458, horizon 22\n", - "adding: mem time437, current time 458, horizon 21\n", - "adding: mem time438, current time 458, horizon 20\n", - "adding: mem time439, current time 458, horizon 19\n", - "adding: mem time440, current time 458, horizon 18\n", - "adding: mem time441, current time 458, horizon 17\n", - "adding: mem time442, current time 458, horizon 16\n", - "adding: mem time443, current time 458, horizon 15\n", - "adding: mem time444, current time 458, horizon 14\n", - "adding: mem time445, current time 458, horizon 13\n", - "adding: mem time446, current time 458, horizon 12\n", - "adding: mem time447, current time 458, horizon 11\n", - "adding: mem time448, current time 458, horizon 10\n", - "adding: mem time449, current time 458, horizon 9\n", - "adding: mem time450, current time 458, horizon 8\n", - "adding: mem time451, current time 458, horizon 7\n", - "adding: mem time452, current time 458, horizon 6\n", - "adding: mem time453, current time 458, horizon 5\n", - "adding: mem time454, current time 458, horizon 4\n", - "adding: mem time455, current time 458, horizon 3\n", - "adding: mem time456, current time 458, horizon 2\n", - "adding: mem time457, current time 458, horizon 1\n", - "adding: mem time400, current time 459, horizon 59\n", - "adding: mem time401, current time 459, horizon 58\n", - "adding: mem time402, current time 459, horizon 57\n", - "adding: mem time403, current time 459, horizon 56\n", - "adding: mem time404, current time 459, horizon 55\n", - "adding: mem time405, current time 459, horizon 54\n", - "adding: mem time406, current time 459, horizon 53\n", - "adding: mem time407, current time 459, horizon 52\n", - "adding: mem time408, current time 459, horizon 51\n", - "adding: mem time409, current time 459, horizon 50\n", - "adding: mem time410, current time 459, horizon 49\n", - "adding: mem time411, current time 459, horizon 48\n", - "adding: mem time412, current time 459, horizon 47\n", - "adding: mem time413, current time 459, horizon 46\n", - "adding: mem time414, current time 459, horizon 45\n", - "adding: mem time415, current time 459, horizon 44\n", - "adding: mem time416, current time 459, horizon 43\n", - "adding: mem time417, current time 459, horizon 42\n", - "adding: mem time418, current time 459, horizon 41\n", - "adding: mem time419, current time 459, horizon 40\n", - "adding: mem time420, current time 459, horizon 39\n", - "adding: mem time421, current time 459, horizon 38\n", - "adding: mem time422, current time 459, horizon 37\n", - "adding: mem time423, current time 459, horizon 36\n", - "adding: mem time424, current time 459, horizon 35\n", - "adding: mem time425, current time 459, horizon 34\n", - "adding: mem time426, current time 459, horizon 33\n", - "adding: mem time427, current time 459, horizon 32\n", - "adding: mem time428, current time 459, horizon 31\n", - "adding: mem time429, current time 459, horizon 30\n", - "adding: mem time430, current time 459, horizon 29\n", - "adding: mem time431, current time 459, horizon 28\n", - "adding: mem time432, current time 459, horizon 27\n", - "adding: mem time433, current time 459, horizon 26\n", - "adding: mem time434, current time 459, horizon 25\n", - "adding: mem time435, current time 459, horizon 24\n", - "adding: mem time436, current time 459, horizon 23\n", - "adding: mem time437, current time 459, horizon 22\n", - "adding: mem time438, current time 459, horizon 21\n", - "adding: mem time439, current time 459, horizon 20\n", - "adding: mem time440, current time 459, horizon 19\n", - "adding: mem time441, current time 459, horizon 18\n", - "adding: mem time442, current time 459, horizon 17\n", - "adding: mem time443, current time 459, horizon 16\n", - "adding: mem time444, current time 459, horizon 15\n", - "adding: mem time445, current time 459, horizon 14\n", - "adding: mem time446, current time 459, horizon 13\n", - "adding: mem time447, current time 459, horizon 12\n", - "adding: mem time448, current time 459, horizon 11\n", - "adding: mem time449, current time 459, horizon 10\n", - "adding: mem time450, current time 459, horizon 9\n", - "adding: mem time451, current time 459, horizon 8\n", - "adding: mem time452, current time 459, horizon 7\n", - "adding: mem time453, current time 459, horizon 6\n", - "adding: mem time454, current time 459, horizon 5\n", - "adding: mem time455, current time 459, horizon 4\n", - "adding: mem time456, current time 459, horizon 3\n", - "adding: mem time457, current time 459, horizon 2\n", - "adding: mem time458, current time 459, horizon 1\n", - "adding: mem time400, current time 460, horizon 60\n", - "adding: mem time401, current time 460, horizon 59\n", - "adding: mem time402, current time 460, horizon 58\n", - "adding: mem time403, current time 460, horizon 57\n", - "adding: mem time404, current time 460, horizon 56\n", - "adding: mem time405, current time 460, horizon 55\n", - "adding: mem time406, current time 460, horizon 54\n", - "adding: mem time407, current time 460, horizon 53\n", - "adding: mem time408, current time 460, horizon 52\n", - "adding: mem time409, current time 460, horizon 51\n", - "adding: mem time410, current time 460, horizon 50\n", - "adding: mem time411, current time 460, horizon 49\n", - "adding: mem time412, current time 460, horizon 48\n", - "adding: mem time413, current time 460, horizon 47\n", - "adding: mem time414, current time 460, horizon 46\n", - "adding: mem time415, current time 460, horizon 45\n", - "adding: mem time416, current time 460, horizon 44\n", - "adding: mem time417, current time 460, horizon 43\n", - "adding: mem time418, current time 460, horizon 42\n", - "adding: mem time419, current time 460, horizon 41\n", - "adding: mem time420, current time 460, horizon 40\n", - "adding: mem time421, current time 460, horizon 39\n", - "adding: mem time422, current time 460, horizon 38\n", - "adding: mem time423, current time 460, horizon 37\n", - "adding: mem time424, current time 460, horizon 36\n", - "adding: mem time425, current time 460, horizon 35\n", - "adding: mem time426, current time 460, horizon 34\n", - "adding: mem time427, current time 460, horizon 33\n", - "adding: mem time428, current time 460, horizon 32\n", - "adding: mem time429, current time 460, horizon 31\n", - "adding: mem time430, current time 460, horizon 30\n", - "adding: mem time431, current time 460, horizon 29\n", - "adding: mem time432, current time 460, horizon 28\n", - "adding: mem time433, current time 460, horizon 27\n", - "adding: mem time434, current time 460, horizon 26\n", - "adding: mem time435, current time 460, horizon 25\n", - "adding: mem time436, current time 460, horizon 24\n", - "adding: mem time437, current time 460, horizon 23\n", - "adding: mem time438, current time 460, horizon 22\n", - "adding: mem time439, current time 460, horizon 21\n", - "adding: mem time440, current time 460, horizon 20\n", - "adding: mem time441, current time 460, horizon 19\n", - "adding: mem time442, current time 460, horizon 18\n", - "adding: mem time443, current time 460, horizon 17\n", - "adding: mem time444, current time 460, horizon 16\n", - "adding: mem time445, current time 460, horizon 15\n", - "adding: mem time446, current time 460, horizon 14\n", - "adding: mem time447, current time 460, horizon 13\n", - "adding: mem time448, current time 460, horizon 12\n", - "adding: mem time449, current time 460, horizon 11\n", - "adding: mem time450, current time 460, horizon 10\n", - "adding: mem time451, current time 460, horizon 9\n", - "adding: mem time452, current time 460, horizon 8\n", - "adding: mem time453, current time 460, horizon 7\n", - "adding: mem time454, current time 460, horizon 6\n", - "adding: mem time455, current time 460, horizon 5\n", - "adding: mem time456, current time 460, horizon 4\n", - "adding: mem time457, current time 460, horizon 3\n", - "adding: mem time458, current time 460, horizon 2\n", - "adding: mem time459, current time 460, horizon 1\n", - "adding: mem time400, current time 461, horizon 61\n", - "adding: mem time401, current time 461, horizon 60\n", - "adding: mem time402, current time 461, horizon 59\n", - "adding: mem time403, current time 461, horizon 58\n", - "adding: mem time404, current time 461, horizon 57\n", - "adding: mem time405, current time 461, horizon 56\n", - "adding: mem time406, current time 461, horizon 55\n", - "adding: mem time407, current time 461, horizon 54\n", - "adding: mem time408, current time 461, horizon 53\n", - "adding: mem time409, current time 461, horizon 52\n", - "adding: mem time410, current time 461, horizon 51\n", - "adding: mem time411, current time 461, horizon 50\n", - "adding: mem time412, current time 461, horizon 49\n", - "adding: mem time413, current time 461, horizon 48\n", - "adding: mem time414, current time 461, horizon 47\n", - "adding: mem time415, current time 461, horizon 46\n", - "adding: mem time416, current time 461, horizon 45\n", - "adding: mem time417, current time 461, horizon 44\n", - "adding: mem time418, current time 461, horizon 43\n", - "adding: mem time419, current time 461, horizon 42\n", - "adding: mem time420, current time 461, horizon 41\n", - "adding: mem time421, current time 461, horizon 40\n", - "adding: mem time422, current time 461, horizon 39\n", - "adding: mem time423, current time 461, horizon 38\n", - "adding: mem time424, current time 461, horizon 37\n", - "adding: mem time425, current time 461, horizon 36\n", - "adding: mem time426, current time 461, horizon 35\n", - "adding: mem time427, current time 461, horizon 34\n", - "adding: mem time428, current time 461, horizon 33\n", - "adding: mem time429, current time 461, horizon 32\n", - "adding: mem time430, current time 461, horizon 31\n", - "adding: mem time431, current time 461, horizon 30\n", - "adding: mem time432, current time 461, horizon 29\n", - "adding: mem time433, current time 461, horizon 28\n", - "adding: mem time434, current time 461, horizon 27\n", - "adding: mem time435, current time 461, horizon 26\n", - "adding: mem time436, current time 461, horizon 25\n", - "adding: mem time437, current time 461, horizon 24\n", - "adding: mem time438, current time 461, horizon 23\n", - "adding: mem time439, current time 461, horizon 22\n", - "adding: mem time440, current time 461, horizon 21\n", - "adding: mem time441, current time 461, horizon 20\n", - "adding: mem time442, current time 461, horizon 19\n", - "adding: mem time443, current time 461, horizon 18\n", - "adding: mem time444, current time 461, horizon 17\n", - "adding: mem time445, current time 461, horizon 16\n", - "adding: mem time446, current time 461, horizon 15\n", - "adding: mem time447, current time 461, horizon 14\n", - "adding: mem time448, current time 461, horizon 13\n", - "adding: mem time449, current time 461, horizon 12\n", - "adding: mem time450, current time 461, horizon 11\n", - "adding: mem time451, current time 461, horizon 10\n", - "adding: mem time452, current time 461, horizon 9\n", - "adding: mem time453, current time 461, horizon 8\n", - "adding: mem time454, current time 461, horizon 7\n", - "adding: mem time455, current time 461, horizon 6\n", - "adding: mem time456, current time 461, horizon 5\n", - "adding: mem time457, current time 461, horizon 4\n", - "adding: mem time458, current time 461, horizon 3\n", - "adding: mem time459, current time 461, horizon 2\n", - "adding: mem time460, current time 461, horizon 1\n", - "adding: mem time400, current time 462, horizon 62\n", - "adding: mem time401, current time 462, horizon 61\n", - "adding: mem time402, current time 462, horizon 60\n", - "adding: mem time403, current time 462, horizon 59\n", - "adding: mem time404, current time 462, horizon 58\n", - "adding: mem time405, current time 462, horizon 57\n", - "adding: mem time406, current time 462, horizon 56\n", - "adding: mem time407, current time 462, horizon 55\n", - "adding: mem time408, current time 462, horizon 54\n", - "adding: mem time409, current time 462, horizon 53\n", - "adding: mem time410, current time 462, horizon 52\n", - "adding: mem time411, current time 462, horizon 51\n", - "adding: mem time412, current time 462, horizon 50\n", - "adding: mem time413, current time 462, horizon 49\n", - "adding: mem time414, current time 462, horizon 48\n", - "adding: mem time415, current time 462, horizon 47\n", - "adding: mem time416, current time 462, horizon 46\n", - "adding: mem time417, current time 462, horizon 45\n", - "adding: mem time418, current time 462, horizon 44\n", - "adding: mem time419, current time 462, horizon 43\n", - "adding: mem time420, current time 462, horizon 42\n", - "adding: mem time421, current time 462, horizon 41\n", - "adding: mem time422, current time 462, horizon 40\n", - "adding: mem time423, current time 462, horizon 39\n", - "adding: mem time424, current time 462, horizon 38\n", - "adding: mem time425, current time 462, horizon 37\n", - "adding: mem time426, current time 462, horizon 36\n", - "adding: mem time427, current time 462, horizon 35\n", - "adding: mem time428, current time 462, horizon 34\n", - "adding: mem time429, current time 462, horizon 33\n", - "adding: mem time430, current time 462, horizon 32\n", - "adding: mem time431, current time 462, horizon 31\n", - "adding: mem time432, current time 462, horizon 30\n", - "adding: mem time433, current time 462, horizon 29\n", - "adding: mem time434, current time 462, horizon 28\n", - "adding: mem time435, current time 462, horizon 27\n", - "adding: mem time436, current time 462, horizon 26\n", - "adding: mem time437, current time 462, horizon 25\n", - "adding: mem time438, current time 462, horizon 24\n", - "adding: mem time439, current time 462, horizon 23\n", - "adding: mem time440, current time 462, horizon 22\n", - "adding: mem time441, current time 462, horizon 21\n", - "adding: mem time442, current time 462, horizon 20\n", - "adding: mem time443, current time 462, horizon 19\n", - "adding: mem time444, current time 462, horizon 18\n", - "adding: mem time445, current time 462, horizon 17\n", - "adding: mem time446, current time 462, horizon 16\n", - "adding: mem time447, current time 462, horizon 15\n", - "adding: mem time448, current time 462, horizon 14\n", - "adding: mem time449, current time 462, horizon 13\n", - "adding: mem time450, current time 462, horizon 12\n", - "adding: mem time451, current time 462, horizon 11\n", - "adding: mem time452, current time 462, horizon 10\n", - "adding: mem time453, current time 462, horizon 9\n", - "adding: mem time454, current time 462, horizon 8\n", - "adding: mem time455, current time 462, horizon 7\n", - "adding: mem time456, current time 462, horizon 6\n", - "adding: mem time457, current time 462, horizon 5\n", - "adding: mem time458, current time 462, horizon 4\n", - "adding: mem time459, current time 462, horizon 3\n", - "adding: mem time460, current time 462, horizon 2\n", - "adding: mem time461, current time 462, horizon 1\n", - "adding: mem time400, current time 463, horizon 63\n", - "adding: mem time401, current time 463, horizon 62\n", - "adding: mem time402, current time 463, horizon 61\n", - "adding: mem time403, current time 463, horizon 60\n", - "adding: mem time404, current time 463, horizon 59\n", - "adding: mem time405, current time 463, horizon 58\n", - "adding: mem time406, current time 463, horizon 57\n", - "adding: mem time407, current time 463, horizon 56\n", - "adding: mem time408, current time 463, horizon 55\n", - "adding: mem time409, current time 463, horizon 54\n", - "adding: mem time410, current time 463, horizon 53\n", - "adding: mem time411, current time 463, horizon 52\n", - "adding: mem time412, current time 463, horizon 51\n", - "adding: mem time413, current time 463, horizon 50\n", - "adding: mem time414, current time 463, horizon 49\n", - "adding: mem time415, current time 463, horizon 48\n", - "adding: mem time416, current time 463, horizon 47\n", - "adding: mem time417, current time 463, horizon 46\n", - "adding: mem time418, current time 463, horizon 45\n", - "adding: mem time419, current time 463, horizon 44\n", - "adding: mem time420, current time 463, horizon 43\n", - "adding: mem time421, current time 463, horizon 42\n", - "adding: mem time422, current time 463, horizon 41\n", - "adding: mem time423, current time 463, horizon 40\n", - "adding: mem time424, current time 463, horizon 39\n", - "adding: mem time425, current time 463, horizon 38\n", - "adding: mem time426, current time 463, horizon 37\n", - "adding: mem time427, current time 463, horizon 36\n", - "adding: mem time428, current time 463, horizon 35\n", - "adding: mem time429, current time 463, horizon 34\n", - "adding: mem time430, current time 463, horizon 33\n", - "adding: mem time431, current time 463, horizon 32\n", - "adding: mem time432, current time 463, horizon 31\n", - "adding: mem time433, current time 463, horizon 30\n", - "adding: mem time434, current time 463, horizon 29\n", - "adding: mem time435, current time 463, horizon 28\n", - "adding: mem time436, current time 463, horizon 27\n", - "adding: mem time437, current time 463, horizon 26\n", - "adding: mem time438, current time 463, horizon 25\n", - "adding: mem time439, current time 463, horizon 24\n", - "adding: mem time440, current time 463, horizon 23\n", - "adding: mem time441, current time 463, horizon 22\n", - "adding: mem time442, current time 463, horizon 21\n", - "adding: mem time443, current time 463, horizon 20\n", - "adding: mem time444, current time 463, horizon 19\n", - "adding: mem time445, current time 463, horizon 18\n", - "adding: mem time446, current time 463, horizon 17\n", - "adding: mem time447, current time 463, horizon 16\n", - "adding: mem time448, current time 463, horizon 15\n", - "adding: mem time449, current time 463, horizon 14\n", - "adding: mem time450, current time 463, horizon 13\n", - "adding: mem time451, current time 463, horizon 12\n", - "adding: mem time452, current time 463, horizon 11\n", - "adding: mem time453, current time 463, horizon 10\n", - "adding: mem time454, current time 463, horizon 9\n", - "adding: mem time455, current time 463, horizon 8\n", - "adding: mem time456, current time 463, horizon 7\n", - "adding: mem time457, current time 463, horizon 6\n", - "adding: mem time458, current time 463, horizon 5\n", - "adding: mem time459, current time 463, horizon 4\n", - "adding: mem time460, current time 463, horizon 3\n", - "adding: mem time461, current time 463, horizon 2\n", - "adding: mem time462, current time 463, horizon 1\n", - "adding: mem time400, current time 464, horizon 64\n", - "adding: mem time401, current time 464, horizon 63\n", - "adding: mem time402, current time 464, horizon 62\n", - "adding: mem time403, current time 464, horizon 61\n", - "adding: mem time404, current time 464, horizon 60\n", - "adding: mem time405, current time 464, horizon 59\n", - "adding: mem time406, current time 464, horizon 58\n", - "adding: mem time407, current time 464, horizon 57\n", - "adding: mem time408, current time 464, horizon 56\n", - "adding: mem time409, current time 464, horizon 55\n", - "adding: mem time410, current time 464, horizon 54\n", - "adding: mem time411, current time 464, horizon 53\n", - "adding: mem time412, current time 464, horizon 52\n", - "adding: mem time413, current time 464, horizon 51\n", - "adding: mem time414, current time 464, horizon 50\n", - "adding: mem time415, current time 464, horizon 49\n", - "adding: mem time416, current time 464, horizon 48\n", - "adding: mem time417, current time 464, horizon 47\n", - "adding: mem time418, current time 464, horizon 46\n", - "adding: mem time419, current time 464, horizon 45\n", - "adding: mem time420, current time 464, horizon 44\n", - "adding: mem time421, current time 464, horizon 43\n", - "adding: mem time422, current time 464, horizon 42\n", - "adding: mem time423, current time 464, horizon 41\n", - "adding: mem time424, current time 464, horizon 40\n", - "adding: mem time425, current time 464, horizon 39\n", - "adding: mem time426, current time 464, horizon 38\n", - "adding: mem time427, current time 464, horizon 37\n", - "adding: mem time428, current time 464, horizon 36\n", - "adding: mem time429, current time 464, horizon 35\n", - "adding: mem time430, current time 464, horizon 34\n", - "adding: mem time431, current time 464, horizon 33\n", - "adding: mem time432, current time 464, horizon 32\n", - "adding: mem time433, current time 464, horizon 31\n", - "adding: mem time434, current time 464, horizon 30\n", - "adding: mem time435, current time 464, horizon 29\n", - "adding: mem time436, current time 464, horizon 28\n", - "adding: mem time437, current time 464, horizon 27\n", - "adding: mem time438, current time 464, horizon 26\n", - "adding: mem time439, current time 464, horizon 25\n", - "adding: mem time440, current time 464, horizon 24\n", - "adding: mem time441, current time 464, horizon 23\n", - "adding: mem time442, current time 464, horizon 22\n", - "adding: mem time443, current time 464, horizon 21\n", - "adding: mem time444, current time 464, horizon 20\n", - "adding: mem time445, current time 464, horizon 19\n", - "adding: mem time446, current time 464, horizon 18\n", - "adding: mem time447, current time 464, horizon 17\n", - "adding: mem time448, current time 464, horizon 16\n", - "adding: mem time449, current time 464, horizon 15\n", - "adding: mem time450, current time 464, horizon 14\n", - "adding: mem time451, current time 464, horizon 13\n", - "adding: mem time452, current time 464, horizon 12\n", - "adding: mem time453, current time 464, horizon 11\n", - "adding: mem time454, current time 464, horizon 10\n", - "adding: mem time455, current time 464, horizon 9\n", - "adding: mem time456, current time 464, horizon 8\n", - "adding: mem time457, current time 464, horizon 7\n", - "adding: mem time458, current time 464, horizon 6\n", - "adding: mem time459, current time 464, horizon 5\n", - "adding: mem time460, current time 464, horizon 4\n", - "adding: mem time461, current time 464, horizon 3\n", - "adding: mem time462, current time 464, horizon 2\n", - "adding: mem time463, current time 464, horizon 1\n", - "adding: mem time400, current time 465, horizon 65\n", - "adding: mem time401, current time 465, horizon 64\n", - "adding: mem time402, current time 465, horizon 63\n", - "adding: mem time403, current time 465, horizon 62\n", - "adding: mem time404, current time 465, horizon 61\n", - "adding: mem time405, current time 465, horizon 60\n", - "adding: mem time406, current time 465, horizon 59\n", - "adding: mem time407, current time 465, horizon 58\n", - "adding: mem time408, current time 465, horizon 57\n", - "adding: mem time409, current time 465, horizon 56\n", - "adding: mem time410, current time 465, horizon 55\n", - "adding: mem time411, current time 465, horizon 54\n", - "adding: mem time412, current time 465, horizon 53\n", - "adding: mem time413, current time 465, horizon 52\n", - "adding: mem time414, current time 465, horizon 51\n", - "adding: mem time415, current time 465, horizon 50\n", - "adding: mem time416, current time 465, horizon 49\n", - "adding: mem time417, current time 465, horizon 48\n", - "adding: mem time418, current time 465, horizon 47\n", - "adding: mem time419, current time 465, horizon 46\n", - "adding: mem time420, current time 465, horizon 45\n", - "adding: mem time421, current time 465, horizon 44\n", - "adding: mem time422, current time 465, horizon 43\n", - "adding: mem time423, current time 465, horizon 42\n", - "adding: mem time424, current time 465, horizon 41\n", - "adding: mem time425, current time 465, horizon 40\n", - "adding: mem time426, current time 465, horizon 39\n", - "adding: mem time427, current time 465, horizon 38\n", - "adding: mem time428, current time 465, horizon 37\n", - "adding: mem time429, current time 465, horizon 36\n", - "adding: mem time430, current time 465, horizon 35\n", - "adding: mem time431, current time 465, horizon 34\n", - "adding: mem time432, current time 465, horizon 33\n", - "adding: mem time433, current time 465, horizon 32\n", - "adding: mem time434, current time 465, horizon 31\n", - "adding: mem time435, current time 465, horizon 30\n", - "adding: mem time436, current time 465, horizon 29\n", - "adding: mem time437, current time 465, horizon 28\n", - "adding: mem time438, current time 465, horizon 27\n", - "adding: mem time439, current time 465, horizon 26\n", - "adding: mem time440, current time 465, horizon 25\n", - "adding: mem time441, current time 465, horizon 24\n", - "adding: mem time442, current time 465, horizon 23\n", - "adding: mem time443, current time 465, horizon 22\n", - "adding: mem time444, current time 465, horizon 21\n", - "adding: mem time445, current time 465, horizon 20\n", - "adding: mem time446, current time 465, horizon 19\n", - "adding: mem time447, current time 465, horizon 18\n", - "adding: mem time448, current time 465, horizon 17\n", - "adding: mem time449, current time 465, horizon 16\n", - "adding: mem time450, current time 465, horizon 15\n", - "adding: mem time451, current time 465, horizon 14\n", - "adding: mem time452, current time 465, horizon 13\n", - "adding: mem time453, current time 465, horizon 12\n", - "adding: mem time454, current time 465, horizon 11\n", - "adding: mem time455, current time 465, horizon 10\n", - "adding: mem time456, current time 465, horizon 9\n", - "adding: mem time457, current time 465, horizon 8\n", - "adding: mem time458, current time 465, horizon 7\n", - "adding: mem time459, current time 465, horizon 6\n", - "adding: mem time460, current time 465, horizon 5\n", - "adding: mem time461, current time 465, horizon 4\n", - "adding: mem time462, current time 465, horizon 3\n", - "adding: mem time463, current time 465, horizon 2\n", - "adding: mem time464, current time 465, horizon 1\n", - "adding: mem time400, current time 466, horizon 66\n", - "adding: mem time401, current time 466, horizon 65\n", - "adding: mem time402, current time 466, horizon 64\n", - "adding: mem time403, current time 466, horizon 63\n", - "adding: mem time404, current time 466, horizon 62\n", - "adding: mem time405, current time 466, horizon 61\n", - "adding: mem time406, current time 466, horizon 60\n", - "adding: mem time407, current time 466, horizon 59\n", - "adding: mem time408, current time 466, horizon 58\n", - "adding: mem time409, current time 466, horizon 57\n", - "adding: mem time410, current time 466, horizon 56\n", - "adding: mem time411, current time 466, horizon 55\n", - "adding: mem time412, current time 466, horizon 54\n", - "adding: mem time413, current time 466, horizon 53\n", - "adding: mem time414, current time 466, horizon 52\n", - "adding: mem time415, current time 466, horizon 51\n", - "adding: mem time416, current time 466, horizon 50\n", - "adding: mem time417, current time 466, horizon 49\n", - "adding: mem time418, current time 466, horizon 48\n", - "adding: mem time419, current time 466, horizon 47\n", - "adding: mem time420, current time 466, horizon 46\n", - "adding: mem time421, current time 466, horizon 45\n", - "adding: mem time422, current time 466, horizon 44\n", - "adding: mem time423, current time 466, horizon 43\n", - "adding: mem time424, current time 466, horizon 42\n", - "adding: mem time425, current time 466, horizon 41\n", - "adding: mem time426, current time 466, horizon 40\n", - "adding: mem time427, current time 466, horizon 39\n", - "adding: mem time428, current time 466, horizon 38\n", - "adding: mem time429, current time 466, horizon 37\n", - "adding: mem time430, current time 466, horizon 36\n", - "adding: mem time431, current time 466, horizon 35\n", - "adding: mem time432, current time 466, horizon 34\n", - "adding: mem time433, current time 466, horizon 33\n", - "adding: mem time434, current time 466, horizon 32\n", - "adding: mem time435, current time 466, horizon 31\n", - "adding: mem time436, current time 466, horizon 30\n", - "adding: mem time437, current time 466, horizon 29\n", - "adding: mem time438, current time 466, horizon 28\n", - "adding: mem time439, current time 466, horizon 27\n", - "adding: mem time440, current time 466, horizon 26\n", - "adding: mem time441, current time 466, horizon 25\n", - "adding: mem time442, current time 466, horizon 24\n", - "adding: mem time443, current time 466, horizon 23\n", - "adding: mem time444, current time 466, horizon 22\n", - "adding: mem time445, current time 466, horizon 21\n", - "adding: mem time446, current time 466, horizon 20\n", - "adding: mem time447, current time 466, horizon 19\n", - "adding: mem time448, current time 466, horizon 18\n", - "adding: mem time449, current time 466, horizon 17\n", - "adding: mem time450, current time 466, horizon 16\n", - "adding: mem time451, current time 466, horizon 15\n", - "adding: mem time452, current time 466, horizon 14\n", - "adding: mem time453, current time 466, horizon 13\n", - "adding: mem time454, current time 466, horizon 12\n", - "adding: mem time455, current time 466, horizon 11\n", - "adding: mem time456, current time 466, horizon 10\n", - "adding: mem time457, current time 466, horizon 9\n", - "adding: mem time458, current time 466, horizon 8\n", - "adding: mem time459, current time 466, horizon 7\n", - "adding: mem time460, current time 466, horizon 6\n", - "adding: mem time461, current time 466, horizon 5\n", - "adding: mem time462, current time 466, horizon 4\n", - "adding: mem time463, current time 466, horizon 3\n", - "adding: mem time464, current time 466, horizon 2\n", - "adding: mem time465, current time 466, horizon 1\n", - "adding: mem time400, current time 467, horizon 67\n", - "adding: mem time401, current time 467, horizon 66\n", - "adding: mem time402, current time 467, horizon 65\n", - "adding: mem time403, current time 467, horizon 64\n", - "adding: mem time404, current time 467, horizon 63\n", - "adding: mem time405, current time 467, horizon 62\n", - "adding: mem time406, current time 467, horizon 61\n", - "adding: mem time407, current time 467, horizon 60\n", - "adding: mem time408, current time 467, horizon 59\n", - "adding: mem time409, current time 467, horizon 58\n", - "adding: mem time410, current time 467, horizon 57\n", - "adding: mem time411, current time 467, horizon 56\n", - "adding: mem time412, current time 467, horizon 55\n", - "adding: mem time413, current time 467, horizon 54\n", - "adding: mem time414, current time 467, horizon 53\n", - "adding: mem time415, current time 467, horizon 52\n", - "adding: mem time416, current time 467, horizon 51\n", - "adding: mem time417, current time 467, horizon 50\n", - "adding: mem time418, current time 467, horizon 49\n", - "adding: mem time419, current time 467, horizon 48\n", - "adding: mem time420, current time 467, horizon 47\n", - "adding: mem time421, current time 467, horizon 46\n", - "adding: mem time422, current time 467, horizon 45\n", - "adding: mem time423, current time 467, horizon 44\n", - "adding: mem time424, current time 467, horizon 43\n", - "adding: mem time425, current time 467, horizon 42\n", - "adding: mem time426, current time 467, horizon 41\n", - "adding: mem time427, current time 467, horizon 40\n", - "adding: mem time428, current time 467, horizon 39\n", - "adding: mem time429, current time 467, horizon 38\n", - "adding: mem time430, current time 467, horizon 37\n", - "adding: mem time431, current time 467, horizon 36\n", - "adding: mem time432, current time 467, horizon 35\n", - "adding: mem time433, current time 467, horizon 34\n", - "adding: mem time434, current time 467, horizon 33\n", - "adding: mem time435, current time 467, horizon 32\n", - "adding: mem time436, current time 467, horizon 31\n", - "adding: mem time437, current time 467, horizon 30\n", - "adding: mem time438, current time 467, horizon 29\n", - "adding: mem time439, current time 467, horizon 28\n", - "adding: mem time440, current time 467, horizon 27\n", - "adding: mem time441, current time 467, horizon 26\n", - "adding: mem time442, current time 467, horizon 25\n", - "adding: mem time443, current time 467, horizon 24\n", - "adding: mem time444, current time 467, horizon 23\n", - "adding: mem time445, current time 467, horizon 22\n", - "adding: mem time446, current time 467, horizon 21\n", - "adding: mem time447, current time 467, horizon 20\n", - "adding: mem time448, current time 467, horizon 19\n", - "adding: mem time449, current time 467, horizon 18\n", - "adding: mem time450, current time 467, horizon 17\n", - "adding: mem time451, current time 467, horizon 16\n", - "adding: mem time452, current time 467, horizon 15\n", - "adding: mem time453, current time 467, horizon 14\n", - "adding: mem time454, current time 467, horizon 13\n", - "adding: mem time455, current time 467, horizon 12\n", - "adding: mem time456, current time 467, horizon 11\n", - "adding: mem time457, current time 467, horizon 10\n", - "adding: mem time458, current time 467, horizon 9\n", - "adding: mem time459, current time 467, horizon 8\n", - "adding: mem time460, current time 467, horizon 7\n", - "adding: mem time461, current time 467, horizon 6\n", - "adding: mem time462, current time 467, horizon 5\n", - "adding: mem time463, current time 467, horizon 4\n", - "adding: mem time464, current time 467, horizon 3\n", - "adding: mem time465, current time 467, horizon 2\n", - "adding: mem time466, current time 467, horizon 1\n", - "adding: mem time400, current time 468, horizon 68\n", - "adding: mem time401, current time 468, horizon 67\n", - "adding: mem time402, current time 468, horizon 66\n", - "adding: mem time403, current time 468, horizon 65\n", - "adding: mem time404, current time 468, horizon 64\n", - "adding: mem time405, current time 468, horizon 63\n", - "adding: mem time406, current time 468, horizon 62\n", - "adding: mem time407, current time 468, horizon 61\n", - "adding: mem time408, current time 468, horizon 60\n", - "adding: mem time409, current time 468, horizon 59\n", - "adding: mem time410, current time 468, horizon 58\n", - "adding: mem time411, current time 468, horizon 57\n", - "adding: mem time412, current time 468, horizon 56\n", - "adding: mem time413, current time 468, horizon 55\n", - "adding: mem time414, current time 468, horizon 54\n", - "adding: mem time415, current time 468, horizon 53\n", - "adding: mem time416, current time 468, horizon 52\n", - "adding: mem time417, current time 468, horizon 51\n", - "adding: mem time418, current time 468, horizon 50\n", - "adding: mem time419, current time 468, horizon 49\n", - "adding: mem time420, current time 468, horizon 48\n", - "adding: mem time421, current time 468, horizon 47\n", - "adding: mem time422, current time 468, horizon 46\n", - "adding: mem time423, current time 468, horizon 45\n", - "adding: mem time424, current time 468, horizon 44\n", - "adding: mem time425, current time 468, horizon 43\n", - "adding: mem time426, current time 468, horizon 42\n", - "adding: mem time427, current time 468, horizon 41\n", - "adding: mem time428, current time 468, horizon 40\n", - "adding: mem time429, current time 468, horizon 39\n", - "adding: mem time430, current time 468, horizon 38\n", - "adding: mem time431, current time 468, horizon 37\n", - "adding: mem time432, current time 468, horizon 36\n", - "adding: mem time433, current time 468, horizon 35\n", - "adding: mem time434, current time 468, horizon 34\n", - "adding: mem time435, current time 468, horizon 33\n", - "adding: mem time436, current time 468, horizon 32\n", - "adding: mem time437, current time 468, horizon 31\n", - "adding: mem time438, current time 468, horizon 30\n", - "adding: mem time439, current time 468, horizon 29\n", - "adding: mem time440, current time 468, horizon 28\n", - "adding: mem time441, current time 468, horizon 27\n", - "adding: mem time442, current time 468, horizon 26\n", - "adding: mem time443, current time 468, horizon 25\n", - "adding: mem time444, current time 468, horizon 24\n", - "adding: mem time445, current time 468, horizon 23\n", - "adding: mem time446, current time 468, horizon 22\n", - "adding: mem time447, current time 468, horizon 21\n", - "adding: mem time448, current time 468, horizon 20\n", - "adding: mem time449, current time 468, horizon 19\n", - "adding: mem time450, current time 468, horizon 18\n", - "adding: mem time451, current time 468, horizon 17\n", - "adding: mem time452, current time 468, horizon 16\n", - "adding: mem time453, current time 468, horizon 15\n", - "adding: mem time454, current time 468, horizon 14\n", - "adding: mem time455, current time 468, horizon 13\n", - "adding: mem time456, current time 468, horizon 12\n", - "adding: mem time457, current time 468, horizon 11\n", - "adding: mem time458, current time 468, horizon 10\n", - "adding: mem time459, current time 468, horizon 9\n", - "adding: mem time460, current time 468, horizon 8\n", - "adding: mem time461, current time 468, horizon 7\n", - "adding: mem time462, current time 468, horizon 6\n", - "adding: mem time463, current time 468, horizon 5\n", - "adding: mem time464, current time 468, horizon 4\n", - "adding: mem time465, current time 468, horizon 3\n", - "adding: mem time466, current time 468, horizon 2\n", - "adding: mem time467, current time 468, horizon 1\n", - "adding: mem time400, current time 469, horizon 69\n", - "adding: mem time401, current time 469, horizon 68\n", - "adding: mem time402, current time 469, horizon 67\n", - "adding: mem time403, current time 469, horizon 66\n", - "adding: mem time404, current time 469, horizon 65\n", - "adding: mem time405, current time 469, horizon 64\n", - "adding: mem time406, current time 469, horizon 63\n", - "adding: mem time407, current time 469, horizon 62\n", - "adding: mem time408, current time 469, horizon 61\n", - "adding: mem time409, current time 469, horizon 60\n", - "adding: mem time410, current time 469, horizon 59\n", - "adding: mem time411, current time 469, horizon 58\n", - "adding: mem time412, current time 469, horizon 57\n", - "adding: mem time413, current time 469, horizon 56\n", - "adding: mem time414, current time 469, horizon 55\n", - "adding: mem time415, current time 469, horizon 54\n", - "adding: mem time416, current time 469, horizon 53\n", - "adding: mem time417, current time 469, horizon 52\n", - "adding: mem time418, current time 469, horizon 51\n", - "adding: mem time419, current time 469, horizon 50\n", - "adding: mem time420, current time 469, horizon 49\n", - "adding: mem time421, current time 469, horizon 48\n", - "adding: mem time422, current time 469, horizon 47\n", - "adding: mem time423, current time 469, horizon 46\n", - "adding: mem time424, current time 469, horizon 45\n", - "adding: mem time425, current time 469, horizon 44\n", - "adding: mem time426, current time 469, horizon 43\n", - "adding: mem time427, current time 469, horizon 42\n", - "adding: mem time428, current time 469, horizon 41\n", - "adding: mem time429, current time 469, horizon 40\n", - "adding: mem time430, current time 469, horizon 39\n", - "adding: mem time431, current time 469, horizon 38\n", - "adding: mem time432, current time 469, horizon 37\n", - "adding: mem time433, current time 469, horizon 36\n", - "adding: mem time434, current time 469, horizon 35\n", - "adding: mem time435, current time 469, horizon 34\n", - "adding: mem time436, current time 469, horizon 33\n", - "adding: mem time437, current time 469, horizon 32\n", - "adding: mem time438, current time 469, horizon 31\n", - "adding: mem time439, current time 469, horizon 30\n", - "adding: mem time440, current time 469, horizon 29\n", - "adding: mem time441, current time 469, horizon 28\n", - "adding: mem time442, current time 469, horizon 27\n", - "adding: mem time443, current time 469, horizon 26\n", - "adding: mem time444, current time 469, horizon 25\n", - "adding: mem time445, current time 469, horizon 24\n", - "adding: mem time446, current time 469, horizon 23\n", - "adding: mem time447, current time 469, horizon 22\n", - "adding: mem time448, current time 469, horizon 21\n", - "adding: mem time449, current time 469, horizon 20\n", - "adding: mem time450, current time 469, horizon 19\n", - "adding: mem time451, current time 469, horizon 18\n", - "adding: mem time452, current time 469, horizon 17\n", - "adding: mem time453, current time 469, horizon 16\n", - "adding: mem time454, current time 469, horizon 15\n", - "adding: mem time455, current time 469, horizon 14\n", - "adding: mem time456, current time 469, horizon 13\n", - "adding: mem time457, current time 469, horizon 12\n", - "adding: mem time458, current time 469, horizon 11\n", - "adding: mem time459, current time 469, horizon 10\n", - "adding: mem time460, current time 469, horizon 9\n", - "adding: mem time461, current time 469, horizon 8\n", - "adding: mem time462, current time 469, horizon 7\n", - "adding: mem time463, current time 469, horizon 6\n", - "adding: mem time464, current time 469, horizon 5\n", - "adding: mem time465, current time 469, horizon 4\n", - "adding: mem time466, current time 469, horizon 3\n", - "adding: mem time467, current time 469, horizon 2\n", - "adding: mem time468, current time 469, horizon 1\n", - "adding: mem time400, current time 470, horizon 70\n", - "adding: mem time401, current time 470, horizon 69\n", - "adding: mem time402, current time 470, horizon 68\n", - "adding: mem time403, current time 470, horizon 67\n", - "adding: mem time404, current time 470, horizon 66\n", - "adding: mem time405, current time 470, horizon 65\n", - "adding: mem time406, current time 470, horizon 64\n", - "adding: mem time407, current time 470, horizon 63\n", - "adding: mem time408, current time 470, horizon 62\n", - "adding: mem time409, current time 470, horizon 61\n", - "adding: mem time410, current time 470, horizon 60\n", - "adding: mem time411, current time 470, horizon 59\n", - "adding: mem time412, current time 470, horizon 58\n", - "adding: mem time413, current time 470, horizon 57\n", - "adding: mem time414, current time 470, horizon 56\n", - "adding: mem time415, current time 470, horizon 55\n", - "adding: mem time416, current time 470, horizon 54\n", - "adding: mem time417, current time 470, horizon 53\n", - "adding: mem time418, current time 470, horizon 52\n", - "adding: mem time419, current time 470, horizon 51\n", - "adding: mem time420, current time 470, horizon 50\n", - "adding: mem time421, current time 470, horizon 49\n", - "adding: mem time422, current time 470, horizon 48\n", - "adding: mem time423, current time 470, horizon 47\n", - "adding: mem time424, current time 470, horizon 46\n", - "adding: mem time425, current time 470, horizon 45\n", - "adding: mem time426, current time 470, horizon 44\n", - "adding: mem time427, current time 470, horizon 43\n", - "adding: mem time428, current time 470, horizon 42\n", - "adding: mem time429, current time 470, horizon 41\n", - "adding: mem time430, current time 470, horizon 40\n", - "adding: mem time431, current time 470, horizon 39\n", - "adding: mem time432, current time 470, horizon 38\n", - "adding: mem time433, current time 470, horizon 37\n", - "adding: mem time434, current time 470, horizon 36\n", - "adding: mem time435, current time 470, horizon 35\n", - "adding: mem time436, current time 470, horizon 34\n", - "adding: mem time437, current time 470, horizon 33\n", - "adding: mem time438, current time 470, horizon 32\n", - "adding: mem time439, current time 470, horizon 31\n", - "adding: mem time440, current time 470, horizon 30\n", - "adding: mem time441, current time 470, horizon 29\n", - "adding: mem time442, current time 470, horizon 28\n", - "adding: mem time443, current time 470, horizon 27\n", - "adding: mem time444, current time 470, horizon 26\n", - "adding: mem time445, current time 470, horizon 25\n", - "adding: mem time446, current time 470, horizon 24\n", - "adding: mem time447, current time 470, horizon 23\n", - "adding: mem time448, current time 470, horizon 22\n", - "adding: mem time449, current time 470, horizon 21\n", - "adding: mem time450, current time 470, horizon 20\n", - "adding: mem time451, current time 470, horizon 19\n", - "adding: mem time452, current time 470, horizon 18\n", - "adding: mem time453, current time 470, horizon 17\n", - "adding: mem time454, current time 470, horizon 16\n", - "adding: mem time455, current time 470, horizon 15\n", - "adding: mem time456, current time 470, horizon 14\n", - "adding: mem time457, current time 470, horizon 13\n", - "adding: mem time458, current time 470, horizon 12\n", - "adding: mem time459, current time 470, horizon 11\n", - "adding: mem time460, current time 470, horizon 10\n", - "adding: mem time461, current time 470, horizon 9\n", - "adding: mem time462, current time 470, horizon 8\n", - "adding: mem time463, current time 470, horizon 7\n", - "adding: mem time464, current time 470, horizon 6\n", - "adding: mem time465, current time 470, horizon 5\n", - "adding: mem time466, current time 470, horizon 4\n", - "adding: mem time467, current time 470, horizon 3\n", - "adding: mem time468, current time 470, horizon 2\n", - "adding: mem time469, current time 470, horizon 1\n", - "adding: mem time400, current time 471, horizon 71\n", - "adding: mem time401, current time 471, horizon 70\n", - "adding: mem time402, current time 471, horizon 69\n", - "adding: mem time403, current time 471, horizon 68\n", - "adding: mem time404, current time 471, horizon 67\n", - "adding: mem time405, current time 471, horizon 66\n", - "adding: mem time406, current time 471, horizon 65\n", - "adding: mem time407, current time 471, horizon 64\n", - "adding: mem time408, current time 471, horizon 63\n", - "adding: mem time409, current time 471, horizon 62\n", - "adding: mem time410, current time 471, horizon 61\n", - "adding: mem time411, current time 471, horizon 60\n", - "adding: mem time412, current time 471, horizon 59\n", - "adding: mem time413, current time 471, horizon 58\n", - "adding: mem time414, current time 471, horizon 57\n", - "adding: mem time415, current time 471, horizon 56\n", - "adding: mem time416, current time 471, horizon 55\n", - "adding: mem time417, current time 471, horizon 54\n", - "adding: mem time418, current time 471, horizon 53\n", - "adding: mem time419, current time 471, horizon 52\n", - "adding: mem time420, current time 471, horizon 51\n", - "adding: mem time421, current time 471, horizon 50\n", - "adding: mem time422, current time 471, horizon 49\n", - "adding: mem time423, current time 471, horizon 48\n", - "adding: mem time424, current time 471, horizon 47\n", - "adding: mem time425, current time 471, horizon 46\n", - "adding: mem time426, current time 471, horizon 45\n", - "adding: mem time427, current time 471, horizon 44\n", - "adding: mem time428, current time 471, horizon 43\n", - "adding: mem time429, current time 471, horizon 42\n", - "adding: mem time430, current time 471, horizon 41\n", - "adding: mem time431, current time 471, horizon 40\n", - "adding: mem time432, current time 471, horizon 39\n", - "adding: mem time433, current time 471, horizon 38\n", - "adding: mem time434, current time 471, horizon 37\n", - "adding: mem time435, current time 471, horizon 36\n", - "adding: mem time436, current time 471, horizon 35\n", - "adding: mem time437, current time 471, horizon 34\n", - "adding: mem time438, current time 471, horizon 33\n", - "adding: mem time439, current time 471, horizon 32\n", - "adding: mem time440, current time 471, horizon 31\n", - "adding: mem time441, current time 471, horizon 30\n", - "adding: mem time442, current time 471, horizon 29\n", - "adding: mem time443, current time 471, horizon 28\n", - "adding: mem time444, current time 471, horizon 27\n", - "adding: mem time445, current time 471, horizon 26\n", - "adding: mem time446, current time 471, horizon 25\n", - "adding: mem time447, current time 471, horizon 24\n", - "adding: mem time448, current time 471, horizon 23\n", - "adding: mem time449, current time 471, horizon 22\n", - "adding: mem time450, current time 471, horizon 21\n", - "adding: mem time451, current time 471, horizon 20\n", - "adding: mem time452, current time 471, horizon 19\n", - "adding: mem time453, current time 471, horizon 18\n", - "adding: mem time454, current time 471, horizon 17\n", - "adding: mem time455, current time 471, horizon 16\n", - "adding: mem time456, current time 471, horizon 15\n", - "adding: mem time457, current time 471, horizon 14\n", - "adding: mem time458, current time 471, horizon 13\n", - "adding: mem time459, current time 471, horizon 12\n", - "adding: mem time460, current time 471, horizon 11\n", - "adding: mem time461, current time 471, horizon 10\n", - "adding: mem time462, current time 471, horizon 9\n", - "adding: mem time463, current time 471, horizon 8\n", - "adding: mem time464, current time 471, horizon 7\n", - "adding: mem time465, current time 471, horizon 6\n", - "adding: mem time466, current time 471, horizon 5\n", - "adding: mem time467, current time 471, horizon 4\n", - "adding: mem time468, current time 471, horizon 3\n", - "adding: mem time469, current time 471, horizon 2\n", - "adding: mem time470, current time 471, horizon 1\n", - "adding: mem time400, current time 472, horizon 72\n", - "adding: mem time401, current time 472, horizon 71\n", - "adding: mem time402, current time 472, horizon 70\n", - "adding: mem time403, current time 472, horizon 69\n", - "adding: mem time404, current time 472, horizon 68\n", - "adding: mem time405, current time 472, horizon 67\n", - "adding: mem time406, current time 472, horizon 66\n", - "adding: mem time407, current time 472, horizon 65\n", - "adding: mem time408, current time 472, horizon 64\n", - "adding: mem time409, current time 472, horizon 63\n", - "adding: mem time410, current time 472, horizon 62\n", - "adding: mem time411, current time 472, horizon 61\n", - "adding: mem time412, current time 472, horizon 60\n", - "adding: mem time413, current time 472, horizon 59\n", - "adding: mem time414, current time 472, horizon 58\n", - "adding: mem time415, current time 472, horizon 57\n", - "adding: mem time416, current time 472, horizon 56\n", - "adding: mem time417, current time 472, horizon 55\n", - "adding: mem time418, current time 472, horizon 54\n", - "adding: mem time419, current time 472, horizon 53\n", - "adding: mem time420, current time 472, horizon 52\n", - "adding: mem time421, current time 472, horizon 51\n", - "adding: mem time422, current time 472, horizon 50\n", - "adding: mem time423, current time 472, horizon 49\n", - "adding: mem time424, current time 472, horizon 48\n", - "adding: mem time425, current time 472, horizon 47\n", - "adding: mem time426, current time 472, horizon 46\n", - "adding: mem time427, current time 472, horizon 45\n", - "adding: mem time428, current time 472, horizon 44\n", - "adding: mem time429, current time 472, horizon 43\n", - "adding: mem time430, current time 472, horizon 42\n", - "adding: mem time431, current time 472, horizon 41\n", - "adding: mem time432, current time 472, horizon 40\n", - "adding: mem time433, current time 472, horizon 39\n", - "adding: mem time434, current time 472, horizon 38\n", - "adding: mem time435, current time 472, horizon 37\n", - "adding: mem time436, current time 472, horizon 36\n", - "adding: mem time437, current time 472, horizon 35\n", - "adding: mem time438, current time 472, horizon 34\n", - "adding: mem time439, current time 472, horizon 33\n", - "adding: mem time440, current time 472, horizon 32\n", - "adding: mem time441, current time 472, horizon 31\n", - "adding: mem time442, current time 472, horizon 30\n", - "adding: mem time443, current time 472, horizon 29\n", - "adding: mem time444, current time 472, horizon 28\n", - "adding: mem time445, current time 472, horizon 27\n", - "adding: mem time446, current time 472, horizon 26\n", - "adding: mem time447, current time 472, horizon 25\n", - "adding: mem time448, current time 472, horizon 24\n", - "adding: mem time449, current time 472, horizon 23\n", - "adding: mem time450, current time 472, horizon 22\n", - "adding: mem time451, current time 472, horizon 21\n", - "adding: mem time452, current time 472, horizon 20\n", - "adding: mem time453, current time 472, horizon 19\n", - "adding: mem time454, current time 472, horizon 18\n", - "adding: mem time455, current time 472, horizon 17\n", - "adding: mem time456, current time 472, horizon 16\n", - "adding: mem time457, current time 472, horizon 15\n", - "adding: mem time458, current time 472, horizon 14\n", - "adding: mem time459, current time 472, horizon 13\n", - "adding: mem time460, current time 472, horizon 12\n", - "adding: mem time461, current time 472, horizon 11\n", - "adding: mem time462, current time 472, horizon 10\n", - "adding: mem time463, current time 472, horizon 9\n", - "adding: mem time464, current time 472, horizon 8\n", - "adding: mem time465, current time 472, horizon 7\n", - "adding: mem time466, current time 472, horizon 6\n", - "adding: mem time467, current time 472, horizon 5\n", - "adding: mem time468, current time 472, horizon 4\n", - "adding: mem time469, current time 472, horizon 3\n", - "adding: mem time470, current time 472, horizon 2\n", - "adding: mem time471, current time 472, horizon 1\n", - "adding: mem time400, current time 473, horizon 73\n", - "adding: mem time401, current time 473, horizon 72\n", - "adding: mem time402, current time 473, horizon 71\n", - "adding: mem time403, current time 473, horizon 70\n", - "adding: mem time404, current time 473, horizon 69\n", - "adding: mem time405, current time 473, horizon 68\n", - "adding: mem time406, current time 473, horizon 67\n", - "adding: mem time407, current time 473, horizon 66\n", - "adding: mem time408, current time 473, horizon 65\n", - "adding: mem time409, current time 473, horizon 64\n", - "adding: mem time410, current time 473, horizon 63\n", - "adding: mem time411, current time 473, horizon 62\n", - "adding: mem time412, current time 473, horizon 61\n", - "adding: mem time413, current time 473, horizon 60\n", - "adding: mem time414, current time 473, horizon 59\n", - "adding: mem time415, current time 473, horizon 58\n", - "adding: mem time416, current time 473, horizon 57\n", - "adding: mem time417, current time 473, horizon 56\n", - "adding: mem time418, current time 473, horizon 55\n", - "adding: mem time419, current time 473, horizon 54\n", - "adding: mem time420, current time 473, horizon 53\n", - "adding: mem time421, current time 473, horizon 52\n", - "adding: mem time422, current time 473, horizon 51\n", - "adding: mem time423, current time 473, horizon 50\n", - "adding: mem time424, current time 473, horizon 49\n", - "adding: mem time425, current time 473, horizon 48\n", - "adding: mem time426, current time 473, horizon 47\n", - "adding: mem time427, current time 473, horizon 46\n", - "adding: mem time428, current time 473, horizon 45\n", - "adding: mem time429, current time 473, horizon 44\n", - "adding: mem time430, current time 473, horizon 43\n", - "adding: mem time431, current time 473, horizon 42\n", - "adding: mem time432, current time 473, horizon 41\n", - "adding: mem time433, current time 473, horizon 40\n", - "adding: mem time434, current time 473, horizon 39\n", - "adding: mem time435, current time 473, horizon 38\n", - "adding: mem time436, current time 473, horizon 37\n", - "adding: mem time437, current time 473, horizon 36\n", - "adding: mem time438, current time 473, horizon 35\n", - "adding: mem time439, current time 473, horizon 34\n", - "adding: mem time440, current time 473, horizon 33\n", - "adding: mem time441, current time 473, horizon 32\n", - "adding: mem time442, current time 473, horizon 31\n", - "adding: mem time443, current time 473, horizon 30\n", - "adding: mem time444, current time 473, horizon 29\n", - "adding: mem time445, current time 473, horizon 28\n", - "adding: mem time446, current time 473, horizon 27\n", - "adding: mem time447, current time 473, horizon 26\n", - "adding: mem time448, current time 473, horizon 25\n", - "adding: mem time449, current time 473, horizon 24\n", - "adding: mem time450, current time 473, horizon 23\n", - "adding: mem time451, current time 473, horizon 22\n", - "adding: mem time452, current time 473, horizon 21\n", - "adding: mem time453, current time 473, horizon 20\n", - "adding: mem time454, current time 473, horizon 19\n", - "adding: mem time455, current time 473, horizon 18\n", - "adding: mem time456, current time 473, horizon 17\n", - "adding: mem time457, current time 473, horizon 16\n", - "adding: mem time458, current time 473, horizon 15\n", - "adding: mem time459, current time 473, horizon 14\n", - "adding: mem time460, current time 473, horizon 13\n", - "adding: mem time461, current time 473, horizon 12\n", - "adding: mem time462, current time 473, horizon 11\n", - "adding: mem time463, current time 473, horizon 10\n", - "adding: mem time464, current time 473, horizon 9\n", - "adding: mem time465, current time 473, horizon 8\n", - "adding: mem time466, current time 473, horizon 7\n", - "adding: mem time467, current time 473, horizon 6\n", - "adding: mem time468, current time 473, horizon 5\n", - "adding: mem time469, current time 473, horizon 4\n", - "adding: mem time470, current time 473, horizon 3\n", - "adding: mem time471, current time 473, horizon 2\n", - "adding: mem time472, current time 473, horizon 1\n", - "adding: mem time400, current time 474, horizon 74\n", - "adding: mem time401, current time 474, horizon 73\n", - "adding: mem time402, current time 474, horizon 72\n", - "adding: mem time403, current time 474, horizon 71\n", - "adding: mem time404, current time 474, horizon 70\n", - "adding: mem time405, current time 474, horizon 69\n", - "adding: mem time406, current time 474, horizon 68\n", - "adding: mem time407, current time 474, horizon 67\n", - "adding: mem time408, current time 474, horizon 66\n", - "adding: mem time409, current time 474, horizon 65\n", - "adding: mem time410, current time 474, horizon 64\n", - "adding: mem time411, current time 474, horizon 63\n", - "adding: mem time412, current time 474, horizon 62\n", - "adding: mem time413, current time 474, horizon 61\n", - "adding: mem time414, current time 474, horizon 60\n", - "adding: mem time415, current time 474, horizon 59\n", - "adding: mem time416, current time 474, horizon 58\n", - "adding: mem time417, current time 474, horizon 57\n", - "adding: mem time418, current time 474, horizon 56\n", - "adding: mem time419, current time 474, horizon 55\n", - "adding: mem time420, current time 474, horizon 54\n", - "adding: mem time421, current time 474, horizon 53\n", - "adding: mem time422, current time 474, horizon 52\n", - "adding: mem time423, current time 474, horizon 51\n", - "adding: mem time424, current time 474, horizon 50\n", - "adding: mem time425, current time 474, horizon 49\n", - "adding: mem time426, current time 474, horizon 48\n", - "adding: mem time427, current time 474, horizon 47\n", - "adding: mem time428, current time 474, horizon 46\n", - "adding: mem time429, current time 474, horizon 45\n", - "adding: mem time430, current time 474, horizon 44\n", - "adding: mem time431, current time 474, horizon 43\n", - "adding: mem time432, current time 474, horizon 42\n", - "adding: mem time433, current time 474, horizon 41\n", - "adding: mem time434, current time 474, horizon 40\n", - "adding: mem time435, current time 474, horizon 39\n", - "adding: mem time436, current time 474, horizon 38\n", - "adding: mem time437, current time 474, horizon 37\n", - "adding: mem time438, current time 474, horizon 36\n", - "adding: mem time439, current time 474, horizon 35\n", - "adding: mem time440, current time 474, horizon 34\n", - "adding: mem time441, current time 474, horizon 33\n", - "adding: mem time442, current time 474, horizon 32\n", - "adding: mem time443, current time 474, horizon 31\n", - "adding: mem time444, current time 474, horizon 30\n", - "adding: mem time445, current time 474, horizon 29\n", - "adding: mem time446, current time 474, horizon 28\n", - "adding: mem time447, current time 474, horizon 27\n", - "adding: mem time448, current time 474, horizon 26\n", - "adding: mem time449, current time 474, horizon 25\n", - "adding: mem time450, current time 474, horizon 24\n", - "adding: mem time451, current time 474, horizon 23\n", - "adding: mem time452, current time 474, horizon 22\n", - "adding: mem time453, current time 474, horizon 21\n", - "adding: mem time454, current time 474, horizon 20\n", - "adding: mem time455, current time 474, horizon 19\n", - "adding: mem time456, current time 474, horizon 18\n", - "adding: mem time457, current time 474, horizon 17\n", - "adding: mem time458, current time 474, horizon 16\n", - "adding: mem time459, current time 474, horizon 15\n", - "adding: mem time460, current time 474, horizon 14\n", - "adding: mem time461, current time 474, horizon 13\n", - "adding: mem time462, current time 474, horizon 12\n", - "adding: mem time463, current time 474, horizon 11\n", - "adding: mem time464, current time 474, horizon 10\n", - "adding: mem time465, current time 474, horizon 9\n", - "adding: mem time466, current time 474, horizon 8\n", - "adding: mem time467, current time 474, horizon 7\n", - "adding: mem time468, current time 474, horizon 6\n", - "adding: mem time469, current time 474, horizon 5\n", - "adding: mem time470, current time 474, horizon 4\n", - "adding: mem time471, current time 474, horizon 3\n", - "adding: mem time472, current time 474, horizon 2\n", - "adding: mem time473, current time 474, horizon 1\n", - "adding: mem time400, current time 475, horizon 75\n", - "adding: mem time401, current time 475, horizon 74\n", - "adding: mem time402, current time 475, horizon 73\n", - "adding: mem time403, current time 475, horizon 72\n", - "adding: mem time404, current time 475, horizon 71\n", - "adding: mem time405, current time 475, horizon 70\n", - "adding: mem time406, current time 475, horizon 69\n", - "adding: mem time407, current time 475, horizon 68\n", - "adding: mem time408, current time 475, horizon 67\n", - "adding: mem time409, current time 475, horizon 66\n", - "adding: mem time410, current time 475, horizon 65\n", - "adding: mem time411, current time 475, horizon 64\n", - "adding: mem time412, current time 475, horizon 63\n", - "adding: mem time413, current time 475, horizon 62\n", - "adding: mem time414, current time 475, horizon 61\n", - "adding: mem time415, current time 475, horizon 60\n", - "adding: mem time416, current time 475, horizon 59\n", - "adding: mem time417, current time 475, horizon 58\n", - "adding: mem time418, current time 475, horizon 57\n", - "adding: mem time419, current time 475, horizon 56\n", - "adding: mem time420, current time 475, horizon 55\n", - "adding: mem time421, current time 475, horizon 54\n", - "adding: mem time422, current time 475, horizon 53\n", - "adding: mem time423, current time 475, horizon 52\n", - "adding: mem time424, current time 475, horizon 51\n", - "adding: mem time425, current time 475, horizon 50\n", - "adding: mem time426, current time 475, horizon 49\n", - "adding: mem time427, current time 475, horizon 48\n", - "adding: mem time428, current time 475, horizon 47\n", - "adding: mem time429, current time 475, horizon 46\n", - "adding: mem time430, current time 475, horizon 45\n", - "adding: mem time431, current time 475, horizon 44\n", - "adding: mem time432, current time 475, horizon 43\n", - "adding: mem time433, current time 475, horizon 42\n", - "adding: mem time434, current time 475, horizon 41\n", - "adding: mem time435, current time 475, horizon 40\n", - "adding: mem time436, current time 475, horizon 39\n", - "adding: mem time437, current time 475, horizon 38\n", - "adding: mem time438, current time 475, horizon 37\n", - "adding: mem time439, current time 475, horizon 36\n", - "adding: mem time440, current time 475, horizon 35\n", - "adding: mem time441, current time 475, horizon 34\n", - "adding: mem time442, current time 475, horizon 33\n", - "adding: mem time443, current time 475, horizon 32\n", - "adding: mem time444, current time 475, horizon 31\n", - "adding: mem time445, current time 475, horizon 30\n", - "adding: mem time446, current time 475, horizon 29\n", - "adding: mem time447, current time 475, horizon 28\n", - "adding: mem time448, current time 475, horizon 27\n", - "adding: mem time449, current time 475, horizon 26\n", - "adding: mem time450, current time 475, horizon 25\n", - "adding: mem time451, current time 475, horizon 24\n", - "adding: mem time452, current time 475, horizon 23\n", - "adding: mem time453, current time 475, horizon 22\n", - "adding: mem time454, current time 475, horizon 21\n", - "adding: mem time455, current time 475, horizon 20\n", - "adding: mem time456, current time 475, horizon 19\n", - "adding: mem time457, current time 475, horizon 18\n", - "adding: mem time458, current time 475, horizon 17\n", - "adding: mem time459, current time 475, horizon 16\n", - "adding: mem time460, current time 475, horizon 15\n", - "adding: mem time461, current time 475, horizon 14\n", - "adding: mem time462, current time 475, horizon 13\n", - "adding: mem time463, current time 475, horizon 12\n", - "adding: mem time464, current time 475, horizon 11\n", - "adding: mem time465, current time 475, horizon 10\n", - "adding: mem time466, current time 475, horizon 9\n", - "adding: mem time467, current time 475, horizon 8\n", - "adding: mem time468, current time 475, horizon 7\n", - "adding: mem time469, current time 475, horizon 6\n", - "adding: mem time470, current time 475, horizon 5\n", - "adding: mem time471, current time 475, horizon 4\n", - "adding: mem time472, current time 475, horizon 3\n", - "adding: mem time473, current time 475, horizon 2\n", - "adding: mem time474, current time 475, horizon 1\n", - "adding: mem time400, current time 476, horizon 76\n", - "adding: mem time401, current time 476, horizon 75\n", - "adding: mem time402, current time 476, horizon 74\n", - "adding: mem time403, current time 476, horizon 73\n", - "adding: mem time404, current time 476, horizon 72\n", - "adding: mem time405, current time 476, horizon 71\n", - "adding: mem time406, current time 476, horizon 70\n", - "adding: mem time407, current time 476, horizon 69\n", - "adding: mem time408, current time 476, horizon 68\n", - "adding: mem time409, current time 476, horizon 67\n", - "adding: mem time410, current time 476, horizon 66\n", - "adding: mem time411, current time 476, horizon 65\n", - "adding: mem time412, current time 476, horizon 64\n", - "adding: mem time413, current time 476, horizon 63\n", - "adding: mem time414, current time 476, horizon 62\n", - "adding: mem time415, current time 476, horizon 61\n", - "adding: mem time416, current time 476, horizon 60\n", - "adding: mem time417, current time 476, horizon 59\n", - "adding: mem time418, current time 476, horizon 58\n", - "adding: mem time419, current time 476, horizon 57\n", - "adding: mem time420, current time 476, horizon 56\n", - "adding: mem time421, current time 476, horizon 55\n", - "adding: mem time422, current time 476, horizon 54\n", - "adding: mem time423, current time 476, horizon 53\n", - "adding: mem time424, current time 476, horizon 52\n", - "adding: mem time425, current time 476, horizon 51\n", - "adding: mem time426, current time 476, horizon 50\n", - "adding: mem time427, current time 476, horizon 49\n", - "adding: mem time428, current time 476, horizon 48\n", - "adding: mem time429, current time 476, horizon 47\n", - "adding: mem time430, current time 476, horizon 46\n", - "adding: mem time431, current time 476, horizon 45\n", - "adding: mem time432, current time 476, horizon 44\n", - "adding: mem time433, current time 476, horizon 43\n", - "adding: mem time434, current time 476, horizon 42\n", - "adding: mem time435, current time 476, horizon 41\n", - "adding: mem time436, current time 476, horizon 40\n", - "adding: mem time437, current time 476, horizon 39\n", - "adding: mem time438, current time 476, horizon 38\n", - "adding: mem time439, current time 476, horizon 37\n", - "adding: mem time440, current time 476, horizon 36\n", - "adding: mem time441, current time 476, horizon 35\n", - "adding: mem time442, current time 476, horizon 34\n", - "adding: mem time443, current time 476, horizon 33\n", - "adding: mem time444, current time 476, horizon 32\n", - "adding: mem time445, current time 476, horizon 31\n", - "adding: mem time446, current time 476, horizon 30\n", - "adding: mem time447, current time 476, horizon 29\n", - "adding: mem time448, current time 476, horizon 28\n", - "adding: mem time449, current time 476, horizon 27\n", - "adding: mem time450, current time 476, horizon 26\n", - "adding: mem time451, current time 476, horizon 25\n", - "adding: mem time452, current time 476, horizon 24\n", - "adding: mem time453, current time 476, horizon 23\n", - "adding: mem time454, current time 476, horizon 22\n", - "adding: mem time455, current time 476, horizon 21\n", - "adding: mem time456, current time 476, horizon 20\n", - "adding: mem time457, current time 476, horizon 19\n", - "adding: mem time458, current time 476, horizon 18\n", - "adding: mem time459, current time 476, horizon 17\n", - "adding: mem time460, current time 476, horizon 16\n", - "adding: mem time461, current time 476, horizon 15\n", - "adding: mem time462, current time 476, horizon 14\n", - "adding: mem time463, current time 476, horizon 13\n", - "adding: mem time464, current time 476, horizon 12\n", - "adding: mem time465, current time 476, horizon 11\n", - "adding: mem time466, current time 476, horizon 10\n", - "adding: mem time467, current time 476, horizon 9\n", - "adding: mem time468, current time 476, horizon 8\n", - "adding: mem time469, current time 476, horizon 7\n", - "adding: mem time470, current time 476, horizon 6\n", - "adding: mem time471, current time 476, horizon 5\n", - "adding: mem time472, current time 476, horizon 4\n", - "adding: mem time473, current time 476, horizon 3\n", - "adding: mem time474, current time 476, horizon 2\n", - "adding: mem time475, current time 476, horizon 1\n", - "adding: mem time400, current time 477, horizon 77\n", - "adding: mem time401, current time 477, horizon 76\n", - "adding: mem time402, current time 477, horizon 75\n", - "adding: mem time403, current time 477, horizon 74\n", - "adding: mem time404, current time 477, horizon 73\n", - "adding: mem time405, current time 477, horizon 72\n", - "adding: mem time406, current time 477, horizon 71\n", - "adding: mem time407, current time 477, horizon 70\n", - "adding: mem time408, current time 477, horizon 69\n", - "adding: mem time409, current time 477, horizon 68\n", - "adding: mem time410, current time 477, horizon 67\n", - "adding: mem time411, current time 477, horizon 66\n", - "adding: mem time412, current time 477, horizon 65\n", - "adding: mem time413, current time 477, horizon 64\n", - "adding: mem time414, current time 477, horizon 63\n", - "adding: mem time415, current time 477, horizon 62\n", - "adding: mem time416, current time 477, horizon 61\n", - "adding: mem time417, current time 477, horizon 60\n", - "adding: mem time418, current time 477, horizon 59\n", - "adding: mem time419, current time 477, horizon 58\n", - "adding: mem time420, current time 477, horizon 57\n", - "adding: mem time421, current time 477, horizon 56\n", - "adding: mem time422, current time 477, horizon 55\n", - "adding: mem time423, current time 477, horizon 54\n", - "adding: mem time424, current time 477, horizon 53\n", - "adding: mem time425, current time 477, horizon 52\n", - "adding: mem time426, current time 477, horizon 51\n", - "adding: mem time427, current time 477, horizon 50\n", - "adding: mem time428, current time 477, horizon 49\n", - "adding: mem time429, current time 477, horizon 48\n", - "adding: mem time430, current time 477, horizon 47\n", - "adding: mem time431, current time 477, horizon 46\n", - "adding: mem time432, current time 477, horizon 45\n", - "adding: mem time433, current time 477, horizon 44\n", - "adding: mem time434, current time 477, horizon 43\n", - "adding: mem time435, current time 477, horizon 42\n", - "adding: mem time436, current time 477, horizon 41\n", - "adding: mem time437, current time 477, horizon 40\n", - "adding: mem time438, current time 477, horizon 39\n", - "adding: mem time439, current time 477, horizon 38\n", - "adding: mem time440, current time 477, horizon 37\n", - "adding: mem time441, current time 477, horizon 36\n", - "adding: mem time442, current time 477, horizon 35\n", - "adding: mem time443, current time 477, horizon 34\n", - "adding: mem time444, current time 477, horizon 33\n", - "adding: mem time445, current time 477, horizon 32\n", - "adding: mem time446, current time 477, horizon 31\n", - "adding: mem time447, current time 477, horizon 30\n", - "adding: mem time448, current time 477, horizon 29\n", - "adding: mem time449, current time 477, horizon 28\n", - "adding: mem time450, current time 477, horizon 27\n", - "adding: mem time451, current time 477, horizon 26\n", - "adding: mem time452, current time 477, horizon 25\n", - "adding: mem time453, current time 477, horizon 24\n", - "adding: mem time454, current time 477, horizon 23\n", - "adding: mem time455, current time 477, horizon 22\n", - "adding: mem time456, current time 477, horizon 21\n", - "adding: mem time457, current time 477, horizon 20\n", - "adding: mem time458, current time 477, horizon 19\n", - "adding: mem time459, current time 477, horizon 18\n", - "adding: mem time460, current time 477, horizon 17\n", - "adding: mem time461, current time 477, horizon 16\n", - "adding: mem time462, current time 477, horizon 15\n", - "adding: mem time463, current time 477, horizon 14\n", - "adding: mem time464, current time 477, horizon 13\n", - "adding: mem time465, current time 477, horizon 12\n", - "adding: mem time466, current time 477, horizon 11\n", - "adding: mem time467, current time 477, horizon 10\n", - "adding: mem time468, current time 477, horizon 9\n", - "adding: mem time469, current time 477, horizon 8\n", - "adding: mem time470, current time 477, horizon 7\n", - "adding: mem time471, current time 477, horizon 6\n", - "adding: mem time472, current time 477, horizon 5\n", - "adding: mem time473, current time 477, horizon 4\n", - "adding: mem time474, current time 477, horizon 3\n", - "adding: mem time475, current time 477, horizon 2\n", - "adding: mem time476, current time 477, horizon 1\n", - "adding: mem time400, current time 478, horizon 78\n", - "adding: mem time401, current time 478, horizon 77\n", - "adding: mem time402, current time 478, horizon 76\n", - "adding: mem time403, current time 478, horizon 75\n", - "adding: mem time404, current time 478, horizon 74\n", - "adding: mem time405, current time 478, horizon 73\n", - "adding: mem time406, current time 478, horizon 72\n", - "adding: mem time407, current time 478, horizon 71\n", - "adding: mem time408, current time 478, horizon 70\n", - "adding: mem time409, current time 478, horizon 69\n", - "adding: mem time410, current time 478, horizon 68\n", - "adding: mem time411, current time 478, horizon 67\n", - "adding: mem time412, current time 478, horizon 66\n", - "adding: mem time413, current time 478, horizon 65\n", - "adding: mem time414, current time 478, horizon 64\n", - "adding: mem time415, current time 478, horizon 63\n", - "adding: mem time416, current time 478, horizon 62\n", - "adding: mem time417, current time 478, horizon 61\n", - "adding: mem time418, current time 478, horizon 60\n", - "adding: mem time419, current time 478, horizon 59\n", - "adding: mem time420, current time 478, horizon 58\n", - "adding: mem time421, current time 478, horizon 57\n", - "adding: mem time422, current time 478, horizon 56\n", - "adding: mem time423, current time 478, horizon 55\n", - "adding: mem time424, current time 478, horizon 54\n", - "adding: mem time425, current time 478, horizon 53\n", - "adding: mem time426, current time 478, horizon 52\n", - "adding: mem time427, current time 478, horizon 51\n", - "adding: mem time428, current time 478, horizon 50\n", - "adding: mem time429, current time 478, horizon 49\n", - "adding: mem time430, current time 478, horizon 48\n", - "adding: mem time431, current time 478, horizon 47\n", - "adding: mem time432, current time 478, horizon 46\n", - "adding: mem time433, current time 478, horizon 45\n", - "adding: mem time434, current time 478, horizon 44\n", - "adding: mem time435, current time 478, horizon 43\n", - "adding: mem time436, current time 478, horizon 42\n", - "adding: mem time437, current time 478, horizon 41\n", - "adding: mem time438, current time 478, horizon 40\n", - "adding: mem time439, current time 478, horizon 39\n", - "adding: mem time440, current time 478, horizon 38\n", - "adding: mem time441, current time 478, horizon 37\n", - "adding: mem time442, current time 478, horizon 36\n", - "adding: mem time443, current time 478, horizon 35\n", - "adding: mem time444, current time 478, horizon 34\n", - "adding: mem time445, current time 478, horizon 33\n", - "adding: mem time446, current time 478, horizon 32\n", - "adding: mem time447, current time 478, horizon 31\n", - "adding: mem time448, current time 478, horizon 30\n", - "adding: mem time449, current time 478, horizon 29\n", - "adding: mem time450, current time 478, horizon 28\n", - "adding: mem time451, current time 478, horizon 27\n", - "adding: mem time452, current time 478, horizon 26\n", - "adding: mem time453, current time 478, horizon 25\n", - "adding: mem time454, current time 478, horizon 24\n", - "adding: mem time455, current time 478, horizon 23\n", - "adding: mem time456, current time 478, horizon 22\n", - "adding: mem time457, current time 478, horizon 21\n", - "adding: mem time458, current time 478, horizon 20\n", - "adding: mem time459, current time 478, horizon 19\n", - "adding: mem time460, current time 478, horizon 18\n", - "adding: mem time461, current time 478, horizon 17\n", - "adding: mem time462, current time 478, horizon 16\n", - "adding: mem time463, current time 478, horizon 15\n", - "adding: mem time464, current time 478, horizon 14\n", - "adding: mem time465, current time 478, horizon 13\n", - "adding: mem time466, current time 478, horizon 12\n", - "adding: mem time467, current time 478, horizon 11\n", - "adding: mem time468, current time 478, horizon 10\n", - "adding: mem time469, current time 478, horizon 9\n", - "adding: mem time470, current time 478, horizon 8\n", - "adding: mem time471, current time 478, horizon 7\n", - "adding: mem time472, current time 478, horizon 6\n", - "adding: mem time473, current time 478, horizon 5\n", - "adding: mem time474, current time 478, horizon 4\n", - "adding: mem time475, current time 478, horizon 3\n", - "adding: mem time476, current time 478, horizon 2\n", - "adding: mem time477, current time 478, horizon 1\n", - "adding: mem time400, current time 479, horizon 79\n", - "adding: mem time401, current time 479, horizon 78\n", - "adding: mem time402, current time 479, horizon 77\n", - "adding: mem time403, current time 479, horizon 76\n", - "adding: mem time404, current time 479, horizon 75\n", - "adding: mem time405, current time 479, horizon 74\n", - "adding: mem time406, current time 479, horizon 73\n", - "adding: mem time407, current time 479, horizon 72\n", - "adding: mem time408, current time 479, horizon 71\n", - "adding: mem time409, current time 479, horizon 70\n", - "adding: mem time410, current time 479, horizon 69\n", - "adding: mem time411, current time 479, horizon 68\n", - "adding: mem time412, current time 479, horizon 67\n", - "adding: mem time413, current time 479, horizon 66\n", - "adding: mem time414, current time 479, horizon 65\n", - "adding: mem time415, current time 479, horizon 64\n", - "adding: mem time416, current time 479, horizon 63\n", - "adding: mem time417, current time 479, horizon 62\n", - "adding: mem time418, current time 479, horizon 61\n", - "adding: mem time419, current time 479, horizon 60\n", - "adding: mem time420, current time 479, horizon 59\n", - "adding: mem time421, current time 479, horizon 58\n", - "adding: mem time422, current time 479, horizon 57\n", - "adding: mem time423, current time 479, horizon 56\n", - "adding: mem time424, current time 479, horizon 55\n", - "adding: mem time425, current time 479, horizon 54\n", - "adding: mem time426, current time 479, horizon 53\n", - "adding: mem time427, current time 479, horizon 52\n", - "adding: mem time428, current time 479, horizon 51\n", - "adding: mem time429, current time 479, horizon 50\n", - "adding: mem time430, current time 479, horizon 49\n", - "adding: mem time431, current time 479, horizon 48\n", - "adding: mem time432, current time 479, horizon 47\n", - "adding: mem time433, current time 479, horizon 46\n", - "adding: mem time434, current time 479, horizon 45\n", - "adding: mem time435, current time 479, horizon 44\n", - "adding: mem time436, current time 479, horizon 43\n", - "adding: mem time437, current time 479, horizon 42\n", - "adding: mem time438, current time 479, horizon 41\n", - "adding: mem time439, current time 479, horizon 40\n", - "adding: mem time440, current time 479, horizon 39\n", - "adding: mem time441, current time 479, horizon 38\n", - "adding: mem time442, current time 479, horizon 37\n", - "adding: mem time443, current time 479, horizon 36\n", - "adding: mem time444, current time 479, horizon 35\n", - "adding: mem time445, current time 479, horizon 34\n", - "adding: mem time446, current time 479, horizon 33\n", - "adding: mem time447, current time 479, horizon 32\n", - "adding: mem time448, current time 479, horizon 31\n", - "adding: mem time449, current time 479, horizon 30\n", - "adding: mem time450, current time 479, horizon 29\n", - "adding: mem time451, current time 479, horizon 28\n", - "adding: mem time452, current time 479, horizon 27\n", - "adding: mem time453, current time 479, horizon 26\n", - "adding: mem time454, current time 479, horizon 25\n", - "adding: mem time455, current time 479, horizon 24\n", - "adding: mem time456, current time 479, horizon 23\n", - "adding: mem time457, current time 479, horizon 22\n", - "adding: mem time458, current time 479, horizon 21\n", - "adding: mem time459, current time 479, horizon 20\n", - "adding: mem time460, current time 479, horizon 19\n", - "adding: mem time461, current time 479, horizon 18\n", - "adding: mem time462, current time 479, horizon 17\n", - "adding: mem time463, current time 479, horizon 16\n", - "adding: mem time464, current time 479, horizon 15\n", - "adding: mem time465, current time 479, horizon 14\n", - "adding: mem time466, current time 479, horizon 13\n", - "adding: mem time467, current time 479, horizon 12\n", - "adding: mem time468, current time 479, horizon 11\n", - "adding: mem time469, current time 479, horizon 10\n", - "adding: mem time470, current time 479, horizon 9\n", - "adding: mem time471, current time 479, horizon 8\n", - "adding: mem time472, current time 479, horizon 7\n", - "adding: mem time473, current time 479, horizon 6\n", - "adding: mem time474, current time 479, horizon 5\n", - "adding: mem time475, current time 479, horizon 4\n", - "adding: mem time476, current time 479, horizon 3\n", - "adding: mem time477, current time 479, horizon 2\n", - "adding: mem time478, current time 479, horizon 1\n", - "adding: mem time400, current time 480, horizon 80\n", - "adding: mem time401, current time 480, horizon 79\n", - "adding: mem time402, current time 480, horizon 78\n", - "adding: mem time403, current time 480, horizon 77\n", - "adding: mem time404, current time 480, horizon 76\n", - "adding: mem time405, current time 480, horizon 75\n", - "adding: mem time406, current time 480, horizon 74\n", - "adding: mem time407, current time 480, horizon 73\n", - "adding: mem time408, current time 480, horizon 72\n", - "adding: mem time409, current time 480, horizon 71\n", - "adding: mem time410, current time 480, horizon 70\n", - "adding: mem time411, current time 480, horizon 69\n", - "adding: mem time412, current time 480, horizon 68\n", - "adding: mem time413, current time 480, horizon 67\n", - "adding: mem time414, current time 480, horizon 66\n", - "adding: mem time415, current time 480, horizon 65\n", - "adding: mem time416, current time 480, horizon 64\n", - "adding: mem time417, current time 480, horizon 63\n", - "adding: mem time418, current time 480, horizon 62\n", - "adding: mem time419, current time 480, horizon 61\n", - "adding: mem time420, current time 480, horizon 60\n", - "adding: mem time421, current time 480, horizon 59\n", - "adding: mem time422, current time 480, horizon 58\n", - "adding: mem time423, current time 480, horizon 57\n", - "adding: mem time424, current time 480, horizon 56\n", - "adding: mem time425, current time 480, horizon 55\n", - "adding: mem time426, current time 480, horizon 54\n", - "adding: mem time427, current time 480, horizon 53\n", - "adding: mem time428, current time 480, horizon 52\n", - "adding: mem time429, current time 480, horizon 51\n", - "adding: mem time430, current time 480, horizon 50\n", - "adding: mem time431, current time 480, horizon 49\n", - "adding: mem time432, current time 480, horizon 48\n", - "adding: mem time433, current time 480, horizon 47\n", - "adding: mem time434, current time 480, horizon 46\n", - "adding: mem time435, current time 480, horizon 45\n", - "adding: mem time436, current time 480, horizon 44\n", - "adding: mem time437, current time 480, horizon 43\n", - "adding: mem time438, current time 480, horizon 42\n", - "adding: mem time439, current time 480, horizon 41\n", - "adding: mem time440, current time 480, horizon 40\n", - "adding: mem time441, current time 480, horizon 39\n", - "adding: mem time442, current time 480, horizon 38\n", - "adding: mem time443, current time 480, horizon 37\n", - "adding: mem time444, current time 480, horizon 36\n", - "adding: mem time445, current time 480, horizon 35\n", - "adding: mem time446, current time 480, horizon 34\n", - "adding: mem time447, current time 480, horizon 33\n", - "adding: mem time448, current time 480, horizon 32\n", - "adding: mem time449, current time 480, horizon 31\n", - "adding: mem time450, current time 480, horizon 30\n", - "adding: mem time451, current time 480, horizon 29\n", - "adding: mem time452, current time 480, horizon 28\n", - "adding: mem time453, current time 480, horizon 27\n", - "adding: mem time454, current time 480, horizon 26\n", - "adding: mem time455, current time 480, horizon 25\n", - "adding: mem time456, current time 480, horizon 24\n", - "adding: mem time457, current time 480, horizon 23\n", - "adding: mem time458, current time 480, horizon 22\n", - "adding: mem time459, current time 480, horizon 21\n", - "adding: mem time460, current time 480, horizon 20\n", - "adding: mem time461, current time 480, horizon 19\n", - "adding: mem time462, current time 480, horizon 18\n", - "adding: mem time463, current time 480, horizon 17\n", - "adding: mem time464, current time 480, horizon 16\n", - "adding: mem time465, current time 480, horizon 15\n", - "adding: mem time466, current time 480, horizon 14\n", - "adding: mem time467, current time 480, horizon 13\n", - "adding: mem time468, current time 480, horizon 12\n", - "adding: mem time469, current time 480, horizon 11\n", - "adding: mem time470, current time 480, horizon 10\n", - "adding: mem time471, current time 480, horizon 9\n", - "adding: mem time472, current time 480, horizon 8\n", - "adding: mem time473, current time 480, horizon 7\n", - "adding: mem time474, current time 480, horizon 6\n", - "adding: mem time475, current time 480, horizon 5\n", - "adding: mem time476, current time 480, horizon 4\n", - "adding: mem time477, current time 480, horizon 3\n", - "adding: mem time478, current time 480, horizon 2\n", - "adding: mem time479, current time 480, horizon 1\n", - "adding: mem time400, current time 481, horizon 81\n", - "adding: mem time401, current time 481, horizon 80\n", - "adding: mem time402, current time 481, horizon 79\n", - "adding: mem time403, current time 481, horizon 78\n", - "adding: mem time404, current time 481, horizon 77\n", - "adding: mem time405, current time 481, horizon 76\n", - "adding: mem time406, current time 481, horizon 75\n", - "adding: mem time407, current time 481, horizon 74\n", - "adding: mem time408, current time 481, horizon 73\n", - "adding: mem time409, current time 481, horizon 72\n", - "adding: mem time410, current time 481, horizon 71\n", - "adding: mem time411, current time 481, horizon 70\n", - "adding: mem time412, current time 481, horizon 69\n", - "adding: mem time413, current time 481, horizon 68\n", - "adding: mem time414, current time 481, horizon 67\n", - "adding: mem time415, current time 481, horizon 66\n", - "adding: mem time416, current time 481, horizon 65\n", - "adding: mem time417, current time 481, horizon 64\n", - "adding: mem time418, current time 481, horizon 63\n", - "adding: mem time419, current time 481, horizon 62\n", - "adding: mem time420, current time 481, horizon 61\n", - "adding: mem time421, current time 481, horizon 60\n", - "adding: mem time422, current time 481, horizon 59\n", - "adding: mem time423, current time 481, horizon 58\n", - "adding: mem time424, current time 481, horizon 57\n", - "adding: mem time425, current time 481, horizon 56\n", - "adding: mem time426, current time 481, horizon 55\n", - "adding: mem time427, current time 481, horizon 54\n", - "adding: mem time428, current time 481, horizon 53\n", - "adding: mem time429, current time 481, horizon 52\n", - "adding: mem time430, current time 481, horizon 51\n", - "adding: mem time431, current time 481, horizon 50\n", - "adding: mem time432, current time 481, horizon 49\n", - "adding: mem time433, current time 481, horizon 48\n", - "adding: mem time434, current time 481, horizon 47\n", - "adding: mem time435, current time 481, horizon 46\n", - "adding: mem time436, current time 481, horizon 45\n", - "adding: mem time437, current time 481, horizon 44\n", - "adding: mem time438, current time 481, horizon 43\n", - "adding: mem time439, current time 481, horizon 42\n", - "adding: mem time440, current time 481, horizon 41\n", - "adding: mem time441, current time 481, horizon 40\n", - "adding: mem time442, current time 481, horizon 39\n", - "adding: mem time443, current time 481, horizon 38\n", - "adding: mem time444, current time 481, horizon 37\n", - "adding: mem time445, current time 481, horizon 36\n", - "adding: mem time446, current time 481, horizon 35\n", - "adding: mem time447, current time 481, horizon 34\n", - "adding: mem time448, current time 481, horizon 33\n", - "adding: mem time449, current time 481, horizon 32\n", - "adding: mem time450, current time 481, horizon 31\n", - "adding: mem time451, current time 481, horizon 30\n", - "adding: mem time452, current time 481, horizon 29\n", - "adding: mem time453, current time 481, horizon 28\n", - "adding: mem time454, current time 481, horizon 27\n", - "adding: mem time455, current time 481, horizon 26\n", - "adding: mem time456, current time 481, horizon 25\n", - "adding: mem time457, current time 481, horizon 24\n", - "adding: mem time458, current time 481, horizon 23\n", - "adding: mem time459, current time 481, horizon 22\n", - "adding: mem time460, current time 481, horizon 21\n", - "adding: mem time461, current time 481, horizon 20\n", - "adding: mem time462, current time 481, horizon 19\n", - "adding: mem time463, current time 481, horizon 18\n", - "adding: mem time464, current time 481, horizon 17\n", - "adding: mem time465, current time 481, horizon 16\n", - "adding: mem time466, current time 481, horizon 15\n", - "adding: mem time467, current time 481, horizon 14\n", - "adding: mem time468, current time 481, horizon 13\n", - "adding: mem time469, current time 481, horizon 12\n", - "adding: mem time470, current time 481, horizon 11\n", - "adding: mem time471, current time 481, horizon 10\n", - "adding: mem time472, current time 481, horizon 9\n", - "adding: mem time473, current time 481, horizon 8\n", - "adding: mem time474, current time 481, horizon 7\n", - "adding: mem time475, current time 481, horizon 6\n", - "adding: mem time476, current time 481, horizon 5\n", - "adding: mem time477, current time 481, horizon 4\n", - "adding: mem time478, current time 481, horizon 3\n", - "adding: mem time479, current time 481, horizon 2\n", - "adding: mem time480, current time 481, horizon 1\n", - "adding: mem time400, current time 482, horizon 82\n", - "adding: mem time401, current time 482, horizon 81\n", - "adding: mem time402, current time 482, horizon 80\n", - "adding: mem time403, current time 482, horizon 79\n", - "adding: mem time404, current time 482, horizon 78\n", - "adding: mem time405, current time 482, horizon 77\n", - "adding: mem time406, current time 482, horizon 76\n", - "adding: mem time407, current time 482, horizon 75\n", - "adding: mem time408, current time 482, horizon 74\n", - "adding: mem time409, current time 482, horizon 73\n", - "adding: mem time410, current time 482, horizon 72\n", - "adding: mem time411, current time 482, horizon 71\n", - "adding: mem time412, current time 482, horizon 70\n", - "adding: mem time413, current time 482, horizon 69\n", - "adding: mem time414, current time 482, horizon 68\n", - "adding: mem time415, current time 482, horizon 67\n", - "adding: mem time416, current time 482, horizon 66\n", - "adding: mem time417, current time 482, horizon 65\n", - "adding: mem time418, current time 482, horizon 64\n", - "adding: mem time419, current time 482, horizon 63\n", - "adding: mem time420, current time 482, horizon 62\n", - "adding: mem time421, current time 482, horizon 61\n", - "adding: mem time422, current time 482, horizon 60\n", - "adding: mem time423, current time 482, horizon 59\n", - "adding: mem time424, current time 482, horizon 58\n", - "adding: mem time425, current time 482, horizon 57\n", - "adding: mem time426, current time 482, horizon 56\n", - "adding: mem time427, current time 482, horizon 55\n", - "adding: mem time428, current time 482, horizon 54\n", - "adding: mem time429, current time 482, horizon 53\n", - "adding: mem time430, current time 482, horizon 52\n", - "adding: mem time431, current time 482, horizon 51\n", - "adding: mem time432, current time 482, horizon 50\n", - "adding: mem time433, current time 482, horizon 49\n", - "adding: mem time434, current time 482, horizon 48\n", - "adding: mem time435, current time 482, horizon 47\n", - "adding: mem time436, current time 482, horizon 46\n", - "adding: mem time437, current time 482, horizon 45\n", - "adding: mem time438, current time 482, horizon 44\n", - "adding: mem time439, current time 482, horizon 43\n", - "adding: mem time440, current time 482, horizon 42\n", - "adding: mem time441, current time 482, horizon 41\n", - "adding: mem time442, current time 482, horizon 40\n", - "adding: mem time443, current time 482, horizon 39\n", - "adding: mem time444, current time 482, horizon 38\n", - "adding: mem time445, current time 482, horizon 37\n", - "adding: mem time446, current time 482, horizon 36\n", - "adding: mem time447, current time 482, horizon 35\n", - "adding: mem time448, current time 482, horizon 34\n", - "adding: mem time449, current time 482, horizon 33\n", - "adding: mem time450, current time 482, horizon 32\n", - "adding: mem time451, current time 482, horizon 31\n", - "adding: mem time452, current time 482, horizon 30\n", - "adding: mem time453, current time 482, horizon 29\n", - "adding: mem time454, current time 482, horizon 28\n", - "adding: mem time455, current time 482, horizon 27\n", - "adding: mem time456, current time 482, horizon 26\n", - "adding: mem time457, current time 482, horizon 25\n", - "adding: mem time458, current time 482, horizon 24\n", - "adding: mem time459, current time 482, horizon 23\n", - "adding: mem time460, current time 482, horizon 22\n", - "adding: mem time461, current time 482, horizon 21\n", - "adding: mem time462, current time 482, horizon 20\n", - "adding: mem time463, current time 482, horizon 19\n", - "adding: mem time464, current time 482, horizon 18\n", - "adding: mem time465, current time 482, horizon 17\n", - "adding: mem time466, current time 482, horizon 16\n", - "adding: mem time467, current time 482, horizon 15\n", - "adding: mem time468, current time 482, horizon 14\n", - "adding: mem time469, current time 482, horizon 13\n", - "adding: mem time470, current time 482, horizon 12\n", - "adding: mem time471, current time 482, horizon 11\n", - "adding: mem time472, current time 482, horizon 10\n", - "adding: mem time473, current time 482, horizon 9\n", - "adding: mem time474, current time 482, horizon 8\n", - "adding: mem time475, current time 482, horizon 7\n", - "adding: mem time476, current time 482, horizon 6\n", - "adding: mem time477, current time 482, horizon 5\n", - "adding: mem time478, current time 482, horizon 4\n", - "adding: mem time479, current time 482, horizon 3\n", - "adding: mem time480, current time 482, horizon 2\n", - "adding: mem time481, current time 482, horizon 1\n", - "adding: mem time400, current time 483, horizon 83\n", - "adding: mem time401, current time 483, horizon 82\n", - "adding: mem time402, current time 483, horizon 81\n", - "adding: mem time403, current time 483, horizon 80\n", - "adding: mem time404, current time 483, horizon 79\n", - "adding: mem time405, current time 483, horizon 78\n", - "adding: mem time406, current time 483, horizon 77\n", - "adding: mem time407, current time 483, horizon 76\n", - "adding: mem time408, current time 483, horizon 75\n", - "adding: mem time409, current time 483, horizon 74\n", - "adding: mem time410, current time 483, horizon 73\n", - "adding: mem time411, current time 483, horizon 72\n", - "adding: mem time412, current time 483, horizon 71\n", - "adding: mem time413, current time 483, horizon 70\n", - "adding: mem time414, current time 483, horizon 69\n", - "adding: mem time415, current time 483, horizon 68\n", - "adding: mem time416, current time 483, horizon 67\n", - "adding: mem time417, current time 483, horizon 66\n", - "adding: mem time418, current time 483, horizon 65\n", - "adding: mem time419, current time 483, horizon 64\n", - "adding: mem time420, current time 483, horizon 63\n", - "adding: mem time421, current time 483, horizon 62\n", - "adding: mem time422, current time 483, horizon 61\n", - "adding: mem time423, current time 483, horizon 60\n", - "adding: mem time424, current time 483, horizon 59\n", - "adding: mem time425, current time 483, horizon 58\n", - "adding: mem time426, current time 483, horizon 57\n", - "adding: mem time427, current time 483, horizon 56\n", - "adding: mem time428, current time 483, horizon 55\n", - "adding: mem time429, current time 483, horizon 54\n", - "adding: mem time430, current time 483, horizon 53\n", - "adding: mem time431, current time 483, horizon 52\n", - "adding: mem time432, current time 483, horizon 51\n", - "adding: mem time433, current time 483, horizon 50\n", - "adding: mem time434, current time 483, horizon 49\n", - "adding: mem time435, current time 483, horizon 48\n", - "adding: mem time436, current time 483, horizon 47\n", - "adding: mem time437, current time 483, horizon 46\n", - "adding: mem time438, current time 483, horizon 45\n", - "adding: mem time439, current time 483, horizon 44\n", - "adding: mem time440, current time 483, horizon 43\n", - "adding: mem time441, current time 483, horizon 42\n", - "adding: mem time442, current time 483, horizon 41\n", - "adding: mem time443, current time 483, horizon 40\n", - "adding: mem time444, current time 483, horizon 39\n", - "adding: mem time445, current time 483, horizon 38\n", - "adding: mem time446, current time 483, horizon 37\n", - "adding: mem time447, current time 483, horizon 36\n", - "adding: mem time448, current time 483, horizon 35\n", - "adding: mem time449, current time 483, horizon 34\n", - "adding: mem time450, current time 483, horizon 33\n", - "adding: mem time451, current time 483, horizon 32\n", - "adding: mem time452, current time 483, horizon 31\n", - "adding: mem time453, current time 483, horizon 30\n", - "adding: mem time454, current time 483, horizon 29\n", - "adding: mem time455, current time 483, horizon 28\n", - "adding: mem time456, current time 483, horizon 27\n", - "adding: mem time457, current time 483, horizon 26\n", - "adding: mem time458, current time 483, horizon 25\n", - "adding: mem time459, current time 483, horizon 24\n", - "adding: mem time460, current time 483, horizon 23\n", - "adding: mem time461, current time 483, horizon 22\n", - "adding: mem time462, current time 483, horizon 21\n", - "adding: mem time463, current time 483, horizon 20\n", - "adding: mem time464, current time 483, horizon 19\n", - "adding: mem time465, current time 483, horizon 18\n", - "adding: mem time466, current time 483, horizon 17\n", - "adding: mem time467, current time 483, horizon 16\n", - "adding: mem time468, current time 483, horizon 15\n", - "adding: mem time469, current time 483, horizon 14\n", - "adding: mem time470, current time 483, horizon 13\n", - "adding: mem time471, current time 483, horizon 12\n", - "adding: mem time472, current time 483, horizon 11\n", - "adding: mem time473, current time 483, horizon 10\n", - "adding: mem time474, current time 483, horizon 9\n", - "adding: mem time475, current time 483, horizon 8\n", - "adding: mem time476, current time 483, horizon 7\n", - "adding: mem time477, current time 483, horizon 6\n", - "adding: mem time478, current time 483, horizon 5\n", - "adding: mem time479, current time 483, horizon 4\n", - "adding: mem time480, current time 483, horizon 3\n", - "adding: mem time481, current time 483, horizon 2\n", - "adding: mem time482, current time 483, horizon 1\n", - "adding: mem time400, current time 484, horizon 84\n", - "adding: mem time401, current time 484, horizon 83\n", - "adding: mem time402, current time 484, horizon 82\n", - "adding: mem time403, current time 484, horizon 81\n", - "adding: mem time404, current time 484, horizon 80\n", - "adding: mem time405, current time 484, horizon 79\n", - "adding: mem time406, current time 484, horizon 78\n", - "adding: mem time407, current time 484, horizon 77\n", - "adding: mem time408, current time 484, horizon 76\n", - "adding: mem time409, current time 484, horizon 75\n", - "adding: mem time410, current time 484, horizon 74\n", - "adding: mem time411, current time 484, horizon 73\n", - "adding: mem time412, current time 484, horizon 72\n", - "adding: mem time413, current time 484, horizon 71\n", - "adding: mem time414, current time 484, horizon 70\n", - "adding: mem time415, current time 484, horizon 69\n", - "adding: mem time416, current time 484, horizon 68\n", - "adding: mem time417, current time 484, horizon 67\n", - "adding: mem time418, current time 484, horizon 66\n", - "adding: mem time419, current time 484, horizon 65\n", - "adding: mem time420, current time 484, horizon 64\n", - "adding: mem time421, current time 484, horizon 63\n", - "adding: mem time422, current time 484, horizon 62\n", - "adding: mem time423, current time 484, horizon 61\n", - "adding: mem time424, current time 484, horizon 60\n", - "adding: mem time425, current time 484, horizon 59\n", - "adding: mem time426, current time 484, horizon 58\n", - "adding: mem time427, current time 484, horizon 57\n", - "adding: mem time428, current time 484, horizon 56\n", - "adding: mem time429, current time 484, horizon 55\n", - "adding: mem time430, current time 484, horizon 54\n", - "adding: mem time431, current time 484, horizon 53\n", - "adding: mem time432, current time 484, horizon 52\n", - "adding: mem time433, current time 484, horizon 51\n", - "adding: mem time434, current time 484, horizon 50\n", - "adding: mem time435, current time 484, horizon 49\n", - "adding: mem time436, current time 484, horizon 48\n", - "adding: mem time437, current time 484, horizon 47\n", - "adding: mem time438, current time 484, horizon 46\n", - "adding: mem time439, current time 484, horizon 45\n", - "adding: mem time440, current time 484, horizon 44\n", - "adding: mem time441, current time 484, horizon 43\n", - "adding: mem time442, current time 484, horizon 42\n", - "adding: mem time443, current time 484, horizon 41\n", - "adding: mem time444, current time 484, horizon 40\n", - "adding: mem time445, current time 484, horizon 39\n", - "adding: mem time446, current time 484, horizon 38\n", - "adding: mem time447, current time 484, horizon 37\n", - "adding: mem time448, current time 484, horizon 36\n", - "adding: mem time449, current time 484, horizon 35\n", - "adding: mem time450, current time 484, horizon 34\n", - "adding: mem time451, current time 484, horizon 33\n", - "adding: mem time452, current time 484, horizon 32\n", - "adding: mem time453, current time 484, horizon 31\n", - "adding: mem time454, current time 484, horizon 30\n", - "adding: mem time455, current time 484, horizon 29\n", - "adding: mem time456, current time 484, horizon 28\n", - "adding: mem time457, current time 484, horizon 27\n", - "adding: mem time458, current time 484, horizon 26\n", - "adding: mem time459, current time 484, horizon 25\n", - "adding: mem time460, current time 484, horizon 24\n", - "adding: mem time461, current time 484, horizon 23\n", - "adding: mem time462, current time 484, horizon 22\n", - "adding: mem time463, current time 484, horizon 21\n", - "adding: mem time464, current time 484, horizon 20\n", - "adding: mem time465, current time 484, horizon 19\n", - "adding: mem time466, current time 484, horizon 18\n", - "adding: mem time467, current time 484, horizon 17\n", - "adding: mem time468, current time 484, horizon 16\n", - "adding: mem time469, current time 484, horizon 15\n", - "adding: mem time470, current time 484, horizon 14\n", - "adding: mem time471, current time 484, horizon 13\n", - "adding: mem time472, current time 484, horizon 12\n", - "adding: mem time473, current time 484, horizon 11\n", - "adding: mem time474, current time 484, horizon 10\n", - "adding: mem time475, current time 484, horizon 9\n", - "adding: mem time476, current time 484, horizon 8\n", - "adding: mem time477, current time 484, horizon 7\n", - "adding: mem time478, current time 484, horizon 6\n", - "adding: mem time479, current time 484, horizon 5\n", - "adding: mem time480, current time 484, horizon 4\n", - "adding: mem time481, current time 484, horizon 3\n", - "adding: mem time482, current time 484, horizon 2\n", - "adding: mem time483, current time 484, horizon 1\n", - "adding: mem time400, current time 485, horizon 85\n", - "adding: mem time401, current time 485, horizon 84\n", - "adding: mem time402, current time 485, horizon 83\n", - "adding: mem time403, current time 485, horizon 82\n", - "adding: mem time404, current time 485, horizon 81\n", - "adding: mem time405, current time 485, horizon 80\n", - "adding: mem time406, current time 485, horizon 79\n", - "adding: mem time407, current time 485, horizon 78\n", - "adding: mem time408, current time 485, horizon 77\n", - "adding: mem time409, current time 485, horizon 76\n", - "adding: mem time410, current time 485, horizon 75\n", - "adding: mem time411, current time 485, horizon 74\n", - "adding: mem time412, current time 485, horizon 73\n", - "adding: mem time413, current time 485, horizon 72\n", - "adding: mem time414, current time 485, horizon 71\n", - "adding: mem time415, current time 485, horizon 70\n", - "adding: mem time416, current time 485, horizon 69\n", - "adding: mem time417, current time 485, horizon 68\n", - "adding: mem time418, current time 485, horizon 67\n", - "adding: mem time419, current time 485, horizon 66\n", - "adding: mem time420, current time 485, horizon 65\n", - "adding: mem time421, current time 485, horizon 64\n", - "adding: mem time422, current time 485, horizon 63\n", - "adding: mem time423, current time 485, horizon 62\n", - "adding: mem time424, current time 485, horizon 61\n", - "adding: mem time425, current time 485, horizon 60\n", - "adding: mem time426, current time 485, horizon 59\n", - "adding: mem time427, current time 485, horizon 58\n", - "adding: mem time428, current time 485, horizon 57\n", - "adding: mem time429, current time 485, horizon 56\n", - "adding: mem time430, current time 485, horizon 55\n", - "adding: mem time431, current time 485, horizon 54\n", - "adding: mem time432, current time 485, horizon 53\n", - "adding: mem time433, current time 485, horizon 52\n", - "adding: mem time434, current time 485, horizon 51\n", - "adding: mem time435, current time 485, horizon 50\n", - "adding: mem time436, current time 485, horizon 49\n", - "adding: mem time437, current time 485, horizon 48\n", - "adding: mem time438, current time 485, horizon 47\n", - "adding: mem time439, current time 485, horizon 46\n", - "adding: mem time440, current time 485, horizon 45\n", - "adding: mem time441, current time 485, horizon 44\n", - "adding: mem time442, current time 485, horizon 43\n", - "adding: mem time443, current time 485, horizon 42\n", - "adding: mem time444, current time 485, horizon 41\n", - "adding: mem time445, current time 485, horizon 40\n", - "adding: mem time446, current time 485, horizon 39\n", - "adding: mem time447, current time 485, horizon 38\n", - "adding: mem time448, current time 485, horizon 37\n", - "adding: mem time449, current time 485, horizon 36\n", - "adding: mem time450, current time 485, horizon 35\n", - "adding: mem time451, current time 485, horizon 34\n", - "adding: mem time452, current time 485, horizon 33\n", - "adding: mem time453, current time 485, horizon 32\n", - "adding: mem time454, current time 485, horizon 31\n", - "adding: mem time455, current time 485, horizon 30\n", - "adding: mem time456, current time 485, horizon 29\n", - "adding: mem time457, current time 485, horizon 28\n", - "adding: mem time458, current time 485, horizon 27\n", - "adding: mem time459, current time 485, horizon 26\n", - "adding: mem time460, current time 485, horizon 25\n", - "adding: mem time461, current time 485, horizon 24\n", - "adding: mem time462, current time 485, horizon 23\n", - "adding: mem time463, current time 485, horizon 22\n", - "adding: mem time464, current time 485, horizon 21\n", - "adding: mem time465, current time 485, horizon 20\n", - "adding: mem time466, current time 485, horizon 19\n", - "adding: mem time467, current time 485, horizon 18\n", - "adding: mem time468, current time 485, horizon 17\n", - "adding: mem time469, current time 485, horizon 16\n", - "adding: mem time470, current time 485, horizon 15\n", - "adding: mem time471, current time 485, horizon 14\n", - "adding: mem time472, current time 485, horizon 13\n", - "adding: mem time473, current time 485, horizon 12\n", - "adding: mem time474, current time 485, horizon 11\n", - "adding: mem time475, current time 485, horizon 10\n", - "adding: mem time476, current time 485, horizon 9\n", - "adding: mem time477, current time 485, horizon 8\n", - "adding: mem time478, current time 485, horizon 7\n", - "adding: mem time479, current time 485, horizon 6\n", - "adding: mem time480, current time 485, horizon 5\n", - "adding: mem time481, current time 485, horizon 4\n", - "adding: mem time482, current time 485, horizon 3\n", - "adding: mem time483, current time 485, horizon 2\n", - "adding: mem time484, current time 485, horizon 1\n", - "adding: mem time400, current time 486, horizon 86\n", - "adding: mem time401, current time 486, horizon 85\n", - "adding: mem time402, current time 486, horizon 84\n", - "adding: mem time403, current time 486, horizon 83\n", - "adding: mem time404, current time 486, horizon 82\n", - "adding: mem time405, current time 486, horizon 81\n", - "adding: mem time406, current time 486, horizon 80\n", - "adding: mem time407, current time 486, horizon 79\n", - "adding: mem time408, current time 486, horizon 78\n", - "adding: mem time409, current time 486, horizon 77\n", - "adding: mem time410, current time 486, horizon 76\n", - "adding: mem time411, current time 486, horizon 75\n", - "adding: mem time412, current time 486, horizon 74\n", - "adding: mem time413, current time 486, horizon 73\n", - "adding: mem time414, current time 486, horizon 72\n", - "adding: mem time415, current time 486, horizon 71\n", - "adding: mem time416, current time 486, horizon 70\n", - "adding: mem time417, current time 486, horizon 69\n", - "adding: mem time418, current time 486, horizon 68\n", - "adding: mem time419, current time 486, horizon 67\n", - "adding: mem time420, current time 486, horizon 66\n", - "adding: mem time421, current time 486, horizon 65\n", - "adding: mem time422, current time 486, horizon 64\n", - "adding: mem time423, current time 486, horizon 63\n", - "adding: mem time424, current time 486, horizon 62\n", - "adding: mem time425, current time 486, horizon 61\n", - "adding: mem time426, current time 486, horizon 60\n", - "adding: mem time427, current time 486, horizon 59\n", - "adding: mem time428, current time 486, horizon 58\n", - "adding: mem time429, current time 486, horizon 57\n", - "adding: mem time430, current time 486, horizon 56\n", - "adding: mem time431, current time 486, horizon 55\n", - "adding: mem time432, current time 486, horizon 54\n", - "adding: mem time433, current time 486, horizon 53\n", - "adding: mem time434, current time 486, horizon 52\n", - "adding: mem time435, current time 486, horizon 51\n", - "adding: mem time436, current time 486, horizon 50\n", - "adding: mem time437, current time 486, horizon 49\n", - "adding: mem time438, current time 486, horizon 48\n", - "adding: mem time439, current time 486, horizon 47\n", - "adding: mem time440, current time 486, horizon 46\n", - "adding: mem time441, current time 486, horizon 45\n", - "adding: mem time442, current time 486, horizon 44\n", - "adding: mem time443, current time 486, horizon 43\n", - "adding: mem time444, current time 486, horizon 42\n", - "adding: mem time445, current time 486, horizon 41\n", - "adding: mem time446, current time 486, horizon 40\n", - "adding: mem time447, current time 486, horizon 39\n", - "adding: mem time448, current time 486, horizon 38\n", - "adding: mem time449, current time 486, horizon 37\n", - "adding: mem time450, current time 486, horizon 36\n", - "adding: mem time451, current time 486, horizon 35\n", - "adding: mem time452, current time 486, horizon 34\n", - "adding: mem time453, current time 486, horizon 33\n", - "adding: mem time454, current time 486, horizon 32\n", - "adding: mem time455, current time 486, horizon 31\n", - "adding: mem time456, current time 486, horizon 30\n", - "adding: mem time457, current time 486, horizon 29\n", - "adding: mem time458, current time 486, horizon 28\n", - "adding: mem time459, current time 486, horizon 27\n", - "adding: mem time460, current time 486, horizon 26\n", - "adding: mem time461, current time 486, horizon 25\n", - "adding: mem time462, current time 486, horizon 24\n", - "adding: mem time463, current time 486, horizon 23\n", - "adding: mem time464, current time 486, horizon 22\n", - "adding: mem time465, current time 486, horizon 21\n", - "adding: mem time466, current time 486, horizon 20\n", - "adding: mem time467, current time 486, horizon 19\n", - "adding: mem time468, current time 486, horizon 18\n", - "adding: mem time469, current time 486, horizon 17\n", - "adding: mem time470, current time 486, horizon 16\n", - "adding: mem time471, current time 486, horizon 15\n", - "adding: mem time472, current time 486, horizon 14\n", - "adding: mem time473, current time 486, horizon 13\n", - "adding: mem time474, current time 486, horizon 12\n", - "adding: mem time475, current time 486, horizon 11\n", - "adding: mem time476, current time 486, horizon 10\n", - "adding: mem time477, current time 486, horizon 9\n", - "adding: mem time478, current time 486, horizon 8\n", - "adding: mem time479, current time 486, horizon 7\n", - "adding: mem time480, current time 486, horizon 6\n", - "adding: mem time481, current time 486, horizon 5\n", - "adding: mem time482, current time 486, horizon 4\n", - "adding: mem time483, current time 486, horizon 3\n", - "adding: mem time484, current time 486, horizon 2\n", - "adding: mem time485, current time 486, horizon 1\n", - "adding: mem time400, current time 487, horizon 87\n", - "adding: mem time401, current time 487, horizon 86\n", - "adding: mem time402, current time 487, horizon 85\n", - "adding: mem time403, current time 487, horizon 84\n", - "adding: mem time404, current time 487, horizon 83\n", - "adding: mem time405, current time 487, horizon 82\n", - "adding: mem time406, current time 487, horizon 81\n", - "adding: mem time407, current time 487, horizon 80\n", - "adding: mem time408, current time 487, horizon 79\n", - "adding: mem time409, current time 487, horizon 78\n", - "adding: mem time410, current time 487, horizon 77\n", - "adding: mem time411, current time 487, horizon 76\n", - "adding: mem time412, current time 487, horizon 75\n", - "adding: mem time413, current time 487, horizon 74\n", - "adding: mem time414, current time 487, horizon 73\n", - "adding: mem time415, current time 487, horizon 72\n", - "adding: mem time416, current time 487, horizon 71\n", - "adding: mem time417, current time 487, horizon 70\n", - "adding: mem time418, current time 487, horizon 69\n", - "adding: mem time419, current time 487, horizon 68\n", - "adding: mem time420, current time 487, horizon 67\n", - "adding: mem time421, current time 487, horizon 66\n", - "adding: mem time422, current time 487, horizon 65\n", - "adding: mem time423, current time 487, horizon 64\n", - "adding: mem time424, current time 487, horizon 63\n", - "adding: mem time425, current time 487, horizon 62\n", - "adding: mem time426, current time 487, horizon 61\n", - "adding: mem time427, current time 487, horizon 60\n", - "adding: mem time428, current time 487, horizon 59\n", - "adding: mem time429, current time 487, horizon 58\n", - "adding: mem time430, current time 487, horizon 57\n", - "adding: mem time431, current time 487, horizon 56\n", - "adding: mem time432, current time 487, horizon 55\n", - "adding: mem time433, current time 487, horizon 54\n", - "adding: mem time434, current time 487, horizon 53\n", - "adding: mem time435, current time 487, horizon 52\n", - "adding: mem time436, current time 487, horizon 51\n", - "adding: mem time437, current time 487, horizon 50\n", - "adding: mem time438, current time 487, horizon 49\n", - "adding: mem time439, current time 487, horizon 48\n", - "adding: mem time440, current time 487, horizon 47\n", - "adding: mem time441, current time 487, horizon 46\n", - "adding: mem time442, current time 487, horizon 45\n", - "adding: mem time443, current time 487, horizon 44\n", - "adding: mem time444, current time 487, horizon 43\n", - "adding: mem time445, current time 487, horizon 42\n", - "adding: mem time446, current time 487, horizon 41\n", - "adding: mem time447, current time 487, horizon 40\n", - "adding: mem time448, current time 487, horizon 39\n", - "adding: mem time449, current time 487, horizon 38\n", - "adding: mem time450, current time 487, horizon 37\n", - "adding: mem time451, current time 487, horizon 36\n", - "adding: mem time452, current time 487, horizon 35\n", - "adding: mem time453, current time 487, horizon 34\n", - "adding: mem time454, current time 487, horizon 33\n", - "adding: mem time455, current time 487, horizon 32\n", - "adding: mem time456, current time 487, horizon 31\n", - "adding: mem time457, current time 487, horizon 30\n", - "adding: mem time458, current time 487, horizon 29\n", - "adding: mem time459, current time 487, horizon 28\n", - "adding: mem time460, current time 487, horizon 27\n", - "adding: mem time461, current time 487, horizon 26\n", - "adding: mem time462, current time 487, horizon 25\n", - "adding: mem time463, current time 487, horizon 24\n", - "adding: mem time464, current time 487, horizon 23\n", - "adding: mem time465, current time 487, horizon 22\n", - "adding: mem time466, current time 487, horizon 21\n", - "adding: mem time467, current time 487, horizon 20\n", - "adding: mem time468, current time 487, horizon 19\n", - "adding: mem time469, current time 487, horizon 18\n", - "adding: mem time470, current time 487, horizon 17\n", - "adding: mem time471, current time 487, horizon 16\n", - "adding: mem time472, current time 487, horizon 15\n", - "adding: mem time473, current time 487, horizon 14\n", - "adding: mem time474, current time 487, horizon 13\n", - "adding: mem time475, current time 487, horizon 12\n", - "adding: mem time476, current time 487, horizon 11\n", - "adding: mem time477, current time 487, horizon 10\n", - "adding: mem time478, current time 487, horizon 9\n", - "adding: mem time479, current time 487, horizon 8\n", - "adding: mem time480, current time 487, horizon 7\n", - "adding: mem time481, current time 487, horizon 6\n", - "adding: mem time482, current time 487, horizon 5\n", - "adding: mem time483, current time 487, horizon 4\n", - "adding: mem time484, current time 487, horizon 3\n", - "adding: mem time485, current time 487, horizon 2\n", - "adding: mem time486, current time 487, horizon 1\n", - "adding: mem time400, current time 488, horizon 88\n", - "adding: mem time401, current time 488, horizon 87\n", - "adding: mem time402, current time 488, horizon 86\n", - "adding: mem time403, current time 488, horizon 85\n", - "adding: mem time404, current time 488, horizon 84\n", - "adding: mem time405, current time 488, horizon 83\n", - "adding: mem time406, current time 488, horizon 82\n", - "adding: mem time407, current time 488, horizon 81\n", - "adding: mem time408, current time 488, horizon 80\n", - "adding: mem time409, current time 488, horizon 79\n", - "adding: mem time410, current time 488, horizon 78\n", - "adding: mem time411, current time 488, horizon 77\n", - "adding: mem time412, current time 488, horizon 76\n", - "adding: mem time413, current time 488, horizon 75\n", - "adding: mem time414, current time 488, horizon 74\n", - "adding: mem time415, current time 488, horizon 73\n", - "adding: mem time416, current time 488, horizon 72\n", - "adding: mem time417, current time 488, horizon 71\n", - "adding: mem time418, current time 488, horizon 70\n", - "adding: mem time419, current time 488, horizon 69\n", - "adding: mem time420, current time 488, horizon 68\n", - "adding: mem time421, current time 488, horizon 67\n", - "adding: mem time422, current time 488, horizon 66\n", - "adding: mem time423, current time 488, horizon 65\n", - "adding: mem time424, current time 488, horizon 64\n", - "adding: mem time425, current time 488, horizon 63\n", - "adding: mem time426, current time 488, horizon 62\n", - "adding: mem time427, current time 488, horizon 61\n", - "adding: mem time428, current time 488, horizon 60\n", - "adding: mem time429, current time 488, horizon 59\n", - "adding: mem time430, current time 488, horizon 58\n", - "adding: mem time431, current time 488, horizon 57\n", - "adding: mem time432, current time 488, horizon 56\n", - "adding: mem time433, current time 488, horizon 55\n", - "adding: mem time434, current time 488, horizon 54\n", - "adding: mem time435, current time 488, horizon 53\n", - "adding: mem time436, current time 488, horizon 52\n", - "adding: mem time437, current time 488, horizon 51\n", - "adding: mem time438, current time 488, horizon 50\n", - "adding: mem time439, current time 488, horizon 49\n", - "adding: mem time440, current time 488, horizon 48\n", - "adding: mem time441, current time 488, horizon 47\n", - "adding: mem time442, current time 488, horizon 46\n", - "adding: mem time443, current time 488, horizon 45\n", - "adding: mem time444, current time 488, horizon 44\n", - "adding: mem time445, current time 488, horizon 43\n", - "adding: mem time446, current time 488, horizon 42\n", - "adding: mem time447, current time 488, horizon 41\n", - "adding: mem time448, current time 488, horizon 40\n", - "adding: mem time449, current time 488, horizon 39\n", - "adding: mem time450, current time 488, horizon 38\n", - "adding: mem time451, current time 488, horizon 37\n", - "adding: mem time452, current time 488, horizon 36\n", - "adding: mem time453, current time 488, horizon 35\n", - "adding: mem time454, current time 488, horizon 34\n", - "adding: mem time455, current time 488, horizon 33\n", - "adding: mem time456, current time 488, horizon 32\n", - "adding: mem time457, current time 488, horizon 31\n", - "adding: mem time458, current time 488, horizon 30\n", - "adding: mem time459, current time 488, horizon 29\n", - "adding: mem time460, current time 488, horizon 28\n", - "adding: mem time461, current time 488, horizon 27\n", - "adding: mem time462, current time 488, horizon 26\n", - "adding: mem time463, current time 488, horizon 25\n", - "adding: mem time464, current time 488, horizon 24\n", - "adding: mem time465, current time 488, horizon 23\n", - "adding: mem time466, current time 488, horizon 22\n", - "adding: mem time467, current time 488, horizon 21\n", - "adding: mem time468, current time 488, horizon 20\n", - "adding: mem time469, current time 488, horizon 19\n", - "adding: mem time470, current time 488, horizon 18\n", - "adding: mem time471, current time 488, horizon 17\n", - "adding: mem time472, current time 488, horizon 16\n", - "adding: mem time473, current time 488, horizon 15\n", - "adding: mem time474, current time 488, horizon 14\n", - "adding: mem time475, current time 488, horizon 13\n", - "adding: mem time476, current time 488, horizon 12\n", - "adding: mem time477, current time 488, horizon 11\n", - "adding: mem time478, current time 488, horizon 10\n", - "adding: mem time479, current time 488, horizon 9\n", - "adding: mem time480, current time 488, horizon 8\n", - "adding: mem time481, current time 488, horizon 7\n", - "adding: mem time482, current time 488, horizon 6\n", - "adding: mem time483, current time 488, horizon 5\n", - "adding: mem time484, current time 488, horizon 4\n", - "adding: mem time485, current time 488, horizon 3\n", - "adding: mem time486, current time 488, horizon 2\n", - "adding: mem time487, current time 488, horizon 1\n", - "adding: mem time400, current time 489, horizon 89\n", - "adding: mem time401, current time 489, horizon 88\n", - "adding: mem time402, current time 489, horizon 87\n", - "adding: mem time403, current time 489, horizon 86\n", - "adding: mem time404, current time 489, horizon 85\n", - "adding: mem time405, current time 489, horizon 84\n", - "adding: mem time406, current time 489, horizon 83\n", - "adding: mem time407, current time 489, horizon 82\n", - "adding: mem time408, current time 489, horizon 81\n", - "adding: mem time409, current time 489, horizon 80\n", - "adding: mem time410, current time 489, horizon 79\n", - "adding: mem time411, current time 489, horizon 78\n", - "adding: mem time412, current time 489, horizon 77\n", - "adding: mem time413, current time 489, horizon 76\n", - "adding: mem time414, current time 489, horizon 75\n", - "adding: mem time415, current time 489, horizon 74\n", - "adding: mem time416, current time 489, horizon 73\n", - "adding: mem time417, current time 489, horizon 72\n", - "adding: mem time418, current time 489, horizon 71\n", - "adding: mem time419, current time 489, horizon 70\n", - "adding: mem time420, current time 489, horizon 69\n", - "adding: mem time421, current time 489, horizon 68\n", - "adding: mem time422, current time 489, horizon 67\n", - "adding: mem time423, current time 489, horizon 66\n", - "adding: mem time424, current time 489, horizon 65\n", - "adding: mem time425, current time 489, horizon 64\n", - "adding: mem time426, current time 489, horizon 63\n", - "adding: mem time427, current time 489, horizon 62\n", - "adding: mem time428, current time 489, horizon 61\n", - "adding: mem time429, current time 489, horizon 60\n", - "adding: mem time430, current time 489, horizon 59\n", - "adding: mem time431, current time 489, horizon 58\n", - "adding: mem time432, current time 489, horizon 57\n", - "adding: mem time433, current time 489, horizon 56\n", - "adding: mem time434, current time 489, horizon 55\n", - "adding: mem time435, current time 489, horizon 54\n", - "adding: mem time436, current time 489, horizon 53\n", - "adding: mem time437, current time 489, horizon 52\n", - "adding: mem time438, current time 489, horizon 51\n", - "adding: mem time439, current time 489, horizon 50\n", - "adding: mem time440, current time 489, horizon 49\n", - "adding: mem time441, current time 489, horizon 48\n", - "adding: mem time442, current time 489, horizon 47\n", - "adding: mem time443, current time 489, horizon 46\n", - "adding: mem time444, current time 489, horizon 45\n", - "adding: mem time445, current time 489, horizon 44\n", - "adding: mem time446, current time 489, horizon 43\n", - "adding: mem time447, current time 489, horizon 42\n", - "adding: mem time448, current time 489, horizon 41\n", - "adding: mem time449, current time 489, horizon 40\n", - "adding: mem time450, current time 489, horizon 39\n", - "adding: mem time451, current time 489, horizon 38\n", - "adding: mem time452, current time 489, horizon 37\n", - "adding: mem time453, current time 489, horizon 36\n", - "adding: mem time454, current time 489, horizon 35\n", - "adding: mem time455, current time 489, horizon 34\n", - "adding: mem time456, current time 489, horizon 33\n", - "adding: mem time457, current time 489, horizon 32\n", - "adding: mem time458, current time 489, horizon 31\n", - "adding: mem time459, current time 489, horizon 30\n", - "adding: mem time460, current time 489, horizon 29\n", - "adding: mem time461, current time 489, horizon 28\n", - "adding: mem time462, current time 489, horizon 27\n", - "adding: mem time463, current time 489, horizon 26\n", - "adding: mem time464, current time 489, horizon 25\n", - "adding: mem time465, current time 489, horizon 24\n", - "adding: mem time466, current time 489, horizon 23\n", - "adding: mem time467, current time 489, horizon 22\n", - "adding: mem time468, current time 489, horizon 21\n", - "adding: mem time469, current time 489, horizon 20\n", - "adding: mem time470, current time 489, horizon 19\n", - "adding: mem time471, current time 489, horizon 18\n", - "adding: mem time472, current time 489, horizon 17\n", - "adding: mem time473, current time 489, horizon 16\n", - "adding: mem time474, current time 489, horizon 15\n", - "adding: mem time475, current time 489, horizon 14\n", - "adding: mem time476, current time 489, horizon 13\n", - "adding: mem time477, current time 489, horizon 12\n", - "adding: mem time478, current time 489, horizon 11\n", - "adding: mem time479, current time 489, horizon 10\n", - "adding: mem time480, current time 489, horizon 9\n", - "adding: mem time481, current time 489, horizon 8\n", - "adding: mem time482, current time 489, horizon 7\n", - "adding: mem time483, current time 489, horizon 6\n", - "adding: mem time484, current time 489, horizon 5\n", - "adding: mem time485, current time 489, horizon 4\n", - "adding: mem time486, current time 489, horizon 3\n", - "adding: mem time487, current time 489, horizon 2\n", - "adding: mem time488, current time 489, horizon 1\n", - "adding: mem time400, current time 490, horizon 90\n", - "adding: mem time401, current time 490, horizon 89\n", - "adding: mem time402, current time 490, horizon 88\n", - "adding: mem time403, current time 490, horizon 87\n", - "adding: mem time404, current time 490, horizon 86\n", - "adding: mem time405, current time 490, horizon 85\n", - "adding: mem time406, current time 490, horizon 84\n", - "adding: mem time407, current time 490, horizon 83\n", - "adding: mem time408, current time 490, horizon 82\n", - "adding: mem time409, current time 490, horizon 81\n", - "adding: mem time410, current time 490, horizon 80\n", - "adding: mem time411, current time 490, horizon 79\n", - "adding: mem time412, current time 490, horizon 78\n", - "adding: mem time413, current time 490, horizon 77\n", - "adding: mem time414, current time 490, horizon 76\n", - "adding: mem time415, current time 490, horizon 75\n", - "adding: mem time416, current time 490, horizon 74\n", - "adding: mem time417, current time 490, horizon 73\n", - "adding: mem time418, current time 490, horizon 72\n", - "adding: mem time419, current time 490, horizon 71\n", - "adding: mem time420, current time 490, horizon 70\n", - "adding: mem time421, current time 490, horizon 69\n", - "adding: mem time422, current time 490, horizon 68\n", - "adding: mem time423, current time 490, horizon 67\n", - "adding: mem time424, current time 490, horizon 66\n", - "adding: mem time425, current time 490, horizon 65\n", - "adding: mem time426, current time 490, horizon 64\n", - "adding: mem time427, current time 490, horizon 63\n", - "adding: mem time428, current time 490, horizon 62\n", - "adding: mem time429, current time 490, horizon 61\n", - "adding: mem time430, current time 490, horizon 60\n", - "adding: mem time431, current time 490, horizon 59\n", - "adding: mem time432, current time 490, horizon 58\n", - "adding: mem time433, current time 490, horizon 57\n", - "adding: mem time434, current time 490, horizon 56\n", - "adding: mem time435, current time 490, horizon 55\n", - "adding: mem time436, current time 490, horizon 54\n", - "adding: mem time437, current time 490, horizon 53\n", - "adding: mem time438, current time 490, horizon 52\n", - "adding: mem time439, current time 490, horizon 51\n", - "adding: mem time440, current time 490, horizon 50\n", - "adding: mem time441, current time 490, horizon 49\n", - "adding: mem time442, current time 490, horizon 48\n", - "adding: mem time443, current time 490, horizon 47\n", - "adding: mem time444, current time 490, horizon 46\n", - "adding: mem time445, current time 490, horizon 45\n", - "adding: mem time446, current time 490, horizon 44\n", - "adding: mem time447, current time 490, horizon 43\n", - "adding: mem time448, current time 490, horizon 42\n", - "adding: mem time449, current time 490, horizon 41\n", - "adding: mem time450, current time 490, horizon 40\n", - "adding: mem time451, current time 490, horizon 39\n", - "adding: mem time452, current time 490, horizon 38\n", - "adding: mem time453, current time 490, horizon 37\n", - "adding: mem time454, current time 490, horizon 36\n", - "adding: mem time455, current time 490, horizon 35\n", - "adding: mem time456, current time 490, horizon 34\n", - "adding: mem time457, current time 490, horizon 33\n", - "adding: mem time458, current time 490, horizon 32\n", - "adding: mem time459, current time 490, horizon 31\n", - "adding: mem time460, current time 490, horizon 30\n", - "adding: mem time461, current time 490, horizon 29\n", - "adding: mem time462, current time 490, horizon 28\n", - "adding: mem time463, current time 490, horizon 27\n", - "adding: mem time464, current time 490, horizon 26\n", - "adding: mem time465, current time 490, horizon 25\n", - "adding: mem time466, current time 490, horizon 24\n", - "adding: mem time467, current time 490, horizon 23\n", - "adding: mem time468, current time 490, horizon 22\n", - "adding: mem time469, current time 490, horizon 21\n", - "adding: mem time470, current time 490, horizon 20\n", - "adding: mem time471, current time 490, horizon 19\n", - "adding: mem time472, current time 490, horizon 18\n", - "adding: mem time473, current time 490, horizon 17\n", - "adding: mem time474, current time 490, horizon 16\n", - "adding: mem time475, current time 490, horizon 15\n", - "adding: mem time476, current time 490, horizon 14\n", - "adding: mem time477, current time 490, horizon 13\n", - "adding: mem time478, current time 490, horizon 12\n", - "adding: mem time479, current time 490, horizon 11\n", - "adding: mem time480, current time 490, horizon 10\n", - "adding: mem time481, current time 490, horizon 9\n", - "adding: mem time482, current time 490, horizon 8\n", - "adding: mem time483, current time 490, horizon 7\n", - "adding: mem time484, current time 490, horizon 6\n", - "adding: mem time485, current time 490, horizon 5\n", - "adding: mem time486, current time 490, horizon 4\n", - "adding: mem time487, current time 490, horizon 3\n", - "adding: mem time488, current time 490, horizon 2\n", - "adding: mem time489, current time 490, horizon 1\n", - "adding: mem time400, current time 491, horizon 91\n", - "adding: mem time401, current time 491, horizon 90\n", - "adding: mem time402, current time 491, horizon 89\n", - "adding: mem time403, current time 491, horizon 88\n", - "adding: mem time404, current time 491, horizon 87\n", - "adding: mem time405, current time 491, horizon 86\n", - "adding: mem time406, current time 491, horizon 85\n", - "adding: mem time407, current time 491, horizon 84\n", - "adding: mem time408, current time 491, horizon 83\n", - "adding: mem time409, current time 491, horizon 82\n", - "adding: mem time410, current time 491, horizon 81\n", - "adding: mem time411, current time 491, horizon 80\n", - "adding: mem time412, current time 491, horizon 79\n", - "adding: mem time413, current time 491, horizon 78\n", - "adding: mem time414, current time 491, horizon 77\n", - "adding: mem time415, current time 491, horizon 76\n", - "adding: mem time416, current time 491, horizon 75\n", - "adding: mem time417, current time 491, horizon 74\n", - "adding: mem time418, current time 491, horizon 73\n", - "adding: mem time419, current time 491, horizon 72\n", - "adding: mem time420, current time 491, horizon 71\n", - "adding: mem time421, current time 491, horizon 70\n", - "adding: mem time422, current time 491, horizon 69\n", - "adding: mem time423, current time 491, horizon 68\n", - "adding: mem time424, current time 491, horizon 67\n", - "adding: mem time425, current time 491, horizon 66\n", - "adding: mem time426, current time 491, horizon 65\n", - "adding: mem time427, current time 491, horizon 64\n", - "adding: mem time428, current time 491, horizon 63\n", - "adding: mem time429, current time 491, horizon 62\n", - "adding: mem time430, current time 491, horizon 61\n", - "adding: mem time431, current time 491, horizon 60\n", - "adding: mem time432, current time 491, horizon 59\n", - "adding: mem time433, current time 491, horizon 58\n", - "adding: mem time434, current time 491, horizon 57\n", - "adding: mem time435, current time 491, horizon 56\n", - "adding: mem time436, current time 491, horizon 55\n", - "adding: mem time437, current time 491, horizon 54\n", - "adding: mem time438, current time 491, horizon 53\n", - "adding: mem time439, current time 491, horizon 52\n", - "adding: mem time440, current time 491, horizon 51\n", - "adding: mem time441, current time 491, horizon 50\n", - "adding: mem time442, current time 491, horizon 49\n", - "adding: mem time443, current time 491, horizon 48\n", - "adding: mem time444, current time 491, horizon 47\n", - "adding: mem time445, current time 491, horizon 46\n", - "adding: mem time446, current time 491, horizon 45\n", - "adding: mem time447, current time 491, horizon 44\n", - "adding: mem time448, current time 491, horizon 43\n", - "adding: mem time449, current time 491, horizon 42\n", - "adding: mem time450, current time 491, horizon 41\n", - "adding: mem time451, current time 491, horizon 40\n", - "adding: mem time452, current time 491, horizon 39\n", - "adding: mem time453, current time 491, horizon 38\n", - "adding: mem time454, current time 491, horizon 37\n", - "adding: mem time455, current time 491, horizon 36\n", - "adding: mem time456, current time 491, horizon 35\n", - "adding: mem time457, current time 491, horizon 34\n", - "adding: mem time458, current time 491, horizon 33\n", - "adding: mem time459, current time 491, horizon 32\n", - "adding: mem time460, current time 491, horizon 31\n", - "adding: mem time461, current time 491, horizon 30\n", - "adding: mem time462, current time 491, horizon 29\n", - "adding: mem time463, current time 491, horizon 28\n", - "adding: mem time464, current time 491, horizon 27\n", - "adding: mem time465, current time 491, horizon 26\n", - "adding: mem time466, current time 491, horizon 25\n", - "adding: mem time467, current time 491, horizon 24\n", - "adding: mem time468, current time 491, horizon 23\n", - "adding: mem time469, current time 491, horizon 22\n", - "adding: mem time470, current time 491, horizon 21\n", - "adding: mem time471, current time 491, horizon 20\n", - "adding: mem time472, current time 491, horizon 19\n", - "adding: mem time473, current time 491, horizon 18\n", - "adding: mem time474, current time 491, horizon 17\n", - "adding: mem time475, current time 491, horizon 16\n", - "adding: mem time476, current time 491, horizon 15\n", - "adding: mem time477, current time 491, horizon 14\n", - "adding: mem time478, current time 491, horizon 13\n", - "adding: mem time479, current time 491, horizon 12\n", - "adding: mem time480, current time 491, horizon 11\n", - "adding: mem time481, current time 491, horizon 10\n", - "adding: mem time482, current time 491, horizon 9\n", - "adding: mem time483, current time 491, horizon 8\n", - "adding: mem time484, current time 491, horizon 7\n", - "adding: mem time485, current time 491, horizon 6\n", - "adding: mem time486, current time 491, horizon 5\n", - "adding: mem time487, current time 491, horizon 4\n", - "adding: mem time488, current time 491, horizon 3\n", - "adding: mem time489, current time 491, horizon 2\n", - "adding: mem time490, current time 491, horizon 1\n", - "adding: mem time400, current time 492, horizon 92\n", - "adding: mem time401, current time 492, horizon 91\n", - "adding: mem time402, current time 492, horizon 90\n", - "adding: mem time403, current time 492, horizon 89\n", - "adding: mem time404, current time 492, horizon 88\n", - "adding: mem time405, current time 492, horizon 87\n", - "adding: mem time406, current time 492, horizon 86\n", - "adding: mem time407, current time 492, horizon 85\n", - "adding: mem time408, current time 492, horizon 84\n", - "adding: mem time409, current time 492, horizon 83\n", - "adding: mem time410, current time 492, horizon 82\n", - "adding: mem time411, current time 492, horizon 81\n", - "adding: mem time412, current time 492, horizon 80\n", - "adding: mem time413, current time 492, horizon 79\n", - "adding: mem time414, current time 492, horizon 78\n", - "adding: mem time415, current time 492, horizon 77\n", - "adding: mem time416, current time 492, horizon 76\n", - "adding: mem time417, current time 492, horizon 75\n", - "adding: mem time418, current time 492, horizon 74\n", - "adding: mem time419, current time 492, horizon 73\n", - "adding: mem time420, current time 492, horizon 72\n", - "adding: mem time421, current time 492, horizon 71\n", - "adding: mem time422, current time 492, horizon 70\n", - "adding: mem time423, current time 492, horizon 69\n", - "adding: mem time424, current time 492, horizon 68\n", - "adding: mem time425, current time 492, horizon 67\n", - "adding: mem time426, current time 492, horizon 66\n", - "adding: mem time427, current time 492, horizon 65\n", - "adding: mem time428, current time 492, horizon 64\n", - "adding: mem time429, current time 492, horizon 63\n", - "adding: mem time430, current time 492, horizon 62\n", - "adding: mem time431, current time 492, horizon 61\n", - "adding: mem time432, current time 492, horizon 60\n", - "adding: mem time433, current time 492, horizon 59\n", - "adding: mem time434, current time 492, horizon 58\n", - "adding: mem time435, current time 492, horizon 57\n", - "adding: mem time436, current time 492, horizon 56\n", - "adding: mem time437, current time 492, horizon 55\n", - "adding: mem time438, current time 492, horizon 54\n", - "adding: mem time439, current time 492, horizon 53\n", - "adding: mem time440, current time 492, horizon 52\n", - "adding: mem time441, current time 492, horizon 51\n", - "adding: mem time442, current time 492, horizon 50\n", - "adding: mem time443, current time 492, horizon 49\n", - "adding: mem time444, current time 492, horizon 48\n", - "adding: mem time445, current time 492, horizon 47\n", - "adding: mem time446, current time 492, horizon 46\n", - "adding: mem time447, current time 492, horizon 45\n", - "adding: mem time448, current time 492, horizon 44\n", - "adding: mem time449, current time 492, horizon 43\n", - "adding: mem time450, current time 492, horizon 42\n", - "adding: mem time451, current time 492, horizon 41\n", - "adding: mem time452, current time 492, horizon 40\n", - "adding: mem time453, current time 492, horizon 39\n", - "adding: mem time454, current time 492, horizon 38\n", - "adding: mem time455, current time 492, horizon 37\n", - "adding: mem time456, current time 492, horizon 36\n", - "adding: mem time457, current time 492, horizon 35\n", - "adding: mem time458, current time 492, horizon 34\n", - "adding: mem time459, current time 492, horizon 33\n", - "adding: mem time460, current time 492, horizon 32\n", - "adding: mem time461, current time 492, horizon 31\n", - "adding: mem time462, current time 492, horizon 30\n", - "adding: mem time463, current time 492, horizon 29\n", - "adding: mem time464, current time 492, horizon 28\n", - "adding: mem time465, current time 492, horizon 27\n", - "adding: mem time466, current time 492, horizon 26\n", - "adding: mem time467, current time 492, horizon 25\n", - "adding: mem time468, current time 492, horizon 24\n", - "adding: mem time469, current time 492, horizon 23\n", - "adding: mem time470, current time 492, horizon 22\n", - "adding: mem time471, current time 492, horizon 21\n", - "adding: mem time472, current time 492, horizon 20\n", - "adding: mem time473, current time 492, horizon 19\n", - "adding: mem time474, current time 492, horizon 18\n", - "adding: mem time475, current time 492, horizon 17\n", - "adding: mem time476, current time 492, horizon 16\n", - "adding: mem time477, current time 492, horizon 15\n", - "adding: mem time478, current time 492, horizon 14\n", - "adding: mem time479, current time 492, horizon 13\n", - "adding: mem time480, current time 492, horizon 12\n", - "adding: mem time481, current time 492, horizon 11\n", - "adding: mem time482, current time 492, horizon 10\n", - "adding: mem time483, current time 492, horizon 9\n", - "adding: mem time484, current time 492, horizon 8\n", - "adding: mem time485, current time 492, horizon 7\n", - "adding: mem time486, current time 492, horizon 6\n", - "adding: mem time487, current time 492, horizon 5\n", - "adding: mem time488, current time 492, horizon 4\n", - "adding: mem time489, current time 492, horizon 3\n", - "adding: mem time490, current time 492, horizon 2\n", - "adding: mem time491, current time 492, horizon 1\n", - "adding: mem time400, current time 493, horizon 93\n", - "adding: mem time401, current time 493, horizon 92\n", - "adding: mem time402, current time 493, horizon 91\n", - "adding: mem time403, current time 493, horizon 90\n", - "adding: mem time404, current time 493, horizon 89\n", - "adding: mem time405, current time 493, horizon 88\n", - "adding: mem time406, current time 493, horizon 87\n", - "adding: mem time407, current time 493, horizon 86\n", - "adding: mem time408, current time 493, horizon 85\n", - "adding: mem time409, current time 493, horizon 84\n", - "adding: mem time410, current time 493, horizon 83\n", - "adding: mem time411, current time 493, horizon 82\n", - "adding: mem time412, current time 493, horizon 81\n", - "adding: mem time413, current time 493, horizon 80\n", - "adding: mem time414, current time 493, horizon 79\n", - "adding: mem time415, current time 493, horizon 78\n", - "adding: mem time416, current time 493, horizon 77\n", - "adding: mem time417, current time 493, horizon 76\n", - "adding: mem time418, current time 493, horizon 75\n", - "adding: mem time419, current time 493, horizon 74\n", - "adding: mem time420, current time 493, horizon 73\n", - "adding: mem time421, current time 493, horizon 72\n", - "adding: mem time422, current time 493, horizon 71\n", - "adding: mem time423, current time 493, horizon 70\n", - "adding: mem time424, current time 493, horizon 69\n", - "adding: mem time425, current time 493, horizon 68\n", - "adding: mem time426, current time 493, horizon 67\n", - "adding: mem time427, current time 493, horizon 66\n", - "adding: mem time428, current time 493, horizon 65\n", - "adding: mem time429, current time 493, horizon 64\n", - "adding: mem time430, current time 493, horizon 63\n", - "adding: mem time431, current time 493, horizon 62\n", - "adding: mem time432, current time 493, horizon 61\n", - "adding: mem time433, current time 493, horizon 60\n", - "adding: mem time434, current time 493, horizon 59\n", - "adding: mem time435, current time 493, horizon 58\n", - "adding: mem time436, current time 493, horizon 57\n", - "adding: mem time437, current time 493, horizon 56\n", - "adding: mem time438, current time 493, horizon 55\n", - "adding: mem time439, current time 493, horizon 54\n", - "adding: mem time440, current time 493, horizon 53\n", - "adding: mem time441, current time 493, horizon 52\n", - "adding: mem time442, current time 493, horizon 51\n", - "adding: mem time443, current time 493, horizon 50\n", - "adding: mem time444, current time 493, horizon 49\n", - "adding: mem time445, current time 493, horizon 48\n", - "adding: mem time446, current time 493, horizon 47\n", - "adding: mem time447, current time 493, horizon 46\n", - "adding: mem time448, current time 493, horizon 45\n", - "adding: mem time449, current time 493, horizon 44\n", - "adding: mem time450, current time 493, horizon 43\n", - "adding: mem time451, current time 493, horizon 42\n", - "adding: mem time452, current time 493, horizon 41\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "IOPub data rate exceeded.\n", - "The notebook server will temporarily stop sending output\n", - "to the client in order to avoid crashing it.\n", - "To change this limit, set the config variable\n", - "`--NotebookApp.iopub_data_rate_limit`.\n", - "\n", - "Current values:\n", - "NotebookApp.iopub_data_rate_limit=1000000.0 (bytes/sec)\n", - "NotebookApp.rate_limit_window=3.0 (secs)\n", - "\n" - ] - } - ], + "outputs": [], "source": [ - "num_trials = 10\n", - "\n", "step = 0\n", "trial = 0\n", "total_rewards = []\n", @@ -44464,6 +285,9 @@ "while trial < num_trials:\n", " traj = []\n", " obs = env.reset()\n", + " \n", + " # create a new agent each trial to get a variety of PID parameters\n", + " agent = create_pid_agent(env.action_space.shape[0])\n", " agent.reset()\n", " done = False\n", " total_reward = 0.0\n", @@ -44479,7 +303,7 @@ " # if not the first step, iterate through memory and append each sub-trajectory\n", " if len(traj[:-1]) > 0:\n", " for obs_t, t in traj[:-1]:\n", - " print(f\"adding: mem time {t}, current time {step}, horizon {step-t}\")\n", + "# print(f\"adding: mem time {t}, current time {step}, horizon {step-t}\")\n", " replay_buffer.add(obs_t, np.concatenate((agent.get_parameters(), np.array([step-t,]))), next_obs, reward, done)\n", "\n", " total_reward += reward\n", @@ -44497,26 +321,6 @@ " \n" ] }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2200" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(replay_buffer)" - ] - }, { "cell_type": "markdown", "metadata": { @@ -44528,37 +332,104 @@ "# Training the Trajectory Based Model" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a basic model trainer for our Gaussian MLP." + ] + }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 113, + "metadata": {}, + "outputs": [], + "source": [ + "model_trainer = models.ModelTrainer(dynamics_model, optim_lr=1e-4, weight_decay=5e-5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a training & validation dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [], + "source": [ + "train_dataset, val_dataset = common_util.get_basic_buffer_iterators(\n", + " replay_buffer, cfg[\"overrides\"][\"model_batch_size\"], .1, ensemble_size=ensemble_size, shuffle_each_epoch=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Train the model!" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [], + "source": [ + "train_losses, val_losses = model_trainer.train(train_dataset, val_dataset, num_epochs=50, patience=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting Results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model Loss" + ] + }, + { + "cell_type": "code", + "execution_count": 116, "metadata": {}, "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9IAAAHwCAYAAABKaFfKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAACAIElEQVR4nOzdd5yddZn//9d12vReMjPpjcAkFCEgKiAoSlnFrmt33RV1V7/Wn+Kqq8taV9e2q66uddW1ggoKFkBAEIRQQ0hI7216r+dcvz/ueyYnk0kyk5wzZ2byfj4eZ+/73Pd97vsaH2czvOfTzN0RERERERERkYmJ5LoAERERERERkZlEQVpERERERERkEhSkRURERERERCZBQVpERERERERkEhSkRURERERERCZBQVpERERERERkEk7pIG1m283Mx3m9ONe1iYiIiIiIyPQUy3UB08DvgY+POfZUDuoQERERERGRGUBBGprd/f5cFyEiIiIiIiIzwyndtVtERERERERkshSk4YVm1mtmA2Z2v8ZHi4iIiIiIyLGc6kH6ZuCdwBXAa4F+4Jdm9rqcViUiIiIiIiLTlrl7rmvICDO7HPjjBC69y90vPco9osD9QJ27zz/KNdcC1wIUFRWdd/rpp59YwSIiIiIiIjKtPfTQQ83uXjP2+GwK0oXAgglc2uvuO49xnw8AnwUa3H3fsW60evVqX7NmzeQKFRERERERkRnBzB5y99Vjj8+aWbvdvRfYkMlbZvBeIiIiIiIiMkuc6mOkD2NmMeBVwE5335/rekRERERERGT6mTUt0pNlZq8GXgTcAuwC5gD/BJwLvDqHpYmIiIiIiMg0dsoGaWAbUAt8DqgEeoA1wJXu/vtcFiYiIiIiIiLT1ykbpN39fuA5ua5DREREREREZpasBGkzywOeAVwINAAFQDPwFHC3u2/NxnNFREREREREsi2jQdrMlgHvBl4LlAEpoAPoI+g+nQ+4mT0EfA34X3dPZbIGCTy2q513/eQRvvS3T+Oc+eW5LkdERERERGTWyNis3Wb2VeBJ4Hzg+nCb7+5V7j7P3QuBeuClwKPAF4B1Zvb0TNUgh1QVJ9je0su6vR25LkVERERERGRWyWSLdANwgbs/erQL3P0A8Gvg12b2TuCtwNnAXzNYhwBzywsozY/x5N7OXJciIiIiIiIyq2QsSLv7SyZ5/QDwlUw9Xw5nZjQ2lPLkPgVpERERERGRTMpY126Zfhrry9iwr4tkynNdioiIiIiIyKyRsRZpM7tkMte7+92ZeraMr7GhlL6hJNuae1hWW5zrckRERERERGaFTI6RvhOYSNOnhddFM/hsGUdjfSkAT+7rVJAWERERERHJkEwG6csyeC/JgGW1xcSjxpN7O7nm7IZclyMiIiIiIjIrZHKysbsydS/JjEQswvLaEk04JiIiIiIikkGabGyWW9lQqiWwREREREREMiiTk43dMYnL3d2fm6lny9E1NpTy84d2c7Crn9qS/FyXIyIiIiIiMuNlskU6QjCR2EReagmfIqMTjqlVWkREREREJCMyOUb60kzdSzLnjIZDM3dfuqI2x9WIiIiIiIjMfGoZnuVK8+PMryxQi7SIiIiIiEiGZHL5q8OYWQS4AFgAHDE4193/N1vPlsM11pdq5m4REREREZEMyUqQNrNG4FfAUoIx0WM5oCA9RRrry/jDkwfoHRymMJG1v52IiIiIiIicErKVqr4W3vuVwFpgIEvPkQlobCjFHdbv6+K8hRW5LkdERERERGRGy1aQPhd4k7vfmKX7yyQ0pk04piAtIiIiIiJycrI12VgzMJile8skNZTlU1YQ14RjIiIiIiIiGZCtIP1F4J/MLJql+8skmJkmHBMREREREcmQbHXtrgFWAE+a2R+B1jHn3d0/lqVnyzgaG0r54f07GE6miEW16pmIiIiIiMiJylaQ/kja/vJxzjugID2FVjaUMjCcYntLD8tqS3JdjoiIiIiIyIyVlaZJd48c56Uu31NsZMKxdRonLSIiIiIiclJmZR9fM3uvmd1sZvvMzM3s48e49sVm9oiZ9ZvZDjP7yGwc2720pphENKJx0iIiIiIiIidpVgZp4C1ALfCrY11kZlcANwAPAlcBXybolv6pLNc35eLRCKfVFWvmbhERERERkZOUrTHSubbS3VNmFgPedozrPgPc4+7Xhu//ZGbFwEfM7Ivuvj/rlU6hxvpSbl9/EHfHzHJdjoiIiIiIyIw0K1uk3T11vGvMbD5wDvDDMad+AMQJWqhnlcb6Ulp6BmnqGsh1KSIiIiIiIjPWrAzSE7Qy3D6RftDdtwG9QOOUV5RljQ1lAKzTOGkREREREZETdioH6cpw2zbOuba087PG6fXBslcaJy0iIiIiInLipn2QNrPLw5m3j/e6c4rqudbM1pjZmqampql4ZMaU5sdZUFmoIC0iIiIiInISsjLZmJklgA8BrwYWAHljLnF3n+iz/wKcMYHreideIXCoJbpinHMVQOt4H3L3bwLfBFi9erVP8pk511hfqiWwRERERERETkK2Zu3+HPBPwK3AjcAJz27l7r3AhgzVlW5duF0J3Ddy0MwWAYXAk1l4Zs41NpTy+yf30z0wTHHebJ20XUREREREJHuylaReDnzM3T+ZpfufNHffaWaPAa8FvpV26nXAEMEfAWadxvpS3OGp/Z2ct3DWDQMXERERERHJumwF6WLSWnmnmpmtBhZxaAx4o5m9PNy/JWzlBvhn4Ddm9g3gx8DTgI8AX55ta0iPWDm3FAgmHFOQFhERERERmbxsBembgUuAO7J0/+N5B/DGtPevCF8Ai4HtAO5+SxiwPwa8CTgAfAqYti3pJ6uuNJ+KwrjGSYuIiIiIiJygbAXp/wT+18xSwC2MM3GXu2/N0rNx9zcRBOOJXHsjwTjuU4KZ0dhQqpm7RURERERETlC2gvRIt+6PE7T2jieapWfLcTTWl/K/9+1gOJkiFp32K6CJiIiIiIhMK9kK0m8GZtzSUKeKxoZSBoZTbGvuYfmcklyXIyIiIiIiMqNkJUi7+/eycV/JjMb6MgCe3NepIC0iIiIiIjJJ6td7ClpSU0QiFmGdxkmLiIiIiIhMWra6dmNmtcCrgRVA/pjT7u5/n61ny7HFoxFWzCnRhGMiIiIiIiInICtB2sxWEEw4FgOKgGagkmCCsTagIxvPlYlrrC/lj+sP4O6YWa7LERERERERmTGy1bX7c8CDwBzAgKuAAuAfgF7gJVl6rkxQY0MprT2DHOgcyHUpIiIiIiIiM0q2gvT5wNeAkZQWcfdhd/8O8F/Al7L0XJmgxoZSAJ7cp84BIiIiIiIik5GtIF0MtLp7iqAbd3XauQcJgrbk0Ol1wWzdGictIiIiIiIyOdkK0tuBunD/KeAVaedeALRn6bkyQSX5cRZWFfLkPgVpERERERGRychWkP4j8Lxw/wvA35nZU2a2DngX8J0sPVcmYWVDqVqkRUREREREJilby199CMgDcPefmVkf8CqgEPgy8D9Zeq5MQmN9Kbes3U/3wDDFeVlbCU1ERERERGRWyUp6cvcBDk00hrvfDNycjWfJiRuZcGzDvk5WL6rMcTUiIiIiIiIzQ7a6dssM0FhfBqBx0iIiIiIiIpOQsRZpM7sD+Ed33xDuH4u7+3Mz9Ww5MXNK86gsSrBuj4K0iIiIiIjIRGWya7el7UcAn+C1kiNmRmN9qVqkRUREREREJiFjQdrdL0vbvzRT95Xsamwo5Xt/2c5QMkU8qp7+IiIiIiIix6PkdIprrC9lcDjF1qaeXJciIiIiIiIyI2QlSJvZi8zs79LeLzSz+8ysy8x+YWbF2XiuTN7IzN1P7uvIcSUiIiIiIiIzQ7ZapD8C1KS9/wIwD/gmcAnw8Sw9VyZpSXURiViEJ/dqnLSIiIiIiMhEZCtILwUeBzCzAuBq4L3u/j7gn4GXZOm5MkmxaITT60o04ZiIiIiIiMgEZStI5wN94f4zCSY1+0P4/imgIUvPlRPQWF/Kk3s7cT/WROsiIiIiIiIC2QvS24GLwv0XAQ+5+8gg3FpAA3KnkZUNpbT1DrG/sz/XpYiIiIiIiEx72QrS3wA+bmZrgH8Evp127hnAk1l6rpyA0QnHNE5aRERERETkuLISpN39y8CbgPuAN7v7/6SdLgG+m43njjCz95rZzWa2z8zczD5+lOu+F54f+/pSNuubblbUlWKmIC0iIiIiIjIRsWzd2N1/BPxonONvzdYz07wF6AR+BbztONc2AdeMObYvCzVNW8V5MRZVFWnCMRERERERkQnISpA2s9OAcnd/IHxfAPwLsAr4vbv/Vzaem2alu6fMLMbxg/Sgu9+f5Xqmvcb6Utbu0dB1ERERERGR48nWGOn/Al6e9v6TwPsIZuv+opn9U5aeC4C7p7J5/9mosaGUna29dPYP5boUERERERGRaS1bQfps4F4AM4sAbwA+6O7nAZ8Ars3Sc09ErZk1m9mwmW00sw+aWTTXRU21xvpgwrEN+7pyXImIiIiIiMj0lq0gXQa0hPtPAyqAX4Tv7wSWZOm5k/UoQUv5KwnGSd8FfJpg1vFTyqGZu9W9W0RERERE5FiyNdnYAWAZcA/wfGCLu+8KzxUDwxO9kZldDvxxApfe5e6XTqZId//SmEO3mFk38G4z+6y7bxqnnmsJW9QXLFgwmcdNa7UleVQVJTThmIiIiIiIyHFkK0jfBHzazFYRLIOV3sJ7JrB1Evf6C3DGBK7rncQ9j+XHwLuB1cARQdrdvwl8E2D16tWeoWfmnJnR2FCqIC0iIiIiInIc2QrS1wH5wBUEofqTaeeuAf4w0Ru5ey+wIaPVTfDROXhmTjXWl/Lde7czlEwRj2ar17+IiIiIiMjMlpUg7e49BGs5j3fumdl4Zga9liBEP5jrQqZaY0Mpg8kUW5q6Ob2uNNfliIiIiIiITEvZapHOKTNbDSzi0GRqjWY2shzXLe7ea2YLgR8APwE2A3nASwi7orv7liktehpYOTrhWKeCtIiIiIiIyFFkJUib2R3HucTd/bnZeHboHcAb096/InwBLAa2A11AK/BBYA6QIuhC/v+Ar2WxtmlrcXUx+fEIT+7t5KXn5roaERERERGR6SlbLdIRjhxjXAWsAJqAjVl6LgDu/iaCluVjXdMKvDibdcw00Yixok4TjomIiIiIiBxLtsZIXzrecTNbCvwK+FQ2nisnr7G+lFvW7sPdMbNclyMiIiIiIjLtTOnUzOG4488An5vK58rENTaU0tE3xN6O/lyXIiIiIiIiMi3lYo2jJuC0HDxXJqCx/tCEYyIiIiIiInKkKQ3SZlYFvBc45WbEnilOryvBTEFaRERERETkaLI1a/c2jpxsLEEwOzbAy7LxXDl5RXkxFlcV8eS+jlyXIiIiIiIiMi1la9buuzgySPcDO4Cfn4prNM8kZzSU8vju9lyXISIiIiIiMi1la9buN2XjvjI1GutL+e3j++joG6KsIJ7rckRERERERKaVXEw2JtNcY0Mw4dgGrSctIiIiIiJyhGx17cbMEsBVwAogf8xpd/d/y9az5eSsHJm5e18nT19SleNqREREREREppdsTTbWANwDLCIYK23hqfRx0wrS01RNSR7VxQnN3C0iIiIiIjKObHXt/hzBetELCEL004ElwCeBzeG+TFNmRmNDGU+qa7eIiIiIiMgRshWkLwb+A9gbvk+5+3Z3/xfgF8BXsvRcyZDG+lI2HuhicDiV61JERERERESmlWwF6Spgr7ungB6gIu3cHcClWXquZEhjQylDSWfzwe5clyIiIiIiIjKtZCtI7waqw/0twPPTzl1AsKa0TGONaROOiYiIiIiIyCHZmrX7T8CzgV8B3wC+ambnAEPAFeExmcYWVxeRH48EE46dl+tqREREREREpo9sBemPAJUA7v51M4sBrwIKgX8Hrs/ScyVDohHj9LpSntjTketSREREREREppWsdO1292Z335j2/j/d/SJ3P9fd/9nd1bV7Brh0RQ0PbG/lTxsO5roUERERERGRaSNbY6RlFnjbs5eyYk4JH7jhcVp7BnNdjoiIiIiIyLSQla7dZvadY5xOAR3AQ8CNap2evvLjUb74qnN40Vfv4cO/XMvXXnsuZpbrskRERERERHIqW2OkLwPKgHJgGGgmmMU7BrSH17wH2GJml7n77izVISepsaGU9z5vBZ/93QZ++cgeXnruvFyXJCIiIiIiklPZ6tr9GoJW55cB+e7eAOQDrwA6gRcSLIOVD3w6SzVIhlx7yRLOX1TBx369jj3tfbkuR0REREREJKeyFaS/CHzW3X/p7ikAd0+5+w3AZ4EvuvsaghD9vCzVIBkSjRj/8YpzSLnz/p89RirluS5JREREREQkZ7IVpM8Gthzl3BZgVbj/JFCRpRokgxZUFfIvL2zkvq0tfPcv23NdjoiIiIiISM5kK0jvB15+lHOvAA6E+6VAW5ZqkAx75er5XH5GLZ/93QY2HujKdTkiIiIiIiI5ka0g/WXgLWZ2s5m90cyuCre/Af6eoOs3wMXAI5l8sJmdZmZfNrPHzazbzPaZ2U1mdvZRrn+LmW0wswEze8rM3pbJemYTM+PTLz2LkrwY7/npowwOp3JdkoiIiIiIyJTLSpB29y8B1xJ08f4u8NtwexbwFnf/SnjpV4E3ZfjxzyeYNfz7BJOa/SNQA9xvZuelX2hmbwG+AdwAXAn8HPiamb09wzXNGjUleXzqpWeybm8nX7l9U67LERERERERmXLmnr2JoyxYdHgeUA/sA3Z7Nh8YPLMaaEl/jpmVAduBm939DeGxGLAXuNXd35h27XeAa4B6dx861rNWr17ta9asyfwPMQO8/+ePcePDu/n5257JeQs1zF1ERERERGYfM3vI3VePPZ6trt0AeGCXuz8QbrM+3bO7N499jrt3ABuBuWmHn0HQUv3DMbf4AVAFXJTNOme6j72wkfqyAt77s0fpGRjOdTkiIiIiIiJTJmNB2sxeegKfqTezCzNVwzGeU0kwU/j6tMMrw+0TYy5fF24bs13XTFaSH+cLrzybna29fPKW9cf/gIiIiIiIyCyRyRbp/zSzR83sbWFwPSozu9jMvglsJhg3nW3/CRjwpbRjIzWOnTW8dcx5OYqnL6niLRcv4f/+upM/bTiY63JERERERESmRCaD9HLgRuB64EA4a/YPzOwLZvZpM/tvM/uDmbUCd4bXP8/dv3msm5rZ5WbmE3jdeZTPfwh4DfAOd998sj+kmV1rZmvMbE1TU9PJ3m7Ge+/zTmPFnBI+cMPjtPYM5rocERERERGRrMv4ZGNmlgBeAlwBXAg0APlAC7ABuBv4qbtvmOD9CoEFE7i01913jvns24CvAx9x90+OOfd24GtAg7vvSzteS7DO9Tvc/avHeuCpPNlYuif3dvKir97D5WfM4WuvPZdgjjkREREREZGZ7WiTjcUy/SB3HwR+Gr4ycb9eggA+KWb2eoKg/B9jQ3RoZCz0SoIZxUeMjI1+crLPPFU1NpTy3uet4LO/28AvH9nDS8+dl+uSREREREREsiars3bnipm9hGDd6m+5+/uPctl9QDPw2jHHX0cwTvre7FU4+1x7yRLOX1TBx369jj3tfbkuR0REREREJGtmXZA2s0uAHwOPAd8zswvTXk8buS5cI/qjwBvN7BNmdqmZXQ+8GfiXsGVdJigaMf7jFeeQcuf9P3uMVCrrK52JiIiIiIjkxKwL0sBzgDzgXIJW5fvSXr9Mv9Dd/xt4O/BK4PfAq5nA2GgZ34KqQj76gkbu29rCd/+yPdfliIiIiIiIZMWsC9Lu/nF3t6O8Fo1z/Tfc/TR3z3P35e7+tRyUPWu86vz5XH5GLZ/93QY2HujKdTkiIiIiIiIZN+uCtOSWmfHpl55FSV6M9/z0UQaHU7kuSUREREREJKMUpCXjakry+NRLz2Td3k6+cvumXJcjIiIiIiKSUVkJ0mZ2mpldkPa+wMw+bWY3m9k7svFMmV6uWFnHy8+bx9fu3MxPH9xJUpOPiYiIiIjILJGtFun/Al6e9v6TwPuABuCLZvZPWXquTCMfe2Ej58wv54M3rOUF/3kPd29synVJIiIiIiIiJy1bQfpswnWYzSwCvAH4oLufB3wCuDZLz5VppCQ/zi/e9kz+89VPo3tgiDd85wFe/+2/sm5vR65LExEREREROWHZCtJlQEu4/zSgAvhF+P5OYEmWnivTTCRivPDsBm5777P5lxc0snZPBy/4z3t4708fZU97X67LExERERERmbRsBekDwLJw//nAFnffFb4vBoaz9FyZpvJiUd580WLu+v8u462XLOU3a/dx2efv5NO3rqejbyjX5YmIiIiIiExYtoL0TcCnzezzBGOjf5527kxga5aeK9NcWUGc6646nT+9/1JeeFYD37x7K8/+3J/41p+3MjCczHV5IiIiIiIix5WtIH0d8BvgCoJQ/cm0c9cAf8jSc2WGmFtewH+88mx++86LOWteOZ/47Xou/8Jd3PTYXlKa4VtERERERKYxc1doOVGrV6/2NWvW5LqMWeHPm5r41C0bWL+vk7PmlfGhq87gGUurcl2WiIiIiIicwszsIXdfPfZ4ttaRjphZbMyxK8zsfWZ2TjaeKTPbxctr+O07L+ILrzyb5q4BXv0/9/Pm7z3IxgNduS5NRERERETkMFlpkTaznwID7v6G8P3bgK+Fp4eAv3H32zL+4CmmFuns6B9K8r2/bOerf9pMz8AwL37aXF59wQJWL6zAzHJdnoiIiIiInCKO1iKdrSC9g2Dd6J+E77cAtxNMPPZNoM7dL8v4g6eYgnR2tfUM8l9/2syPH9hJ72CShVWFvPRp83jpuXOZX1mY6/JERERERGSWm+og3Qc8393/bGbLgI3AOe7+uJk9H/g/d6/O+IOnmIL01OgZGOZ3T+znhod3c9/WFtzhgsWVvOzcuVx9Zj0l+fFclygiIiIiIrPQ0YJ0bLyLM6ATGJkp6lKg2d0fD98ngfwsPVdmoaK8GC87bx4vO28ee9r7+NUje7jhod188Ia1/Muv13HFyjpedt48LlpWTTSirt8iIiIiIpJd2QrSfwGuM7Nh4N3ALWnnlgG7s/RcmeXmlhfwT5ct4x8vXcqju9q58eE93PTYXm56bC+1JXm85Glzedl58zhtTkmuSxURERERkVkqW127lxOE56XAVuByd98enrsD2OHuf5fxB08xde2eHgaGk9yx/iA3PLyHO586yHDKWTW3lJedO49rzm6gqjgv1yWKiIiIiMgMNKVjpNMeWuXuLWOOnQnsd/emrD14iihITz/N3QPc/Nhebnh4N0/s6SQWMS5dUcvlZ9Ry/uJKllQXaeZvERERERGZkJwE6fDBxUAF0Obu3Vl92BRTkJ7entrfxY0P7+ZXj+7hQOcAAFVFCVYvquD8RZVcsLiSxvpSYtGsLKcuIiIiIiIz3JQHaTO7AvgkcA5ggAMPAx929z9m5aFTTEF6ZnB3tjT1sGZ7Kw9sb+XB7a3sau0DoDAR5dwFQbA+f3EFT5tfQUEimuOKRURERERkOpjq5a+uAH4LbAZ+DOwH6oFXEUw2dvVsCNMK0jPX/o5+HgxD9YPb29iwvxN3iEWMVXPLuGBxJasXBgG7oiiR63JFRERERCQHpjpI3we0AS9w91Ta8QjwG6Dc3Z+Z8QdPMQXp2aOjb4iHd7SNhuvHdnUwmAy+ustri1m9qIKz5pVz5twyTptTQiKm7uAiIiIiIrPdVAfpXuAV7v7bcc69APiZuxdm/MFTTEF69uofSvL47o7RYP3wjjY6+4cBSMQinFFXwpnzyjhzbhlnzi1n+Zxi4hprLSIiIiIyqxwtSGdrHekBoPQo50rC8yLTVn48ygWLgwnJIBhnvbO1l8d3d7B2Twdrd3fw60f28sP7dwKQF4twRn0pZ80rY9XcMs6aV8aymmJNZCYiIiIiMgtlq0X6l8CZwPPcfVva8QXAH4F17v7SjD84eMZpwD8BlwFLgC7gQeCj7v7YmGvvBJ49zm3e4+5fOt6z1CJ9akulnB2tvTy+u521YcB+Yk8HPYNJAPLjERrrSzlrXjmr5pZxRn0JS6qLNZmZiIiIiMgMMdVdu08D7gXKgPuBfUAdcCHQDlzk7psy/uDg2e8ArgW+TzBLeDnwAYLZwy9y94fSrr2TYGmut465zXZ333+8ZylIy1iplLOtpWc0WK/d3cETezvoDcO1GcwtL2BZbTFLa4pZVls8ul+pSc1ERERERKaVXCx/VQ+8D7gYqARagbuAL7r7vqw8NHhuNdDiaT+YmZUB24Gb3f0NacfvBGLuftGJPEtBWiYimXK2NXfz1P5uNh/sZktTsN3a3E3/0OhcfFQWJVhWU8zS2qLRkL20ppi55QVEIpbDn0BERERE5NQ01WOkCcPy+7N1/2M8t3mcYx1mthGYO9X1iEQjxrLaEpbVlhx2PJVy9rT3sbmpmy1pAft3T+ynrXdo9LqCeJQlNUG4Xl5bzPI5QcheWFWkCc5ERERERHIga0F6OjGzSmAV8N1xTj/NzDqAQmA98GV3//ZU1ienpkjEmF9ZyPzKQi5bUXvYudaeQTYfPLwF+6Edbdz02N7Ra2IRY3F1URCsa4pZNqeE5bXFLK4uIj+ucdgiIiIiItmSsSBtZndM4nJ39+dm6tkT8J+AAV8ac/xu4EfARoKx1G8AvmVm9e7+ifFuZGbXEozBZsGCBVkqV051lUWJw2YNH9E7OMyWgz1sOtjF5oPdbDrYzfp9Xfzuif2kwsEMEYMFlYUsqy0ZDdnL5wTdxIvyTom/nYmIiIiIZFXGxkiH440nfDN3v2yC972cYKbv47nL3S8d5/MfAj4F/L27f2cCz/slcCVQ4+7dx7pWY6RluugfSrK9pYdNB4JwveVgN5sOdrGtuYeh5KH/t5xbXjDaTXxpbTFLa4pYVlNMTUkeZhqHLSIiIiKSLutjpMcLsRnyF+CMCVzXO/aAmb2NIER/ZCIhOvRj4MUEy3fdN8HPiORUfjzK6XWlnF53+PLtQ8kUO1p6g9brA11saepmS1MPP1uza3QmcYCSvBhLwmC9tGZkRvEiFlQWkYhpHLaIiIiISLpp38/T3XuBDZP9nJm9Hvga8B/u/skTefQJfEZkWolHI6NLbF25qm70uLuzv7OfLQd7wnAdvP6yuYUbH94zel0sYiyoKhwN10tqiphTmk9VUYLq4jwqixIK2iIiIiJyypn2QfpEmNlLCCYW+5a7T3bm8NcCfcDajBcmMk2YGfVlBdSXFXDR8urDznX1D7GtuWd0krORsH3nUwcP6yY+ojQ/RnVxHlXFCaqKwm1xHjXhtqoo2FYXJyjNj2spLxERERGZ8WZdkDazSwi6Zz8GfM/MLkw7PeDuj4TXXQxcB9xIsMZ0GfBG4BrgOnfvmcq6RaaLkvw4Z80r56x55YcdH06m2NPeR1PXAM3dg7T0DNDSPUhL9wDNPcF2S1M3D2wfpK13kPGmX4hFjDml+SytPTQJ2vKwxby8MDE1P6CIiIiIyEmadUEaeA6QB5wL3Dvm3A5gUbi/D4gA1wPVwBDwOPAad//xlFQqMoPEohEWVhWxsKrouNcOJ1O09Q6Nhu3m7jB09wywpy1YO/v/trXQP5Qa/Ux1cd5oqB5ZK3tZbTE1xZoITURERESml4zN2n0q0qzdIiculXL2tPeFy3h1selAN5ubutl8oJuugeHR68oK4qMBe+TVUF5AVVGC8sIEUXUVFxEREZEsOdqs3QrSJ0FBWiTz3J0DnQOHAvbBIFxvOthFW+/QYddGLFhzu6oomPisqjiYBG1kXHYwbvvQfkleTK3bIiIiIjJhWV/+6igPrQMWAPljz7n73dl8tojMTGZGXVk+dWX5R0yE1tIdBOyDXQO0dA/Q0jNIc/cgrWEX8nV7O2nuHqCrf3jceyeiEaqKE1QUJijJj1GSHw+3was47/D3h87HKc6LUZwXUwu4iIiIiGQnSJvZXOAHwLPHO02wtFQ0G88WkdkraFnOO+51A8NJWnsGw3HZwURoLd2DNPcM0No9SGvPIF0Dw+xp76Orf4jugWG6+odJpo7fQ2ckUNeX57OsJuhqvjTczq8sVNAWEREROQVkq0X668CZwAcIlpEayNJzRESOkBeLji7vNVHuTt9Qku7+YTr7h+nqH6KrfzgM2cH+yKuzf4jdbb386akmfv7Q7tF7JKIRFlcXBeG6tpilNUWjQTs/rr8dioiIiMwW2QrSFwP/z91/kKX7i4hklJlRmIhRmIhRWzrxz3X0DrG5qZstB7tH195+Ym8Htz6xj5EGbjOYW14QTJZWE4TsRVVFFOVFyYtFyYtFSMQi5MUi5MWD97GIaTy3iIiIyDSVrSDdBxzM0r1FRKaNssI45y2s4LyFFYcd7x9Ksr2lh80Hu9lysCeYkfxgN/dtaWFgOHWUux1iRhCsxwbtWHR0v7QgzpzSPOaU5DOnNJ+a0f08KgoTRNTNXERERCQrshWk/wd4PfD7LN1fRGRay49HOb2ulNPrDm/eHln2a2drL/1DSQaGUwwMJxkcTgX7Q2Peh+cH0s4PJlP0DyXZ1drLmu2tR8xmDhCPGjXFedSWBsF6Tmk+tSUj74NjtSX5lBXENa5bREREZJKyFaT3AK83s9uBW4HWsRe4+3ey9GwRkWkrEjHmVxYyv7IwY/ccGE7S1DXAgc4BDnb2c6CznwNdAxzsHOBgVz/bmnu4f2srHX1HBm6zYK3uisIE5YVxKguD9bkrCuNUFAXHKgqDmc4rig5dlxfTmG8RERE5dWVlHWkzO16/RXf3Gf9fYVpHWkRmkv6hkcDdz4HOYNveO0hb7xBtvYPBq2do9FjfUPKo9ypMRKkoTFBaEKc4L0phIkbRyDYRpTAv3KYfHz0fozAvSlEiRkEi7LoejagruoiIiEw7U72O9OIs3VdERE5Qfjw6qdbw/qEk7WNCdlvv4GHhu7NviN7BJO19Q+xt76N3MEnP4DC9A0kGk8cfC54uFjHi0WA8eDwaIRG10f2R44lohHjMgm00QjwWoSgRpa6sgIayfBrKC2goz6e+rICivGz9ihMREZFTXVb+K8Pdd2TjviIiMnXy41HqyqLUleWf0OcHh1P0jQTrwWF6Bg6F7J7wfe/gMAPDKYaSKQbD7VDSGTzsfbA/mHSGwnHiXf3Do+e7+odp6h5gbAer0vwYDeUF1I8G7GC/viwI23Vl+eqiLiIiIidEf64XEZGsSISzjZcVxrP+rKFkigOd/ezr6Gdvex972/vZ13Fo++iu9nEnZasuzqOhPJ+a4jwqixJUFieoKkpQWZQXboNXVXGCwoR+ZYqIiEggY/9VYGZbgZe4+2Nmtg041uBrd/elmXq2iIic2uLRCPMqCplXcfRu632DSfZ19B0ZtjuCAL5ubyetPYNH7ZKeH49QVZR3KFyPBO3iBGUFcYxgjLfjuKf9EnQf3XcHH/s+3C9MRKkuzqO6OBFu8yhIqMVcRERkOsrkn9fvAjrT9jM/i5mIiMgJKkhEWVJTzJKa4qNe4+50DwzT2jNIS88grd2Dh/Z7BsJt8Np8sJvWnsFjTsp2sooSUapLglBdVZQY3a8Jw3bVSPAuyaMkL4aZJmwTERGZChkL0u7+d2n7b8rUfUVERKaKmVGSH6ckP87CqqIJfaZvMDm6tNhIjrXw/4y0UpuFx8Jn2GHXBjs9g8M0dw8Er65BmnvCbXhsR0svD+1oo7V38Ijx4BB0pa8cWcasKEFFUbCMWWXhyH6wTb+mMBFV+BYRETkBGvAlIiJyEgoS0Yx0wS4rjNNQXnDc64aTKVp7B2npPhSyW7oHaeoeoK0nnFG9Z5D1+zpHZ10/2kqXiVgkWDM8XCu8JD82Ojv6yBj39BnTj33OSESjmI10WffR5zqHd2knPA8j3d0PdWPLi0WoLwsmgyvJz/74ehERkROR1SBtZmcDK4Ajpnx19//N5rNFRERmo1g0Qm1JPrUlE5tNPZlyOvuGaA2XLmvtGQoD9yCtvYOHhe+drb3hDOmp0e3QyDY59SO2ivNio6E62AbLnNWFs6/XleVTmq8u7SIiMvWyEqTNrBz4LXDhyKFwm/5bWEFaREQky6IRC7p2FyVO6j6plDOUCgP2aMh2BpPJcAkzZ3D40ERtI93ZD2VcG7eL+6Frg/N9Q0n2dfSzP5wYbl97P/s6+9l4oImDXUcucxasI34oWNeX5VOaHyc/HiE/HiU/HqVgZJuIkBcLehAcOh4hPxYlElEYFxGRictWi/SngCrgEuDPwEuADuDNwDOAv83Sc0VERCQLIhEjLxLN6drbQ8kUB7sGDg/ZHf3s7wze37OpmYNd/aROoPE8EYuMBuu8WJRYxIhEjKiF2whEzYhGglfkKPsj11QWJVhYVcjCqiIWVhWyoLKQ/LhmYRcRmS2yFaSvAP4VuD98v9vdHwLuNLOvA+8C3pClZ4uIiMgsFI9GmFtewNxjjCVPppy+oSR9g0n6h0ZeKfrC/b6hI4/3DSbpH07SPxgc6x9Okkw5KXeSKSeZIm0/fHnQAp90JxW+H04GnxlOOU1dA3T1Dx9WW11pfhiuDwXshZVFLKgqpKxA48FFRGaSbAXpemCruyfNrB8oSTt3I/CTLD1XRERETmHRiFGcF6M4L7fzqbo77b1D7GjtZUdLDztaetne0sPOll7+9FQTTV27D7u+ojDOgqoiFlUVsrCykIbyApLu9A+lGBgOAv7AUNCNvn8C2/6hFPnxyDhjyw+9ryrOI6ou7SIiJyRbv2X2A+Xh/g6C7tx3hu+XZemZIiIiItOC2aGx6efMLz/ifM/AMDsPC9m97Gzt4aEdbdz82N5xu6fnxSLkxYKx33nh2O6RbX48QnlB/LDjfYPBePPHd7fz+3X9h41hB4hFjDmlhwL2SMge2Z9Tmk8sYuGs68FnRmZjH52JfeS4H36O8Hx+PEptSR6xaCRT/9OKiEwL2QrS9xBMNPYb4AfAx8xsETAMvBG4KUvPFREREZn2ivJinFFfyhn1pUecGxxOcbCrn0Q0GK+dFw8C9MnMTu7utPYMhhO5BRO47e/oGx1nvm5vJ7etP0D/UOr4N5ukiEFtST715fk0jAT18qBVvL48eF9TnKcJ30RkRslWkP5XoCHc/xzBxGOvAgoJQvQ7s/RczKwE+DZwLkEX8yFgI/AVd//hmGsjwAeBtwJ1wFPA9e5+Q7bqExERETmWRCzCvIrCjN7TzKgqzqOqOI9Vc8vGvcbd6egbCiZy6+jjQOcAyZQfNqv62JnWGZ2d3UZnaR89B/QOJtnf0cfe8J7r93Vy+4YjA/tI63hDeTAD+0jorisLWsWHks5QMsVwKnVoP9wOJZ3hZCrYTzlDwymGUyPnUkTMqCpOUFOcR3VJ3ui2ujhPy6eJyAnLSpB29y3AlnB/CHhf+JoKCYKW708D24E8ghD/AzOrcfcvpl37b8D7gQ8DDxHMJv5zM3uBu98yRfWKiIiI5JyZUV6YoLwwMW5LeaaMjB/fO9oiHgbt9mD7yK42bn2i/4TWLk9EI8SiRixiJGIRYpEIybA1PjlOf/lELJIWsBNUF+dRE4bskW11cYKivBixiBGLBPePRox4NELEUBAXOUWZj12Q8WRvaJYgGCP9JnefNl24zew+oNjdzwzf1wK7gM+4+8fSrrsdqHH3s453z9WrV/uaNWuyVbKIiIjIKSmVclp6Btnf0U/KnXg0QjwahNdYuB3djwTnohE7aqhNpZy23kGauwdp6hqguTt4NXUN0BRuR8619gxMagm1kWfHIxGi0TBsR2w00MeiERLRCGUFccoL45QVxCkrjFNekKC8ME752PeFcQriUQV0kWnCzB5y99Vjj2e8RdrdB81sGOjP9L1PUguQn/b+CoLW6x+Oue6HwHfMbLG7b5uq4kREREQkEIkYNSVBq3Cm7jfStX1FXckxr02mghbs9LDdNxQsiTbSjXw4FSx3lkwF3cmTYVfykWuSqaDr+XDKGU6lGBhK0dk/xOaD3bT3DdHRO8Rg8ujj0RPRSBiuD4XvorzY6MRyefEo+bFgmxc7/P0R23Bt9Pz4yFrp0ZMecy8i2Rsj/Svg5cAfsnT/47LgX4coUAa8jCA4/33aJSuBAWDzmI+uC7eNgIK0iIiIyCkkmuEQPx4PlzZr7xukvXeI9t4hOkb2+4bo6Dv82J72fnoHhxkI1zkf2Z5ox1IzyI9FKUhEKQhngS+IB/sFiSh5o+fC8J2Ijs4Gn4gGLe7xWCToDRALWuHH9hoIutkfOjZyvjARozChMC8zX7aC9K3AV8zsFwSheh+HVkMAwN3vyNKzR/wT8J/h/hDwLnf/37TzlUC7H9m3vTXtvIiIiIhIRplZEFQTBdSXFZzQPdydwWTq0Bri6WuOH2XbP5SkbyhJ/2Cw7QvXHE8/1jMwTHP3YHDt4Mg1wRrlmRSLGEXhmu9FeVEKE4f2i/JiFCVi4fnw/eixKCX5h94Xh+cSMS2xJlMrW0F6ZNbrl4avEU4wuaMTtBYfl5ldDvxxApfe5e6Xpr3/KXA/UA1cA/ynmSXd/RsTee4x6rkWuBZgwYIFJ3MrEREREZETYmbB8mixKKX58aw/L5VyBoZTDKXSZ0w/NGv64JiZ1EdmWR8c9nC29RRDw07v4DA9g0m6B4bpHRimeyAI7z2Dw3QPDHOwq5+egSQ9g8P0DAxPeNK5RCxyKIgnYofCdl6M4kSM4vxDwTwWObnQHYtaOOY9QUVhnIrCYHx7cZ5mgT+VZCtIP4cxLdAn4S/AGRO4rjf9jbs3AU3h29+ZWSHweTP7TjiTeBtQbmY2plV6pCW6lXG4+zeBb0Iw2djEfwwRERERkZkpEglb0SfWFpYxA8PJIFiHYbsnLXx39wfhu2dgmO7B4H36+daeQXa29I5e0zOYzGqt8ahRFk4aV1E4NmgnRo+VF8YpzY+PtsQX5UU1wdwMlK3lr+7M4L16gQ0ZuNUa4I3AHGA3wVjoPGAph4+Tbgy3T2bgmSIiIiIicoJGWt0rixInfa9UyukdSpI8gaXV0g2lUuHY9kHaeodo6x2kvTcYz942enyQXa29PL47uGbwOF3jzaAwHqUwL0ZR4lDAPmybCM4X58XIj0eJGEQsbY13s2BJtnDd98iY9d5Hrw2P58cjYcA/NGN8Xmxq/1Ayk2UlSJvZVuAl7v7YOOdWATe5+5JsPPsYng10AwfD978jGDv9WuBf0657HfCEZuwWEREREZk9IhGjOC8z8ae6eOKT0Y1MLtcWBuz23iG6+odHu7n3DqRvh+kZSAbnBpK09w6yp/3QNT0DwwxPZn22SSqIRw9rOU8P2SMt6+UFcSqK4pQVJIhGTq4VPWrGgqrCDFU/tbLVtXsRQWvvePKBhVl6Lmb2VuBC4DaClucq4JUEs4hf5+6DAO5+0My+AHzIzLqAh4FXEXRLvyZb9YmIiIiIyKkjfXK5hvITm1wu3eBwir7BJCl3HIKtgxNu0/ZHzgGH3hOE+76h5Ois8eO1qrf3DbF+fycd4WzyySwE+MqiBA9/9HkZv+9UyFaQhqOPkV4NtGfxuWuBFwGfJxjv3AysB17g7r8dc+2HCVqp3wXUAU8Br3T332SxPhERERERkROSiEWmfJbyVMrpGhimIwzdbb2DdPQNnfASbCNm8mzrduTqTyd4I7P3AO8J384lmOhrcMxlBQTh9ifu/tqMPDiHVq9e7WvWrMl1GSIiIiIiIpIFZvaQu68eezyTLdJbgdvD/TcSTO7VNOaaAYJJvL6VweeKiIiIiIiITJmMBWl3/zXwa2Bk6vbrNWGXiIiIiIiIzDbZWv7q77JxXxEREREREZFcm7mju0VERERERERyQEFaREREREREZBIUpEVEREREREQmQUFaREREREREZBIyto70qcjMmoAdua7jOKqB5lwXIZJG30mZjvS9lOlG30mZjvS9lOko29/Lhe5eM/aggvQsZ2ZrxltAXCRX9J2U6UjfS5lu9J2U6UjfS5mOcvW9VNduERERERERkUlQkBYRERERERGZBAXp2e+buS5AZAx9J2U60vdSpht9J2U60vdSpqOcfC81RlpERERERERkEtQiLSIiIiIiIjIJCtKzjJnNN7NfmFmHmXWa2Y1mtiDXdcmpw8zmmdl/mtl9ZtZrZm5mi8a5Lt/MPmdm+8ysL7z+khyULLOcmb3czG4wsx3hd+0pM/u0mZWMua7CzL5lZs1m1mNmt5nZmbmqW2Y3M7vCzO4ws/1mNmBmu83sZ2bWOOY6/V6XnDGz34W/xz8x5rj+vZQpYWaXht/Bsa/2MddN+XdSQXoWMbNC4A7gdOCNwOuB5cCfzKwol7XJKWUZ8EqgDfjzMa77NvAW4F+AFwD7gN+b2TnZLlBOOe8HksA/A1cCXwfeDvzRzCIAZmbAzeH5dwIvA+IE/37Oy0XRMutVAg8B7wCeD3wIWAncb2YLQb/XJbfM7NXA2eMc17+Xkgv/D3hG2uvykRO5+k7GsnVjyYm3AEuAFe6+GcDMHgc2AW8FvpDD2uTUcbe7zwEws38g+A/Ew5jZ2cBrgDe7+3fDY3cB64DrgWumrlw5BbzQ3ZvS3t9lZq3A94FLCYLKNcCzgOe4+58AzOw+YBvwAYJf4CIZ4+4/Bn6cfszMHgA2AC8H/gP9XpccMbMK4IvAe4D/G3Na/15KLqx39/uPci4n30m1SM8u1wD3j/yyBXD3bcC9wItyVpWcUtw9NYHLrgGGgJ+mfW4Y+AlwhZnlZak8OQWNCdEjHgy3c8PtNcDekV/A4ec6CP7CrX8/Zaq0hNvhcKvf65IrnwWeCP/gM5b+vZTpJiffSQXp2WUl8MQ4x9cBjeMcF8mVlcA2d+8dc3wdkCDoHi6STc8Ot+vD7bH+/VxgZsVTUpWccswsamYJM1sOfAPYz6GWav1elylnZhcBbwD+6SiX6N9LyYUfmVnSzFrM7P/GzBWRk++kgvTsUkkwLnWsVqBiimsROZZjfVdHzotkhZnNJRhCcJu7rwkPH+87qX9DJVv+CgwAG4GzCLomHgzP6fe6TCkzSxD8Qefz7v7UUS7Tv5cylToIhrr8A/Ac4N8IxkffZ2a14TU5+U5qjLSIiJwywr9K/5qg6+zf5bgcEQgmECslGAv9foJJ8C5y9+05rUpOVR8ACoBP5roQEQB3fwR4JO3QXWZ2N/AAwdjnj+SkMNQiPdu0Mf5fXI72VxqRXDnWdxUO/QVRJGPMrIBgvNQS4Ap33512+njfSf0bKlnh7uvd/a/hWNTnAsXAdeFp/V6XKRN2lf0w8FEgz8zKzaw8PD3yPor+vZQcc/eHCXrxnB8eysl3UkF6dllHMEZgrEbgySmuReRY1gGLw6Vd0jUCg8DmIz8icuLMLA78AlgNXO3ua8dccqx/P3e6e3eWSxTB3dsJ/v0bmSdCv9dlKi0B8oEfEgSPkRcEvSXagDPRv5cyfXi4zcl3UkF6drkJuNDMlowcMLNFBNPB35SrokTGcTPB+n6vGDlgZjHgVcAf3H0gV4XJ7BOuFf0jgrFVLz7K8hk3AXPN7NlpnysFXoj+/ZQpYmZzCNaM3hIe0u91mUqPApeN84IgXF9G8Ice/XspOWVmq4EVBN27IUffSXP3418lM4KZFQGPAX0E4wWcYEB+CXCW/kIoU8XMXh7uPhd4G/CPQBPQ5O53hdf8BLgC+P8I1vl7O/AC4Jlhlx2RjDCzrxN8Dz8J/GbM6d3uvjsM2/cA8wm+k23Ahwgmfzrb3XdNYclyCjCzXwIPA48DncBpBGv21gEXuPtG/V6X6cDMHPiku38kfK9/L2XKmNmPCP478WGgHXgawfetFzjX3Ztz9Z1UkJ5lwvEtXwSeBxhwO/BuTVoiUyn8pTueu9z90vCakclMXgOUE/zH4gfd/c4pKFFOIWa2HVh4lNP/6u4fD6+rBD4PvJige+N9wHvd/bHsVymnGjP7IPBKYCnBsn+7gDuBT6f/ztbvdcm1sUE6PKZ/L2VKmNmHgFcT/B4vJFgi8FbgY+6+L+26Kf9OKkiLiIiIiIiITILGSIuIiIiIiIhMgoK0iIiIiIiIyCQoSIuIiIiIiIhMgoK0iIiIiIiIyCQoSIuIiIiIiIhMgoK0iIiIiIiIyCQoSIuIiMiUMLPtZvbDXNchIiJyshSkRURERERERCZBQVpERERERERkEhSkRUREZiEzO9vMbjKzNjPrM7N7zezitPPfM7PdZvZMM3vQzPrDrtfvHOdeF5jZbWbWbWY9Zna7mV0wznXPNrM/mllHeN1jZvb341z3t2a2PrxmjZldlPn/BURERLJHQVpERGSWMbNzgb8AlcBbgJcBLcBtZnZe2qWlwE+B7wMvBu4EvmJmb0q711nAXUAF8CbgDeHn7jKzs9OuexFwO5AA3gq8CPgOsHBMeRcD7wM+CrwKiAK/MbPyk/yxRUREpoy5e65rEBERkQwys9uBBuBsdx8Mj0WBJ4Cn3P3FZvY94I3Aq939J2mf/SNwGrDI3d3MfgFcHr5vD68pBbYDd7r7S83MgG1AM3CBu6eOUtd2oAxY4u5t4bHVwIPAa939/zL6P4SIiEiWqEVaRERkFjGzAuDZwM+BlJnFzCwGGHAbcEna5UnghjG3+AmwAJgbvr8E+M1IiAZw907gpvA5ACsIWp6/dbQQnea+kRAdWhtuFxz/pxMREZkeFKRFRERml0qC7tIfBYbGvN4BVJjZyO//NncfGvP5A+F2JEhXAvvGec5+gu7eAFXhdvcE6mtNf+PuA+Fu/gQ+KyIiMi3Ecl2AiIiIZFQ7kAK+CvzveBe4eyrojU2FmcXHhOk54XZPuG0F6sa5TR0w0rLcHG7njnOdiIjIrKMgLSIiMou4e4+Z/Rk4G3j4OF2towQTkf0k7djfAjs5FKTvAq42sxJ37wIwsxLghQSTkwFsJBgz/Q9m9k3XBCwiIjLLKUiLiIjMPu8F7gZ+b2bfJuiaXQ2cC0Td/brwui7g382sGtgEvJpgYrE3pYXhfwNeANxuZp8FHPggUAhcDxBOSvZu4EbgDjP7b6AJOAOodfePZfnnFRERmVIaIy0iIjLLuPvDwPkES159BfgD8GXgTIKAPaKToAX6jcCvgcuAd7n799Pu9ThwaXjt94EfAN3As939sbTrfg08L3z7bYLJyK4laKkWERGZVbT8lYiIyCkoXP7qcnefl+taREREZhoF6ZNQXV3tixYtynUZIiIiIiIikgUPPfRQs7vXjD2uMdInYdGiRaxZsybXZYiIiIiIiEgWmNmO8Y5rjLSIiIiIiIjIJChIi4iIiIiIiEyCgrSIiIiIiIjIJChIi4iIiIiIiEyCgrSIiIiIiIjIJChIi4iIiIiIiEyCgvQstflgF//4o4fY1dqb61JERERERERmFQXpWSoejXDL2v38ft3+XJciIiIiIiIyqyhIz1ILq4pY2VDKLWv35boUERERERGRWUVBeha7+sx6Ht7Zzr6OvlyXIiIiIiIiMmsoSM9iV62qA+B3T6h7t4iIiIiISKYoSM9iS2qKOb2uhFvXKkiLiIiIiIhkioL0LHfVqnoe3NHKwc7+XJciIiIiIiIyKyhIz3JXn1mHO5q9W0REREREJEMUpGe55XNKWFZbzC3q3i0iIiIiIpIRCtKngKtW1fHXbS20dA/kuhQREREREZEZT0H6FHDVqnpSDn948kCuSxEREREREZnxpjxIm9l8M/uFmXWYWaeZ3WhmC07gPteZmZvZPeOce6+Z3Wxm+8JrPn6M+7zYzB4xs34z22FmHzGz6GTrmc7OqC9hUVUht6zdl+tSREREREREZrwpDdJmVgjcAZwOvBF4PbAc+JOZFU3iPkuAjwAHj3LJW4Ba4FfHuc8VwA3Ag8BVwJfD+35qorXMBGbGVWfW85ctLbT1DOa6HBERERERkRltqluk3wIsAV7s7r9y918D1wALgbdO4j5fB34ErD/K+ZXu/nTgnce5z2eAe9z9Wnf/k7t/gSBEv8fM6iZRz7R39ap6kinnj+vVvVtERERERORkTHWQvga43903jxxw923AvcCLJnIDM3sNcC7woaNd4+6pCdxnPnAO8MMxp34AxAlaqGeNVXNLmVdRwK3q3i0iIiIiInJSpjpIrwSeGOf4OqDxeB82swrgi8AH3L01A7Uwtp4w2PdOpJ6ZxMy4+sx67tncTEffUK7LERERERERmbGmOkhXAm3jHG8FKibw+c8BG4HvZagWjlJPW9r5WeOqVXUMJZ3b1b1bRERERETkhM2Y5a/M7GLgDcDb3d1zWMe1ZrbGzNY0NTXlqowTcs78chrK8rll7f5clyIiIiIiIjJjTXWQbmP8luejtVSn+wbwbWC3mZWbWTkQA6Lh+7wTqIWj1FNB0Ep+BHf/pruvdvfVNTU1k3xkbpkZV66q5+5NTXT1q3u3iIiIiIjIiZjqIL2OQ2OT0zUCTx7ns2cAbyMIwCOvZwEXhvtvP4FaGFuPmS0CCidQz4x01Zl1DA6nuGPD0VYOExERERERkWOZ6iB9E3BhuA40MBpcnxWeO5bLxnk9RjBZ2GXALyZTiLvvDD//2jGnXgcMAbdO5n4zxXkLKqgtyeN3T6h7t4iIiIiIyImITfHz/gd4B/BrM/sI4MC/AbsIum4DYGYLgS3A9e5+PYC73zn2ZmbWDsTGnjOz1cAiDv2hoNHMXh7u3+LuveH+PwO/MbNvAD8GngZ8BPiyu8/KpBmJGFeuquNna3bROzhMYWKqvwIiIiIiIiIz25S2SLt7D/Acgpm3fwD8CNgGPMfdu9MuNSB6EvW9A/g58NPw/SvC9z8HatPquQV4OUH38N8D7wE+BVx3gs+dEa5aVU//UIo7n5pZk6WJiIiIiIhMB1PeHBl2qX7Zca7ZThCmj3evS49y/E3AmyZYz43AjRO5dra4YHElVUUJblm7j6vPrM91OSIiIiIiIjPKjFn+SjInGjGuWFXHHRsO0j+UzHU5IiIiIiIiM4qC9Cnq6lX19A4muWujuneLiIiIiIhMhoL0KerpSyqpKIxz69p9uS5FRERERERkRlGQPkXFoxGe31jHbesPMjCs7t0iIiIiIiITpSB9CrvqzDq6B4a5Z1NzrksRERERERGZMRSkT2HPXFpNSX6MW5+YlUtmi4iIiIiIZIWC9CksEYvwvMY5/GHdfgaHU7kuR0REREREZEZQkD7FXb2qns7+Ye7b2pLrUkRERERERGYEBelT3EXLqynOi2n2bhERERERkQlSkD7F5cejPPeMWn6/bj/DSXXvFhEREREROR4FaeGqVfW09Q7x122tuS5FRERERERk2lOQFi5dUUNhIsot6t4tIiIiIiJyXArSQn48ymWnB927kynPdTkiIiIiIiLTmoK0AMHs3c3dgzy4Xd27RUREREREjiU20QvNbC7wPOBCoAEoAJqBp4C7gLvcXbNVzVCXrqghPx7h1rX7uHBJVa7LERERERERmbaO2yJtZs82s98A24HvAFcDcwmC9NnA+4HbgV1m9nEzK81euZItRXkxLj2tlt+t209K3btFRERERESO6phB2sx+C9wK9ACvBGrdfYG7n+fuF7l7I1AKnAN8DXgFsMXMrshu2ZINV51Zx4HOAR7Z1ZbrUkRERERERKat43Xt3gj8vbvvP9oFYXfux8PXJ83sGqAscyXKVHnO6bUkohFuWbuf8xZW5rocERERERGRaemYLdLu/p5jheijfOYmd//ZyZUluVCSH+eS06q5de0+3NW9W0REREREZDyatVsOc9WqevZ29PPY7o5clyIiIiIiIjItTSpIm9nTzOxGM2s2s2EzOzc8/ikzuzI7JcpUuvyMOcSjxq1r9+W6FBERERERkWlpwkHazC4C7gNOB/5vzGdTwNsyW5rkQllhnGctq+aWJ9S9W0REREREZDyTaZH+DPB7YCXw3jHnHgbOzVRRkltXr6pnV2sf6/Z25roUERERERGRaWcyQfpc4OseNFOObapsBmoyVpXk1PMa5xCNGLeoe7eIiIiIiMgRJhOk+4HCo5yrBzQ71SxRUZTgmUuruPWJ/ereLSIiIiIiMsZkgvQ9wLvNLJp2bCRl/T1wR8aqkpy7alU925p7eOpAV65LERERERERmVYmE6Q/StC9+7Fw34E3mtmfgAuBf818eZIrz185h4jBLWsntYy4iIiIiIjIrDfhIO3ujwGXAAeADwMGvCM8/Wx3fyrz5UmuVBfn8fTFVfzP3Vv58C/Xsn6fJh4TEREREREBsBMZA2tm+UAl0O7uvRmvaoZYvXq1r1mzJtdlZM2u1l6+fPsmbn5sLwPDKc5dUM7rLlzI1WfWkx+PHv8GIiIiIiIiM5iZPeTuq484fjKTSZlZJbAYeMLdB06ivhlptgfpEe29g9zw8B5+9NcdbG3qobwwzivOm8drnr6QxdVFuS5PREREREQkK046SJvZR4Aid/9Q+P4S4DdAEbAHeK67b8pcydPfqRKkR7g7921t4Uf37+T36/YznHIuWlbN6y5cwOVnzCEWncyQexERERERkektE0F6A/Af7v4/4fv7gGHg34F/Aba4+99mruTp71QL0ukOdvbzszW7+PEDu9jT3sec0jxedf4CXn3BfOrLCnJdnoiIiIiIyEnLRJDuAl7o7neaWQ2wn6AV+k4zexnwFXefm9Gqp7lTOUiPSKacP204yI/+uoM7NzYRMeO5p9fy2gsXcvGyaiIRy3WJIiIiIiIiJ+RoQTo2iXskgUS4fwnQD9wbvm8imHxMTjHRiHF54xwub5zDrtZefvzATn62Zhd/ePIACyoLefUFCzhnfjl1ZfnMKc2jMDGZr5yIiIiIiMj0M5lUsw54nZn9BXgzcJe7D4Xn5gMHM12czCzzKwv5wJWn8+7LT+N36/bzo/t38NnfbTjsmpL8GHWl+WGwDsJ1XWmwX1eWT11pPlXFeUTVki0iIiIiItPUZIL09cCvgdcCQ8AVaeeuBh7OYF0ygyViEa45u4Frzm5gd1svO1t62d/Zz/7Ofg50hNvOATYfbOZg1wDJ1OHDC6IRo6Y4jzll+dSV5rGkpphrzm7gjPrSHP1EIiIiIiIih0w4SLv7783sDOBc4FF335J2+m7gsUwXJzPfvIpC5lUUHvV8MuW0dA9woHNgnLDdz7bmHu7YcJCv37mF0+tKeNm583jROQ3UluZP4U8hIiIiIiJyyEmtI32q02RjU6OtZ5DfPL6XGx7ew6O72okYXLS8hpc+bS7PXzlH465FRERERCQrTnrW7vAmMeAZBGOixzYJurt/96SqnGEUpKfe1qZufvnIHn75yB52t/VRlIhy5ap6XnbuXC5cUpW1WcLdHTON2xYREREROZVkYvmrc4FfAvOA8RKFu3v0pKqcYRSkcyeVch7c3sovH9nDbx/fR9fAMPVl+bzonLm87Ny5LJ9TMul7Dgwn2dnSy9bmHrY197C1qZtt4X7fYJI3X7SYay9ZQkl+PAs/kYiIiIiITDeZCNIPAEXAdcAGYHDsNe6+4yTrnFEUpKeH/qEkt60/wI0P7+GujU0kU86quaW89GnzuOacBqqL80avTaWc/eHY661N3Wxt7mFrUxCWd7f1kj7vWXVxHktqilhSXURH3xC3PrGfyqIE73zOMl779IUkYpEc/LQiIiIiIjJVMhGku4FXuvstJ1nIfOCLwPMIWrZvA97t7jsneZ/rgE8D97r7RWPORYAPAm8F6oCngOvd/YYx190JPHuc27/H3b90vBoUpKef5u4Bbnp0L798ZA9r93QQjRiXLK+mMBELW5q76R9KjV5fmIiyuLqIxdVFLKkpZkl1EUtqilhUXUTpmJbnx3e385lbN/CXLS0sqCzk/Ves4AVn1metO7mIiIiIiORWJoL0w8Cn3f3nJ1FEIcHs3gPARwAHPgEUAme5e88E77MEeBzoATaNE6Q/Cbwf+DDwEPC3wFuAF6T/ISAM0hUEgTvddnfff7w6FKSnt40Hurjx4T38du1eomYsqSkOA3MYnKuLmVOaN6mxz+7OXRub+MytG9iwv4sz55Zx3VWn86xl1Vn8SUREREREJBcyEaSvBD4LvHCyrcdp93gX8AVghbtvDo8tBjYBH3D3L0zwPr8HtgMrgFh6kDazWmAX8Bl3/1ja8duBGnc/K+3YnWM/PxkK0qeuVMr51aN7+I8/bGRPex8XL6/muqtOZ2VDWa5LExERERGRDDlakJ7wIE93/x1wK7DJzNaa2d1jXndN4DbXAPePhOjwvtuAe4EXTaQOM3sNwVrWHzrKJVcACeCHY47/EDgzDO4iJyUSMV567jxuf9+z+cjfnMHaPR38zVfu4d0/eYRdrb0ZfVZX/xD3bWnhxod30z0wnNF7i4iIiIjI5E14Ad5wTPIHgCagE0iewPNWAr8e5/g64BUTqKGCYHz1B9y99ShdclcSdB3fPOb4unDbCGxLO/40M+sg6F6+Hviyu3/7eLWIAOTHo/zDxUt4xer5fP3OLXz33m3csnY/r3/GQt5x2TIqihKTul/v4DDr9nby+O4O1u5u5/E9HWxtOjTioa70KT72wkauXFWn5bhERERERHJkwkEaeDfwDeAd7n4iIRqgEmgb53grwVjl4/kcsBH43nGe0e5H9llvTTs/4m7gR+E9y4E3AN8ys3p3/8QE6hEBoKwgznVXnc4bn7mQL/5xI9+9dxs/e3AXb7t0KW9+1mIKEkeuDNc/lGT9vk7W7ukIg3MHmw52jc4cXleaz5nzynjJOXM5a3458ajxid+s5+0/epjLVtRw/YtWMb+ycIp/UhERERERmcwY6U7gxe5+xwk/zGwQ+IK7Xzfm+CeA69z9qMHezC4GbgfOdfcnwmN3cuQY6W8C17h73ZjPLyMYi/0Gd//BMZ7zS+BKgvHU3eOcvxa4FmDBggXn7dhxSq34JRO08UAX//67Ddy2/iBzSvN4z+WnsWpuWRCY97Tz+O4OntrfxXCYmquKEpw1r4wz55Vz1twyzppXRm1p/hH3HU6m+P59O/jCH55iOOX8v+cu5y0XL9FSXCIiIiIiWZCJycZ+Cjzu7p88iSIOAL9y97eOOf414BXuXnOMzz4J3MXhY6N/A0SBq4A+dx8ws88C7wIK0lulzewC4K8EM3f/9hjPeSXwU+CZ7n7fsX4eTTYmx/PAtlY+fet6HtnZPnqsrCAehOYwMJ81r5z6svxJddXe39HP9b9Zxy1r97O0poh/e/EqnrlUM4eLiIiIiGTS0YL0ZLp2fwn4Xvgf+79jnC7a7r71OPdYRzCGeaxG4MnjfPaM8PW2cc61Ae8Ja1wH5AFLOXycdGO4Pd5zRkzsLwwix3DB4kpufPszuWtjE539w5w9r4wFlYUnPb65riyfr732PO586iD/8ut1vOZ//spLnjaXf776DGpK8jJUvYiIiIiIjGcyLdKptLfjfsjdjxwIevg93g18HjhtJHSb2SKCLtfXuft/HOOzl45z+EsELdLvBDa7++5w+avdwCfd/V/TPn8bMMfdzzxOjb8GnkfQtfuY61qrRVqmg/6hJF/902b++64tFMSjfODK03nNBQuIRDQZmYiIiIjIychE1+43cZxWWnf//nHuUQQ8BvQBHwnv929ACXDWyJhkM1sIbAGud/frj3G/OxlnHWgz+wzB5Gj/DDwMvAp4K8HY6d+E11wMXAfcSLAmdRnwRoIluq5z988e62cBBWmZXrY0dfPRXz3BX7a0cPb8cj754lWsmqt1rUVERERETtRJd+129++dbBHu3mNmzyFYwuoHgBFMIPbuMRN7GUFL84nOoPRhoJtgrHQd8BTwypEQHdoX3v96oBoYAh4HXuPuPz7B54rkzNKaYn70D0/npsf28m+/eZJr/use3vCMRbzv+adRkh/PdXkiIiIiIrPGhFuk5UhqkZbpqqNviM///il++Ncd1BTn8S8vbORvzqw/qbHZ7s5wyolHNUO4iIiIiJwaTqhrt5l9BfiUu++fxINeCiTc/ScnVOkMoiAt091ju9r58K/W8sSeTi45rYY3XLiQwWSKnoFhegeT9AwO0zswZjuYHP/8YJJkylleW8yzllXzjKVVXLikirICtXaLiIiIyOx0okH6JuBy4GbgR8A97t465poIcBbwQuB1QDnwenf/Q8aqn6YUpGUmSKacH9y3nc//YSPdA8NHnI8YFCViFOZFD9sW5cUoTBx+LBIxHt3VzoPbWukbShIxWDW3jGcureaZS6s4f1ElBYljzjkoIiIiIjJjnPBkY2Z2CfB+grWaI8BeoAkYACqA+UA+wZjj/wG+6O6dGa1+mlKQlpmktWeQbc3dFOXFgnCciFKUFyMvFpl0l+/B4RSP7mrn3s3N3LelhUd2tTGUdOJR42kLKnjW0mqeuayKs+eVk4ipK7iIiIiIzEyZmLW7Hng+8HSggSA8twAbgLuBP7t76uh3mH0UpEUCvYPDPLi9jb9sbuYvW1p4Ym8H7lCYiHL+okqeubSKZy2r5oz6UqJalktEREREZoiTDtJyJAVpkfG19w5y/9ZW7tvSzL1bWth8MJiUv6wgzoVLKnnGkiouXFrFabUlWu9aRERERKatk17+SkRkosoLE1y5qo4rV9UBcLCzn79saeHezc3cv62F3687AEBFYZynL64KwvXSapbXFitYi4iIiMi0pxbpk6AWaZETs6u1l79ua+X+rS3cv7WF3W19AFQWJXj64kouXBLMCK5gLSIiIiK5pBZpEZk25lcWMr+ykJefNw8IgnUQqoNwfesTwYp76cH6GUuDYH0ya2GLiIiIiGSCgrSI5NxIsH7F6vnA0YN1VVGCCxZXsqCqkPKCBOWFccoL4pQVxg+9L4xTEI8qcIuIiIhI1ihIi8i0kx6s3Z3dbX3cF3YDf3B7K7evP8hg8uiLBCSikTBcB8G6LC10lxfGmVOazzOXVTO3vGAKfyoRERERmS0UpEVkWjOz0WD9yrDF2t3pH0rR3jdIe+8Q7b1DdIzs94153zvEnvY+ntzbQXvfEL2DydF7L60p4pLTarjktBouXFxFQSKaqx9TRERERGaQCQdpM3sRUOnu3w3fLwR+AqwCfg+8yd27s1KliEgaM6MgEaUgUUB92eRalQeGk+xo6eXujU3cvamZ//vrTr5773YS0QjnL67gkuVBsD69rkTdw0VERERkXBOetdvMHgR+7u7/Hr6/AbgA+BnweuB/3f392Sp0OtKs3SIzX/9Qkge2tYbBuomNB4K/B9aW5HHx8houOa2ai5ZVU1Wcl+NKRURERGSqZWLW7qXA4+HNCoCrgTe4+8/NbD3wIeCUCtIiMvPlx6Oj3bsB9nf0c/emJu7e2MTtGw5ww8O7MYNVDWVcclo1lyyv4dyFFcSjkRxXLiIiIiK5MpkW6V7gKne/y8yeC/wOqHb3DjO7GPiDu59SM/eoRVpkdkumnLV7OoLW6o1NPLKrnWTKKc6LcebcMk6bU8yyOSUsry3mtDklVBYlpqQud6epe4CSvLjGdYuIiIhkUSZapLcDFwF3AS8CHnL3jvBcLdBxlM+JiMxI0Yhxzvxyzplfzv977nI6+oa4b0sLf97UxLq9ndzw8B66B4ZHr68qSrAsDNXL5xSP7lcVJSY13jqVCoLy7rZedrf1pb162dPWx572PgaGU5Tkx3jN0xfw5mctZk5pfjb+JxARERGRcUymRfpdwOeBx4BzgLe7+/+E5z4PnOvuz8lSndOSWqRFTm3uzv7OfjYe6GbTgS42H+xm44EuNh3spqv/UMCuKIyzvDYI18tri1k+p4S55QWHwnJrEI5HwvLe9v4jlveqKkowt6KAeRUFzKsopKEsnwd3tHHr2n1EI8aLzpnLtZcs4bQ5JVP9P4OIiIjIrHW0FukJB+nwJq8FLgQedPf/TTv+DeAed/9BJoqdKRSkRWQ87s7BroEgVB/oZtPBIGhvPNBFZ1rATlddnMe8ioLDwvK88oLRY4WJ8TsQ7Wzp5dv3bOWna3bRP5TishU1XHvJUi5cUqlZx0VEREROUkaCtBxOQVpEJmNkbPOmA93sae9jTmk+c8sLmFtecNJjndt6BvnB/Tv4/l+209IzyFnzyrj2kiVcubKOmCZGExERETkhJx2kzew0oNzdHwjfFwD/QriOtLv/VwbrnREUpEVkuukfSnLDw7v51p+3sa25h/mVBfzDRUt4xep5R23VFhEREZHxZSJI/wF41N0/EL7/AvAOYC1wFvBud/9q5kqe/hSkRWS6SqacPz55gG/evYWHd7ZTXhjnDRcu5A3PXES11sQWERERmZBMBOkDwLXu/msziwAHgU+6+xfN7GPAS9397IxWPc0pSIvITLBmeyvfuHsrt60/QCIa4WXnzeMfLlrMkpriXJcmIiIiMq1lYvmrMqAl3H8aUAH8Inx/J/D+kylQRESyY/WiSlYvqmRLUzff+vNWfvHQbn78wE6ee3otS2uLKU7EKMqLUZwXbIvyoqP76cfyYlqzWkRERAQmF6QPAMuAe4DnA1vcfVd4rhgYfypaERGZFpbWFPPpl57Fe5+3gu//ZTu/eGg3d29sPmKpraOJR43CxEi4jlKUF6M0P05VcYLq4jyqihJUFoX7xQmqwmP5cQVwERERmV0mE6RvAj5tZquANwHfSDt3JrA1g3WJiEiW1JTk8f4rVvD+K1YAMDicomdgmJ7BYXoGknQPDAfvB4YP7Q8eOn7ofJLWnkE2H+ymuXuAgeHxA3lRIkpVcV4YshNUFQVBu7IoQU1JHisbylhaU6TlukRERGTGmEyQvg7IB64gCNWfSjt3DfCHDNYlIiJTJBGLkIglqChKnPA93J3ewSQt3YM09wzQ2j1IS88Azd2DtPYM0tI9QEvPIHva+1m7p4OW7kGGU4fm6KgpyePCJVU8Y0kVFy6pZHG1grWIiIhMXxMO0u7eA7zlKOeembGKRERkxjGzcCx1jAVVhce93t3p7BvmQFc/D+1o4/6tLdy3pYWbH9sLwJzSIFiPhOuFVYUK1iIiIjJtTHjW7tEPmFUCzwAqgVbgPndvzUJt055m7RYRyRx3Z1tzD/dvbeW+rS3cv7WFpq4BAOrL8sNgXckzllQzv7JAwVpERESy7qSXvwpv8gngfUD6IqQDwOfd/aMnXeUMoyAtIpI97s6Wpp6gtXprC3/d2kJz9yAADWX5XLg0aLE+b2EF8yoKNKu4iIiIZNxJL39lZu8G/hn4NvBDYD9QB7wO+Gcza3L3r2SmXBEROdWZGctqi1lWW8zrLlyIu7P5YDf3b23h/q2t3PVUEzc+vCe8FuaU5DOvoiB8FR62bSgvIBGL5PgnEhERkdliwi3SZrYBuNXd3zPOuS8CV7n76Rmub1pTi7SISO64O5sOdvP47g52t/Wyu61vdLuvo59k2mRmZlBXmj8mZB/an1teQCyqoC0iIiKHO+kWaWAR8NujnPst8PYTqEtEROSEmBmnzSnhtDklR5wbTqbY39kfhuu+w4L2g9tbuemxw4N2fjxCY30pZ84tY+XcMs6cW8by2mKFaxERERnXZIJ0C7AKuG2ccyvD8yIiIjkXi0bC1ubxZxBPD9o7W3vZsK+LJ/Z08IuHdvP9+3YAkBeLcEZ9KavmBgF71dwyTptTQlzhWkRE5JQ3mSD9S+DfzKwF+LG7D5tZDHgFcD3w/WwUKCIikmnpQfvCJVWjx1MpZ1tLD0/s6WDt7g7W7ungV4/s5Yf37wQgEY1wen0Jq8JW6zPDcK3x1yIiIqeWyYyRLgFuAZ4FJAmWvqoEosA9wNXu3p2lOqcljZEWEZn9UilnR2sva/d08ET4Wrung67+YQDiUaOxoYwrV9bxwrPrj9oKLiIiIjNPppa/MuBvgIs5tI70XQSTkE1uQepZQEFaROTU5O7sHA3Xndy/tYVHd7UDcN7CCl54Vj1/c1YDNSV5x76RiIiITGsZCdJyOAVpEREZsau1l5se28vNj+1lw/4uIgbPWFrFNWc3cOXKesoK47kuUURERCZJQToLFKRFRGQ8mw50jYbq7S29xKPGs0+r4YVnN/C8xjkUJiYzRYmIiIjkygkFaTNLARNN2u7up9R/GShIi4jIsbg7a/d0cPNje7n5sX3s7+ynIB7l8sY5vPCsep69ooa8WDTXZYqIiMhRnOg60tcz8SAtIiIiacyMs+aVc9a8cj501RnhGtZ7uWXtPm5+bC+l+TGuXFXHC89u4MIlVVpaS0REZIZQ1+6ToBZpERE5EUPJFPdububmx/bxh3X76RoYJhYxFlQWsri6iMXVRSypKQ63RdSW5BHM9ykiIiJT6URbpLNRyHzgi8DzAANuA97t7jsneZ/rgE8D97r7RWPORYAPAm8F6oCngOvd/YZx7vMW4H3AYmA78EV3/+9J/lgiIiITFo9GuHRFLZeuqKV/aBV3PtXE2j3tbGvuYWtTD/dsbmZgODV6fWEieihgp4XsRdVFlBVoEjMREZGpNqVB2swKgTuAAeCNBN3GPwH8yczOcveeCd5nCfAR4OBRLvk34P3Ah4GHgL8Ffm5mL3D3W9Lu8xbgGwSB/DbgucDXzMzc/esn8COKiIhMSn48ypWr6rhyVd3osVTK2dfZz7amHrY1d7O1uYdtzT08vruDW9buI5XWmay6OMHi6iIWVhVRXZxHRWGciqIEFYWJw/bLCuJEI2rVFhERyYQp7dptZu8CvgCscPfN4bHFwCbgA+7+hQne5/cErccrgFh6i7SZ1QK7gM+4+8fSjt8O1Lj7WeH7GLCXYA3sN6Zd9x3gGqDe3YeOVYe6douIyFQbGE6yq7WXrU1BuN7W3MPW5h52tPTQ2jPIUHL83+tmUFYQp6IwQXlhnMrCBOVjwvbi6iJWL6rQWG0REZHQdOnafQ1w/0iIBnD3bWZ2L/AigpB9TGb2GuBc4NXAjeNccgWQAH445vgPge+Y2WJ33wY8A6gZ57ofAH8HXAT8aSI/lIiIyFTJi0VZVlvCstqSI865Oz2DSdp6BmnrHaStd+go+4Ps6+hn/b5OWnsH6R861I28ND/Gs1fUcvkZtVx6Wq3WvxYRERnHVAfplcCvxzm+DnjF8T5sZhUE46s/4O6tR5l4ZSVB1/HNY46vC7eNwLbwOoAnjnGdgrSIiMwYZkZxXozivBjzKwsn/Ln+oSStPYM8vruD29cf4I4NB7n5sb1EI8b5iyq4/Iw5XH7GHBZVF2WxehERkZljqoN0JdA2zvFWoGICn/8csBH43nGe0e5H9llvTTufvh1bz9jrREREZrX8eJSG8gIaygu4clUdyZTz6K52bl9/gNvXH+QTv13PJ367nqU1RUGobpzDuQsqNOZaREROWccM0mb2hsnczN3/9+TKOWYtFwNvAM4dJyRPGTO7FrgWYMGCBbkqQ0REJGuiEeO8hRWct7CCD1x5Ortae7ktDNXfvmcb37h7KxWFcS5bUcvljXO4eHk1JfnqAi4iIqeO47VIf28S93LgeEG6jfFbno/WUp3uG8C3gd1mVh4eiwHR8H2fuw+E9ykPZ95OD9wjLcwjLc4jz6sA9h3jusO4+zeBb0Iw2dhxahYREZnx5lcW8nfPWszfPWsxnf1D3L2xidvXH+SOpw5y4yN7iEeNC5dU8ZzTa1leW0JdWR5zSvMpzotp/WsREZmVjhekF2f4ees4NDY5XSPw5HE+e0b4ets459qA9wBfCp+RByzl8HHSjeF25DkjY6FXcniQHnudiIiIhErz47zgrAZecFYDw8kUD+1o4/YNB7lt/QH+9ebDf3UWJqLUleYzpzSfOaV5zCnLT3ufT11ZPjXFeSRimiVcRERmlmMGaXffkeHn3QR83syWuPtWADNbBDwLuO44n71snGNfAqLAOzkUmn8HDAGvBf417drXAU+EM3YD3Ac0h9fdNua6VuDeCf1EIiIip6hYNMLTl1Tx9CVV/PPVZ7C7rZfdbX0c6Oxnf0c/BzoHgv3OftbsaONg5wCDydQR96kuToyG6/qyfBZVFbGouohFVYXMrywkPx7NwU8nIiJydFM92dj/AO8Afm1mHyHoDv5vBOs+f2PkIjNbCGwBrnf36wHc/c6xNzOzdoJ1pEfPuftBM/sC8CEz6wIeBl4FPIdg+a2R64bM7KPA18xsD0GYfg7wZuCd7j6YuR9bRERk9ptXUci8iqPPFu7utPYMsr+zn4OdA+wPA/fBrmC7r6OfNdtb6ewfHv2MGTSUFbCoupCFVUUsripiYVUhi6uLFLJFRCRnJhWkzez5wNuBFUD+2PPuvuRYn3f3HjN7DsESVj8ADLgdeLe7d6c/iqCl+UT7en0Y6AbeBdQBTwGvdPffjKnnv83MgfcB/x+wE3iHu3/tBJ8rIiIiR2FmVBXnUVWcx8qGo1/X1jPI9pYedrT0sq25hx0tPWxr6eWWtfto7x1Ku18QshdWFY62YC+qKmLl3DIayvI1PltERLLGJjoBtpldDdxM0HL7PIIu1IUE3bJ3AH9297/LUp3T0urVq33NmjW5LkNEROSU0d47yPaWXrY39xwRttvSQvac0jzOXVDB0xaUc+6CClbNLVPrtYiITJqZPeTuq8cen0yL9EeBrxJM6jUEfMTdHzaz04DfA7dmpFIRERGRoygvTHBOYYJz5pcfca6jd4itzd08vruDh3e28fDONm59Yj8A8ajR2FDGuWGwPndhhVqtRUTkhE2mRboNeCVBi/Qw8Ax3fyA890bg/e5+ZrYKnY7UIi0iIjK9NXUN8MjONh7e2c7DO9t4fHc7/UPBhGdqtRYRkePJRIt0Chh2dzezJmAB8EB4bi/BclMiIiIi00ZNSR7PX1nH81fWATCUTLFhX9doi/V4rdZPm1/O8jnFLKspZvmcEiqLErn8EUREZBqaTJB+ClgU7q8B3m1m9xK0Tr8P2J7RykREREQyLB6NcOa8Ms6cV8Ybn7kIOLLV+mdrdtE7mBz9TGVRgmU1xSwbDdfFLKstpq5UXcNFRE5VkwnSPwLOCPc/RtDFe3f4Pgm8JoN1iYiIiEyJsa3WqZSzr7OfTQe62Hywmy1N3Ww60H3ErOHFeTGW1gbhelltMctrg+38ykKiERu9V/9wkr7BJH1DSfqHUvQPjeynHw/O9YXH3J3T60s5e365xnKLiExDEx4jfcQHzeYBVxLM3H2buz+ZycJmAo2RFhEROXW4Oy09g2w60M3mpm42H+gKtge7OdA5MHpdIhahIB6lbyjJ4HDqhJ5lBiP/iVZdnMc588s4e1455ywo56y55ZQVxjPxI4mIyHFkYoz0Ydx9N/Ctk6pKREREZIYwM6qL86guzuMZS6sOO9fRN8SWMFRvOdjNwHCK/HiU/HgQqgsSUfJjUfITUQrSjueHr+B8ZPS6oVQwlvux3e08uqudx3a1c9v6g6PPW1JdxNnzyzl7Xhlnzy/njPpSTZQmIjKFJjNr9yPA94Efu/uBrFY1Q6hFWkRERKZKR98QT+zp4NFd7aOvpq6gJTweNc6oL+XseeWcPb+cc+aXs6S6iEhEXcJFRE7G0VqkJxOkbwGeBzhwO0Go/pW792ey0JlEQVpERERyxd3Z39nPY7vaeXRXB4/taufx3e30hBOllRXEOX9RBRcsruSCxVWsbCglHo3kuGoRkZnlpIN0eJNagknFXgecC3QBNwA/cPc/ZajWGUNBWkRERKaTZMrZ2tTNI7vaeWh7Gw9sb2Vbcw8AhYko5y4YCdaVnDO/XN3BRUSOIyNBeswNzwBeTxCs5wO73X3hSVU5wyhIi4iIyHR3sKufB7e18cC2Fv66rZWnDnThDolohLPnl422WJ+3sILivBOePkdEZFbKeJAOb5oPvAz4DNDg7qfUnzUVpEVERGSm6egdYs2OVh7Y1spft7Wydk8HyZQTMVjZUDbaYn3+okoqixK5LldEJKcyGqTN7DkErdEvBYqBBwi6d3/tZAudSRSkRUREZKbrGRjmkZ3tPLCthQe2t/LIznYGwmW7ivNi1JTkUVOcF2xHXmPeVxYlNP5aRGalk17+ysxWEYyNfg0wD9gOfJkgQG/KUJ0iIiIiMoWK8mJctLyai5ZXAzAwnGTt7g4e3tnG/o4BmroHaOrqZ8P+Tv68aYDO/uEj7mEGlYWJI4J2RVGC4rwYJfkxivNiFOXFRt+P7OfFIphpdnERmVkmMxDmcaAD+Dnwv+5+T3ZKEhEREZFcyYtFWb2oktWLKsc93z+UpLl7gKau8JW+H77f1tzDwa4BBsOW7WOJR200VI8N2SX5MWpK8plbnk9DeUHwKiugIHFKjSYUkWloMkH6lcDN7j6QrWJEREREZHrLj0eZV1HIvIrCY17n7vQOJukZGKZrYJiegWG6+4P97v5hegaH6eofpnucc609g+xs6aWzf5iWngHGjkSsKIynBeu0kF1eQEN5PrUl+US1hraIZNGEg7S7/yKbhYiIiIjI7GEWtDQX5cWoPYn7DCVT7O/oZ297H/s6+tnT3sfe8LWrtZf7t7bQNaa7eSxizCnNZ24YrOdVFDK/siD8A0AQuDWmW0ROhtY4EBEREZFpKx6NML+ykPmVR28B7+wfYl97P3s7DoXsve1B+H5wexs3P76PZOpQs3bEoK40n3mVQbCeV1HI/JFtZQF1pfnEFLRF5BgUpEVERERkRivNj1NaF2dFXcm454eTKfZ19LO7rY9dbb3sbutjd1svu1v7uH9LC/s69xzWfTwaMerL8pkftmBXl+RRkh8LnlMQpzQ/Rkl+nLKCQ8c0aZrIqUVBWkRERERmtVhaq/YzqDri/OBwin0dfUHQbj0UtHe19XH3piZaewYZSh57ydh41EZD9aHQHWwrixKcM7+c8xdVUqG1uUVmBQVpERERETmlJWIRFlYVsbCqaNzz7s7AcIrOviE6+4fp7B8a3e/qH6Kz79CxrrTzBzr76ewfOiyIL68t5vzFlVywqJLzF1cyt7xgKn9UEckQBWkRERERkWMwM/LjUfLjUWpLJ//5/qEka/d08MC2Vh7c3srNj+7l//66E4C55QWcv6hiNFwvqy1WF3GRGUBBWkREREQki/LjUc5fVMn54drcyZSzYX8nD25r5cHtbdy7pYVfPboXCJb2Wr3oUIv1yoZSzTAuMg2Zj12YTyZs9erVvmbNmlyXISIiIiIzmLuzo6WXB7a3jrZa72jpBaAgHuXcheWcPa+c0+aUsHxOMUtrismPR3NctcipwcwecvfVY4+rRVpEREREJIfMjEXVRSyqLuKVq+cDcLCznwe2t/LgtlYe2N7GN+/eynC4hFfEYFFVEcvnFIfhuoQVc0pYXF1EIqbWa5GpoCAtIiIiIjLN1Jbm84KzGnjBWQ1AMLP4tuYeNh7oYtOBLjYe6GbjwS7++OQBRpbIjkWCQH5aGLCDVzELq4pOqHt4KuUk3UmmnOGUM5xMMZR0hlMphpPOUDLFcCrchseHkh6cS6VIph9LpUimgvW7l9QUUVeaTySiseAycylIi4iIiIhMc4lYhBV1JUesld0/lGRrUw+bDnaxMQzYT+7t5NYn9o+ujR2PGgsqC4lHIwynRoLxSNA9FJRHj4f7qSyOAM2PR1hUVcSSmiIWVxexuLqYxdVFLKku0hJhMiMoSIuIiIiIzFD58SiNDaU0Nhw+nXjfYJItTd2j4Xp7cw+OE4tEiEaMWMSCbTTcph2PpJ+PGNFIZPR9PGrEosH7eDRCLBp8duR4PBKejxrxSLgNrzGDPe19bGvuYVtTD9uae9iwr4s/rDsw2m0doLwwHobrIpbWFI/uL6oqoiChseEyPWiysZOgycZERERERE7OUDLF7rY+tjV3s7Wph61pQXt/Z/9h1y6qKuTSFbVcdnotT19cqUnXJOuONtmYgvRJUJAWEREREcmenoFhtrf0jLZiP7Krnb9saaZ/KEVhIsqzllXznNNrec7ptcwpzc91uTILadZuERERERGZUYryYqxsKGNlQ9nosf6hJPdtaeGODQe5Y8NB/vjkAQBWNpTy3NOD1uqz55VrMjPJKrVInwS1SIuIiIiI5I67s/FAN7dvOMCfNhzkoR1tpByqihJcuiJoqb74tGpK8+O5LlVmKHXtzgIFaRERERGR6aO9d5C7NjZxx4aD3PlUEx19Q8QixvmLKnlO2Fq9tKYIM7VWy8QoSGeBgrSIiIiIyPQ0nEzxyK72oAv4+oM8daALgGjEKCuIU14Qp6ww3BbEKS9MhNvwVZAYPV9emKA0P0bsBNbjlplNQToLFKRFRERERGaG3W293L2xmX0dfbT3DtHeN0R77yAdfUPB+95BOvuHj3mPkvwYpflx8mIR4tEIiViw9FcifH/48WCbSL8uGiUeC5YVS2ccen+sxvKRlvSCeJSrz6yjvFBrbmebgnQWKEiLiIiIiMweyZTT2XcoZLf3DdHRe2i/vXeIzv4hhpLO4HCSweFUuJ9iMJkK3wf7Q2nHBpPBdclU5rJXSV6MN1+0mDdftJiyAo0BzxbN2i0iIiIiInIM0YhRUZSgoigBFGX8/slUELpTaY2Z6dHaj3I8OHdof1drL/91x2a+fPsmvnvvNt5y8RLe9KxFlGhStSmjFumToBZpERERERHJlSf2dPCl2zZx2/oDlBfGufaSJbzxGYsoylN7aaaoa3cWKEiLiIiIiEiuPb67nS/dtok7NhyksijBWy9ZwuufsZDChAL1yVKQzgIFaRERERERmS4e2dnGF2/bxN0bm6guTvC2Zy/ldRcuJD8ezXVpM5aCdBYoSIuIiIiIyHTz0I5WvvjHTdyzuZmakjz+8dKlvPqCBQrUJ+BoQXrKF0Izs/lm9gsz6zCzTjO70cwWTOBzC83s12a2w8z6zKzZzO4ys6vHuXZx+Ix2M+sxsz+Z2ZF/RTDbbmY+zuvFGfpxRUREREREptR5Cyv54T88nZ9eeyFLqov415uf5NLP3ckP7tvOwHAy1+XNClPaIm1mhcBjwADwEYLJ6D4BFAJnuXvPMT67EngvcCewGygF3gL8DfAyd78xvK4KeBzoAj4G9IafWw1c4O7r0+65HdgAfHzM455y97bj/TxqkRYRERERkenuL1ua+eIfN/Lg9jYayvJ5x3OW8/Lz5pGITXm76owzLbp2m9m7gC8AK9x9c3hsMbAJ+IC7f2GS94sB24BH3f2F4bGPEATjFe6+JTxWBGwF7nL3V6Z9fjtwj7u/7kR+HgVpERERERGZCdydezY384U/buSRne2YQXlBnIqiBJWFidFtZXHa+6I4FYUJKsMlwUryYphZrn+UKTVd1pG+Brh/JEQDuPs2M7sXeBFByJ4wdx82sw5gOO3whcCmkRAdXtdjZn8GXmBmMXcfHnsvERERERGR2crMuHh5DRctq+bPm5p5aEcbbb2DtPQM0tYzyK7WXh7f3U5rzyBDyfEbW+NRGw3WVcUJVjaUce6CCs5bWEFNSd4U/0S5NdVBeiXw63GOrwNeMZEbmFmEYGx3NXAtcBrwrrRLksDgOB8dAAqApcBTacdfaGa9QBR4BPiMu/9qIrWIiIiIiIjMJGbGJafVcMlpNeOed3e6B4Zp6xmitTcI2SNhO/39wa4Bvnfvdr5591YAFlUVcu7CClYvrOS8hRUsry0mEpm9rddTHaQrgfHGHrcCFRO8x78D7wv3u4G/dffb084/BTzPzKrcvQVGw/cFaTWMuBl4kKB7+BzgHcAvzez17v7DCdYjIiIiIiIyK5gZJflxSvLjLKgqPOa1A8NJntjTwUM72lizvY27nmrixof3AFCaH+PchRWct6CC8xZVcM788lm1rvVUj5EeBL7g7teNOf4J4Dp3P+7/smY2D6gLX28g6C7+cnf/TXh+CfAkcDvw/wgmG/sw8DaCVucL3f2vR7l3FLgfqHP3+Ue55lqClnAWLFhw3o4dO45XsoiIiIiIyKzn7uxo6WXNjjYe2tHKQzva2HigG4BoxGisL+W8hUFX8NWLKqgvK8hxxcc3XSYbOwD8yt3fOub414BXuPv4/QuOfc87CYLv6WnHXgZ8laCVGeBh4A7g/cBCd995jPt9APgs0ODu+471bE02JiIiIiIicnQdvUM8vLMtaLXe0cqju9rpH0oBQXfw2993KdFp3AV8ukw2to5gnPRYjQStyCdiDfDu9APufoOZ/Ypg/PSgu28xs68Du44VoseYur8wiIiIiIiIzEJlhXEuO72Wy06vBWAomWL9vk7WbG+jpWdgWofoY5nqIH0T8HkzW+LuWwHMbBHwLOC6Y31wPOHY54uALWPPuXsS+P/bu/9gOav6juPvD0kQUDBJKTAmEpoWaWFIWopMa4EAYnEcCEylQuhUaIVaq7bUWpFWqoWiY9Uy1XGsVqxUwdiiHSLTFkmQYGlQaGyQNAXtJEJa0iaQgPwoIvn2j+e5w3Z7b8KW3H2ue9+vmZ3n7nnO7v3unTPn3O8+55xnQ1vvJcA5wAd2834z23r3V9WWQeORJEmSJE1s1oy9WDR/Novmz+46lOdl2In0n9Ns6HVDe7/nAq4AHgA+PlYpyQKa5Pjyqrq8LXsPzUZhtwNbaNZIv4FmE7Hzel47i2ZDstXAozRXwC+luRr+oZ56y2huufW37e8/GHgzcAywbE9/cEmSJEnSaBhqIt3ez/kU4CrgM0BoNgW7uKoe66kamo3B9uopW0szhftc4MU0yfQ64ISqur331wCH0yTXs4HNwKeA91ZV722xNgIH0Vylngs8TjNN/NVVddMe+LiSJEmSpBE01M3GRo2bjUmSJEnS6Jpos7G9xqssSZIkSZLGZyItSZIkSdIATKQlSZIkSRqAibQkSZIkSQNws7HnIclW4Dtdx7EbBwLbug5C6mGb1FRku9RUY5vUVGS71FQ02e1yQVX9cH+hifSIS3LXeLvMSV2xTWoqsl1qqrFNaiqyXWoq6qpdOrVbkiRJkqQBmEhLkiRJkjQAE+nR94muA5D62CY1FdkuNdXYJjUV2S41FXXSLl0jLUmSJEnSALwiLUmSJEnSAEykR0ySlya5PskjSR5N8sUkh3Ydl6aPJPOTfCTJmiRPJKkkh41Tb58kH0jyYJIn2/ondhCyRlySs5N8Icl32rZ2b5L3Jdm/r96cJJ9Msi3J40lWJjm6q7g12pKcluSWJFuSPJVkc5K/SnJkXz3HdXUmyd+34/gf9ZXbX2ookpzUtsH+x46+ekNvkybSIyTJfsAtwI8D5wO/DBwOfCXJC7uMTdPKjwGvA7YDX91FvauBi4A/AE4HHgRuSvKTkx2gpp23A88Avwe8GvgY8Cbg5iR7ASQJ8KX2/FuB1wKzaPrP+V0ErZE3F/gn4C3AzwOXAkcBdyRZAI7r6laSZcDiccrtL9WF3wR+tudx6tiJrtrkzMl6Y3XiImAhcERVfRsgyd3At4A3An/SYWyaPm6rqoMBklxI8w/i/5JkMXAe8KtV9Rdt2WpgPXA5sHR44WoaOKOqtvY8X53kYeAa4CSaRGUp8HPAKVX1FYAka4CNwDtoBnBpj6mqzwGf6y1L8nXgX4GzgQ/huK6OJJkDXAX8NnBd32n7S3VhQ1XdMcG5TtqkV6RHy1LgjrHBFqCqNgK3A2d2FpWmlara+RyqLQWeBj7f87rvA8uB05K8YJLC0zTUl0SPubM9zmuPS4H/GBuA29c9QvMNt/2nhuWh9vj99ui4rq68H7in/cKnn/2lpppO2qSJ9Gg5CrhnnPL1wJHjlEtdOQrYWFVP9JWvB/ammR4uTaYl7XFDe9xV/3lokhcNJSpNO0lmJNk7yeHAx4EtPHul2nFdQ5fkeOD1wJsnqGJ/qS5cm+SZJA8lua5vr4hO2qSJ9GiZS7Mutd/DwJwhxyLtyq7a6th5aVIkmUezhGBlVd3VFu+uTdqHarJ8DXgKuA9YRDM18b/ac47rGqoke9N8ofPBqrp3gmr2lxqmR2iWulwInAJcQbM+ek2Sg9o6nbRJ10hLkqaN9lvpG2imzv5Kx+FI0GwgdgDNWui302yCd3xVbeo0Kk1X7wD2Ba7sOhAJoKq+AXyjp2h1ktuAr9OsfX5XJ4HhFelRs53xv3GZ6FsaqSu7aqvw7DeI0h6TZF+a9VILgdOqanPP6d21SftQTYqq2lBVX2vXor4SeBHwzva047qGpp0q+/vAZcALksxOMrs9PfZ8BvaX6lhVraWZxfPytqiTNmkiPVrW06wR6Hck8C9DjkXalfXAj7S3dul1JPA94Nv/9yXS/1+SWcD1wLHAa6rqm31VdtV/3l9Vj01yiBJVtYOm/xvbJ8JxXcO0ENgH+CxN4jH2gGa2xHbgaOwvNXVUe+ykTZpIj5YVwM8kWThWkOQwmu3gV3QVlDSOL9Hc3+8XxwqSzATOAb5cVU91FZhGT3uv6Gtp1ladNcHtM1YA85Is6XndAcAZ2H9qSJIcTHPP6H9rixzXNUz/DJw8zgOa5Ppkmi967C/VqSTHAkfQTO+Gjtpkqmr3tfQDIckLgXXAkzTrBYpmQf7+wCK/IdSwJDm7/fGVwK8DvwFsBbZW1eq2znLgNOB3ae7z9ybgdOAV7ZQdaY9I8jGadnglcGPf6c1VtblNtv8BeClNm9wOXEqz+dPiqnpgiCFrGkjyN8Ba4G7gUeBlNPfsPQQ4rqruc1zXVJCkgCur6l3tc/tLDU2Sa2n+T1wL7AB+iqa9PQEcU1XbumqTJtIjpl3fchXwKiDAKuBiNy3RMLWD7nhWV9VJbZ2xzUzOA2bT/LN4SVXdOoQQNY0k2QQsmOD0H1bVe9p6c4EPAmfRTG9cA7ytqtZNfpSabpJcArwO+FGa2/49ANwKvK93zHZcV9f6E+m2zP5SQ5HkUmAZzTi+H80tAv8OeHdVPdhTb+ht0kRakiRJkqQBuEZakiRJkqQBmEhLkiRJkjQAE2lJkiRJkgZgIi1JkiRJ0gBMpCVJkiRJGoCJtCRJkiRJAzCRliRJQ5FkU5LPdh2HJEnPl4m0JEmSJEkDMJGWJEmSJGkAJtKSJI2gJIuTrEiyPcmTSW5PckLP+U8n2ZzkFUnuTPLf7dTrt47zXsclWZnksSSPJ1mV5Lhx6i1JcnOSR9p665K8YZx65ybZ0Na5K8nxe/4vIEnS5DGRliRpxCQ5BvhHYC5wEfBa4CFgZZKf7ql6APB54BrgLOBW4MNJLuh5r0XAamAOcAHw+vZ1q5Ms7ql3JrAK2Bt4I3Am8ClgQV94JwC/A1wGnAPMAG5MMvt5fmxJkoYmVdV1DJIkaQ9Ksgp4CbC4qr7Xls0A7gHuraqzknwaOB9YVlXLe157M/Ay4LCqqiTXA6e2z3e0dQ4ANgG3VtUvJAmwEdgGHFdVOyeIaxPwYmBhVW1vy44F7gR+qaqu26N/CEmSJolXpCVJGiFJ9gWWAH8N7EwyM8lMIMBK4MSe6s8AX+h7i+XAocC89vmJwI1jSTRAVT0KrGh/D8ARNFeePzlREt1jzVgS3fpmezx0959OkqSpwURakqTRMpdmuvRlwNN9j7cAc5KMjf/bq+rpvtf/Z3scS6TnAg+O83u20Ez3Bvih9rj5OcT3cO+Tqnqq/XGf5/BaSZKmhJldByBJkvaoHcBO4KPAX45Xoap2NrOxmZNkVl8yfXB7/Pf2+DBwyDhvcwgwdmV5W3ucN049SZJGjom0JEkjpKoeT/JVYDGwdjdTrWfQbES2vKfsXOB+nk2kVwOvSbJ/VX0XIMn+wBk0m5MB3EezZvrCJJ8oN2CRJI04E2lJkkbP24DbgJuSXE0zNftA4BhgRlW9s633XeCPkxwIfAtYRrOx2AU9yfAVwOnAqiTvBwq4BNgPuByg3ZTsYuCLwC1J/gzYCvwEcFBVvXuSP68kSUPlGmlJkkZMVa0FXk5zy6sPA18G/hQ4mibBHvMozRXo84EbgJOB36qqa3re627gpLbuNcBngMeAJVW1rqfeDcCr2qdX02xG9ms0V6olSRop3v5KkqRpqL391alVNb/rWCRJ+kHjFWlJkiRJkgZgIi1JkiRJ0gCc2i1JkiRJ0gC8Ii1JkiRJ0gBMpCVJkiRJGoCJtCRJkiRJAzCRliRJkiRpACbSkiRJkiQNwERakiRJkqQB/A+uqSZDn69VEAAAAABJRU5ErkJggg==\n", "text/plain": [ - "array([ 4.32284387, 4.42208292, 3.3031029 , 4.17837783, 0.24627421,\n", - " 1.60552719, 1.59221673, 0. , 0. , 0. ,\n", - " 0. , 0. , 0. , 0. , 0.59455814,\n", - " 0.84819036, 0.91022234, 0.83308917, 0.30861847, 0.7820293 ,\n", - " 0.89154524, 0.40239062, -0.2175147 , 0.8519179 , -0.5969506 ,\n", - " -0.89464083, 0.32461422, -0.24695989])" + "
" ] }, - "execution_count": 59, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "agent.get_parameters().flatten()" + "fig, ax = plt.subplots(2, 1, figsize=(16, 8))\n", + "ax[0].plot(train_losses)\n", + "ax[0].set_xlabel(\"epoch\")\n", + "ax[0].set_ylabel(\"train loss (gaussian nll)\")\n", + "ax[1].plot(val_losses)\n", + "ax[1].set_xlabel(\"epoch\")\n", + "ax[1].set_ylabel(\"val loss (mse)\")\n", + "plt.show()" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, - "source": [ - "# Plotting Results" - ] + "outputs": [], + "source": [] } ], "metadata": { From 4ead4911017efa2a6142e8c0f8dcdc0a9c6bfa07 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Wed, 10 Aug 2022 14:52:19 -0700 Subject: [PATCH 05/24] initial notebook added --- notebooks/traj_based_model.ipynb | 378 ++++++++++++++++++++++++++----- 1 file changed, 324 insertions(+), 54 deletions(-) diff --git a/notebooks/traj_based_model.ipynb b/notebooks/traj_based_model.ipynb index 7ebeb12b..0e450de0 100644 --- a/notebooks/traj_based_model.ipynb +++ b/notebooks/traj_based_model.ipynb @@ -10,28 +10,19 @@ "source": [ "# Preview\n", "\n", - "In this example, we are going to use our toolbox to train and evaluate the [Trajectory-based Dynamics Model](https://arxiv.org/abs/2012.09156) in the reacher environment." + "In this example, we are going to use our toolbox to train and evaluate the [Trajectory-based Dynamics Model](https://arxiv.org/abs/2012.09156) in the reacher environment. Note that the reacher environment in this repository is slightly different than the one used in that paper!" ] }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 1, "metadata": { "pycharm": { "is_executing": true, "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "from IPython import display\n", "%matplotlib inline\n", @@ -46,7 +37,6 @@ "import mbrl.env.reward_fns as reward_fns\n", "import mbrl.env.termination_fns as termination_fns\n", "import mbrl.models as models\n", - "import mbrl.planning as planning\n", "import mbrl.util.common as common_util\n", "\n", "\n", @@ -73,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "pycharm": { "name": "#%%\n" @@ -106,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 3, "metadata": { "pycharm": { "name": "#%%\n" @@ -114,19 +104,96 @@ }, "outputs": [], "source": [ + "import numpy as np\n", + "\n", + "from mbrl.planning import Agent\n", + "\n", + "\n", + "class PIDAgent(Agent):\n", + " \"\"\"\n", + " Agent that reacts via an internal set of PID controllers.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " dim: int,\n", + " Kp: np.ndarray,\n", + " Ki: np.ndarray,\n", + " Kd: np.ndarray,\n", + " target: np.ndarray,\n", + " ):\n", + " \"\"\"\n", + " :param dim: dimensionality of state and control signal\n", + " :param P: proportional control coeff\n", + " :param I: integral control coeff\n", + " :param D: derivative control coeff\n", + " :param target: setpoint\n", + " \"\"\"\n", + " super().__init__()\n", + " assert len(Kp) == dim\n", + " assert len(Ki) == dim\n", + " assert len(Kd) == dim\n", + " assert len(target) == dim\n", + "\n", + " self.n_dof = dim\n", + "\n", + " # TODO: add helper functions for setting and using state_mapping\n", + " self.state_mapping = None # can set to run PID on specific variables\n", + "\n", + "\n", + " # TODO: fix dimensionality with P\n", + " self.Kp = Kp #np.tile(P_value, self.n_dof)\n", + " self.Ki = Ki #np.tile(I_value, self.n_dof)\n", + " self.Kd = Kd #np.tile(D_value, self.n_dof)\n", + " self.target = target\n", + " self.prev_error = 0\n", + " self.error = 0\n", + " # self.cum_error = 0\n", + " # self.I_count = 0\n", + "\n", + " def act(self, obs: np.array) -> np.ndarray:\n", + " if len(obs) > self.n_dof:\n", + " obs = obs[:self.n_dof]\n", + " q_des = self.target\n", + " q = obs\n", + "\n", + " self.error = q_des - q\n", + " P_value = self.Kp * self.error\n", + " I_value = 0 # TODO: implement I and D part\n", + " D_value = self.Kd * (self.error - self.prev_error) # + self.D*(qd_des-qd)\n", + " self.prev_error = self.error\n", + " action = P_value + I_value + D_value\n", + " return action\n", + "\n", + " def _get_P(self):\n", + " return self.Kp\n", + "\n", + " def _get_I(self):\n", + " return self.Ki\n", + "\n", + " def _get_D(self):\n", + " return self.Kd\n", + "\n", + " def _get_targets(self):\n", + " return self.target\n", + "\n", + " def get_parameters(self):\n", + " return np.stack((self._get_P(), self._get_I(), self._get_D(), self._get_targets())).flatten()\n", + "\n", + "\n", "def create_pid_agent(action_dim):\n", " P = np.random.rand(action_dim) * 5\n", " I = np.zeros(action_dim)\n", " D = np.random.rand(action_dim)\n", " target = np.random.rand(action_dim) * 2 - 1\n", "\n", - " agent = planning.PIDAgent(dim=action_dim, Kp=P, Ki=I, Kd=D, target=target)\n", + " agent = PIDAgent(dim=action_dim, Kp=P, Ki=I, Kd=D, target=target)\n", " return agent" ] }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -148,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 5, "metadata": { "pycharm": { "name": "#%%\n" @@ -156,9 +223,10 @@ }, "outputs": [], "source": [ - "trial_length = 100\n", - "num_trials = 100\n", - "ensemble_size = 5\n", + "trial_length = 300\n", + "num_trials = 33\n", + "ensemble_size = 1\n", + "# TODO add support for ensembles in sampling (below)\n", "param_shape = (len(agent.get_parameters())+1,)\n", "\n", "# Everything with \"???\" indicates an option with a missing value.\n", @@ -175,7 +243,7 @@ " \"in_size\": param_shape[0]+obs_shape[0], # control params, horizon, state_0\n", " \"out_size\": obs_shape[0], # state time 0+h\n", " \"deterministic\": False,\n", - " \"propagation_method\": \"fixed_model\",\n", + " \"propagation_method\": \"expectation\",\n", " # can also configure activation function for GaussianMLP\n", " \"activation_fn_cfg\": {\n", " \"_target_\": \"torch.nn.LeakyReLU\",\n", @@ -193,10 +261,44 @@ " \"trial_length\": trial_length,\n", " \"num_steps\": num_trials * trial_length,\n", " \"model_batch_size\": 32,\n", - " \"validation_ratio\": 0.05\n", + " \"validation_ratio\": 0.1\n", " }\n", "}\n", - "cfg = omegaconf.OmegaConf.create(cfg_dict)" + "cfg = omegaconf.OmegaConf.create(cfg_dict)\n", + "\n", + "one_step_config_dict = {\n", + " # dynamics model configuration\n", + " \"dynamics_model\": {\n", + " \"_target_\": \"mbrl.models.GaussianMLP\",\n", + " \"device\": device,\n", + " \"num_layers\": 3,\n", + " \"ensemble_size\": ensemble_size,\n", + " \"hid_size\": 200,\n", + " \"in_size\": \"???\",\n", + " \"out_size\": \"???\",\n", + " \"deterministic\": False,\n", + " \"propagation_method\": \"expectation\",\n", + " # can also configure activation function for GaussianMLP\n", + " \"activation_fn_cfg\": {\n", + " \"_target_\": \"torch.nn.LeakyReLU\",\n", + " \"negative_slope\": 0.01\n", + " }\n", + " },\n", + " # options for training the dynamics model\n", + " \"algorithm\": {\n", + " \"learned_rewards\": False,\n", + " \"target_is_delta\": True, \n", + " \"normalize\": True,\n", + " },\n", + " # these are experiment specific options\n", + " \"overrides\": {\n", + " \"trial_length\": trial_length,\n", + " \"num_steps\": num_trials * trial_length,\n", + " \"model_batch_size\": 40,\n", + " \"validation_ratio\": 0.1\n", + " }\n", + "}\n", + "one_step_config = omegaconf.OmegaConf.create(one_step_config_dict)" ] }, { @@ -214,13 +316,22 @@ }, { "cell_type": "code", - "execution_count": 110, + "execution_count": 6, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nato/miniconda3/envs/mbrl-py39/lib/python3.9/site-packages/hydra/utils.py:32: UserWarning: `OmegaConf.is_none()` is deprecated, see https://github.com/omry/omegaconf/issues/547\n", + " if OmegaConf.is_none(config):\n" + ] + } + ], "source": [ "# Create a 1-D dynamics model for this environment\n", "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n" @@ -234,14 +345,19 @@ } }, "source": [ - "# Create a replay buffer\n", + "# Create replay buffers\n", "\n", - "We can create a replay buffer for this environment an configuration using the following method, where `collect_trajectories` is on for easier plotting of results." + "We can create a replay buffer for this environment using an configuration a built-in method, where `collect_trajectories` is on for easier plotting of results.\n", + "\n", + "Please note, we will create three replay buffers because our use-case pushes the limits of mbrl-lib. \n", + "1. `replay_buffer_traj_train` is a replay buffer where will put all the sub-trajectories used to train the trajectory-based model,\n", + "2. `replay_buffer_traj_val` is a replay buffer storing trajectories with control parameters, used for plotting only.\n", + "3. `one_step_replay_buffer` is a replay buffer mirroring other examples in this library. We can use it for training and plotting one-step model results." ] }, { "cell_type": "code", - "execution_count": 111, + "execution_count": 7, "metadata": { "pycharm": { "name": "#%%\n" @@ -250,11 +366,23 @@ "outputs": [], "source": [ "collect_full_trajectories = True\n", - "replay_buffer = common_util.create_replay_buffer(cfg, \n", + "replay_buffer_traj_train = common_util.create_replay_buffer(cfg, \n", + " obs_shape, \n", + " param_shape, \n", + " rng=rng, \n", + " collect_trajectories=False)\n", + "\n", + "replay_buffer_traj_val = common_util.create_replay_buffer(cfg, \n", " obs_shape, \n", " param_shape, \n", " rng=rng, \n", - " collect_trajectories=collect_full_trajectories)" + " collect_trajectories=True)\n", + "\n", + "one_step_replay_buffer = common_util.create_replay_buffer(one_step_config, \n", + " obs_shape, \n", + " act_shape, \n", + " rng=rng, \n", + " collect_trajectories=True)" ] }, { @@ -270,7 +398,7 @@ }, { "cell_type": "code", - "execution_count": 112, + "execution_count": 8, "metadata": { "pycharm": { "name": "#%%\n" @@ -280,8 +408,6 @@ "source": [ "step = 0\n", "trial = 0\n", - "total_rewards = []\n", - "callback = None\n", "while trial < num_trials:\n", " traj = []\n", " obs = env.reset()\n", @@ -290,35 +416,46 @@ " agent = create_pid_agent(env.action_space.shape[0])\n", " agent.reset()\n", " done = False\n", - " total_reward = 0.0\n", " while not done:\n", " action = agent.act(obs)\n", " next_obs, reward, done, info = env.step(action)\n", - " if callback:\n", - " callback((obs, action, next_obs, reward, done))\n", + " \n", + " # ADD ONE-STEP DATA\n", + " one_step_replay_buffer.add(obs, action, next_obs, reward, done)\n", "\n", + " # use a separate replay buffer for evaluating trajectories later (that can store trajectory info)\n", + " replay_buffer_traj_val.add(obs, \n", + " np.concatenate((agent.get_parameters(), np.array([1,]))),\n", + " next_obs,\n", + " reward,\n", + " done)\n", + "\n", + " \n", " obs = next_obs\n", " traj.append((obs, step))\n", " \n", + " # ADD TRAJ-BASED DATA\n", " # if not the first step, iterate through memory and append each sub-trajectory\n", " if len(traj[:-1]) > 0:\n", " for obs_t, t in traj[:-1]:\n", "# print(f\"adding: mem time {t}, current time {step}, horizon {step-t}\")\n", - " replay_buffer.add(obs_t, np.concatenate((agent.get_parameters(), np.array([step-t,]))), next_obs, reward, done)\n", + " replay_buffer_traj_train.add(obs_t, # obs is state_t\n", + " # action is control params + hor\n", + " np.concatenate((agent.get_parameters(), np.array([step-t,]))), \n", + " next_obs, # next state is state_t+hor\n", + " reward, # reward not used\n", + " done # done not used\n", + " )\n", + " \n", "\n", - " total_reward += reward\n", " step += 1\n", " \n", - " if not collect_full_trajectories and step == steps_or_trials_to_collect:\n", - " total_rewards.append(total_reward)\n", - " break\n", " if trial_length and step % trial_length == 0:\n", - " if collect_full_trajectories and not done and replay_buffer is not None:\n", - " replay_buffer.close_trajectory()\n", + " if collect_full_trajectories and not done:\n", + " replay_buffer_traj_val.close_trajectory()\n", + " one_step_replay_buffer.close_trajectory()\n", " break\n", - " trial += 1\n", - " total_rewards.append(total_reward)\n", - " \n" + " trial += 1 \n" ] }, { @@ -341,7 +478,7 @@ }, { "cell_type": "code", - "execution_count": 113, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -357,12 +494,17 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "train_dataset, val_dataset = common_util.get_basic_buffer_iterators(\n", - " replay_buffer, cfg[\"overrides\"][\"model_batch_size\"], .1, ensemble_size=ensemble_size, shuffle_each_epoch=True)\n" + " replay_buffer_traj_train, \n", + " cfg.overrides.model_batch_size, \n", + " cfg.overrides.validation_ratio, \n", + " ensemble_size=ensemble_size, \n", + " shuffle_each_epoch=True\n", + ")" ] }, { @@ -374,7 +516,7 @@ }, { "cell_type": "code", - "execution_count": 115, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -397,12 +539,12 @@ }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -424,12 +566,140 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prediction Accuracy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize an one-step model" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a 1-D dynamics model for this environment\n", + "one_step_model = common_util.create_one_dim_tr_model(one_step_config, obs_shape, act_shape)\n", + "\n", + "# This functions allows the model to evaluate the true rewards given an observation \n", + "reward_fn = reward_fns.cartpole\n", + "# This function allows the model to know if an observation should make the episode end\n", + "term_fn = termination_fns.cartpole\n", + "\n", + "# Create a gym-like environment to encapsulate the model\n", + "one_step_model_env = models.ModelEnv(env, one_step_model, term_fn, reward_fn, generator=generator)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Train the one-step model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "one_step_model_trainer = models.ModelTrainer(one_step_model, optim_lr=1e-4, weight_decay=5e-5)\n", + "one_step_train_dataset, one_step_val_dataset = common_util.get_basic_buffer_iterators(\n", + " one_step_replay_buffer, # \n", + " batch_size=cfg.overrides.model_batch_size,\n", + " val_ratio=cfg.overrides.validation_ratio,\n", + " ensemble_size=ensemble_size, \n", + " shuffle_each_epoch=True\n", + ")\n", + "train_losses, val_losses = one_step_model_trainer.train(one_step_train_dataset, one_step_val_dataset, \n", + " num_epochs=50, patience=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sample trajectories for evaluation, predict trajectories, and compute MSE across states." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "num_traj = 10\n", + "eval_data = []\n", + "one_step = []\n", + "traj_based = []\n", + "for i in range(num_traj):\n", + " traj = one_step_replay_buffer.sample_trajectory()\n", + " traj_with_params = replay_buffer_traj_val.sample_trajectory()\n", + " eval_data.append(traj)\n", + " \n", + " ### rollout one-step model ###\n", + " states, _, _ = common_util.rollout_model_env(one_step_model_env, \n", + " initial_obs=traj.obs[0],\n", + " plan=traj.act)\n", + " \n", + " true_states = traj.obs\n", + " one_step_pred_states = states[:-1].squeeze()\n", + " one_step_errors = np.mean((true_states - one_step_pred_states)**2, axis=1)\n", + " one_step.append(one_step_errors)\n", + " \n", + " ### rollout trajectory-based model ###\n", + " \n", + " # set time indices\n", + " traj_with_params.act[:,-1] = np.arange(0,len(traj_with_params))+1\n", + "\n", + " # construct batch\n", + " x_data = np.concatenate((traj_with_params.obs,traj_with_params.act), axis=1)\n", + " x_tensor = torch.from_numpy(x_data).float().to(device)\n", + " x_tensor = dynamics_model.input_normalizer.normalize(x_tensor)\n", + "\n", + " with torch.no_grad():\n", + " states_pred, _ = dynamics_model(x_tensor)\n", + " \n", + " traj_based_errors = np.mean((true_states - states_pred.numpy())**2, axis=1)\n", + " traj_based.append(traj_based_errors)\n", + " \n", + "cumulative_errors_os = np.stack(one_step)\n", + "one_step_median = np.median(cumulative_errors_os,axis=0)\n", + "\n", + "cumulative_errors_tb = np.stack(traj_based)\n", + "traj_based_median = np.median(cumulative_errors_tb,axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## MSE Along Predicted Trajectories" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "fig, ax = plt.subplots(2, 1, figsize=(16, 8))\n", + "ax[0].plot(train_losses)\n", + "ax[0].set_xlabel(\"epoch\")\n", + "ax[0].set_ylabel(\"train loss (gaussian nll)\")\n", + "ax[1].plot(val_losses)\n", + "ax[1].set_xlabel(\"epoch\")\n", + "ax[1].set_ylabel(\"val loss (mse)\")\n", + "plt.show()" + ] } ], "metadata": { From 2818f461f2c20346c6292d4ed6f88fff07650bf7 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Mon, 15 Aug 2022 13:57:07 -0700 Subject: [PATCH 06/24] add ensemble support to notebook --- notebooks/traj_based_model.ipynb | 347 +++++++++++++++++++++++-------- 1 file changed, 263 insertions(+), 84 deletions(-) diff --git a/notebooks/traj_based_model.ipynb b/notebooks/traj_based_model.ipynb index 0e450de0..942d6df3 100644 --- a/notebooks/traj_based_model.ipynb +++ b/notebooks/traj_based_model.ipynb @@ -15,14 +15,23 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 270, "metadata": { "pycharm": { "is_executing": true, "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "from IPython import display\n", "%matplotlib inline\n", @@ -63,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 271, "metadata": { "pycharm": { "name": "#%%\n" @@ -74,7 +83,6 @@ "seed = 0\n", "env = reacher_env.Reacher3DEnv()\n", "env.seed(seed)\n", - "rng = np.random.default_rng(seed=0)\n", "generator = torch.Generator(device=device)\n", "generator.manual_seed(seed)\n", "obs_shape = env.observation_space.shape\n", @@ -96,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 272, "metadata": { "pycharm": { "name": "#%%\n" @@ -140,16 +148,12 @@ " # TODO: add helper functions for setting and using state_mapping\n", " self.state_mapping = None # can set to run PID on specific variables\n", "\n", - "\n", - " # TODO: fix dimensionality with P\n", - " self.Kp = Kp #np.tile(P_value, self.n_dof)\n", - " self.Ki = Ki #np.tile(I_value, self.n_dof)\n", - " self.Kd = Kd #np.tile(D_value, self.n_dof)\n", + " self.Kp = Kp \n", + " self.Ki = Ki \n", + " self.Kd = Kd \n", " self.target = target\n", " self.prev_error = 0\n", " self.error = 0\n", - " # self.cum_error = 0\n", - " # self.I_count = 0\n", "\n", " def act(self, obs: np.array) -> np.ndarray:\n", " if len(obs) > self.n_dof:\n", @@ -160,7 +164,7 @@ " self.error = q_des - q\n", " P_value = self.Kp * self.error\n", " I_value = 0 # TODO: implement I and D part\n", - " D_value = self.Kd * (self.error - self.prev_error) # + self.D*(qd_des-qd)\n", + " D_value = self.Kd * (self.error - self.prev_error) \n", " self.prev_error = self.error\n", " action = P_value + I_value + D_value\n", " return action\n", @@ -193,7 +197,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 273, "metadata": {}, "outputs": [], "source": [ @@ -215,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 274, "metadata": { "pycharm": { "name": "#%%\n" @@ -223,9 +227,9 @@ }, "outputs": [], "source": [ - "trial_length = 300\n", - "num_trials = 33\n", - "ensemble_size = 1\n", + "trial_length = 500\n", + "num_trials = 10\n", + "ensemble_size = 5\n", "# TODO add support for ensembles in sampling (below)\n", "param_shape = (len(agent.get_parameters())+1,)\n", "\n", @@ -243,7 +247,7 @@ " \"in_size\": param_shape[0]+obs_shape[0], # control params, horizon, state_0\n", " \"out_size\": obs_shape[0], # state time 0+h\n", " \"deterministic\": False,\n", - " \"propagation_method\": \"expectation\",\n", + " \"propagation_method\": \"random_model\",# NOTE not currently used (predicted in one forward pass, no re-samplign)\n", " # can also configure activation function for GaussianMLP\n", " \"activation_fn_cfg\": {\n", " \"_target_\": \"torch.nn.LeakyReLU\",\n", @@ -260,7 +264,7 @@ " \"overrides\": {\n", " \"trial_length\": trial_length,\n", " \"num_steps\": num_trials * trial_length,\n", - " \"model_batch_size\": 32,\n", + " \"model_batch_size\": 256, # traj based model uses larger batch sizes\n", " \"validation_ratio\": 0.1\n", " }\n", "}\n", @@ -277,6 +281,7 @@ " \"in_size\": \"???\",\n", " \"out_size\": \"???\",\n", " \"deterministic\": False,\n", + "# \"propagation_method\": \"random_model\",\n", " \"propagation_method\": \"expectation\",\n", " # can also configure activation function for GaussianMLP\n", " \"activation_fn_cfg\": {\n", @@ -316,22 +321,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 275, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/nato/miniconda3/envs/mbrl-py39/lib/python3.9/site-packages/hydra/utils.py:32: UserWarning: `OmegaConf.is_none()` is deprecated, see https://github.com/omry/omegaconf/issues/547\n", - " if OmegaConf.is_none(config):\n" - ] - } - ], + "outputs": [], "source": [ "# Create a 1-D dynamics model for this environment\n", "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n" @@ -357,7 +353,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 276, "metadata": { "pycharm": { "name": "#%%\n" @@ -369,19 +365,19 @@ "replay_buffer_traj_train = common_util.create_replay_buffer(cfg, \n", " obs_shape, \n", " param_shape, \n", - " rng=rng, \n", + " rng=np.random.default_rng(seed=0), \n", " collect_trajectories=False)\n", "\n", "replay_buffer_traj_val = common_util.create_replay_buffer(cfg, \n", " obs_shape, \n", " param_shape, \n", - " rng=rng, \n", + " rng=np.random.default_rng(seed=0), \n", " collect_trajectories=True)\n", "\n", "one_step_replay_buffer = common_util.create_replay_buffer(one_step_config, \n", " obs_shape, \n", " act_shape, \n", - " rng=rng, \n", + " rng=np.random.default_rng(seed=0), \n", " collect_trajectories=True)" ] }, @@ -398,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 277, "metadata": { "pycharm": { "name": "#%%\n" @@ -406,9 +402,9 @@ }, "outputs": [], "source": [ - "step = 0\n", "trial = 0\n", "while trial < num_trials:\n", + " step = 0\n", " traj = []\n", " obs = env.reset()\n", " \n", @@ -455,6 +451,8 @@ " replay_buffer_traj_val.close_trajectory()\n", " one_step_replay_buffer.close_trajectory()\n", " break\n", + " \n", + "# print(f\"Trajectory ran of length {step}\")\n", " trial += 1 \n" ] }, @@ -478,7 +476,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 278, "metadata": {}, "outputs": [], "source": [ @@ -494,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 279, "metadata": {}, "outputs": [], "source": [ @@ -516,7 +514,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 280, "metadata": {}, "outputs": [], "source": [ @@ -534,17 +532,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Model Loss" + "## Traj-based Model Loss" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 281, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -582,7 +580,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 282, "metadata": {}, "outputs": [], "source": [ @@ -607,7 +605,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 283, "metadata": {}, "outputs": [], "source": [ @@ -619,87 +617,268 @@ " ensemble_size=ensemble_size, \n", " shuffle_each_epoch=True\n", ")\n", - "train_losses, val_losses = one_step_model_trainer.train(one_step_train_dataset, one_step_val_dataset, \n", + "one_step_train_losses, one_step_val_losses = one_step_model_trainer.train(one_step_train_dataset, one_step_val_dataset, \n", " num_epochs=50, patience=100)" ] }, + { + "cell_type": "code", + "execution_count": 284, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2, 1, figsize=(16, 8))\n", + "ax[0].plot(one_step_train_losses)\n", + "ax[0].set_xlabel(\"epoch\")\n", + "ax[0].set_ylabel(\"train loss (gaussian nll)\")\n", + "ax[1].plot(one_step_val_losses)\n", + "ax[1].set_xlabel(\"epoch\")\n", + "ax[1].set_ylabel(\"val loss (mse)\")\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Sample trajectories for evaluation, predict trajectories, and compute MSE across states." + "Sample trajectories for evaluation, predict trajectories, and compute MSE across states (without batching, does not work for ensemble)." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 285, "metadata": {}, "outputs": [], "source": [ - "num_traj = 10\n", - "eval_data = []\n", + "# num_traj = 10\n", + "# eval_data = []\n", + "# one_step = []\n", + "# traj_based = []\n", + "# for i in range(num_traj):\n", + "# traj = one_step_replay_buffer.sample_trajectory()\n", + "# traj_with_params = replay_buffer_traj_val.sample_trajectory()\n", + "# eval_data.append(traj)\n", + " \n", + "# ### rollout one-step model ###\n", + "# states, _, _ = common_util.rollout_model_env(one_step_model_env, \n", + "# initial_obs=traj.obs[0],\n", + "# plan=traj.act)\n", + " \n", + "# true_states = traj.obs\n", + "# one_step_pred_states = states[:-1].squeeze()\n", + "# one_step_errors = np.mean((true_states - one_step_pred_states)**2, axis=1)\n", + "# one_step.append(one_step_errors)\n", + " \n", + "# ### rollout trajectory-based model ###\n", + " \n", + "# # set time indices\n", + "# traj_with_params.act[:,-1] = np.arange(0,len(traj_with_params))+1\n", + "\n", + "# # construct batch\n", + "# x_data = np.concatenate((traj_with_params.obs,traj_with_params.act), axis=1)\n", + "# x_tensor = torch.from_numpy(x_data).float().to(device)\n", + "# x_tensor = dynamics_model.input_normalizer.normalize(x_tensor)\n", + "\n", + "# with torch.no_grad():\n", + "# states_pred, _ = dynamics_model(x_tensor)\n", + " \n", + "# traj_based_errors = np.mean((true_states - states_pred.numpy())**2, axis=1)\n", + "# traj_based.append(traj_based_errors)\n", + " \n", + "# cumulative_errors_os = np.stack(one_step)\n", + "# one_step_median = np.median(cumulative_errors_os,axis=0)\n", + "\n", + "# cumulative_errors_tb = np.stack(traj_based)\n", + "# traj_based_median = np.median(cumulative_errors_tb,axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Predict trajectories with ensembles, needed correct batch size." + ] + }, + { + "cell_type": "code", + "execution_count": 286, + "metadata": {}, + "outputs": [], + "source": [ + "num_traj_eval = num_trials\n", + "\n", + "# round trajectories to multiple of ensemble size for batching:\n", + "num_traj = int(ensemble_size * np.floor(num_traj_eval/ensemble_size))\n", + "eval_data_obs = []\n", + "eval_data_act = []\n", + "eval_traj_obs = []\n", + "eval_traj_param = []\n", "one_step = []\n", "traj_based = []\n", "for i in range(num_traj):\n", + " \n", + " # base trajectory for computing accuracy\n", " traj = one_step_replay_buffer.sample_trajectory()\n", - " traj_with_params = replay_buffer_traj_val.sample_trajectory()\n", - " eval_data.append(traj)\n", " \n", - " ### rollout one-step model ###\n", - " states, _, _ = common_util.rollout_model_env(one_step_model_env, \n", - " initial_obs=traj.obs[0],\n", - " plan=traj.act)\n", + " # one-step data\n", + " eval_data_obs.append(traj.obs)\n", + " eval_data_act.append(traj.act)\n", " \n", - " true_states = traj.obs\n", - " one_step_pred_states = states[:-1].squeeze()\n", - " one_step_errors = np.mean((true_states - one_step_pred_states)**2, axis=1)\n", - " one_step.append(one_step_errors)\n", + " # traj-based data\n", + " traj_with_params = replay_buffer_traj_val.sample_trajectory()\n", + " traj_with_params.act[:,-1] = np.arange(0,len(traj_with_params))+1\n", + " eval_traj_obs.append(traj.obs)\n", + " eval_traj_param.append(traj_with_params.act)\n", + "\n", " \n", - " ### rollout trajectory-based model ###\n", + "### rollout one-step model in batch of trajectories ###\n", + "states, _, _ = common_util.rollout_model_env(one_step_model_env, \n", + " initial_obs=np.stack([o[0] for o in eval_data_obs],axis=0),\n", + " plan=np.stack(eval_data_act, axis=1))\n", + "\n", + "true_states = np.stack(eval_data_obs)\n", + "one_step_pred_states = np.swapaxes(states[:-1].squeeze(),0,1)\n", + "one_step_errors = np.mean((true_states - one_step_pred_states)**2, axis=-1)\n", + "one_step.append(one_step_errors)\n", " \n", - " # set time indices\n", - " traj_with_params.act[:,-1] = np.arange(0,len(traj_with_params))+1\n", + "### rollout trajectory-based model in batch ###\n", "\n", - " # construct batch\n", - " x_data = np.concatenate((traj_with_params.obs,traj_with_params.act), axis=1)\n", - " x_tensor = torch.from_numpy(x_data).float().to(device)\n", - " x_tensor = dynamics_model.input_normalizer.normalize(x_tensor)\n", + "# construct batch\n", + "x_data = np.concatenate((traj_with_params.obs,traj_with_params.act), axis=1)\n", "\n", - " with torch.no_grad():\n", - " states_pred, _ = dynamics_model(x_tensor)\n", - " \n", - " traj_based_errors = np.mean((true_states - states_pred.numpy())**2, axis=1)\n", - " traj_based.append(traj_based_errors)\n", + "obs_stack = np.stack([o[0] for o in eval_traj_obs])\n", + "param_stack = np.stack(eval_traj_param)\n", + "\n", + "param_dim = np.shape(param_stack)[-1]\n", + "obs_dim = np.shape(obs_stack)[-1]\n", + "param_expand = param_stack.reshape(-1,param_dim)\n", + "obs_expand = np.repeat(obs_stack[:, np.newaxis, :], trial_length, axis=1).reshape(-1,obs_dim)\n", + "\n", + "x_data = np.concatenate((obs_expand,param_expand), axis=1)\n", + "x_tensor = torch.from_numpy(x_data).float().to(device)\n", + "x_tensor = dynamics_model.input_normalizer.normalize(x_tensor)\n", + "\n", + "with torch.no_grad():\n", + " states_pred, _ = dynamics_model(x_tensor)\n", + "\n", + "true_states = np.stack(eval_traj_obs)\n", + "states_pred = states_pred.numpy().reshape(num_traj, trial_length, -1)\n", + "traj_based_errors = np.mean((true_states - states_pred)**2, axis=-1)\n", + "traj_based.append(traj_based_errors)\n", " \n", - "cumulative_errors_os = np.stack(one_step)\n", + "cumulative_errors_os = np.stack(one_step).squeeze()\n", "one_step_median = np.median(cumulative_errors_os,axis=0)\n", "\n", - "cumulative_errors_tb = np.stack(traj_based)\n", + "cumulative_errors_tb = np.stack(traj_based).squeeze()\n", "traj_based_median = np.median(cumulative_errors_tb,axis=0)" ] }, + { + "cell_type": "code", + "execution_count": 287, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5000, 29)" + ] + }, + "execution_count": 287, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "param_dim = np.shape(param_stack)[-1]\n", + "obs_dim = np.shape(obs_stack)[-1]\n", + "param_stack =param_stack.reshape(-1,param_dim).shape\n", + "obs_expand = np.repeat(obs_stack[:, np.newaxis, :], trial_length, axis=1).reshape(-1,obs_dim)\n", + "\n", + "obs_expand.shape\n", + "obs_stack\n", + "param_stack\n", + "# param_stack.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 288, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10, 500)" + ] + }, + "execution_count": 288, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "states_pred.shape\n", + "true_states.shape\n", + "((true_states - states_pred)**2).shape\n", + "one_step_pred_states.shape\n", + "traj_based_errors.shape" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## MSE Along Predicted Trajectories" + "## Trajectory-based vs One-step" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 289, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "fig, ax = plt.subplots(2, 1, figsize=(16, 8))\n", - "ax[0].plot(train_losses)\n", - "ax[0].set_xlabel(\"epoch\")\n", - "ax[0].set_ylabel(\"train loss (gaussian nll)\")\n", - "ax[1].plot(val_losses)\n", - "ax[1].set_xlabel(\"epoch\")\n", - "ax[1].set_ylabel(\"val loss (mse)\")\n", + "fig, ax = plt.subplots(1, 1, figsize=(12, 8))\n", + "ax.plot(one_step_median, label=\"one-step\")\n", + "ax.plot(traj_based_median, label=\"traj-based\")\n", + "ax.set_xlabel(\"Predictive Horizon\")\n", + "ax.set_ylabel(\"Prediction Error (MSE)\")\n", + "ax.legend()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 85f3a1646fb1777626e5958b376334dc2e19f5c3 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Mon, 15 Aug 2022 16:51:27 -0700 Subject: [PATCH 07/24] substantially clean notebook, add text --- notebooks/traj_based_model.ipynb | 456 +++++++++++++++++-------------- 1 file changed, 251 insertions(+), 205 deletions(-) diff --git a/notebooks/traj_based_model.ipynb b/notebooks/traj_based_model.ipynb index 942d6df3..d06ef9a7 100644 --- a/notebooks/traj_based_model.ipynb +++ b/notebooks/traj_based_model.ipynb @@ -10,12 +10,45 @@ "source": [ "# Preview\n", "\n", - "In this example, we are going to use our toolbox to train and evaluate the [Trajectory-based Dynamics Model](https://arxiv.org/abs/2012.09156) in the reacher environment. Note that the reacher environment in this repository is slightly different than the one used in that paper!" + "In this example, we are going to use our toolbox to train and evaluate the [Trajectory-based Dynamics Model](https://arxiv.org/abs/2012.09156) in the reacher environment. Note that the reacher environment in this repository is slightly different than the one used in that paper ([link](https://github.com/natolambert/continuousprediction/blob/master/envs/reacher3d.py))!\n", + "\n", + "## Conceptual Overview\n", + "\n", + "The *Trajectory-based Model* is a alternate type of dynamics model designed for applicatons of model-based reinforcement learning (MBRL) where one would prioritize long-term prediction accuracy (and overcome the well-known [compounding error](http://arxiv.org/abs/2203.09637). This is accomplished by moving away from the standard one-step parametrization of a dynamics model in MBRL.\n", + "\n", + "As a review, state-predictions are often done in a **one-step** manner in MBRL:\n", + "\n", + "$$s_{t+1} = f_\\theta(s_t,a_t),$$\n", + "\n", + "where $s_t$ is the state of the environment, $a_t$ is the action taken by the agent, and $f_\\theta(\\cdot)$ is a learned model of the world. \n", + "A common issue is that the long-term future is predicted with recursive function calls, which is known to lead to compounding error:\n", + "\n", + "$$s{t+h}=f_\\theta(\\ldots f_\\theta(f_\\theta(s_t,a_t),a_{t+1}) \\ldots , a_{t+h}).$$\n", + "\n", + "As an alternate, the trajectory-based model predicts a direct time horizon in the future $h$. In order to avoid needing to pass in every action to the model, it takes in the control parameters that would define the policy $a_t = \\pi_\\phi()$, understanding that the sequence of actions are often highly correlated. This yields a new formulation as follows:\n", + "\n", + "$$s_{t+h} = f_\\theta(s_t, h, \\phi).$$\n", + "\n", + "This model confers a series of benefits on top of long-term prediction accuracy, including stable uncertainty propagation, fast inference (no more recusion -- just pass in a vector of time), and better sample efficiency.\n", + "\n", + "In this notebook, we show you how the model can be trained almost entirely on built in MBRL-Lib code!\n", + "\n", + "-----" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup\n", + "In this section we import the needed code from MBRL-Lib, create the environment, and configure our experiment.\n", + "\n", + "## Imports" ] }, { "cell_type": "code", - "execution_count": 270, + "execution_count": 339, "metadata": { "pycharm": { "is_executing": true, @@ -42,10 +75,8 @@ "import omegaconf\n", "\n", "import mbrl.env.pets_reacher as reacher_env\n", - "import mbrl.env.cartpole_continuous as cartpole_env\n", - "import mbrl.env.reward_fns as reward_fns\n", - "import mbrl.env.termination_fns as termination_fns\n", "import mbrl.models as models\n", + "from mbrl.planning import Agent\n", "import mbrl.util.common as common_util\n", "\n", "\n", @@ -65,14 +96,14 @@ } }, "source": [ - "# Creating the environment\n", + "## Creating the environment\n", "\n", "First we instantiate the environment." ] }, { "cell_type": "code", - "execution_count": 271, + "execution_count": 340, "metadata": { "pycharm": { "name": "#%%\n" @@ -81,12 +112,20 @@ "outputs": [], "source": [ "seed = 0\n", + "\n", "env = reacher_env.Reacher3DEnv()\n", "env.seed(seed)\n", + "\n", + "# experiment constants\n", + "trial_length = 500\n", + "num_trials = 10\n", + "\n", + "# constants and random number generation\n", "generator = torch.Generator(device=device)\n", "generator.manual_seed(seed)\n", + "\n", "obs_shape = env.observation_space.shape\n", - "act_shape = env.action_space.shape\n" + "act_shape = env.action_space.shape" ] }, { @@ -97,14 +136,14 @@ } }, "source": [ - "# PID Agent\n", + "## PID Agent\n", "\n", - "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper." + "In this section we add a basic PID agent to the library to use as the control parameters for prediction with the new model." ] }, { "cell_type": "code", - "execution_count": 272, + "execution_count": 341, "metadata": { "pycharm": { "name": "#%%\n" @@ -112,11 +151,6 @@ }, "outputs": [], "source": [ - "import numpy as np\n", - "\n", - "from mbrl.planning import Agent\n", - "\n", - "\n", "class PIDAgent(Agent):\n", " \"\"\"\n", " Agent that reacts via an internal set of PID controllers.\n", @@ -130,13 +164,6 @@ " Kd: np.ndarray,\n", " target: np.ndarray,\n", " ):\n", - " \"\"\"\n", - " :param dim: dimensionality of state and control signal\n", - " :param P: proportional control coeff\n", - " :param I: integral control coeff\n", - " :param D: derivative control coeff\n", - " :param target: setpoint\n", - " \"\"\"\n", " super().__init__()\n", " assert len(Kp) == dim\n", " assert len(Ki) == dim\n", @@ -186,24 +213,50 @@ "\n", "\n", "def create_pid_agent(action_dim):\n", + " # default is to create a PD controller on the joints of the reacher robot\n", " P = np.random.rand(action_dim) * 5\n", " I = np.zeros(action_dim)\n", " D = np.random.rand(action_dim)\n", + " \n", + " # sample joint angle targets for the end-affector of the reacher\n", " target = np.random.rand(action_dim) * 2 - 1\n", "\n", " agent = PIDAgent(dim=action_dim, Kp=P, Ki=I, Kd=D, target=target)\n", " return agent" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can create an agent by just loading information about the action space from the environment!" + ] + }, { "cell_type": "code", - "execution_count": 273, + "execution_count": 342, "metadata": {}, "outputs": [], "source": [ "agent = create_pid_agent(env.action_space.shape[0])" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The agent determines the dimension of the input for trajectory-based model." + ] + }, + { + "cell_type": "code", + "execution_count": 343, + "metadata": {}, + "outputs": [], + "source": [ + "param_shape = (len(agent.get_parameters())+1,)" + ] + }, { "cell_type": "markdown", "metadata": { @@ -212,14 +265,26 @@ } }, "source": [ - "# Hydra configuration\n", + "## Hydra configurations\n", "\n", "MBRL-Lib uses [Hydra](https://github.com/facebookresearch/hydra) to manage configurations. For the purpose of this example, you can think of the configuration object as a dictionary with key/value pairs--and equivalent attributes--that specify the model and algorithmic options. Our toolbox expects the configuration object to be organized as follows:" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Trajectory-based model config\n", + "We define the trajectory-based model a little differently than the other examples in this library! You can see we are mapping the parameters in where the actions would normally go in the model. \n", + "Additionally, the `\"propagation_method\"` argument is redundant because we can predict entire trajectories with one forward pass!\n", + "The trajectory-based model tends to like bigger batch sizes than one-step models.\n", + "\n", + "Finally, there are some constants that we keep constant with the one-step model too!" + ] + }, { "cell_type": "code", - "execution_count": 274, + "execution_count": 344, "metadata": { "pycharm": { "name": "#%%\n" @@ -227,11 +292,10 @@ }, "outputs": [], "source": [ - "trial_length = 500\n", - "num_trials = 10\n", "ensemble_size = 5\n", - "# TODO add support for ensembles in sampling (below)\n", - "param_shape = (len(agent.get_parameters())+1,)\n", + "num_layers = 3\n", + "hid_size = 200\n", + "deterministic = False\n", "\n", "# Everything with \"???\" indicates an option with a missing value.\n", "# Our utility functions will fill in these details using the \n", @@ -241,12 +305,12 @@ " \"dynamics_model\": {\n", " \"_target_\": \"mbrl.models.GaussianMLP\",\n", " \"device\": device,\n", - " \"num_layers\": 3,\n", + " \"num_layers\": num_layers,\n", " \"ensemble_size\": ensemble_size,\n", - " \"hid_size\": 200,\n", + " \"hid_size\": hid_size,\n", " \"in_size\": param_shape[0]+obs_shape[0], # control params, horizon, state_0\n", " \"out_size\": obs_shape[0], # state time 0+h\n", - " \"deterministic\": False,\n", + " \"deterministic\": deterministic,\n", " \"propagation_method\": \"random_model\",# NOTE not currently used (predicted in one forward pass, no re-samplign)\n", " # can also configure activation function for GaussianMLP\n", " \"activation_fn_cfg\": {\n", @@ -268,19 +332,34 @@ " \"validation_ratio\": 0.1\n", " }\n", "}\n", - "cfg = omegaconf.OmegaConf.create(cfg_dict)\n", - "\n", + "cfg = omegaconf.OmegaConf.create(cfg_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### One-step model config\n", + "We train a one-step model as a baseline against the trajectory-based model!" + ] + }, + { + "cell_type": "code", + "execution_count": 345, + "metadata": {}, + "outputs": [], + "source": [ "one_step_config_dict = {\n", " # dynamics model configuration\n", " \"dynamics_model\": {\n", " \"_target_\": \"mbrl.models.GaussianMLP\",\n", " \"device\": device,\n", - " \"num_layers\": 3,\n", + " \"num_layers\": num_layers,\n", " \"ensemble_size\": ensemble_size,\n", - " \"hid_size\": 200,\n", + " \"hid_size\": hid_size,\n", " \"in_size\": \"???\",\n", " \"out_size\": \"???\",\n", - " \"deterministic\": False,\n", + " \"deterministic\": deterministic,\n", "# \"propagation_method\": \"random_model\",\n", " \"propagation_method\": \"expectation\",\n", " # can also configure activation function for GaussianMLP\n", @@ -303,9 +382,24 @@ " \"validation_ratio\": 0.1\n", " }\n", "}\n", + "\n", "one_step_config = omegaconf.OmegaConf.create(one_step_config_dict)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "----" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Experimentation" + ] + }, { "cell_type": "markdown", "metadata": { @@ -314,23 +408,32 @@ } }, "source": [ - "# Creating a dynamics model\n", + "## Creating a dynamics model\n", "\n", "Given the configuration above, the following two lines of code create a wrapper for 1-D transition reward models, and a gym-like environment that wraps it, which we can use for simulating the real environment. The 1-D model wrapper takes care of creating input/output data tensors to the underlying NN model (by concatenating observations, actions and rewards appropriately), normalizing the input data to the model, and other data processing tasks (e.g., converting observation targets to deltas with respect to the input observation)." ] }, { "cell_type": "code", - "execution_count": 275, + "execution_count": 346, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nato/miniconda3/envs/mbrl-py39/lib/python3.9/site-packages/hydra/utils.py:32: UserWarning: `OmegaConf.is_none()` is deprecated, see https://github.com/omry/omegaconf/issues/547\n", + " if OmegaConf.is_none(config):\n" + ] + } + ], "source": [ "# Create a 1-D dynamics model for this environment\n", - "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n" + "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)" ] }, { @@ -341,7 +444,7 @@ } }, "source": [ - "# Create replay buffers\n", + "## Create replay buffers\n", "\n", "We can create a replay buffer for this environment using an configuration a built-in method, where `collect_trajectories` is on for easier plotting of results.\n", "\n", @@ -353,7 +456,7 @@ }, { "cell_type": "code", - "execution_count": 276, + "execution_count": 347, "metadata": { "pycharm": { "name": "#%%\n" @@ -389,12 +492,13 @@ } }, "source": [ + "## Generate and store data\n", "We can now populate the replay buffer with random trajectories of a desired length, using a modified function based on `util.rollout_agent_trajectories`. The changes are that the tuples are only added to the buffer at the end of the trajectory to add every sub-trajectory for supervised learning." ] }, { "cell_type": "code", - "execution_count": 277, + "execution_count": 348, "metadata": { "pycharm": { "name": "#%%\n" @@ -434,16 +538,14 @@ " # if not the first step, iterate through memory and append each sub-trajectory\n", " if len(traj[:-1]) > 0:\n", " for obs_t, t in traj[:-1]:\n", - "# print(f\"adding: mem time {t}, current time {step}, horizon {step-t}\")\n", " replay_buffer_traj_train.add(obs_t, # obs is state_t\n", - " # action is control params + hor\n", + " \n", + " # action is control params + hor\n", " np.concatenate((agent.get_parameters(), np.array([step-t,]))), \n", " next_obs, # next state is state_t+hor\n", " reward, # reward not used\n", " done # done not used\n", " )\n", - " \n", - "\n", " step += 1\n", " \n", " if trial_length and step % trial_length == 0:\n", @@ -452,7 +554,6 @@ " one_step_replay_buffer.close_trajectory()\n", " break\n", " \n", - "# print(f\"Trajectory ran of length {step}\")\n", " trial += 1 \n" ] }, @@ -464,7 +565,7 @@ } }, "source": [ - "# Training the Trajectory Based Model" + "## Training the Trajectory Based Model" ] }, { @@ -476,7 +577,7 @@ }, { "cell_type": "code", - "execution_count": 278, + "execution_count": 349, "metadata": {}, "outputs": [], "source": [ @@ -492,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 279, + "execution_count": 350, "metadata": {}, "outputs": [], "source": [ @@ -514,7 +615,7 @@ }, { "cell_type": "code", - "execution_count": 280, + "execution_count": 351, "metadata": {}, "outputs": [], "source": [ @@ -537,12 +638,12 @@ }, { "cell_type": "code", - "execution_count": 281, + "execution_count": 352, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9IAAAHqCAYAAADoJXY3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAACVHklEQVR4nOzdd3jV5fnH8fedPcggBAh7bwRURFDcCk6se8+6Wu2v2tpWW7Vqqx222mrdW+uq1rq3KDhABNl777ACCZCd3L8/zgFDTCCBMzI+r+vKdc75ruc+9DTxc57n+zzm7oiIiIiIiIhI3cREuwARERERERGRxkRBWkRERERERKQeFKRFRERERERE6kFBWkRERERERKQeFKRFRERERERE6kFBWkRERERERKQe4qJdQGOWnZ3tXbt2jXYZIiIiIiIiEgZTpkzZ6O6tq29v9kHazDoB9wHHAQZ8Alzv7iv2dG7Xrl2ZPHlymCsUERERERGRaDCz5TVtb9ZDu80sBRgL9AUuAS4CegGfmVlqNGsTERERERGRhqm590hfCXQH+rj7IgAzmwEsBK4G7o1ibSIiIiIiItIANeseaWAMMHFHiAZw96XAV8CpUatKREREREREGqzmHqQHALNq2D4b6B/hWkRERERERKQRaO5BOgvYXMP2PKBlhGsRERERERGRRqC5B+l6M7OrzGyymU3esGFDtMvZrZLyimiXICIiIiIi0uSEZbIxM0sERgDDgfZAMrARmA+Md/cl4Wh3L2ym5p7n2nqqcffHgMcAhg4d6uErbd/MWp3PVc9N5v7z9mdo16xolyMiIiIiItJkhDRIm1lP4HrgAiADqATygSIC4TQJcDObAjwEPOfulaGsoZ5mE7hPurr+wJwI1xJSbdITSYqP5dKnv+XfVxzMkE6Z0S5JRERERESkSQjZ0G4ze5BA+DwIuDP4mOTurdy9o7unAO2A04FpBJaWmm1mB4eqhr3wFjDczLrv2GBmXYFDg/sarTZpSbx45XCyUhO4+MlvmLU6P9oliYiIiIiINAmhvEe6PTDM3Q929/vcfYq7l1c9wN3Xufub7n4VgVD9MDA4hDXU1+PAMuBNMzvVzMYAbwIrgUejWFdI5GQk8eKVB5OWFM9FT37D/Nyt0S5JRERERESk0QtZkHb309x9Wj2OL3H3+4P3HEeFu28HjgYWAM8DLwBLgaPdfVu06gqlji1TePHKg0mIi+GCJyayaH2TeFsiIiIiIiJR0+xn7Xb3Fe5+hrunu3uau//I3ZdFu65Q6tIqlRevHA4Y5z8+kWUbt0e7JBERERERkUbL3EMz8bSZHV6f4919fEgajqKhQ4f65MmTo11Gnc3P3cq5j00gJSGOV64eTseWKdEuSUREREREpMEysynuPvQH20MYpCuBulzMAHf32JA0HEWNLUgDzF6Tz3mPTSQjJZ7/XD2CdhnJ0S5JRERERESkQaotSIdy+aujQngtCZMB7TN4/scHc8ET33D+49/wylXDaZOeFO2yREREREREGo2Q9Ug3R42xR3qHKcvzuOjJSXTITOblq4bTqkVitEsSERERERFpUGrrkW72k401Vwd2yeKpSw9i5eZCLnxyElsKS6NdkoiIiIiISKMQsqHdZja2Hoe7ux8TqrZl7wzv3orHLx7Kj5+dzMVPTeLfVxxMelJ8tMsSERERERFp0ELZIx1DYCKxuvyoJ7yBOKxXax6+4ADmri3g0qcmsa2kPNoliYiIiIiINGi6R3ofNOZ7pKv7YFYu1774HQd2acmzlw0jOaHRT6ouIiIiIiKyT3SPtOzW8QNz+Mc5Q5i8LI8rn5tMcVlFtEsSERERERFpkEK5/NUuzCwGGAZ0Bn6wvpK7PxeutmXvnDK4PaXlldz42nR+8u8pPHLRgSTGqWdaRERERESkqrAEaTPrD7wB9CBwT3R1DihIN0BnHNiR0opKbn59Jj97cSoPXnAA8bEauCAiIiIiIrJDuHqkHwpe+2xgJlASpnYkDM4b1pnS8kp+/9ZsfvXqdO47ZwhmNX0fIiIiIiIi0vyEK0gfAFzq7q+H6foSZpcc0pX8ojLu/XgBI3q04pyDOke7JBERERERkQYhXGN2NwKlYbq2RMh1R/XkkB6tuP2tOSzesC3a5YiIiIiIiDQI4QrS9wHXmplmqmrEYmKMe88eQmJ8DNe/PI3S8spolyQiIiIiIhJ14Rra3RroA8wxs4+BvGr73d1/H6a2JYRyMpL4yxmDuPr5Kfz94/ncfEK/aJckIiIiIiISVeEK0rdUed6rhv0OKEg3EqMH5HDesM48Nn4JR/RqzSE9s6NdkoiIiIiISNSEZWi3u8fs4UdDvhuZW0/uR7fsVG74zzQ2b9ft7yIiIiIi0nxpgWCpk5SEOO4/d3/ytpdy0+szcPdolyQiIiIiIhIVCtJSZwM7ZPCr0X34cPY6Xv52ZbTLERERERERiQoFaamXK0Z2Z2TPbO58W0tiiYiIiIhI86QgLfUSE2P8/ezBJMXH8POXp2pJLBERERERaXYUpKXe2qYHlsSatbqAv380P9rliIiIiIiIRJSCtOyVUQNyOP/gzjw6fglfLdoY7XJEREREREQiRkFa9tqtJ/WnR+tUfqElsUREREREpBkJS5A2swQz+72ZzTOzQjOrqPZTHo52JbKSE2L5Z3BJrN/8V0tiiYiIiIhI8xAXpuveA1wLvA+8DpSEqR2JsoEdMvj16L7c9d5cXpq0kvMP7hztkkRERERERMIqXEH6TOD37n5XmK4vDciPR3Zj/MIN3PnObIZ1y6JnmxbRLklERERERCRswnWPdAtgQpiuLQ1MTIzx97MGk5IQx89fnkpJeUW0SxIREREREQmbcAXpt4HDw3RtaYDaBJfEmr2mgL9/tCDa5YiIiIiIiIRNuIZ2PwA8Z2aVwHtAXvUD3H1JmNqWKDmuf1suHN6Zx8Yv4fBerRnZKzvaJYmIiIiIiISchWOm5WCA3qHGBtw9NuQNR9jQoUN98uTJ0S6jQSkqreCUf31JQVEZH1x/OFmpCdEuSUREREREZK+Y2RR3H1p9e7h6pC+nlgAtTVtyQiz3n7s/P3rwK37z3xk8dtGBmFm0yxIREREREQmZsARpd38mHNeVxqF/+3R+fXwf/vjuXF6ctIILDu4S7ZJERERERERCJlyTjUWVmf3CzN42s7Vm5mZ2+26O/ZGZTTWzYjNbbma3mFmjH3YebZcf2o3DemXzh3fmMGdNQbTLERERERERCZmwBWkza2NmPzezh8zsqWo/T4ar3aArgTbAG3uocTTwX+Bb4ATgn8AtwN1hrq/Ji4kx/n72YDKS4zn3sQlMXvaD+eZEREREREQapXBNNtaHwDrScUAqsBHIAmKBzUC+u3cPecPftx/j7pVmFgeUAXe4++01HDcVKHD3I6psu41AmO7s7rm7a0eTje3ZyrxCLn5qEmvzi3joggM4um/baJckIiIiIiJSJ7VNNhauHul7CPTytgWMQG9vMnAFUAicFqZ2AXD3yj0dY2adgCHAv6vteh6IJ1Cz7KNOWSm8es0IerZpwZXPTeH171ZFuyQREREREZF9Eq4gfRDwEFCyox13L3f3p4B/Af8IU7v1MSD4OKvqRndfSiDs9494RU1UdotEXrpyOAd3y+IX/5nOE19oCXEREREREWm8whWkWwB5wZ7hfCC7yr5vCQTtaMsKPm6uYd/mKvt3YWZXmdlkM5u8YcOGsBXX1KQlxfP0ZQdx4n45/PHdufzlg3mE47YCERERERGRcAtXkF4G5ASfzwfOqrLvZGBLXS9kZscGZ97e08/noSp+d9z9MXcf6u5DW7duHYkmm4zEuFgeOO8Azj+4Mw9/vpib/juT8oo9jsIXERERERFpUMKyjjTwMXAc8CpwL/CymY0EyoG+wF31uNbXQL86HFdYzxp39ES3rGFfS0DTTIdBbIxx148Gkp2awP1jF7G5sJT7z9ufpHitOCYiIiIiIo1DuIL0zUAigLv/x8yKgHOAFAJLTD1e1wu5eyEwLww1zg4+DiAwwzgAZtaVQJ1zwtCmAGbGL0b1ISs1gdvfnsMlT03i8UuGkp4UH+3SRERERERE9igsQ7vdvcTdC6q8ftvdL3T304NDo6N+c6y7rwCmAxdU23UhgSWz3o94Uc3MpYd245/nDmHK8s2c++hENmwt2fNJIiIiIiIiURaue6SjysyGmtmZwOnBTf3N7MzgT0qVQ38LHGFmj5rZkWZ2A4E1pP+5pzWkJTROHdKBJy89iKUbt3PmI1+zYlN9R+iLiIiIiIhEloWqc9jMxgI/dfd5wee74+5+TEgarrmWZ4BLatndzd2XVTn2dOD3BO7dXgc8Adzl7hV7amfo0KE+efLkfa5XYOqKzVz2zLfEx8bw3OXD6NcuPdoliYiIiIhIM2dmU9x9aPXtoeyRtmrXtd38hLUn3N0vdXer5WdZtWNfd/fB7p7o7p3d/c66hGgJrf07t+S1a0YQF2Oc/egEJi3VXG8iIiIiItIwhaxHujlSj3Tord5SxMVPfsOqzUX86/wDOK5/22iXJCIiIiIizVQkeqRF9lmHzGReveYQ+rZL55p/T+E/k1dGuyQREREREZFdhCVIm9mpZnZZldddzGyCmW01s9fMrEU42pWmISs1gRevOJhDerTi16/N4MHPFlFZqZETIiIiIiLSMISrR/oWoHWV1/cCHYHHgMOB28PUrjQRqYlxPHnJQZwyuD33fDifC574hpV5mtFbRERERESiL1xBugcwA8DMkoETgV+4+y8JLDl1WpjalSYkIS6G+88dwp9O34+Zq/MZ/Y/xPD9xuXqnRUREREQkqsIVpJOAouDzQ4A44KPg6/lA+zC1K02MmXHesM58eMPhHNilJbe+MUu90yIiIiIiElXhCtLLgJHB56cCU9w9P/i6DZBf00kitemQmcxzlw9T77SIiIiIiERduIL0o8DtZjYZ+CnwZJV9I4A5YWpXmjD1TouIiIiISEMQliDt7v8ELgUmAJe7++NVdqcBT4ejXWke1DstIiIiIiLRZO4KH3tr6NChPnny5GiX0ayt3lLETf+dwRcLN3JIj1b85YxBdMpKiXZZIiIiIiLSBJjZFHcfWn17uNaR7m1mw6q8TjazP5nZ22Z2XTjalOapau/0jFXqnRYRERERkfAL1z3S/wLOrPL6LuCXBGbrvs/Mrg1Tu9IM1XTv9IVP6t5pEREREREJj3AF6cHAVwBmFgNcDPzG3Q8E/ghcFaZ2pRlT77SIiIiIiERCuIJ0BrAp+Hx/oCXwWvD150D3MLUrzVxtvdOzVuej+QBERERERCQUwhWk1wE9g89HAYvdfWXwdQugPEztigA/7J0++YEvOfbecTzw6UJWbNKQbxERERER2XtxYbruW8CfzGwggWWwHq2ybz9gSZjaFdlpR+/0CQNzeHfmWt6cuoa/f7yAv3+8gAM6Z/Kj/Ttw0n7taNUiMdqlioiIiIhIIxKW5a/MLBX4BzAc+Ba4zt0Lg/u+Bsa5+80hbzjCtPxV47NqcyFvTV/Dm1PXMH/dVuJijMN6ZfOj/TtwXP+2pCSE67slERERERFpbGpb/krrSO8DBenGbe7aAt6Ytpq3pq1hbX4xKQmxjB6Qw6lD2jOyZzZxseG680FERERERBoDBekwUJBuGiornUnL8nhz2mrenbGWguJyslskcPKg9pw6pD1DOmViZtEuU0REREREIiyiQdrMxu7hEHf3Y0LecIQpSDc9JeUVfD5/A29OW80nc9dTWl5Jl1YpnDq4Pcf0a8t+HTKIiVGoFhERERFpDiIdpD8Hql+4FdAH2AAscPejQ95whClIN20FxWV8MCuXN6et5uvFm3CH7BYJHNG7DUf3bcPIXtlkJMdHu0wREREREQmTBjG028x6AG8AN7j7JxFrOEwUpJuPvO2ljFuwns/mbWDcgg3kF5URG2MM7dKSo/u24ai+bejVpoWGgIuIiIiINCENIkgHC7kAuNHd949ow2GgIN08lVdUMm3lFsbOW8/YeeuZl7sVCKxdfVTf1hzdtw0jumeTnBAb5UpFRERERGRfNKQgPQr4n7unRrThMFCQFoC1+UV8Nm8DY+et56tFGykqqyAxLoYRPVoFeqv7tKFTVkq0yxQRERERkXpqEEHazFoBLwDt3X1QxBoOEwVpqa6kvIJvluTx2fz1fDZvPcs2FQLQs00L+rRNIzEuhsT4GBLjYgPP42JIiAu+jo8Jbout4bhY0pLi6NIqRcPHRUREREQiJNKTjS3lh5ONJQBtg8/PcPe3Qt5whClIy54s3bidsfPW8/n89azNL6akvIKSskpKyisDz8srqc//BQe0T+fiEV0YM7iDho6LiIiIiIRZpIP0M/wwSBcDy4FX3X1xyBuNAgVp2VfuTlmF7wzVJeWVlJRVUFpRuWvgLqtk1eZCXpq0kvnrtpKRHM/ZQzty4fAudGnV6O+SEBERERFpkBrE0O6mRkFaIs3dmbQ0j+cmLOeD2blUunNk79ZcPKIrR/RurTWuRURERERCqLYgHReNYkRk75gZB3dvxcHdW5GbX8yLk1bw0qQVXPbMt3RplcKFB3fhrKEdyUxJiHapIiIiIiJNVth6pM0sATgB6AMkVdvt7v6HsDQcQeqRloagtLySD2fn8tyEZXy7bDNJ8TGcOrgDF43owsAOGdEuT0RERESk0Yr0PdLtgS+BrgTuld4x3nRnY+7e6GdKUpCWhmbOmgKen7icN6aupqisggM6Z3LJIV05YWA7EuJi6nWt0vJK8ovKgj+lbCksY1tJOZ2yUujTNo3UxOY5oOXz+eu5+725rNlSTFJ8DEnxsSTHx5KcEPv98+qvE2JIjg++Tghsy26RyGG9sjULu4iIiEgDFukg/QLQEzgDWAEcDGwALgfOAUa5+/KQNxxhCtLSUOUXlfHalFU8P2EZyzYVkt0igXMP6syIHq0oKCpjS1EZWwrL2FJUGnhduON1WfB1KdtLK2q9vhl0yUqhX7t0+uak069dGv3apdOxZXKTDYYr8wq58505fDxnHd2zUzmyTxuKyysoLq2gqCz4U1pBcVnV15UUl1VQWFpOZQ2/akcPaMvfzx5Ci2b6pYSIiIhIQxfpIL0CuBF4DSgHDnL3KcF9dwED3f3UkDccYQrS0tBVVjpfLNrI8xOW8em89T9YaishNoaMlHgyk+PJTIknIzmejOQEMoPbMoLbMlMSyEiOJyUhluWbCpm7tmDnz/K8wp3XTUuMo28wVAdCdhp9ctJISWi8QbG4rIJHxi3m4c8XExtj/OzoXvx4ZLd69fDvmJ29qCwYtEsr+GhOLn/5YD7dslN59KID6dG6RRjfhYiIiIjsjUgH6e3AaHf/0sy2Aqe5+yfBfccAr7t7WG7eNLPewLXAUUB3YCvwLXCru0+v4fgrgV8C3YBlwH3u/khd2lKQlsZk1eZCVuYVBUJySjyZyQkkxcfscw/y9pJy5q/byty1BcxbG3zM3cq2knIg0HvdrVVqIGDnpNM1O5UWiXGkJMSSkhBHSmIsqcHHlPhY4mLrNwQ9XNydT+au5853ZrMyr4iTB7Xjdyf1o11Gcsja+HrxRq57cSpl5ZXce84QjuvfNmTXFhEREZF9F+lZu1cB2cHni4FRwCfB18MIrCkdLqMIhOhnge+ATODXwEQzG7mjZxx2huhHgT8F6zsGeMjMzN0fDmONIhHXsWUKHVumhPy6qYlxHNC5JQd0brlzW2Wls3pLEXOCvdbz1m5l9poC3puZu8frJcTFkLojZCfEkpIYt8vrQHuZjOqfQ0ZKfMjfD8Cyjdu54+3ZfDZ/A73atODFKw7mkJ7Zez6xng7pkc3bPxvJNc9P4crnJvN/x/Ti+mN6aRkzERERkQYuXD3SjwBF7n6Dmf0EeJBAUC0DRgOPuvu1IW840HY2sMmrvDEzyyDQ2/y2u18c3BYHrAHed/dLqhz7FDAGaOfuZbtrSz3SIvWzraSc1ZuLKCwtp6i0gu2lgfuHt5cEHgtLK9heWk5hyfePhWUVFJaU7zw2P3hPd3yscWjPbE4c2I5RA9qGZMmvotIKHvxsEY+NX0JCXAzXH9uLSw7pSnyYe8mLyyq45Y1ZvDZlFUf3bcN95wwhIzk8XxKIiIiISN1Femh3NpDl7guCr39GYJKxFOAD4E53D2evdE01fQNsc/djgq8PA8YTmPjs4yrHHQWMBY529892d00FaZHIc3emr8rn/ZlreXfmWlZtLiIuxjikZzYn7ZfDqP45tEytX6h2dz6Ylcsf353L6i1FnLZ/B24+oS9t0quv3Bc+7s6/Jy7njrfn0LFlMo9eNJQ+OWkRa19EREREfiiiQbqhMbMsYCXwtLtfF9x2DfAw0N7d11Y5tg2wDrjO3R/c3XUVpEWiy92ZuTqfd2eu5b2Za1mZV0RsjHFIj1acuF87Rg/IIWsPoXrR+m3c8fZsvli4kb45adx56kCGdcuK0Dv4oW+X5fHTF75je0k595w5mJMGtYtaLSIiIiLNXXMP0i8ApwGD3H1RcNtvgbuA5Kq948Eh32XAbe7+h91dV0FapOFwd2avKdgZqpdvKiQ2xhjRfUeobkurFok7j99WUs4DYxfy1JdLSYqP5ZfH9ebC4V0axGRn6wqK+cm/p/Ddii1cfUR3fjWqT4OoS0RERKS5ifTQ7qd2s7sSyAemEJi9e7dDvM3sWODj3R0TNM7dj6zh/JuBu4Efu/tTVbbvVZA2s6uAqwA6d+584PLljX45bJEmZ0eofn/WWt6bmcvSjduJMRgeDNUpCbH85YN5rCso4awDO/KbE/qSXSVkNwSl5ZXc8fZsXvhmBSN7ZvPAefvXe8i6iIiIiOybSAfppUAGgRmzy4GNBGbxjgO2BA/LJDCj91Huvmo310oBOteh2UJ3X1Ht3B3Dt29x97uq7fsJ8BAa2i3SpLk7c9du5b1gT/WSjdsBGNghnTtPHbjLbOMN0SvfruDWN2bTOi2RRy86kIEdwrJyoIiIiIjUINJBegTwIvAL4E13rzSzGALDq/8OXACUAP8DPnf3i8JQw0UElsC6191vrGH/4cA44Lgda1wHtx8JfIYmGxNpctyd+eu2smZLEUf0bkNsI1lmatrKLfzk31PI217Kn07fj9MP6BjtkiSEissq+L+XphIXa9x+yoCITnInIiIiuxfpID0ReMbdH6lh30+Ay9x9mJn9lMAQ6pwQt38a8CrwlLtfVcsx8QSWv3rH3S+rsv0JAoG/nbuX7q4dBWkRiZSN20q49oXv+GZpHpce0pXfndQv7MtySfiVV1Ryzb+/49N564iPjSE5Ppbbx/TnR0M6YNY4vugRERFpymoL0nFham8wgWHbNVkMDAw+nwOEdFxlsKf5JWA68IyZDa+yu8TdpwK4e5mZ3Qo8ZGarCaxzfTRwOfCzPYVoEZFIym6RyL+vOJg/vTePp75aypy1Bdx56gBapSaSlhRHYlyMglcjU1np/Oa/M/lk7jruPHUAh/bM5levTueGV6bz7oxc7j59IG3S1DstIiLSEIXzHumP3P3qGvY9Dhzr7t3MbAzwWCh7pM3sduD3texe7u5dqx1/NfBLoAuwArjP3R+qS1vqkRaRaHhj6mpuen0GxWWVO7fFxRgtkuJokRj4SU+K//51Uhxpid8/b5EYR1pSPOlJcbRJT6J9ZhIpCeH6XlVq4u788d25PPnlUm44tjc/P7YXABWVzlNfLuVvH80nKT6WO8YM4NQh7fUliYiISJREemj39cC9wLvAa8B6oA1wFnAicL27329m9wAD3f2EkBcRAQrSIhItyzZuZ9rKLWwtLmNrSTnbisvZFnzcuvOxbOf2rcXllJRX1nq9zJR42mUk0yEziXYZybTLTKJDZjLtMpJpn5lE2/QkDSUPoX+NXcjfPlrApYd05fen9P9BUF68YRs3vjqdqSu2MKp/W/54mnqnRUREoiHi60ib2RXAbUDVWXFWAXe4+5PBY7oCRe6+LixFhJmCtIg0JqXllWwvCQTrguIyCorKWVdQzOotRazNL2LNlmLWbClibX4x+UVlu5xrBm3SEmmfmUz7YLhul5FMm/RE0pPiSU+OJy0p0BOelhRHUnxslN5lw/f8xOXc+sYsTtu/A38/azAxtUx6V1HpPPnlEv720QJSEgK902MGq3daREQkkiIepIONGoEg3Q5YC6zycDYYYQrSItJUbS8pZ21+Eau3FLN2SxFrthSxJr94l8C9ux7uhLiYQMBOiiMtOfAYCNzfh+305HjSk+LJTImnVWoiWS0SaJWa0KRD+FvT1/Dzl6dyTN82PHzhgXXq5V+0PtA7PW1loHf6rtP2o3Vaw1r3XEREpKmKSpBu6hSkRaS5cnfytpeycVspW4vLdvZwB55/3+NdUFzG1uJyCorKdnm+uxCekhBLVmogVGelJpCVmkirFjueJ5DdIrgt+DolIbZR9NJ+Pn89Vzw7mQO6tOS5y4fV6wuDikrn8S+WcO/H6p0WERGJpLAHaTM73d1fr+c57YAu7j4xJEVEmIK0iMjeKSmvYGtxOflFZWwpLGXTtlLytpeyafuO5yVs2h7YtmN7aS3hOzbGiDEwMwyIMcPs+0cDYmJ23WcWPAcjNsY4sk9rbhzVh5apCWF5v1OW53HBE9/Qo3ULXrpqOOlJ8Xt1nUXrt/LLV2cwfeUWjh+Qwx9+NFC90yIiImEUiSC9GtgAPAL8x93zdnPsYcBFwAXADe7+WEiKiDAFaRGRyHB3tpdWkLetlE3bS3aG67ztgR7xSgf3wHFOYGkpByrdd90efF25Y5vDtpJyPpidS1pSHL8a3YdzD+pMbC33Le+NuWsLOOfRCbRqkcir14wgu8W+Bd/yikoe/2Ip9328gNTEWO48dSAnD2qn3mkC/5t+vXgTfXPSaLWP/84iIiIQmSCdAtwIXEdgbei5BNZy3gCUBLd1B4YCGcB44Hfu/nVICogCBWkRkaZhwbqt3PbmLCYuyWNgh3TuGDOQA7u03OfrLt+0nTMfmUCsGa/9ZAQdW6aEoNqAheu2cuOr05m+Kp8TBgZ6p/c1pDdmSzdu59Y3ZvHloo10yEzmmcsOolfbtGiXJSIijVzE7pE2swTgNGA0MBxoDyQBm4B5BAL0K+4+L6QNR4GCtIhI0+HuvDNjLXe9O5fcgmLOOrAjvzmh716H0/UFxZz5yAQKist49eoRYQl15RWVPPbFEv7x8UJaJMVx92n7cfzAnJC3Uxcfzc7l7vfmMrJXNv93dC/apEdmua7isgoe/nwxD3++mMS4GK44rDv//mY5JWUVPHbxUIZ3bxWROkREpGnSZGNhoCAtItL0bC8p54Gxi3jyyyUkxcfyi+N6c9HwLsTVYx3t/MIyzn50Ais3F/LilcMZ0ikzfAUT6FH/xX+mMWt1AecM7cRtp/QnNTEurG3uUFhazh/emctLk1bQpVUKqzcXERdrXH5oN64+ogcZyXt3P3hdfLFwA7e+MYtlmwoZM7g9t5zUjzbpSazaXMilT3/Lik2F3HPWIE4d0iFsNYiISNOmIB0GCtIiIk3X4g3buP2t2XyxcCN9c9K4Y8wADq5D72ZhaTkXPvENs1YX8PRlB3Foz+wIVBtYJ/wfnyzg4XGL6ZyVwn3nDOGAzvs+PH13ZqzawvUvT2Pppu1cc0QPbji2N2u2FHHvxwt4a/oa0pPi+MmRPbn0kK4kJ4RuWbP1W4v54ztzeWv6Grplp/KHUwcysteu/875hWVc9fxkvlmax6+P78NPjuih+8hFRKTeFKTDQEFaRKRpc3c+nL2OP7wzh9Vbijh1SHt+e2I/2tYybLm0vJIrnpvMlws38NAFB3D8wHYRrhgmLc3jhlemkVtQzHVH9eRnR/esV296XVRUOo+MW8x9Hy+gTVoifz97CCN67Polw+w1+fztw/l8Nn8DbdIS+fmxvTh7aKc6rZ29u3Zf+GY593wwn5LySn56VA+uOaJHrUuJlZRX8KtXZ/DW9DVccHBn7hgzIOT/FiIi0rQpSIeBgrSISPNQVFrBw+MW88i4xcTHGP93TC8uO7QbCXHfh7KKSufnL0/lnRlr+csZ+3HOQZ2jVm9BcRm/f3M2/5u6miGdMvnHOUPomp0akmuv3lLEDa9MY9LSPE4a1I67f7QfGSm1D9+etDSPv34wj8nLN9O1VQo3HNebUwa1J6aeM6PPXJXP796YyYxV+RzWK5s7Tx1Itzq8p8pK556P5vPw54s5um8bHjhv/4gNexcRkcZPQToMFKRFRJqX5Zu284d35vDJ3PX0aJ3KHWMCQ4rdnVvemMUL36zg5hP6cvURPaJdKgBvTV/DLf+bSXml8/tT+nP20E77NLz5relr+N3/ZlJZ6dx56kBOP6BDna7n7nw2fz1//WA+83K30q9dOr8+vg9H9m69x/MLisu496MFPDdhGa1aJHLryf05ZS+W+3rhm+Xc+sYsBrTP4MlLh9ImLTKToYmISOOmIB0GCtIiIs3T2HnruOPtOSzfVMgJA3PIyUji6a+Wcc0RPbjphL7RLm8Xa7YU8cv/TGfCkk2M6t+WP58xiKzUhHpdY2uwh/v1qas5oHMm/zhnfzq3qv9SXpWVzlvT13DvxwtYkVfIsK5Z/Pr4PgztmvWDY92dd2eu5c6357BhWwkXD+/CL0f3IT1p7ycvGztvHde+MJWs1ASevfwgerbR8lgiIrJ7CtJhoCAtItJ8FZdV8Pj4JTz4+SKKyyo5b1gn7j5tvwY5oVVlpfPkl0u558P5ZKTE87ezBnNE79Z1Onfysjyuf2Uaa/OL+dnRPbnuqH2/57q0vJJXvl3B/WMXsWFrCcf2a8ONo/vQNycdgGUbt3Prm7P4YuFGBnZI5+7T9mNQx8x9anOHGau2cPkzkymrqOSxiw6s0wRyIiLSfEU0SJtZbyDT3ScFXycDtwEDgQ/d/V8hbzQKFKRFRGTV5kImLN7E6Qd0JLae9/1G2pw1BVz/ylQWrNvGpYd05aYT+tY6UVd5RSX3j13Ev8YupEPLZP5xzv4c2CW0s4AXlpbz9FfLeGTcYraVlPOjIR3olJXCI+MWkxAbw42jenPRiK4h/3ddmVfIpU9PYmVeEX87ezBjBrcP6fVFRKTpiHSQ/giY5u6/Dr6+F7gOmAkMAq539wdD3nCEKUiLiEhjU1xWwV8+mMfTXy2jZ5sW/PPcIQxon7HLMcs3befnL09j2sotnHFAR24f05+0fRhSvSdbCkt5ZNwSnv5qKSXllZw8qB23nty/1tnRQ9XmVc9NYdKyPG4+oS9XHd69QY4mEBGR6Ip0kF4HXOXub5pZDLAeuMvd7zOz3wOnu/vgkDccYQrSIiLSWI1fsIEbX53O5sJSbhzVhysO606MwWtTVnH7W7OJjTHuPn0/Th4Uud7a9VuLydteunOId7gVl1Xwq9dm8Pb0NVw0vAu/P6W/lscSEZFd1Bakw7X+QwawKfh8f6Al8Frw9efAjWFqV0REROrg8N6t+fD6w7n59Zn86f15fDZ/PVmpCbw3M5fh3bO49+whtM9MjmhNbdKSIjqbdlJ8LP88ZwgdMpN5ZNxi1uYXcf95+5OSoOWxRERk98L1tes6oGfw+ShgsbuvDL5uAZSHqV0RERGpo5apCTx84QHcc+YgZq7K56PZ67jphL68cMXwiIfoaImJMW46oS9/OHUAY+et57zHJrJha0nU6ikpr+Cx8Ys55YEv+WLhhqjVISIiuxeur1zfAv5kZgOBS4FHq+zbD1gSpnZFRESkHsyMs4Z2YmSvbIpKK+jeukW0S4qKi0Z0pV1GMj97aSo/evArbhzdmzGDO0RsAjl358PZ6/jT+3NZvqmQzJR4LnlqEr8c1YefHNGDmAY+kZ2ISHMTrh7pm4B3gNEEQvVdVfaNAT4KU7siIiKyF9plJDfbEL3Dsf3b8srVw0lPjueGV6Yz6r5xvDltNRWV4V0qdNbqfM59bCLX/HsKCbExPHv5ML6+6WhOHtSeez6cz9X/nkJBcVlYaxARkfrROtL7QJONiYiIND2Vlc5Hc3K57+OFzF+3lV5tWvDzY3tx4sB2Ie0ZXl9QzD0fzue171bRMiWBG47rzXkHddo54Zm788zXy7jr3bl0bJnMIxcdGLGJ2EREJCDSs3bHADHuXl5l22gC60h/6u7TQt5oFChIi4iINF2Vlc77s3L5xycLWLh+G33apnH9sb0YPSBnnwJ1cVkFj49fwsPjFlNWUcllh3bj2qN6kpFc8xJj3y7L46cvfMe24nL+fMZ+nDqkw163LSIi9RPpIP0KUOLuFwdfXwM8FNxdBpzk7p+EvOEIU5AWERFp+ioqnXdnruUfnyxgyYbt9M1J44bjejOqf9t6rT3t7rw1fQ1/eX8ea/KLGT2gLTef0I+u2al7PHd9QTHXvTiVScvyuPSQrvzupH7Ea6kuEZGwi3SQXg78xt1fDr5eDHwK/BJ4DMhx96NC3nCEKUiLiIg0HxWVztvT1/DPTxeydON2BrRP54Zje3NMvzZ7DNTfrdjMnW/PYdrKLQxon84tJ/VnRI9W9Wq/rKKSP78/jye/XMrQLi156IIDaJMeueXCRESao0gH6SJglLt/YWY9gQXAEHefYWajgBfdPTvkDUeYgrSIiEjzU15RyZvT1nD/2IUs31TIoI4ZXH9sL47q88NAvXpLEX95fx5vTV9D67REfjW6D2cc0HGfZgN/a/oafvPaDFokxfHg+QcwrFvWvr4lERGpRW1BOlzLXxUAO75mPRLY6O4zgq8rAH19KiIiIo1SXGwMZxzYkVOHtOf1qat5YOxCLn9mMoM7ZXLDsb04ondrCksrePjzxTz+RWDFz58d3ZNrjuhBauK+/6fXmMHt6ZuTxtXPT+G8xyfy2xP7cfmhXes1zFxERPZNuHqk/we0A/4I/BmY7O6XBvddDdzg7n1D3nCEqUdaREREyioq+e+UVTwwdhGrtxQxpFMmq7cUsWFrCacOac+vj+9Lh8zkkLdbUFzGjf+Zzkdz1nHyoHb85YxBIQnqIiLyvUgP7e4FvAf0AJYAx7r7suC+scByd78s5A1HmIK0iIiI7FBaXsmrU1by+PglZLdI5Lcn9eOAzi3D2qa788i4Jdzz4Tx6tmnBIxce2OzXAxcRCaWIBukqjbZy903Vtu0H5Lr7hrA1HCEK0iIiItIQfLVoIz97aSql5ZX8/ezBjB6QE+2SRESahNqCdFjXTXD3TWbWwsw6mVmL4LaZTSFEi4iIiDQUh/bM5u2fjaRH61Sufn4Kf/lgHuUVldEuS0SkyQpbj7SZjQbuAoYABjjwHfA7d/84LI1GmHqkRUREpCEpKa/gjrfn8OI3K8hukUB2i0QykuPJTIknMzmBzJR4MoLPW1Z5npkSOCY5Pjaqk5a5O+sKSli8YRuLN2xjxaZCDuqWxXH92hKzDzOdi4jsrUjfIz0aeBdYBLwE5BKYfOwcoCdwYlMI0wrSIiIi0hC9M2MNXyzYyJaiUrYUlpFfVMaWwjI2F5ZSUl57T3VCbEwwXAeCdZu0JNqmJ5GTkRh4TE8iJyOwLSk+dq/rKy6rYPmmwkBgXh8IzUs2bmfx+m1sL63YeVxsjFFR6XTLTuWKw7pxxgEd96ldEZH6inSQngBsBk5298oq22OAd4BMdz8k5A1HmIK0iIiINDbFZRVsKSzbGbIDQTv4vOj713nbS1lfUEJuQTGFVcLtDhnJ8eSkJ9E2I4mc9MQqzwNBu216EjHGzoAc6GXezuIN21iZV0hllf8EbZ+RRI82LejRugU9WqcGHtu0ICs1gQ9m5fLY+CXMXJ1PVmoCF4/owkXDu9CqRWIE/9VEpLmKdJAuBM5y93dr2Hcy8B93Twl5w4HrpwFPAgcQ6AUvAxYA97v7v6sdGwP8BrgayAHmA3e6+3/r0paCtIiIiDQHW4vLWFdQTG5+IFgHnhfv8nzjtpJdwnF1CXExdM9ODQTmHY+tW9AtO3WPy3a5O98szePx8Uv4dN56EuNiOGtoR348sjvdslND/G5FRL5XW5AO12KDJUB6LfvSgvvDJQEoB/4ELAMSCQwpf97MWrv7fVWO/QNwI/A7YApwLvCqmZ3s7u+FsUYRERGRRiMtKZ60pHh6tkmr9Zjyiko2bCshN//7cF3h0L11Kj1bt6B9ZjKxe3mfs5kxvHsrhndvxaL1W3nii6X859tVvPDNCkb1b8tVh3fnwC5Ze/v2RETqLVw90v8D9gOOc/elVbZ3Bj4GZrv76SFvePc1TQBauPt+wddtgJXAn93991WO+xRo7e6D9nRN9UiLiIiIRMf6rcU89/Vynp+4nPyiMg7onMlVh3fnuP45ex3YG6rKYFd/NCdcyy8sY25uAR0yk2mXkURcbFgX/xFpMCI9tLs38BWQAUwE1hIYOj0c2AKMdPeFIW949zW9A3Rw9/2Dry8CngN6V63FzC4DngK6V/0SoCYK0iIiIiLRVVhazquTV/HEl0tYmVdE11Yp/Piw7px5QEeSExrvxGTbS8oZv2ADH81Zx9h56+mbk8azlw+LymRrG7aWcPrDX7EyrwiAuBijfWYynbNS6JSVTKesFDq1TAm+TqFlSnxUZ38XCaWIBulgg+2AXwKHAVlAHjAOuM/d14al0V3bNyCWQJg/A3gQ+LG7Pxfc/2fgeiDZq/wjmNkw4BsCE6X94B7vqhSkRURERBqGikrnw9m5PDp+CdNXbqFlSjwXjejKxSO6kN1IJiZbX1DMJ3PX8/GcXL5avInS8koyU+IZ1jWLj+euY1T/tjx0wYER7XHfXlLOuY9NZNH6bfzp9P0oLqtg5eZCVuQVsTKvkJV5hWzaXrrLOS0S4+jYMnlnsN4RuLtlt9A97dLoRPoeaYJh+cZwXb8OrgUeCD4vA36+I0QHZQFb/IffJORV2S8iIiIijUBsjHHifu04YWAOk5dv5rHxS3hg7EIeH7+E647uyRWHdSMxrmH1ULs7izds46M56/ho9jqmrdwCQKesZC4a3oXj+rdlaJeWxMXG8NSXS7nznTnc/tZs7jx1QER6fMsrKrnuxe+YvSafxy8eyjH92tZ43PaSclZuLmRlXhErguF6ZV4hyzZtZ/zCDRSXfb/k2h1jBnDJIV3DXrtIuIUtSIeKmR1L4L7qPRnn7kdWef0KgWHl2cAY4AEzq3D3R/exnquAqwA6d+68L5cSERERkRAzMw7qmsVBXbNYvGEbf/1gHvd8OJ/Xpqzi96f058g+baJaX0Wl892KzXw8Zx0fz1nH0o3bARjUMYNfHteb4wa0pU/btB8E5ctHdmNdQTGPjl9CTkYS1x7VM6x1uju3vDGLz+Zv4K7TBtYaogFSE+Pom5NO35wfzjXs7mzcVsqKvELu+XAef/9oPqcOaU9mSkI4yxcJu5AN7TazsfU43N39mDpeNwWoS2ItdPcVu7nOMwSGeGe5e5mZ/QX4ORraLSIiItKkjVuwgTvems2Sjds5rn9bbju5P52ywrISa42KSiv4ctFGPp6Ty6dz17NpeynxsYGZyEcNyOHYfm1ol5G8x+tUVjq/+M803pi2hr+eOYizh3YKW833f7qQez9ewHVH9eTG0X1Ccs25aws48f4vuGJkN353Uv+QXFMk3CIxtDsGqGsqr/NYFHcvBObtVUW7mgxcArQFVgGzCSyN1QNYVOW4Hf+vnhOCNkVEREQkyo7o3ZoPrj+cJ79cygNjF3LsveP46ZE9ufqI7mGbvMvdmbpyCy9+s4J3Z6ylqKyCtKQ4jurThuP6t+WIPq1JT4qv1zVjYoy/njmYTdtLufn1mbRukchRfUPfw/7q5JXc+/ECTj+gA78c1Ttk1+3XLp0zD+jIs18v5+IRXSP6ZYZIqIVtsrGGxsxeBY4HWrl7aXD5q1XAXe5+R5XjPgHa7lgma3fUIy0iIiLSuKzNL+Kud+fyzoy1dMpK5raTB3BsvzYhu+d4W0k5b0xdzQvfrGDu2gJSE2IZM6QDJ+6Xw8HdWpEQt+/LRm0rKefcxyaweP12XrpqOEM6Ze574UHjFmzgx898y4gerXjykoNCUm9VufnFHPm3zxjVP4f7z9s/pNcWCYeIz9odLWZ2NYFltj4hEJRbAWcD5wA3uftfqhy7Y+bu3wLfBY+5Ghjj7u/sqS0FaREREZHG6etFG/n9W7NZuH4bR/Vpze9PGUDXfZhRetbqfF74ZgVvTltNYWkF/dulc8Hwzpw6pAMtEkM/LdH6rcWc8fDXbC+p4L8/OSQks2HPWp3POY9OoHOrVP5z9XDS6tljXld/+3A+//psEW9ddyiDOmaGpQ2RUGlOQfoQ4BZgfwIzb28E5hJYduvdasfGAjcDVxJY53o+cKe7v1aXthSkRURERBqvsopKnv16Gf/4ZCGl5ZVcdXh3fnpUD1IS6hZ8C0vLeWf6Wl74ZjnTV+WTFB/DKYPac8HwLgzumBH2mbWXbtzOGQ9/TWpiLP/9ySG0SUva62utzCvk9Ie/Jj7G+N+1h9I2fe+vtSdbi8s48p7P6dmmBS9fNVxrTkuD1myCdCQpSIuIiIg0fusLivnz+/N4fepq2mckcevJ/Tl+YE6tAW9+7lZe/GY5r3+3mq0l5fRq04ILDu7MaQd0JCM5PL24tZm2cgvnPTaRHm1SefmqEXvV+72lsJQzHv6aDVtL+O9PDqFX27QwVLqr5yYs47Y3Z/PkJbUvqyXSEChIh4GCtIiIiEjT8e2yPG59Yxbzcrcysmc2t4/pT882gVBZXFbB+7PW8uI3K/h22WYSYmM4Yb8cLji4Cwd1bRnVXtXP5q3niucmc8he3NdcXFbBRU9+w/SV+Tz/42Ec3L1VGCv9XllFJaPvG09MjPHBzw8jLja092KLhIqCdBgoSIuIiIg0LeUVlbzwzQr+9tF8ikoruOzQrgC8OmUVWwrL6NoqhfMP7syZB3YiK7XhrIX86uSV/Oq1GZy2fwf+ftZgYmL2HOwrK53rXvqO92bm8q/z9+fkQe0jUOn3PpiVyzX/nsLdp+3H+QfXZbVbkciLxPJXIiIiIiKNWlxsDJcc0pWTBrXjrx/M4/EvlhIXY4wa0JYLDu7CiO6t6hRSI+2soZ1YV1DM3z5aQJv0RG4+od8ez/nju3N5b2Yut5zUL+IhGmD0gLYM7dKS+z5ZwKlD2pMahknZRMIlrJ9WM8sBOgM/mK3A3ceHs20RERERkb2V3SKRv545mGuP6klyQuw+TeQVKdce1ZN1BSU8Om4JbdOSuHxkt1qPfeKLJTz11VIuO7QrP97NceFkZtx8Yj/OePhrHv9iCdcfG7o1q0XCLSxB2sw6AM8DR9S0G3AgNhxti4iIiIiESpdW+76sVKSYGbePGcD6rcX84d05tElPrLGn+Z0Za/jju3M5YWAOt5zUP6r3dx/YpSUn7pfDY+OXcP7BnRvFFxYiAOG6q/9hYD/g18AJwNFVfo4KPoqIiIiISAjFxhj/PHd/hnZpyS9emc7Xizfusv+bJZv4xSvTA0OqzxlCbAMYpv7r0X0pq6jkvo8XRrsUkToLV5A+DPiFu//d3T9y93HVf8LUroiIiIhIs5YUH8sTFx9El1YpXP3cFOauLQBg4bqtXPncZDplJfPEJUNJim8YA0S7ZqdywcFdeOXbFSxctzXa5YjUSbiCdBGwPkzXFhERERGR3chIiefZy4eRmhjHpU9P4rsVm7n06W9JjI/lmcuGkZnScGYcB/i/Y3qRmhDHXz6YF+1SROokXEH6ceCiMF1bRERERET2oH1mMs9ePozC0gpOf+hrNheW8vSlB9EpKyXapf1AVmoCPzmqB5/MXc/EJZuiXY7IHoUrSK8GDjGzT83sRjO7vPpPmNoVEREREZGgPjlpPHHxUHq2acFDFxzAwA4Z0S6pVpcf2o32GUnc/d5cKis92uWI7Ja5h/5DamaVezjE3b1h3JSxD4YOHeqTJ0+OdhkiIiIiIk3Cf6es4pevTuef5w7h1CEdol2OCGY2xd2HVt8ernWko7MYnYiIiIiINFo/2r8DT3y5lHs+nM/xA3NIjGv0fW/SRIVlaLe7L9/TTzjaFRERERGRxis2xvjtiX1ZtbmI5ycoMkjDFa57pEVEREREROrtsF6tObx3ax4Yu4j8wrJolyNSo5AFaTNbYmaDg8+XBl/X9rM4VO2KiIiIiEjTcvMJfSkoLuNfny2MdikiNQrlPdLjgIIqzzXVnoiIiIiI1Fu/dumceUBHnv16OReP6Nogl+yS5i1kQdrdL6vy/NJQXVdERERERJqfX4zqzdsz1nDPh/O5/7z9o12OyC50j7SIiIiIiDQ47TKS+fHIbrw1fQ0zVm2JdjlNyrfL8vhy4cZol9GohWv5KwCC90z3AZKq73P358LZtoiIiIiING7XHNGDlyet5O735vLSlcMxs2iX1KgVl1Xw5/fn8czXywC49JCu3HxiXy0zthfCEqTNLBN4Fxi+Y1Pwsep90wrSIiIiIiJSq7SkeH5+bC9ue3M2Y+et55h+baNdUqM1a3U+178yjUXrt3HpIV0BeObrZUxZvpkHzz+Azq10H3p9hGto991AK+BwAiH6NOBo4AVgCTAsTO2KiIiIiEgTct6wznTLTuVP78+jvKIy2uU0OuUVlTz42SJ+9OBXbC0u47nLh3H7mAHcPmYAj1x4IMs3beek+7/g/Zlro11qoxKuID2aQJieGHy9yt0/d/eLgU+An4epXRERERERaULiY2P4zfF9WLR+G/+ZvCra5TQqyzdt55zHJnLPh/MZPTCHD68/nMN7t965//iBObz7f4fRvU0LfvLCd9z25iyKyyqiWHHjYe6hX6XKzAqBUe7+ZfD5ie7+eXDfccDL7t4q5A1H2NChQ33y5MnRLkNEREREpElzd856ZAKTl28mITaGxPgYkuJjSYqPISku9vvn8bEkxsWSnBBLUlzMLtt3/OzXIYMDu7QkNqbp3m/t7rzy7UrufGcOsTHGH380kDGD29d6j3lpeSV//WAeT3y5lAHt03nw/APomp0a4aobJjOb4u5Dq28P12RjuUBm8PlyYATwefB1zzC1KSIiIiIiTZCZ8a/zD+DVySvZXlpBcVkFJeUVFJdVUlwWeF1UVsHW4nI2lJVQUv799uKySorLK6jaf5jdIpFRA9pywsAchndvRXxs01nMaOO2Em7670w+mbuOEd1b8bezB9MhM3m35yTExXDLyf05uHsrbnx1Oic/8CV/PmM/Th7UPkJVNz7h6pF+Dljh7reY2W+B24BngXLgEuAtdz8/5A1HmHqkRUREREQaPnentKKSbcXlfLV4Ex/OyuWz+espLK0gIzmeY/u15fiBORzWK5uk+MY7g/XHc9Zx039nsLWknF+P7sPlh3Yjpp4976s2F/Kzl6YydcUWLji4M7ee3L9R/5vsq9p6pMMVpHsA7d39CzOLB/4MnAOkAB8AP3P3TSFvOMIUpEVEREREGqfisgrGL9jAB7Nz+WTOOgqKy0lJiOWovm04fkAOR/VtQ4vEsK4WHDLbSsr54ztzePnblfRrl84/zhlCn5y0vb5eWUUlf/twPo+OX0K/duk8eP7+dG/dIoQVNx4RDdLNhYK0iIiIiEjjV1peycQlm3h/Vi4fz8ll47ZSEuJiOLxXNscPbMex/dqQmZIQ7TJrNGV5Hje8Mp2Vmwu55ogeXH9sr5CtCz123jp+8Z/plJVXcvfp+3HqkA4huW5jErEgbWYJBO6RvtTd3wrpxRsYBWkRERERkaalotKZvCyPD2bn8uGsXNbkFxMbY4zo3orjB+Ywqn9b2qQnRbtMSssr+eenC3j488W0z0zm3rOHMKxbVsjbWbOliP97aSqTl2/mvGGd+f0pzWuod6SHdq8HLnT3j0J+8QZEQVpEREREpOlyd2asyueD2bl8MCuXpRu3A9A+I4kBHTIY2D6DgR3SGdghgzZpibXOih1qC9dt5fpXpjF7TQFnHdiR207pT1pSfNjaK6uo5N6PA6G9b04aD15wAD2ayVDvSAfpxwDc/aqQX7wBUZAWEREREWke3J0F67YxfsEGZq3JZ9bqfJZs3L5zNvDsFomBUB0M1wPaZ9CxZfJehWt3Z0thGas2F7FqcyGrNhexMvi4anMhSzduJy0pnrtP24/jB+aE+J3W7vP56/nFf6ZTXFbBXacN5EdDOkTsy4NoiXSQPg24H/gGeANYC+zSkLuPDXnDEaYgLSIiIiLSfG0vKWfu2gJmrc5n1prA48L126ioDESfjOT4neE60IOdTtdWqZhBQVH5LuF418citpWU79JWWmIcHbNS6Ngyme7Zqfz4sG60SYv8EPPc/GL+76WpTFqWR+u0RIZ1zeKgri05qFsWfXPSm9z63JEO0pW17HLAAHf3Rj+wXkFaRERERESqKi6rYH7u1mCvdQGz1+QzL3crpeWBiJSaEEuMGVurBeUWiXF0bJlMx5YpwcdkOmWl7NyWkRy+odv1VV5RyetTV/P1oo18u2wzq7cUAZCWFMeBXVpyUNcshnXLYlDHjJBNfBYtkQ7SR1KtB7o6dx8X8oYjTEFaRERERET2pKyikkXrtzFrdT6z1xTg7sGQHAjKnVqmkJ4c12iHSa/aXMi3y/KYtHQz3y7LY9H6bQAkxMUwpGMmB3ULhOsDu7QM673c4dBsl78ys3OBl4DV7t6xhv1XAr8EugHLgPvc/ZG6XFtBWkREREREZFd520v5dlke3y7N49tlecxaU0BFpRNj0K9d+s4e64O6ZtE6LTHa5e5WpHuklwCnufv0GvYNBN5y9+4hb/iHbWUC8wj0jldUD9LBEP0o8CfgE+AY4LfAte7+8J6uryAtIiIiIiKye9tLypm6YguTguF66srNFJdVkpoQy4zbRzfo+6prC9JxYWqvK1DbVwtJQJcwtVvdX4HpBCY7O7bqDjOLA+4Cnnf33wU3f2Zm7YE/mNkT7l4WoTpFRERERESapNTEOEb2ymZkr2wgsAb2rDX5rN5c1KBD9O7EhPHatXV1DwW2hLFdAMzsUOBC4NpaDhkBtAb+XW3780ArYGT4qhMREREREWmeEuJiOKBzS04Z3D7apey1kPVIm9kNwA3Blw68bWal1Q5LBrKAl0PVbi21xAOPAfe4+6JabtofEHycVW377OBjf+Cz8FQoIiIiIiIijVUoh3YvAT4NPr8EmAxsqHZMCTAHeCKE7dbkNwSGlv9pN8dkBR83V9ueV22/iIiIiIiIyE4hC9Lu/ibwJrBj2vY73X3pvl7XzI4FPq7DoePc/Ugz6wn8jsBkZ8X72n4N9VwFXAXQuXPnUF9eREREREREGriwTDbm7peF8HJfA/3qcFxh8PF+YCwwMThrN0ACYMHXJe5exPc90S0JTEa2w46e6Dxq4O6PERg2ztChQ5v22mEiIiIiIiLyA+GatTtk3L2QwBJWddWfwKzg1YdsE9z2T+B6vr8XegC7Bun+wcc59SpUREREREREmoUGH6T3wrkEltiq6ibgQOAsYFVw2wRgI3ABgTWkd7iQQG/0V+EtU0RERERERBqjJhek3X1i9W1mdimBId2fVzmuzMxuBR4ys9UEwvTRwOXAz9y9+ozjIiIiIiIiIph707/N18yeAY5194417Lsa+CWB4eArgPvc/aE6XncDsDyEpYZDNoGed5GGQp9JaYj0uZSGRp9JaYj0uZSGKNyfyy7u3rr6xmYRpJszM5vs7kOjXYfIDvpMSkOkz6U0NPpMSkOkz6U0RNH6XMZEukERERERERGRxkxBWkRERERERKQeFKSbvseiXYBINfpMSkOkz6U0NPpMSkOkz6U0RFH5XOoeaREREREREZF6UI+0iIiIiIiISD0oSDcxZtbJzF4zs3wzKzCz182sc7TrkubDzDqa2QNmNsHMCs3MzaxrDcclmdk9ZrbWzIqCxx8ehZKliTOzM83sv2a2PPhZm29mfzKztGrHtTSzJ8xso5ltN7NPzGy/aNUtTZuZjTazsWaWa2YlZrbKzP5jZv2rHae/6xI1ZvZB8O/4H6tt1+9LiQgzOzL4Gaz+s6XacRH/TCpINyFmlgKMBfoClwAXAb2Az8wsNZq1SbPSEzgb2Ax8sZvjngSuBG4DTgbWAh+a2ZBwFyjNzo1ABfBb4HjgYeAnwMdmFgNgZga8Hdz/M+AMIJ7A78+O0ShamrwsYApwHTAKuBkYAEw0sy6gv+sSXWZ2HjC4hu36fSnR8H/AiCo/x+7YEa3PZFy4LixRcSXQHejj7osAzGwGsBC4Grg3irVJ8zHe3dsCmNkVBP4DcRdmNhg4H7jc3Z8ObhsHzAbuBMZErlxpBk5x9w1VXo8zszzgWeBIAkFlDHAocLS7fwZgZhOApcCvCfwBFwkZd38JeKnqNjObBMwDzgT+jv6uS5SYWUvgPuAG4MVqu/X7UqJhrrtPrGVfVD6T6pFuWsYAE3f8sQVw96XAV8CpUatKmhV3r6zDYWOAMuCVKueVAy8Do80sMUzlSTNULUTv8G3wsUPwcQywZscf4OB5+QS+4dbvT4mUTcHH8uCj/q5LtPwFmBX8wqc6/b6UhiYqn0kF6aZlADCrhu2zgf41bBeJlgHAUncvrLZ9NpBAYHi4SDgdEXycG3zc3e/PzmbWIiJVSbNjZrFmlmBmvYBHgVy+76nW33WJODMbCVwMXFvLIfp9KdHwgplVmNkmM3ux2lwRUflMKkg3LVkE7kutLg9oGeFaRHZnd5/VHftFwsLMOhC4heATd58c3Lynz6R+h0q4fAOUAAuAQQSGJq4P7tPfdYkoM0sg8IXO39x9fi2H6felRFI+gVtdrgCOBv5A4P7oCWbWJnhMVD6TukdaRESajeC30m8SGDp7WZTLEYHABGLpBO6FvpHAJHgj3X1ZVKuS5urXQDJwV7QLEQFw96nA1CqbxpnZeGASgXufb4lKYahHuqnZTM3fuNT2LY1ItOzuswrff4MoEjJmlkzgfqnuwGh3X1Vl954+k/odKmHh7nPd/ZvgvajHAC2Am4K79XddIiY4VPZ3wK1AopllmllmcPeO17Ho96VEmbt/R2AUz0HBTVH5TCpINy2zCdwjUF1/YE6EaxHZndlAt+DSLlX1B0qBRT88RWTvmVk88BowFDjR3WdWO2R3vz9XuPu2MJcogrtvIfD7b8c8Efq7LpHUHUgC/k0geOz4gcBoic3Afuj3pTQcHnyMymdSQbppeQsYbmbdd2wws64EpoN/K1pFidTgbQLr+521Y4OZxQHnAB+5e0m0CpOmJ7hW9AsE7q36US3LZ7wFdDCzI6qclw6cgn5/SoSYWVsCa0YvDm7S33WJpGnAUTX8QCBcH0Xgix79vpSoMrOhQB8Cw7shSp9Jc/c9HyWNgpmlAtOBIgL3CziBG/LTgEH6hlAixczODD49BrgG+CmwAdjg7uOCx7wMjAZ+RWCdv58AJwOHBIfsiISEmT1M4HN4F/BOtd2r3H1VMGx/CXQi8JncDNxMYPKnwe6+MoIlSzNgZv8DvgNmAAVAbwJr9uYAw9x9gf6uS0NgZg7c5e63BF/r96VEjJm9QOC/E78DtgD7E/i8FQIHuPvGaH0mFaSbmOD9LfcBxwEGfApcr0lLJJKCf3RrMs7djwwes2Myk/OBTAL/sfgbd/88AiVKM2Jmy4Autey+w91vDx6XBfwN+BGB4Y0TgF+4+/TwVynNjZn9Bjgb6EFg2b+VwOfAn6r+zdbfdYm26kE6uE2/LyUizOxm4DwCf8dTCCwR+D7we3dfW+W4iH8mFaRFRERERERE6kH3SIuIiIiIiIjUg4K0iIiIiIiISD0oSIuIiIiIiIjUg4K0iIiIiIiISD0oSIuIiIiIiIjUg4K0iIiIiIiISD0oSIuIiEhEmNkyM/t3tOsQERHZVwrSIiIiIiIiIvWgIC0iIiIiIiJSDwrSIiIiTZCZDTazt8xss5kVmdlXZnZYlf3PmNkqMzvEzL41s+Lg0Ouf1XCtYWb2iZltM7PtZvapmQ2r4bgjzOxjM8sPHjfdzH5cw3Hnmtnc4DGTzWxk6P8FREREwkdBWkREpIkxswOAr4Es4ErgDGAT8ImZHVjl0HTgFeBZ4EfA58D9ZnZplWsNAsYBLYFLgYuD540zs8FVjjsV+BRIAK4GTgWeArpUK+8w4JfArcA5QCzwjpll7uPbFhERiRhz92jXICIiIiFkZp8C7YHB7l4a3BYLzALmu/uPzOwZ4BLgPHd/ucq5HwO9ga7u7mb2GnBs8PWW4DHpwDLgc3c/3cwMWApsBIa5e2UtdS0DMoDu7r45uG0o8C1wgbu/GNJ/CBERkTBRj7SIiEgTYmbJwBHAq0ClmcWZWRxgwCfA4VUOrwD+W+0SLwOdgQ7B14cD7+wI0QDuXgC8FWwHoA+BnucnagvRVUzYEaKDZgYfO+/53YmIiDQMCtIiIiJNSxaB4dK3AmXVfq4DWprZjr//m929rNr564KPO4J0FrC2hnZyCQz3BmgVfFxVh/ryqr5w95Lg06Q6nCsiItIgxEW7ABEREQmpLUAl8CDwXE0HuHtlYDQ2Lc0svlqYbht8XB18zANyarhMDrCjZ3lj8LFDDceJiIg0OQrSIiIiTYi7bzezL4DBwHd7GGodS2AisperbDsXWMH3QXoccKKZpbn7VgAzSwNOITA5GcACAvdMX2Fmj7kmYBERkSZOQVpERKTp+QUwHvjQzJ4kMDQ7GzgAiHX3m4LHbQX+ambZwELgPAITi11aJQz/ATgZ+NTM/gI48BsgBbgTIDgp2fXA68BYM3sE2AD0A9q4++/D/H5FREQiSvdIi4iINDHu/h1wEIElr+4HPgL+CexHIGDvUECgB/oS4E3gKODn7v5slWvNAI4MHvss8DywDTjC3adXOe5N4LjgyycJTEZ2FYGeahERkSZFy1+JiIg0Q8Hlr451947RrkVERKSxUZDeB9nZ2d61a9dolyEiIiIiIiJhMGXKlI3u3rr6dt0jvQ+6du3K5MmTo12GiIiIiIiIhIGZLa9pu+6RFhEREREREakHBWkRERERERGRelCQFhEREREREakHBWkRERERERGRelCQFhEREREREakHBWkRERERERGRelCQbqIWrd/GVc9NJje/ONqliIiIiIiINCkK0k1UQmwMH89dx4uTVkS7FBERERERkSZFQbqJ6twqhSN7t+alSSsoq6iMdjkiIiIiIiJNhoJ0E3bxiK5s2FrCh7Nzo12KiIiIiIhIk6Eg3YQd0bs1nbNSeG7C8miXIiIiIiIi0mQoSDdhMTHGhcM7M2lpHvNyC6JdjoiIiIiISJOgIN3EnXVgJxLjYvj3RPVKi4iIiIiIhELEg7SZdTKz18ws38wKzOx1M+tcx3OTzOweM1trZkVmNsHMDq92TG8z+6eZzTCzbcFj3zKzwTVc73Mz8xp+rg/R2426lqkJnDK4Pf/7bjVbi8uiXY6IiIiIiEijF9EgbWYpwFigL3AJcBHQC/jMzFLrcIkngSuB24CTgbXAh2Y2pMoxo4CjgGeBU4CfAq2BiWZ2YA3XnAGMqPbzcn3fW0N28YgubC+t4PXvVke7FBERERERkUYvLsLtXQl0B/q4+yIAM5sBLASuBu6t7cRgj/L5wOXu/nRw2zhgNnAnMCZ46MvAg+7uVc4dCywDfg5cXO3SW9194j6/swZsUMdMBnfM4PmJy7l4RBfMLNoliYiIiIiINFqRHto9Bpi4I0QDuPtS4Cvg1DqcWwa8UuXccgLBebSZJQa3bawaooPb8oEFQIdQvInG6KIRXVm0fhsTlmyKdikiIiIiIiKNWqSD9ABgVg3bZwP963DuUncvrOHcBKBnbSeaWRYwEJhbw+79g/drlwXvq/7xHupolE4e1I7MlHie11JYIiIiIiIi+yTSQToL2FzD9jyg5T6cu2N/bR4ADPhHte3jgesJ9HafSWCI+RNmdkttFzKzq8xssplN3rBhwx5KbjiS4mM5Z2gnPpqzjrX5RdEuR0REREREpNFq8stfmdnNBO6tvq7qkHIAd7/N3R9393Hu/qa7nwG8AfzOzFrUdD13f8zdh7r70NatW4e9/lC6cHgXKt15adLKaJciIiIiIiLSaEU6SG+m5p7n2nqb63oufN8zvZOZXQPcDdzi7k/VscaXgCRgvzoe32h0ykrhqD5teGnSCkrLK6NdjoiIiIiISKMU6SA9m8C9ztX1B+bU4dxuwSW0qp9bCuzS22xmFwEPAX9397v2olbf8yGNz0XDu7Bhawkfzs6NdikiIiIiIiKNUqSD9FvAcDPrvmODmXUFDg3u2523gXjgrCrnxgHnAB+5e0mV7acBTwNPuPuN9azxAqAImFnP8xqFI3q3pnNWCs9P1KRjIiIiIiIieyPSQfpxAus5v2lmp5rZGOBNYCXw6I6DzKyLmZWb2W07trn7VAJLX/3DzK4ws2MILH3VDfh9lXMPJzA8ezrwjJkNr/Kzf5XjDjOzd83sx2Z2jJmdbmZvEph47A533x6+f4boiYkxLhzemUlL85iXWxDtckRERERERBqdiAbpYDg9msCazs8DLwBLgaPdfVuVQw2IraG+ywj0NP8ReBfoBBzv7t9VOeZoIBE4gMD61BOq/PyvynFrg9e/E3gPeA5oDZzv7n/Z1/fakJ11YCcS42K0FJaIiIiIiMheMPcmeStwRAwdOtQnT54c7TL2yo2vTue9mWuZ+NtjSE+Kj3Y5IiIiIiIiDY6ZTXH3odW3N/nlr6RmF4/oQmFpBf/7bnW0SxEREREREWlUFKSbqUEdMxncKZPnJy5HoxJERERERETqTkG6GbtoeBcWrd/GhMWbol2KiIiIiIhIo6Eg3YydPKgdLVPitRSWiIiIiIhIPShIN2NJ8bGcfVAnPpqzjrX5RdEuR0REREREpFFQkG7mLjy4C5XuvPTNimiXIiIiIiIi0igoSDdznbJSOKpPG16ctJLS8spolyMiIiIiItLgKUgLF43owsZtJXw4OzfapYiIiIiIiDR4CtLCEb1a0zkrhecnaNIxERERERGRPVGQFmJijAuHd2bSsjzm5RZEuxwREREREZEGTUFaADh7aCcS42LUKy0iIiIiIrIHCtICQGZKAmMGt+d/U1dTUFwW7XJEREREREQaLAVp2emiEV0oLK3g9Smrol2KiIiIiIhIg6UgLTsN6pjJ4E6ZPD9xOe4e7XJEREREREQaJAVp2cXFw7uweMN2JizeFO1SREREREREGiQFadnFSYPa0TIlnuc06ZiIiIiIiEiNFKRlF0nxsZx9UCc+nruOtflF0S5HRERERESkwVGQlh+48OAuVLrz0jcrol2KiIiIiIhIgxNX1wPNrANwHDAcaA8kAxuB+cA4YJy7V4ajSImsTlkpHNWnDS9OWsl1R/ciIU7ft4iIiIiIiOywx4RkZkeY2TvAMuAp4ESgA4EgPRi4EfgUWGlmt5tZevjKlUi5aEQXNm4r4YPZudEuRUREREREpEHZbZA2s3eB94HtwNlAG3fv7O4HuvtId+8PpANDgIeAs4DFZjY6vGVLuB3RqzWds1K46905/PGdOXw+fz1FpRXRLktERERERCTq9tQjvQDo7u7nuPv/3H1j9QPcvdLdZ7j7Xe4+APgxkFHbBc2sk5m9Zmb5ZlZgZq+bWee6FGtmSWZ2j5mtNbMiM5tgZodXO6a3mf3TzGaY2bbgsW+Z2eBarnmlmc0zsxIzm29m19SllqYuJsa458xB9GjdgucmLOfSp79l8B0fcd5jE3nws0XMWLWFikqtNS0iIiIiIs2PuUcuDJlZCjAdKAFuARz4I5ACDHL37Xs4/wXgJOBXwBLgWuAEYIS7Twsecx1wFfAs8B2QCfyaQK/5SHefUuV6VwKPAn8CPgGOAX4LXOvuD+/p/QwdOtQnT55cp/femBWVVjBpWR5fLtzAFws3Mi93KwCZKfEc0qMVI3u25rBe2XTKSolypSIiIiIiIqFjZlPcfegPtkc4SP8cuBfo4+6Lgtu6AQuBX7v7vbs5dzAwDbjc3Z8ObosDZgPz3X1McFs2sMmrvDEzyyBwj/fb7n5xlXPXAO+7+yVVjn0KGAO0c/ey3b2f5hKkq9uwtYSvFm3ki4Ub+XLRBtYVlADQpVUKI3tmc1ivbEb0yCYjOT7KlYqIiIiIiOy9kARpM9sfuBU4nEBP7zB3/87M7gbGu/sHezj/UyDJ3Q+ttn0cgLsfsZtzbw22nenuhVW23wHcBKS7e8luzv8G2ObuxwRfHwaMB0a5+8dVjjsKGAsc7e6f7e79NNcgXZW7s3jDtkCoXriRiUs2sb20ghiDQR0zOaxXNicPak+fnLRolyoiIiIiIlIvtQXp+ix/NZLA8OclwIvAdVV2VwLXALsN0sAA4M0ats8mMFHZns5dWjVEVzk3AegZfF5T7VnAQODpatcDmFXD9QD6A7sN0gJmRs82afRsk8Zlh3ajtLySaSu3BIaBL9rIg58t4oGxixjcMYMzh3ZizOD26qkWEREREZFGrc5BGvgz8CHwIyCWXYP0d8DFdbhGFrC5hu15QMt9OHfH/to8ABjwj2rXo4Zr7vZ6ZnYVgXuw6dy5TnOkNSsJcTEM65bFsG5Z/GJUHzZtK+HNaWv4z+SV3PrGLP74zhyOH5jD2UM7MaJ7K2JiLNoli4iIiIiI1Et9gvQBwOnu7mZWfTz4RqB16MoKHTO7GTgf+PGO+7L3hbs/BjwGgaHd+3q9pq5Vi0QuH9mNyw7tyqzVBfxn8krenLaaN6etoUNmMmce2JEzD+yoicpERERERKTRqE+QLiYwu3ZN2gH5dbjGZmruea6tt7n6uV1qORe+70neKbiU1d3ALe7+VA3XI1jP2rpcT/aembFfxwz265jB707qx0dz1vHq5JXcP3Yh//x0IYf0aMXZQztx/MAckuJjo12uiIiIiIhIreoTpL8Erjezqvc47+iR/TGBCbr2ZDbf35tcVX9gTh3OPc3MUqrdJ90fKAV26W02s4uAh4C/u/tdtVyPYD1Vg3T/4OOe6pG9lBQfy5jB7RkzuD2rNhfy3ymreXXKSq5/ZRppb8YxZnB7zh7aiUEdMzDT0G8REREREWlY6jxrd3D5qa8ILCP1GoEZtB8ABgMHAge5+/w9XON64G9Ab3dfEtzWlcDyVze5+993c+7+BO7FvtTdnw1uiwNmAovc/ZQqx54GvAo85e5X1XK9eALLX73j7pdV2f4EcBqB5a9Kd/d+NGt36FRWOhOXbuLVyat4b+ZaSsor6d22BWcHJyhrk54U7RJFRERERKSZCdXyVwcA9xBY/iqWwGzdXwC/cPepdTg/FZgOFAG3EOjR/gOQBgxy923B47oAi4E73f3OKue/DIwGfgUsBX4CnAwc4u7fBY85HPiIQI/zz4I17lBStc7g0O+HCAz//gQ4OljXz9z9wT29HwXp8CgoLuPt6Wt4dfIqpq3cAkCbtET6tUunb7s0+rdLp29OOt1bpxIfGxPdYkVEREREpMna5+WvAIJh9RgzSyJwL/GWGpaj2t35283saOA+4HkCM2l/Cly/I0TvqJdAUK+eki4D7gL+SGAd6+nA8TtCdNDRQCKBydG+qnb+cqBrlXoeCU6c9ksC4XwFcJ27P1TX9yShl54UzwUHd+GCg7uwYN1Wxs3fwNzcAuau3crXizdSVhH48ichNoaebVrQr106/dqlBYJ2ThqtWiRG+R2IiIiIiEhTVq8e6R+cHFifuRswy91LQlZVI6Ee6cgrq6hk8YZtzFu7lblrC5ibG3jcsPX7j1+btET67gjXOen0a5dOl1YpmsRMRERERETqZZ97pM3sFiDV3W8Ovj4ceAdIBVab2THuvjBUBYvUJD42hr45gaHdP9q/w87tG7eVMG/tVublFjBnbQHz1m7l6cWbKK34fmR/m7REOrZMpmPLFDq0TN75vGPLZDpkJitoi4iIiIhIndRnsrF5BGbAfjz4egJQDvwVuA1Y7O7nhqvQhkg90g1bWUUlSzZsZ15uAcs3FbJqcyGrNhexanMRa7YUUV6562e/dZWg3bFa0G6fkUxygoK2iIiIiEhzEop7pDsQmF0bM2sNDAOOcffPzSwBuD8klYqESHxsDH1y0uiTk/aDfRWVzvqtxcFgXciqvEDAXrWlkBmrtvDBrLU778XeISE2hvTkONKT4klLjic9KfB8x7b05HjSdrMtJSFWy3mJiIiIiDQB9QnSFUBC8PnhQDHfT+a1gcDkYyKNQmyM0S4jmXYZyRzU9Ycf3epBe21+MQVF5RQUl7G1uJyCojIKistYs6WIguDrkvLKGlr6Xr926Vx3VE9OGJhDTIwCtYiIiIhIY1WfID0buNDMvgYuB8a5e1lwXydgfaiLE4mWPQXtmpSUV1QJ2YHHrcWB8J23vZT/freKa1/8jp5tWnDtUT04ZVB74rR8l4iIiIhIo1Ofe6RHA28C8UAZMNrdxwX3vQCkuPtp4Sq0IdI90lIfFZXO+7PW8q+xi5iXu5UurVL46ZE9OG3/jiTEKVCLiIiIiDQ0td0jXa/lr8ysG4H1mae5++Iq268Gprv7xFAU21goSMveqKx0Pp67jgfGLmTW6gI6ZCZzzZE9OOvAjpo5XERERESkAQlJkJZdKUjLvnB3Pl+wgQc+Xch3K7bQNj2Rqw7vwfnDOmuGcBERERGRBiBUPdJxwAgC90QnVdvt7v70PlXZyChISyi4OxMWb+L+sQuZuCSPVqkJXHFYdy4a0YUWifWZxkBEREREREJpn4O0mR0A/A/oCNQ05bC7e7PqRlOQllD7dlkeD4xdxPgFG8hMiefyQ7txySFdyUiOj3ZpIiIiIiLNTiiC9CQgFbgJmAeUVj/G3ZfvY52NioK0hMu0lVv419iFfDJ3PWmJcVxySFcuH9mNrNSEPZ8sIiIiIiIhEYogvQ04293fC3VxjZWCtITb7DX5PPjZIt6flUtiXAzDurViRPdWjOjRioHt07V8loiIiIhIGNUWpOtzA+YCAj3SIhIhA9pn8NAFB7Jw3VZe+GYFXy3ayF8+mAdAWmIcw7plMaJHK4Z3b0X/dunExNR014WIiIiIiIRSfYL0b4G/mNk37r4iXAWJyA/1apvG7WMGALBhawkTl2xiwpJNTFi8iU/nrQcgIzmeg7tlcUiPVozokU3vti0wU7AWEREREQm1Ogdpd//AzI4EFprZAmDzDw/xI0JYm4jUoHVaIqcMbs8pg9sDkJtfzIQlG5mwOBCuP5qzDoBWqQkM796K4T0Cw8F7tE5VsBYRERERCYE6B2kzuwn4NbABKAAqwlWUiNRdTkYSp+3fkdP27wjAyrxCJizZxMRgsH535loA2qQlMqxbFkM6ZTKkUyYDO2SQFN+sJtoXEREREQmJ+kw2lktg+avr3F0hGk02Jg2fu7N8UyFfB0P1d8s3s3pLEQBxMUbfdmkM6ZTJ4I6Z7N85k+7ZLXSftYiIiIhIUChm7S4AfuTuY0NdXGOlIC2N0fqCYqat3MK0lVuYvmoLM1bms7WkHAhMYDaoU0aw17olQzpl0jotMcoVi4iIiIhERyhm7X4fGAEoSIs0Ym3Skxg1IIdRA3IAqKx0Fm/YtjNcT1u5hUfGLaGiMvAlW4fM5J3DwQd3yqRfuzTSkuKj+RZERERERKKqPkH6H8AzwcmKPuCHk43h7ktCU5aIREpMjNGrbRq92qZx1tBOABSVVjB7TT7TVm5h6sotTF+5Zee91hAI131z0uiTk0bfdun0zUmjW3Yq8VrXWkRERESagfoM7a6s8rLGk9y9Wc1cpKHd0pxs2FrCjFVbmJe7lXm5W5mfW8CSDdspD/ZcJ8TG0L11ajBgB8J133Zp5KQnabZwEREREWmUQjG0+3JqCdD1LKQTcB9wHGDAJ8D1dVmb2sySgD8AFwKZwDTgN+4+vtpxvwCOAoYCOcAd7n57Ddd7Brikhqb+6e7X1/EtiTQLrdMSOaZfW47p13bntpLyCpZs2M683IJguN7KN0vzeGPamp3HpCfF0TcnnT7BHuxBHTMY2D5Dk5qJiIiISKNVn3Wkn9nXxswshcA91iUEAqwDfwQ+M7NB7r59D5d4EjgJ+BWwBLgW+NDMRrj7tCrHXUlgia43gGv2cM0NwJhq29bWdKCI7CoxLpZ+7dLp1y59l+35hWXMX7d1l4D9v6mr2Rac1CwrNYHDemVzRO/WHNartSY0ExEREZFGpT490qFwJdAd6OPuiwDMbAawELgauLe2E81sMHA+cLm7Px3cNg6YDdzJrmF4gLtXmlkcew7Spe4+cS/fj4jUICMlnmHdshjWLWvnNndn9ZYipizfzLj5Gxi/cANvBnuu9+uQwRG9W3NEn9bs3ymTON1rLSIiIiIN2G6DtJndD9zt7rl1vaCZnQ4kuPvLNeweA0zcEaIB3H2pmX0FnMpugnTw3DLglSrnlpvZy8BNZpbo7iXB7ZW1XENEosTM6NgyhY4tUzh1SAcqK505awv4fP56xi3YwMPjFvOvzxaRlhTHyJ7ZHNmnNYf3bk27jORoly4iIiIisos99Uh3BZaY2dvAC8CX7p5X9QAziwEGAafw/b3LF9VyvQHAmzVsnw2ctYdaBgBL3b2whnMTgJ7B5/XVxsw2Eqh7CYHh439z94q9uJaI1FFMjDGwQwYDO2Rw3dG9yC8q4+tFGxm3YAOfz9/A+7MC39/1aZvGEX1ac0Tv1gzt2pLEuGY1p6GIiIiINEC7DdLuPsbMDgduBP4LxJjZGgL3FZcALYFOQBKB+4ofB+5z94JaLplFDctmAXnBa+3O7s7dsb++pgFTCATwJOA04E9AL+CKmk4ws6uAqwA6d+68F02KSE0ykuM5Yb92nLBfO9ydBeu2MW5BoLf66a+W8tj4JaQkxHJIj1Yc068to/q3pVUL3VstIiIiIpG3x3ukgzNijzezdsAo4GCgPYHguYRAT/V44IvGNqTa3f9RbdN7ZrYNuN7M/uLuC2s45zHgMQgsfxX+KkWaHzPbOcv3VYf3YHtJORMWb2Lcgg18Nn89n8xdz+/+N5ODumZxwsAcRg/M0RBwEREREYmY+szavRZ4NviztzZTc89zbb3N1c/tUsu58H3P9L56CbiewNJZPwjSIhJ5qYlxHNu/Lcf2b4t74N7qD2fl8sHsXG5/ew63vz2HwZ0yOWFgDscPyKFrdmq0SxYRERGRJizSs3bPJnCvc3X9gTl1OPc0M0updp90f6AUWFTzaXtNvc0iDZCZMaB9BgPaZ/CLUX1YvGEbH8zK5cPZufz5/Xn8+f159M1J4/iBORw/MIc+bdMw05rVIiIiIhI6kQ7SbwF/M7Pu7r4EwMy6AocCN+3h3LeBOwhMSvZs8Nw44Bzgox0zdofABQRC9Lchup6IhFGP1i249qieXHtUT1ZtLuTD2ev4YNZa/vnpQv7xyUK6tkrh+IHtOH5gDoM7ZihUi4iIiMg+M/fIdbyaWSowHSgCbiEQWP8ApAGD3H1b8LguwGLgTne/s8r5LwOjgV8BS4GfACcDh7j7d1WOG0pgxvEYAstlvQr8J7j7PXcvDLbxPPAygd7sRAKTjV0KPOruP9nT+xk6dKhPnjx5b/4pRCTM1m8t5uM56/hgVi4TFm+ivNJpl5HE6AE5HN47m4zkBFISYkmOjw08JsSSkhBHbIyCtoiIiIgEmNkUdx/6g+2RDNLBQjoD9wHHAQZ8Clzv7suqHNOVQFC+w91vr7I9GbgLOJ/AclXTgd+4++fV2ngGuKSWErq5+zIzywKeAvYH2gKVwLzgtofqMnGagrRI47ClsJRP567n/Vm5jF+4gdLy2v/vnRAXQ0pCLCnxgXCdnBBLSnxcMGjH7nw8qGsWJ+3XjrjYmAi+ExERERGJpAYTpJsSBWmRxmd7STlz1hawvaScotIKCksrKCyroKi0nMLSCorKKnZuDzwGtheXBY8trWBrcRkFxeV0zkrhmiN6cMaBHbS+tYiIiEgTpCAdBgrSIs1TZaXz8dx1PPTZIqavyqdNWiJXHtad8w/uTGpipKeeEBEREZFwqS1I13lMopmdamaXVXndxcwmmNlWM3vNzFqEqlgRkYYsJsYYPSCHN649lH//+GB6tmnBXe/N5dC/jOW+jxeweXtptEsUERERkTCqz819twCtq7y+F+gIPAYcDtweurJERBo+M2Nkr2xevHI4//vpIRzUNYt/frqQQ/8ylrvencO6guJolygiIiIiYVDnod1mlgec7+4fBCf9ygMudvdXzewK4GZ37xHGWhscDe0Wkerm527l4c8X8faMtcSaccaBHbnmiO50aZUa7dJEREREpJ72eWg3kERg2SqAQwisQf1R8PV8oP0+VSgi0gT0yUnjH+fuz2e/PJKzhnbkv9+t4qi/fc7/vTSVuWsLol2eiIiIiIRAfYL0MmBk8PmpwBR3zw++bgPk13SSiEhz1LlVCnedth9f/voorjysO5/OXccJ//yCHz/zLVOWb452eSIiIiKyD+oztPvnwN8IrN08BPiJuz8e3Pc34AB3PzpMdTZIGtotInWVX1jGsxOW8fRXS9lcWMawrlmMGtCWkb2y6dM2DTOLdokiIiIiUk1Ilr8yswuA4cC37v5cle2PAl+6+/OhKLaxUJAWkfoqLC3npUkreeGb5SzZsB2A7BaJjOzZipG9WjOyZzY5GUlRrlJEREREQOtIh4WCtIjsi9Vbivhq0cadPxu3BZbN6tmmBSN7ZjOyZzYHd88iLSk+ypWKiIiINE/7HKTNrDeQ6e6Tgq+TgduAgcCH7v6vENbbKChIi0ioVFY689dt5cuFG/ly0Ua+WbqJ4rJKYmOM/TtlcmjPbA7rlc3gTpnEx9ZnegsRERER2VuhCNIfAdPc/dfB1/cC1wEzgUHA9e7+YOhKbvgUpEUkXErKK/hu+Ra+XLSBLxdtYuaqLVQ6tEiMY3j3LA7tGQjVHTOTyW6RSEyM7rEWERERCbVQBOl1wFXu/qaZxQDrgbvc/T4z+z1wursPDmnVDZyCtIhESn5hGROWbOSLhYFh4Ms2Fe7clxAbQ7vMJNpnJNOhZTLtM5PpmBl47NAymXYZSSTFx0axehEREZHGqbYgHVePa2QAm4LP9wdaAq8FX38O3LgvBYqISO0yUuI5fmA7jh/YDoCVeYUsXL+V1VuKWb25iNVbilizpYgvF25k3dZiqn9Hmt0ikQ6ZSYGgnREI2Z2yUji4exbpugdbREREpF7qE6TXAT2BL4FRwGJ3Xxnc1wIoD3FtIiJSi05ZKXTKSqlxX1lFJbn5xTvD9erNRazJL2LV5iLm525l7Lz1FJdVAhAfaxzaM5sTB7bjuP5taZmaEMm3ISIiItIo1SdIvwX8ycwGApcCj1bZtx+wJIR1iYjIXoqPjdlt0HZ3NheWsWj9Nj6ek8v7s3L59X9nEPs/Y3j3LI4f2I7RA9rSJk3LcImIiIjUpD73SKcC/yC4jjTwM3ffHtz3NTDO3W8OU50Nku6RFpGmwN2ZvaaA92et5f2ZuSzZuB0zGNqlZXA4eQ4dMpOjXaaIiIhIxGkd6TBQkBaRpsbdWbBuG+/PWssHs3KZl7sVgMGdMjlhYA4nDMyhS6vUKFcpIiIiEhkhC9JmlgWMALKAPGCCu+eFpMpGRkFaRJq6JRu28cHsXN6fmcvM1fkA9GuXvjNU92qbFuUKRURERMInJEHazP4I/BJIrLK5BPibu9+6z1U2MgrSItKcrMwr5MPZgXuqpyzfDEDPNi04eVA7Thncnh6tW0S5QhEREZHQCsU60tcD9wJPAv8GcoEc4ELgcuAGd78/VAU3BgrSItJcrSso5sPZubwzYy3fLsvDPdBTfcrgdpwyqH2tE52JiIiINCahCNLzgPfd/YYa9t0HnODuffe50kZEQVpEBHLzi3l35lrembGGqSu2AIF7qk8Z1I6TBrWjXYYmKhMREZHGqbYgHVOPa3QF3q1l37vB/XUppJOZvWZm+WZWYGavm1nnOp6bZGb3mNlaMysyswlmdngNx/3CzN4OHudmdvturvkjM5tqZsVmttzMbjGz2LrUIyIikJORxI9HduN/Pz2UL359FDed0JeKykr++O5cRvxpLGc98jXPTVjGhq0l0S5VREREJCTqE6Q3AQNr2TcguH+3zCwFGAv0BS4BLgJ6AZ8Fl9fakyeBK4HbgJOBtcCHZjak2nFXAm2AN/ZQz2jgvwSW8zoB+CdwC3B3HWoREZFqOmWlcM0RPXjnZ4fx2Y1H8svjepNfVMZtb87m4Ls/4YInJvLSpBVs3l4a7VJFRERE9lp9hnb/i0D4/SnwkruXm1kccBbwCPCsu//fHq7xcwL3Wfdx90XBbd2AhcCv3f3e3Zw7GJgGXO7uTwe3xQGzgfnuPqbKsTHuXhncXwbc4e6313DNqUCBux9RZdttBMJ0Z3fP3d370dBuEZG6mZ+7lXdmrOGdGWtZunE7cTHGyF7ZnDKoPaMH5tAiMS7aJYqIiIj8QCjukU4D3gMOBSoILH2VBcQCXwInuvu2PVzjUyDJ3Q+ttn0cQNVAW8O5twK3ApnuXlhl+x3ATUC6u5dUO6fWIG1mnYAVwFXu/niV7d2AJVQJ7LVRkBYRqR93Z/aaAt6esYZ3pq9l9ZYiUhNiGTOkPece1JlBHTMws2iXKSIiIgLUHqTr3AXg7luD9yOfBBzG9+tIjyMwCVldEvkA4M0ats8m0LO9p3OXVg3RVc5NAHoGn9fVgODjrKob3X2pmRUC/etxLRERqQMzY2CHDAZ2yOCm4/vy3YrNvDxpJW9MXcNLk1bSr1065w3rxKlDOpCRHB/tckVERERqVK+xdMGw/E7wZ29kAZtr2J4HtNyHc3fsr28t1HLNzbVdz8yuAq4C6Ny5TnOkiYhIDcyMA7tkcWCXLG47pT9vTlvDy9+u4LY3Z3PXu3M5ab92nDusMwd1baleahEREWlQdFNaPbn7Y8BjEBjaHeVyRESahLSkeC4c3oULh3dh1up8Xpq0gjenreH1qavp0TqVcw/qzBkHdiQrNSHapYqIiIjsftZuM6s0s4o6/pTXob3N1NzzXFtvc13Phe97putqR3s1XbPlXlxPRERCYGCHDO46bT8m/e4Y/nrmIDKS47nrvbkcfPcnXPvid3y5cCOVlfoeU0RERKJnTz3SdwKh/K+V2Xx/b3JV/YE5dTj3NDNLqXafdH+gFFi0F7UQrGfCjo1m1hVIqUM9IiISRikJcZw9tBNnD+3E/NytvPztCl7/bjXvzlhL56wUzjmoE2cd2JE26UnRLlVERESamTrP2h2SxsyuB/4G9Hb3JcFtXQksf3WTu/99N+fuD3wHXOruzwa3xQEzgUXufkoN5+xp+atpwGZ3P6rKtlsIrFOt5a9ERBqY4rIKPpydy0uTVjBxSR6xMcaRvVtzZN82HNGrNZ1bpUS7RBEREWlC9nn5qxAVkQpMB4oIrNXswB+ANGDQjuWzzKwLsBi4093vrHL+y8Bo4FfAUuAnwMnAIe7+XZXjhgJdCQxdfwV4FfhPcPd7O3q0zexEAhOnPQ68BOwP/Al4wN1/taf3oyAtIhI9Szdu5+VvV+xcRguga6sUDu/dmsN7tWZEj1akan1qERER2QcNIkgHC+kM3AccBxjwKXC9uy+rckxXAkF5l55kM0sG7gLOBzIJhPLfuPvn1dp4BriklhK6VWvrdOD3QF9gHfAEcJe7V+zpvShIi4hEn7uzdON2xi/YwPiFG5mweBNFZRXExxoHdmm5M1j3b5dOTIxm/xYREZG6azBBuilRkBYRaXhKyiuYvGwz4xdsYNyCDczL3QpAdotEDuuVzeG9szmsV2uyWyRGuVIRERFp6BSkw0BBWkSk4VtfUMz4hRsZv2ADXy7aSN72UgAGtE/f2Vs9tGtL4mN3u5CFiIiINEMK0mGgIC0i0rhUVjqz1uQHhoEv2MiUFZupqHQyU+IZ3T+HEwe145AerRSqRUREBFCQDgsFaRGRxm1rcRlfLdrIB7Ny+WTueraVlJOZEs+o/m05aVB7hWoREZFmbq+CtJldXJ9G3P25vait0VKQFhFpOorLKhi/YAPvzVyrUC0iIiLA3gfpynq04e4euzfFNVYK0iIiTdPuQvWJ+7Xj0J7ZCtUiIiLNQG1Bek8LbHYLUz0iIiINVlJ8LKMG5DBqQM4uofq9mbn8Z/IqhWoREZFmTvdI7wP1SIuINC/FZRV8sXAj785Ys7OnOiM5nmP6tWH/Tpn0b59Bv3ZppCTs6XtqERERaQz2tkdaREREgpLiYzmuf1uO6992Z6h+b+Zaxs5bz+vfrQbADLplpzKgfQYD2qcHfzLISk2IcvUiIiISKvUK0mY2CvgJ0AdIqr7f3buHqC4REZEGrWqodnfW5Bcze3U+s9cUMHtNAd8t38zb09fsPL5dRhID2qfTv106/YMhu2PLZMwsiu9CRERE9kadg7SZnQi8DXwC9AU+AFKAQ4HlwBfhKFBERKShMzM6ZCbTITOZUQNydm7fvL2UOWsL+P/27jxMrrrO9/j7W0t3daf3dEL2DiEETSBB0jCiERTlwqMYuS6gjCPqFb1e9YKjCA46jiyPeq8DzswzbiM6DKhB0bkg48oWBEHoRBISICSQfYEsvSTppbbv/eOc6lRXOkl30l3Vy+f1PP2cqt/5nVO/7pynKp/6LWftjkMB+6EXXiUbzqqqrYgzf2rQa/3GUxs579RJRCMK1iIiIiPdgOdIm9kTwNPAZ4EU0OzuK81sHvA74Dp3/9mwtXQE0hxpEREZrK5khhd2dfQG6+d2tPPCrv30pLNMqUnw3sUzuKx5JrMmVpa6qSIiIuPecd3+quAErcBlBD3SaeBcd38q3Hcl8Hl3P2PomjzyKUiLiMhQSKazPPTCKyx7eiuPvribrMMbTpnI5WfP5KIFU0jEx9XdJUVEREaMoVhsLAuk3d3NbDcwC3gq3LcDOOXEmykiIjL+lMUiXHz6VC4+fSo727u4p2UbP1uxlauXPUNtRZxLz5zGZWfPZMG02lI3VURERBhcj/SfgH9z9x+Z2f1AHfA+gt7pO4FZ7j5/uBo6EqlHWkREhks26zzx8l7ufnorv127i2Q6y+nTa7i8eSZLz5xObUW81E0UEREZ84ZiaPengCZ3/4KZLSYY4l0T7s4AV7j7PUPV4NFAQVpERIqhrTPJvc/sYNnTW3l+ZwflsQhvP2MqlzXP5PVzGrTyt4iIyDA54SDdzwlnABcTrNz9gLs/d2JNHH0UpEVEpJjcnTXbO7i7ZQv3PrOD/d1pmiZWclnzTN67eAYn1Rx2Z0oRERE5AUMepEVBWkRESqcrmeE3a3Zy99Nb+fPGfZjBnMYJLJxRx8IZtSycUceCaTVaqExEROQEDMXQ7r8AdwA/dfdXhrh9o5KCtIiIjASb9hzk/tU7eGZrG6u2tbN7fw8AsYgx76Tq3mC9cEYtp02pJh6NlLjFIiIio8NQBOlfAxcCDjxIEKr/n7t3D2VDRxMFaRERGYl2tXezalsbq7e1sXpbO6u3tdPelQKgPBZh/rQaFk4PwvWimbXMaawiEtE8axERkUJDMrTbzCYDVwAfBM4C9gO/AO5094eHqK2jhoK0iIiMBu7Oln2drNrWzuqtQbhes6OdzmQGgKryGKdPr2HRzDrObmpgcVM99RPKStxqERGR0huOxcZeC/wNQbCeCWxz96YTauUooyAtIiKjVSbrvLT7AKu25nqt23huZwepTPD/grmTqzh7dj2Lmxo4e3Y9sxoqtTq4iIiMO8Oy2JiZJYD3AF8Hprn7MVc0MbOZwG0Ew8SN4DZa17j7lgG+3k0EPeJ1wDPAde7+aEG9CHAd8AlgCrAOuNHdf1FQ7xHg/H5e6rPu/q1jtUdBWkRExpLuVIZVW9to2dxKy6Z9rNjcSkd3GoDGqnLOnl1P8+wGmpvqmT+tRnOtRURkzDtSkI4d58kuIOiNfjdQBTwFfG0Ax1UCDwE9wJUE861vBh42s4XufvAYp7gdeAdwLfAy8Cngd2Z2rrs/k1fvJuDzwA3ACuD9wM/N7BJ3/3XBOVcTBO58m471u4iIiIw1iXiUv5ozkb+aMxGAbNZZ/+oBWjbvo2VTKy2b9/GbNbsAqIhHOXNmXdBrPbuBs2bVUZ2Il7L5IiIiRTOYxcZOJ+gJvgKYQRA27yKYH71+gOe4GrgVOM3dN4RlJwPrgS+4+61HOXYRQQ/0R939R2FZDFgLrHP3pWHZZGAr8HV3/0re8Q8Ck9x9YV7ZI0DM3ZcMpP2F1CMtIiLjza727j7B+rkdHWQdIganTamhuame5tn1nDWrnhn1FRoOLiIio9pQ9EivBtqBnwP/4e6PHUc7lgJP5kI0gLtvNLPHgXcRhOyjHZsC7s47Nm1my4Drzazc3XuAi4AygpCf7y7gh2Z2srtvPI62i4iIjHtTahNcsnAalyycBsCBnjTPbGnrDde/XLmNO5/cDMBJNeU0NzVwVlO9hoOLiMiYMpggfRnwqzCsHq8FwL39lK8F3jeAYze6e2c/x5YBc8PHCwiGjm/opx7AfCA/SL/OzNqBSuB54J/c/fZjtEVEREQIVvxecmojS05tBCCdybLulf2s2NzKis2ttGxq5b+e3QlAIh5h0Yw6mmfXs7gp6LWuq9Tq4CIiMvoMOEi7+z1D8HoNQGs/5fuA+hM4Nrc/t23zw8esF9YDeBT4MfAiweJlHwJ+YGZT3f3m/hphZh8HPg4wa9asYzRZRERkfIlFIyyYVsuCabV86NzZQDAcfMXmYCj4is2tfHf5y2Sywcf0qZOrWNwUBOvm2Q3MnqjVwUVEZOQ7rsXGxgp3//uConvN7D+BG8zsW+5+oJ9jvg98H4I50kVopoiIyKg2pTbBOxZO5R0LpwLQmUyzams7K8Jg/etnd7Ls6a1AsDr4efMaOX/eJJbMbWRiVXkpmy4iItKvYgfpVvrveT5Sb3Phsf3dpzrXw7wvr16dmVlBr3RhvSP5KXApcAbwxDHqioiIyCBVlsU495SJnHvKodXBX9p9gJbNrTzx0l4efuFVfrlyO2awcHot582bxPnzJnHmzDpimmMtIiIjQLGDdG4Oc6H5wHMDOPa/m1llwTzp+UCSQ3Oi1wLlwCn0nSc9P9we63Vy1NssIiJSBJGIcepJ1Zx6UjUfOGcWmayzZns7y1/czfIXd/OvD2/gXx7aQHUixpK5QW/1efMmMa2uotRNFxGRcWrAt78akhczuwb4JjDP3V8Oy2YT3P7qenf/x6Mc+zpgJfBhd78jLIsBzwIb3P2dYdlkYBtwi7t/Ne/4B4CT3P2MY7TxXuBCgltlHfW+1rr9lYiIyPBr70zx+Et7WL4uCNa7OrqBYH71+fMmcf5pkzh7dgOJeLTELRURkbHmSLe/KnaQngCsArqALxH0+t4EVAMLc3OSzawJeAm40d1vzDt+GcHtra4lWHn7k8AlwBvcfWVeva8D1wB/RxC+Lwc+ASx19/vDOm8Crgd+SXBP7FrgSoLbbF3v7t841u+jIC0iIlJc7s76Vw/0huqnNu4jmcmSiEd4/ZyJnD9vEm86tZFTJlVp0TIRETlhQ3Ef6RPm7gfN7ALgNuBOwIAHgWsKFvYyIAoUToT6CHALcDPBKturgIvzQ3ToBuAAcDUwBVgHXJYL0aGd4flvBBoJ7lG9GrjC3X96Yr+piIiIDAczY95J1cw7qZqrzptDZzLNn1/e1zsM/Ku/CmZwTa1N8Ma5jSyZ28gb5zYyqVqLlomIyNApao/0WKMeaRERkZFly95OHtuwh8c27ObxDXtp70oB8Jop1SyZG9zv+pyTG6gsG9c3LhERkQEaEUO7xxoFaRERkZErk3XW7mjnj+v38PiGPbRsaiWZyVIWjXBWU10YrCdxxvRaohENAxcRkcMpSA8DBWkREZHRoyuZ4elN+4Ie6/V7eG5nBwA1iRhvOCXorV4yt5GmiZWaXy0iIsAImSMtIiIiUioVZVHOC2+dBbDnQA9/emkvj63fzWPr9/DbtbsAmF5Xwdmz61ncVM/ipgZOm1KtHmsREelDPdInQD3SIiIiY4O7s3HPQR7bsIcnXtpLy+ZWdu/vAaCqPMbrZtWxuKme5qYGzpxVR1W5+iJERMYDDe0eBgrSIiIiY5O7s621i5bN+1ixuZWWTa2se2U/7hAxeM2UGpp7e63rmV5XoeHgIiJjkIL0MFCQFhERGT86ulM8s6WNls2trNi8j79saaMzmQFgSk2CxbPrWTyrnubZ9bx2ag3xaOFdPEVEZLTRHGkRERGRE1CTiPeZY53OZHlh135WbG7t/fmv1TsBKItFeO3UGhZOr+WMGbUsnFHL3ElVxBSuRUTGBPVInwD1SIuIiEi+ne1dtGxq5dnt7aze1saa7R0c6EkDkIhHmD+1hoUz6jh9ehCuT5lUpYXMRERGMA3tHgYK0iIiInI02ayzce9B1mxvZ/W2dp7d1s6aHe29Q8Ir4lEWTKvp7bU+Y3otJzcqXIuIjBQK0sNAQVpEREQGK5N1Nu45EATr7UG4Xrujg65UEK4nlEWZP62GmQ2VzKirYHp9BTPqK5leV8HUugTlsWiJfwMRkfFDc6RFRERERoBoxJg7uZq5k6t591kzgCBcv7Q7DNfb2nh+536efGkvuzq6yRb0eUyuLmd6fQXT80J2LnBPr6tggm7NJSIy7NQjfQLUIy0iIiLDKZXJsqu9m22tXWxv62J7axfbWjuDx21d7GjrIpXp+3+5usp4ELLzwvW03p8EjRPKiWjouIjIgKhHWkRERGSUiUcjzGyoZGZDZb/7s1nn1f09bG/rLAjbXWzcc5DHNuzpnY+dUxaLMK020Ruuc6E7F7Sn1VWQiGv4uIjI0ShIi4iIiIxSkYgxpTbBlNoEi5sO3+/udHSl+/Rg78h7/Nj6Pbyyv5vCAYqNVWVMra2gYUIZ9ZVx6irLqKuMU3+EbVV5DDP1covI+KEgLSIiIjJGmRm1lXFqK+PMn1bTb51kOssrHd0FQbubHW1dtHYm2bjnIK2dSfZ3p4/4OrGIURcG7t7gXRGnpiJORTxKRVmURDxKIh4JnsejJMqiJGLBvt6yeIRE+Dyed89tdyeZydKTztKdytCTynucztKTzpVl+pansqSzTnks0uf1E/Eo5fGwLBa+bvxQGxOxqIa/58lknWQ6SzRilMV0L3QRUJAWERERGdfKYkcfPp6TzmRp60rR1pmkrTNFa2eK1s4kbZ1JWjtTtHWmwsdJtu7rZHUYvrtTmcMWTBuIWMRIxKOks0FoLvayPmWxCIkwgOduR5Zrg+N9ngdlHFZ2qNTCMH94YO8v1Ffk1SkPH0cM0hknnXXSmeALgkzWSWWyZLK5ciedzfapk39MMpMllcmSTAd/02Q6fB6WBc893JcJ6wevkzOhLEpdZRkNEw6NSsh9edK3rIz6CcHjyrKoRizImKMgLSIiIiLHFItGaKwqp7GqfFDH5XqTu5NZutMZupIZulIZulOHtt2pbJ/y3L6uZJZ4NAih5fFon20i9zwWoTwMoOWxIJTm749GjJ5U8NrdqWzv+btzZclMwb5wG/ZyB18EHAqSRhAIc7mwbz60w8oMyDq9vea5c3ensrR1pnpfsyf823Sns32C62BFDGKRCLGoEY0Y8WiEWMSIhb3J8WiEslik9/GE8hj10chh+8qifbfxaIRMNht8gXIw+MKktTPF1n2dtHamaO9KHbFNZdFIb8Aujwf/JrHIofblP4+F7c2VFT4vj0UPhfUJuVEQQZivScQ1kkCKRkFaRERERIaNWRB+ymNRaomXpA2VZSV52eOWyvQN9T3pDO70DZ5R6w3MQVAOAmepgmQ6k6W9KxWOTkgeFrhzoxVSmb696J3JTG+Pea6ssKc9k9fDfrQRDhGD2orCOfxByK6fcChw14bTDmoSweOqRKx31IHIQClIi4iIiIiMIPFo0ANcnSh1SwYuFo0wsaqciYMcsTBY2ayzvyd9KKyH0wv2HTwU1nPBfWd7N8/v7KC1M0VXKnPU81aXx6ipiFOdiPWG7JqKWBC6E7ng3Xdfrry6PKae8HFIQVpEREREREaFSMSorQh6kpsmDvy47lSGts4U+w4m6ehO0dGVoqM7HW5TdHSlae99nGJ7WxfP7wyeH22hPQiG8leVx44ZuAvLcz3jVWUK4qORgrSIiIiIiIxpiXiUKbVRptQOvps/k3UO9AShu70rL4QfIZB3dAdzx/eH5ft7jh7EIwbVidyQ81jvkPOaRLDifk3iUOjOH5LeWFWmeeElVPQgbWYzgduACwnWX3gAuMbdtwzg2ARwE/BBoA54BrjO3R8tqBcBrgM+AUwB1gE3uvsv+jnnVcDngJOBTcBt7v7d4/vtRERERERkLInm9YLPPI7jM1lnf17Ibu9Ksb87F8oPlfUG9e4061890BvOu1PZI547FjEaJgQrpjdWlTOxqoyJE4JtY5/HwbayTP2oQ6Wof0kzqwQeAnqAKwnuCXAz8LCZLXT3g8c4xe3AO4BrgZeBTwG/M7Nz3f2ZvHo3AZ8HbgBWAO8Hfm5ml7j7r/PacxXwPeBrBIH+rcC3zczc/Tsn+vuKiIiIiMj4Fo1YcG/141z1rjuVYX/3oaHnudC990CSvQd72HsgyZ7w8ZYtnew90MPBZP9zwivi0TBsl1E/oYzqRNDjXR0ON889r+nzPJg7rtuY9WVexJvymdnVwK3Aae6+ISw7GVgPfMHdbz3KsYsIeqA/6u4/CstiwFpgnbsvDcsmA1uBr7v7V/KOfxCY5O4L847dAfzG3a/Mq/dDYCkw1d2PvI4/0Nzc7C0tLYP7I4iIiIiIiAyjrmSGvQd72HcwGQbtHvYeTLL3QBC8dx/oCXvGDw1LT2WOngujEQsWYwuDdU0izoTyGBPKo1SWxagKtxPKo0F5WRC+q8pjVJbHmFCWV14eJR6NFOmvcWLMbIW7NxeWF7tvfynwZC5EA7j7RjN7HHgXQcg+2rEp4O68Y9Nmtgy43szK3b0HuAgoA+4qOP4u4IdmdrK7bwTOBSb1U+9O4CPAEuDh4/gdRURERERESqaiLMqMskpm1FcOqL6705PO9pn/3TvHO28++P6CfdvbuuhMpjnYk+ZgT+aYq6PnK4tGmFqXYPm1bzneX7Okih2kFwD39lO+FnjfAI7d6O6d/RxbBswNHy8gGDq+oZ96APOBjWE9gDVHqacgLSIiIiIiY5qZkYhHScSjTK45/vNksk5nMk1nMtMbrg8m02HYDsuSGTp70hxIpomO4qHixQ7SDUBrP+X7gPoTODa3P7dt88PHrPdXj37OWVivDzP7OPBxgFmzZh2jySIiIiIiIuNDMPw7TnUiXuqmDLvRMTB9BHH377t7s7s3T5o0qdTNERERERERkSIrdpBupf+e5yP1Ng/0WDjUk9wK1NnhS8r1V49+zllYT0RERERERKRXsYN0bg5zofnAcwM49uTwFlqFxyY5NCd6LVAOnNJPPfJeJzcXurA9hfVEREREREREehU7SN8HvN7M5uQKzGw28MZw39H8CoiTtyhZeAury4Hfhyt2A/yWYHXvvy44/oPAmnDFboAngD1HqLcPeHxgv5KIiIiIiIiMJ8VebOzfgE8D95rZlwAHbiK47/P3cpXMrAl4CbjR3W8EcPe/mNndwLfMLE6w8vYngZPJC8Pu/qqZ3Qp80cz2AysJwvYFBLfQytVLmdmXgW+b2XbggbDOR4HPuHtymP4GIiIiIiIiMooVNUi7+0EzuwC4jeB+zQY8CFzj7gfyqhoQ5fAe848AtwA3A3XAKuBid19ZUO8G4ABwNTAFWAdc5u73F7Tnu2bmwOeAa4EtwKfd/dsn+KuKiIiIiIjIGGWH3yVKBqq5udlbWlpK3QwREREREREZBma2wt2bDytXkD5+ZrYb2FzqdhxDI8FccJGRQtekjES6LmWk0TUpI5GuSxmJhvu6bHL3w+57rCA9xplZS3/foIiUiq5JGYl0XcpIo2tSRiJdlzISleq6LPaq3SIiIiIiIiKjmoK0iIiIiIiIyCAoSI993y91A0QK6JqUkUjXpYw0uiZlJNJ1KSNRSa5LzZEWERERERERGQT1SIuIiIiIiIgMgoL0GGNmM83sHjNrN7MOM/ulmc0qdbtk/DCzGWb2L2b2hJl1mpmb2ex+6iXM7P+a2U4z6wrrn1eCJssYZ2bvNbNfmNnm8FpbZ2ZfM7Pqgnr1ZvYDM9tjZgfN7AEzO6NU7ZaxzcwuMrOHzGyXmfWY2TYz+5mZzS+op891KRkz+234OX5zQbneL6UozOzN4TVY+NNWUK/o16SC9BhiZpXAQ8BrgCuBvwFOBR42swmlbJuMK3OBy4BW4I9HqXc7cBXw98AlwE7gd2Z25nA3UMadzwMZ4O+Ai4HvAJ8E/mBmEQAzM+BX4f7PAO8B4gTvnzNK0WgZ8xqAFcCngf8GfBFYADxpZk2gz3UpLTP7ALCon3K9X0op/G/g3Lyft+V2lOqajA3XiaUkrgLmAKe5+wYAM1sNrAc+AdxawrbJ+PGou58EYGYfI/gPYh9mtgi4Aviou/8oLFsOrAVuBJYWr7kyDrzT3XfnPV9uZvuAO4A3EwSVpcAbgQvc/WEAM3sC2Ah8geADXGTIuPtPgZ/ml5nZU8ALwHuBf0Sf61IiZlYP3AZ8FvhJwW69X0opPO/uTx5hX0muSfVIjy1LgSdzH7YA7r4ReBx4V8laJeOKu2cHUG0pkALuzjsuDSwDLjKz8mFqnoxDBSE65+lwOz3cLgV25D6Aw+PaCb7h1vunFMvecJsOt/pcl1L5BrAm/MKnkN4vZaQpyTWpID22LADW9FO+FpjfT7lIqSwANrp7Z0H5WqCMYHi4yHA6P9w+H26P9v45y8yqitIqGXfMLGpmZWZ2KvA9YBeHeqr1uS5FZ2ZLgA8BnzpCFb1fSin82MwyZrbXzH5SsFZESa5JBemxpYFgXmqhfUB9kdsicjRHu1Zz+0WGhZlNJ5hC8IC7t4TFx7om9R4qw+XPQA/wIrCQYGjiq+E+fa5LUZlZGcEXOt9093VHqKb3SymmdoKpLh8DLgBuIpgf/YSZTQ7rlOSa1BxpEREZN8Jvpe8lGDr7kRI3RwSCBcRqCOZCf55gEbwl7r6ppK2S8eoLQAVwS6kbIgLg7n8B/pJXtNzMHgWeIpj7/KWSNAz1SI81rfT/jcuRvqURKZWjXatw6BtEkSFjZhUE86XmABe5+7a83ce6JvUeKsPC3Z939z+Hc1HfClQB14e79bkuRRMOlb0B+DJQbmZ1ZlYX7s49j6L3Sykxd19JMIrn7LCoJNekgvTYspZgjkCh+cBzRW6LyNGsBU4Ob+2Sbz6QBDYcfojI8TOzOHAP0Ay83d2fLahytPfPLe5+YJibKIK7txG8/+XWidDnuhTTHCAB3EUQPHI/EIyWaAXOQO+XMnJ4uC3JNakgPbbcB7zezObkCsxsNsFy8PeVqlEi/fgVwf393pcrMLMYcDnwe3fvKVXDZOwJ7xX9Y4K5VZce4fYZ9wHTzez8vONqgHei908pEjM7ieCe0S+FRfpcl2J6BnhLPz8QhOu3EHzRo/dLKSkzawZOIxjeDSW6Js3dj11LRgUzmwCsAroI5gs4wYT8amChviGUYjGz94YP3wr8T+B/AbuB3e6+PKyzDLgIuJbgPn+fBC4B3hAO2REZEmb2HYLr8Bbg/oLd29x9Wxi2HwNmElyTrcAXCRZ/WuTuW4vYZBkHzOw/gZXAaqADmEdwz94pwDnu/qI+12UkMDMHbnH3L4XP9X4pRWNmPyb4f+JKoA14HcH11gmc5e57SnVNKkiPMeH8ltuACwEDHgSu0aIlUkzhh25/lrv7m8M6ucVMrgDqCP6zeJ27P1KEJso4YmabgKYj7P6qu/9DWK8B+CZwKcHwxieAv3X3VcPfShlvzOw64DLgFILb/m0FHgG+lv+Zrc91KbXCIB2W6f1SisLMvgh8gOBzvJLgFoG/Ab7i7jvz6hX9mlSQFhERERERERkEzZEWERERERERGQQFaREREREREZFBUJAWERERERERGQQFaREREREREZFBUJAWERERERERGQQFaREREREREZFBUJAWERGRojCzTWZ2V6nbISIicqIUpEVEREREREQGQUFaREREREREZBAUpEVERMYgM1tkZveZWauZdZnZ42b2prz9/25m28zsDWb2tJl1h0OvP9PPuc4xswfM7ICZHTSzB83snH7qnW9mfzCz9rDeKjP7H/3Ue7+ZPR/WaTGzJUP/FxARERk+CtIiIiJjjJmdBfwJaACuAt4D7AUeMLPFeVVrgLuBO4BLgUeAfzazD+edayGwHKgHPgx8KDxuuZktyqv3LuBBoAz4BPAu4IdAU0Hz3gR8DvgycDkQBe43s7oT/LVFRESKxty91G0QERGRIWRmDwLTgEXungzLosAaYJ27X2pm/w5cCXzA3ZflHfsHYB4w293dzO4B3hY+bwvr1ACbgEfc/d1mZsBGYA9wjrtnj9CuTUAtMMfdW8OyZuBp4K/d/SdD+ocQEREZJuqRFhERGUPMrAI4H/g5kDWzmJnFAAMeAM7Lq54BflFwimXALGB6+Pw84P5ciAZw9w7gvvB1AE4j6Hn+wZFCdJ4nciE69Gy4nXXs305ERGRkUJAWEREZWxoIhkt/GUgV/HwaqDez3Od/q7unCo5/JdzmgnQDsLOf19lFMNwbYGK43TaA9u3Lf+LuPeHDxACOFRERGRFipW6AiIiIDKk2IAv8K/Af/VVw92wwGpt6M4sXhOmTwu32cLsPmNLPaaYAuZ7lPeF2ej/1RERExhwFaRERkTHE3Q+a2R+BRcDKYwy1jhIsRLYsr+z9wBYOBenlwNvNrNrd9wOYWTXwToLFyQBeJJgz/TEz+75rARYRERnjFKRFRETGnr8FHgV+Z2a3EwzNbgTOAqLufn1Ybz/wf8ysEVgPfIBgYbEP54Xhm4BLgAfN7BuAA9cBlcCNAOGiZNcAvwQeMrPvAruB1wKT3f0rw/z7ioiIFJXmSIuIiIwx7r4SOJvgllf/DPwe+CfgDIKAndNB0AN9JXAv8Bbgane/I+9cq4E3h3XvAO4EDgDnu/uqvHr3AheGT28nWIzs4wQ91SIiImOKbn8lIiIyDoW3v3qbu88odVtERERGG/VIi4iIiIiIiAyCgrSIiIiIiIjIIGhot4iIiIiIiMggqEdaREREREREZBAUpEVEREREREQGQUFaREREREREZBAUpEVEREREREQGQUFaREREREREZBAUpEVEREREREQG4f8DbCFg3urC0igAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -580,20 +681,12 @@ }, { "cell_type": "code", - "execution_count": 282, + "execution_count": 353, "metadata": {}, "outputs": [], "source": [ "# Create a 1-D dynamics model for this environment\n", - "one_step_model = common_util.create_one_dim_tr_model(one_step_config, obs_shape, act_shape)\n", - "\n", - "# This functions allows the model to evaluate the true rewards given an observation \n", - "reward_fn = reward_fns.cartpole\n", - "# This function allows the model to know if an observation should make the episode end\n", - "term_fn = termination_fns.cartpole\n", - "\n", - "# Create a gym-like environment to encapsulate the model\n", - "one_step_model_env = models.ModelEnv(env, one_step_model, term_fn, reward_fn, generator=generator)" + "one_step_model = common_util.create_one_dim_tr_model(one_step_config, obs_shape, act_shape)" ] }, { @@ -605,7 +698,7 @@ }, { "cell_type": "code", - "execution_count": 283, + "execution_count": 354, "metadata": {}, "outputs": [], "source": [ @@ -623,12 +716,12 @@ }, { "cell_type": "code", - "execution_count": 284, + "execution_count": 355, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+cAAAHqCAYAAABm/z9LAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAACh70lEQVR4nOzdd3xUZfbH8c+Z9JAQCCX0XhQQRKKCvS62tfeua13d37q7usV1m2XXrequa+9l7brWtSs2UAEFBaUjvSXUhPTz++POwBACSSDJzSTf9+s1r5m597n3noljwrnP85zH3B0RERERERERCU8k7ABEREREREREWjsl5yIiIiIiIiIhU3IuIiIiIiIiEjIl5yIiIiIiIiIhU3IuIiIiIiIiEjIl5yIiIiIiIiIhSw47gJbGzHoCtwCHAwa8DVzl7gtqO7Zjx47ep0+fxg1QREREREREQjFp0qRV7t6ppn1KzhuQmWUC7wKlwHmAAzcC75nZcHcv2t7xffr0YeLEiY0fqIiIiIiIiDQ5M/tuW/uUnDesi4F+wGB3nw1gZlOBWcClwD9CjE1ERERERESaKc05b1jHAhNiiTmAu88DPgaOCy0qERERERERadaUnDesocDXNWyfBgxp4lhEREREREQkQSg5b1i5wOoathcC7Zs4FhEREREREUkQSs5DZmaXmNlEM5u4cuXKsMMRERERERGRECg5b1irqbmHfFs96rj7Pe6e7+75nTrVWFFfREREREREWriEqNZuZmnAGGA00A3IAFYBM4AP3H1uiOHFm0Yw77y6IcD0Jo6lQa0uKuPEOz8hNSlCSrKRmhQhNTlCSlKEtOhzanIkuj943mJ79HVGShI5GSlbPjJTyE5LJhKxsD+miIiIiIhIKJp1cm5mA4CrgLOAHKAKWAtsJOiNTgfczCYBdwCPuHtVONEC8BLwNzPrF7thYGZ9gH2BX4YY104zg2HdcyirqKS80imrqKKssor1JRUUVFRRXhm8L4u+Lq2o2tTGvfbzRwyy04NkvV1m8Nw2mry3i0vk22Wm0LtDGwZ0ziIlSQM/RERERESkZTCvS+YUAjP7N8G64V8ATwIfAFPcvSKuTR5Bb/rRwMnAcuB8d/+06SMGM2sDTCG4eXAd4MANQDYw3N03bO/4/Px8nzhxYqPH2dQqool7eYVTXF7Buo0VrCkuY+3G8u0/ije/rqja8nuamhRhUJcshnRty9BuOQzp1pZdumSTnZ4S0qcUERERERHZPjOb5O75Ne5rxsn5C8Af3P3LOrZPAy4FStz9nsaMrZY4egG3AIcDBrwDXOXu82s7tqUm5zvL3Skuq2TtxnIKi8qYs3ID05euY/qSdUxbso7CorJNbft0yGRIt7ZbJO2ds9Mw05B5EREREREJV0Im562RkvP6c3eWrytl+tK1m5L16UvX8V1B8aY2HbNS2bVrW4Z0CxL23Xu0o1eHzBCjFhERERGR1mh7yXmznnMuUhszo0tOOl1y0jlkl7xN29eVlPPt0vVMX7J2U8L+wEfzKK8MbkYdPLgTPzx4AHv2yQ0rdBERERERkU2abc+5mR1Qn/bu/kFjxdJU1HPeuMoqqpi9YgNvf7Ochz6ZT2FRGXv1yeXyg/tz0KBOGvouIiIiIiKNKiGHtZtZFUFBtVqbAu7uSY0cUqNTct50issqeOrzhdz7wVyWrC1hSNe2XH5Qf47arStJWtJNREREREQaQaIm5wfWp727j2usWJqKkvOmV1ZRxYtfLubOcXOYu7KIPh0yufTA/py4R3fSkhP+fo+IiIiIiDQjCZmct0ZKzsNTWeW8OW0Zd7w/h68WryWvbRoX79+PM/bqRZs0lWYQEREREZGdp+Q8QSg5D5+789HsVdzx3hzGzy2gXWYK543pw/n79KF9m9SwwxMRERERkQSWkMm5mb1bj+bu7oc2WjBNRMl58zJ5wWrufH8Ob01fTmZqEmfs1YuL9+9Hl5z0sEMTEREREZEElKjJ+fvUrSAcAO5+cONF0zSUnDdPM5at565xc3hpyhIiBieO7MGVhwygZ67WShcRERERkbpLyOS8NVJy3rwtLCzmng/m8tTEhWSkJHHHWXuw74COYYclIiIiIiIJYnvJeaSpgxFJVD1zM7nh+GG8/ZMDyWubxrkPfMYj4+eHHZaIiIiIiLQACVOG2swiwF5AL2CrSb/u/kiTByWtUq8OmTx3+T5c9eSX/PbFacxYtp7fHzuUlCTd6xIRERERkR2TEMm5mQ0B/gv0B6yGJg4oOZcmk52ewj3n5vOXN77l7nFzmbNyA3eeNUoV3UVEREREZIckSlffHQQ3Ek4FdgH6Vnv0Cy80aa2SIsavjtyVf5w6gsnfreG4f3/MrOXrww5LREREREQSUKIk53sAV7v7c+4+092/q/4IO0BpvU7cowdPXjqa4rJKTrjjE979dnnYIYmIiIiISIJJlOR8FVAWdhAi27JHr/a8dOW+9O6QyQ8ensg9H8xBKyGIiIiIiEhdJUpyfgtwhZklhR2IyLZ0a5fBM5eN4chhXfjja99y9TNTKa2oDDssERERERFJAAlREA7oBAwGppvZW0Bhtf3u7r9r+rBEtpSZmsztZ+zBP/Nmcevbs5i3agN3nTOKztlbLTAgIiIiIiKyiSXC0Fszq6qlibt7wveq5+fn+8SJE8MOQxrIa18t5adPf0luZir3nJvPsO45YYckIiIiIiIhMrNJ7p5f076EGNbu7pFaHgmfmEvLc9RuXXn2sn1w4JS7xvO/r5aGHZKIiIiIiDRTCZGciySqYd1zePHKfdmlazaXPz6Z296epUJxIiIiIiKyFSXnIo2sc3Y6T1w8mhP36M4tb8/kyie+YGOZCsWJiIiIiMhmiVIQTiShpack8fdTRjA4L5ubX/+W7wqKuP+8Pclrq0JxIiIiIiKinnORJmNmXHpgf+47N5+5K4s48Y5PmLNyQ9hhiYiIiIhIM6DkXKSJHbprHk9eMpqS8kpOvvMTvliwOuyQREREREQkZErORUIwvEc7nrt8H7LTUzjz3k95b8aKsEMSEREREZEQKTkXCUmfjm149vIx9OvUhosensizkxaFHZKIiIiIiIQkIZJzM0s1s9+Z2bdmVmxmldUeFWHHKLIjOmen8+QloxndL5ern5nCne/P0VJrIiIiIiKtUKJUa/8rcAXwP+B5oDTccEQaTnZ6Cg+cvydXPzOVP7/+LSvWl/Cbo4cQiVjYoYmIiIiISBNJlOT8ZOB37n5T2IGINIa05CRuO213OmWl8cDH81i5vpS/nzqCtOSksEMTEREREZEmkCjJeRYwPuwgRBpTJGL85phd6dw2jZv/9y2FRWXcfc4ostNTwg5NREREREQaWULMOQdeBg4IOwiRxmZmXHZgf/5+ygg+nVfIaXdPYMX6krDDEhERERGRRpYoPef/Ah4xsyrgNaCwegN3n9vkUYk0kpNG9SA3K5UfPjaZk+78hEcu3Ju+HduEHZaIiIiIiDQSS4TK0NGkPKbGgN094Sfn5ufn+8SJE8MOQ5qRLxeu4cKHPgfgwfP3ZETPduEGJCIiIiIiO8zMJrl7fk37EqXn/EK2kZSLtGS792zHs5eN4dwHPuOMeydw59mjOHBQp7DDEhERERGRBpYQPeethXrOZVtWrCvhvAc/Z9by9fz1lOGcMLJH2CGJiIiIiEg9ba/nPFEKwoXKzH5qZi+b2VIzczP7/XbaHm9mX5hZiZl9Z2bXmVnCD7mXcHVum85Tl45mzz65/OSpKdzzwZywQxIRERERkQaUKMPaMbPOwBnAYCC92m539x804uUvBtYB/wUu21YjMxsLPAfcD/wUGAn8EcgGftGI8Ukr0DY9hYcu3JOfPj2FP772LSvWlXLtUbsSiVjYoYmIiIiIyE5KiOTczAYTrHOeDLQBVgG5QBKwGljbyCEMdfcqM0tmO8k5cDPwkbtfEn3/npllAdeZ2S3uvqyR45QWLi05iX+dPpJOWWnc99E8Vqwv5W+njCA1WYNgREREREQSWaL8i/6vwOdAHmDAkUAGcBFQDJzQmBd396ra2phZT2B34LFqux4FUghiFtlpkYjxu+8P4edHDOalKUu44KHPWF9SHnZYIiIiIiKyExIlOd8TuAMojb6PuHuFuz8A3A7cGlZgcYZGn7+O3+ju8whuIAxp8oikxTIzfnjQAP52yggmzC3ktLsnsGJ9SdhhiYiIiIjIDkqU5DwLKIz2YK8FOsbt+5wgeQ9bbvR5dQ37VsftF2kwJ4/qwX3n5TNvVREn3fkJc1duCDskERERERHZAYmSnM8HukRfzwBOidt3DLCmricys8OiFddre7zfUMHXEs8lZjbRzCauXLmyKS4pLczBgzvzxCWjKSqt5OS7xvPlwjVhhyQiIiIiIvWUKMn5W8Dh0df/AC4wsxlmNg34MfBAPc71CbBrHR7n1jPGWI95+xr2tQcKazrI3e9x93x3z+/UqVM9LykS2L1nO567fB/apCVxxj0TeO/bFWGHJCIiIiIi9ZAQ1dqBXwFpAO7+tJltBE4DMoHbgHvreiJ3Lwa+bYQYp0WfhxJUlgfAzPoQxDm9Ea4psknfjm147vJ9uODBz7nokYncfOJunJLfM+ywRERERESkDhKi59zdS919Xdz7l939bHc/Mdrz7GHGF41pATAFOKvarrOBcuB/TR6UtDqds9N56tIxjOnXgWuencq/35tNM/jfQ0REREREapEoPeehMrN8oA+bb2YMMbOTo69fi/bGA1wLvGJmdwNPACOB64DbtMa5NJWstGQeOH9Prnl2Cn99YwbL15Xwu+8PJSliYYcmIiIiIiLb0GyTczN7F/ihu38bfb097u6HNmI4VwLnxb0/hc1F6foSFKzD3V+LJu2/A84HlgN/BG5qxNhEtpKaHOGWU3enc3Ya9344j5XrS7nltN1JT0kKOzQREREREalBs03OgfhuvgiwvbG5jdol6O7nEyTbdWn7PPB8Y8YjUheRiPHro4eQ1zadG1/9hoKiz7j33HxyMlLCDk1ERERERKpptsm5ux8c9/qgEEMRSWgX7d+PTtlpXP3MFE69azwPX7gXXXLSww5LRERERETiJERBOBHZOcft3p0Hz9+LRauLOfGOj5m9Yn3YIYmIiIiISJyESM7N7DgzuyDufW8zG29m683sWTPLCjM+kUSw38COPHXpGMoqnZPuHM/E+YVhhyQiIiIiIlEJkZwTVDzvFPf+H0AP4B7gAOD3IcQkknCGdc/hhR/uQ26bVM6671Pe/XZ52CGJiIiIiAiJk5z3B6YCmFkGcBTwU3f/GcHyZSeEGJtIQumZm8mzl41hUF42lzwyide+Whp2SCIiIiIirV6iJOfpwMbo630ICtm9GX0/A+gWRlAiiapDVhqPX7w3I3q248r/TOb5yYvCDklEREREpFVLlOR8PrBf9PVxwCR3Xxt93xlYW9NBIrJtbdNTePQHezG6Xwd+9swU/vPpgrBDEhERERFptRIlOb8b+L2ZTQR+CNwft28MMD2UqEQSXGZqMg+cvycHDerEtS98xf0fzQs7JBERERGRVikhknN3vw04HxgPXOju98btzgYeDCMukZYgPSWJu8/J58hhXbjhlenc/u6ssEMSEREREWl1ksMOoK7c/XHg8Rq2XxpCOCItSmpyhH+dMZJrnp3K396cycbySq7+3mDMLOzQRERERERahYRIzs1sENDO3T+Lvs8AfgsMA95w99vDjE+kJUhOivD3U0aQnhLh3+/Nobiskt8eM0QJuoiIiIhIE0iI5By4HfgS+Cz6/ibgSuAr4BYzc3f/d0ixibQYkYjxxxN2Iz0liQc/nk9JeRU3HT+MSEQJuoiIiIhIY0qIOefACOBjADOLAOcCv3D3UcCNwCUhxibSopgZvz1mCFcc3J8nPlvAz56ZQkVlVdhhiYiIiIi0aInSc54DFERfjwTaA89G378PXB1CTCItlplxzdhdyEhJ4m9vzqSkvJLbTh9JanKi3M8TEREREUksifIv7eXAgOjr7wFz3H1h9H0WUBFKVCIt3JWHDOQ3xwzhf18v47LHJlFSXhl2SCIiIiIiLVKiJOcvAX8ys78BPwOeidu3GzA3lKhEWoEf7NeXm04YxnszVnDhQ59TVKp7YSIiIiIiDS1RkvNfAq8AYwkS9Zvi9h0LvBlGUCKtxVl79+bvp4xgwtwCzn3gM9aVlIcdkoiIiIhIi5IQc87dvQi4eBv79mnicERapRP36EF6ShL/98QXnHXvpzxy4V60b5MadlgiIiIiIi1CovSci0gzcNRuXbnn3FHMWL6e0++ZwMr1pWGHJCIiIiLSIpi7hx1Drczs3VqauLsf2iTBNKL8/HyfOHFi2GGI1Orj2au46OGJdM1J5z8Xj6ZLTnrYIYmIiIiINHtmNsnd82valyg95xHAqj06AvsCg6LvRaSJ7DugI4/8YC9WrC/l1LvHs2h1cdghiYiIiIgktIRIzt39IHc/uNpjODAEWA38MeQQRVqdPfvk8thFe7OmuIzT7p7A/FVFYYckIiIiIpKwEiI53xZ3nwPcDPw17FhEWqPde7bjPxePprisgtPuGc/sFRvCDklEREREJCEldHIetZJgaLuIhGBY9xyevGQMlVXO6feMZ8ay9WGHJCIiIiKScBI6OTezDsBPgTlhxyLSmg3uks2Tl4whKWKcfs94vl68NuyQREREREQSSkIk52Y2z8zmVnssApYBhwLXhRyiSKs3oHMWT186hszUZM68dwJfLFgddkgiIiIiIgkjIZJzYFwNj5eB3wC7uPtLIcYmIlG9O7ThqUtH0y4zlXPu/4zP5xeGHZKIiIiISEJIiHXOWwutcy4txbK1JZx53wSWrinh/vPy2WdAx7BDEhEREREJXUtY51xEEkiXnHSeumQMvXIzueChz3l/xoqwQxIRERERadYSpufczFKBI4HBQHq13e7uNzR9VA1LPefS0hQWlXH2fZ8ye8UG/n3WHhw+JC/skEREREREQrO9nvOESM7NrBvwEdAHcMCiuzYF7+5JTR9Zw1JyLi3R2uJyzn3wM6YtXsttp4/k6OFdww5JRERERCQULWFY+18J1jPvRZCY7w30A24CZkdfi0gzlJOZwmM/2Ivde7bjR09M5oUvFoUdkoiIiIhIs5Moyfn+wN+BJdH3Ve4+391/CzwL/DO0yESkVtnpKTx84V7s3bcDP316Ck9/vjDskEREREREmpVESc47AEvcvQooAtrH7XsXOCiMoESk7tqkJfPgBXuy/8BO/Py5qTw6fn7YIYmIiIiINBuJkpwvAmJrMc0Bvhe3by+gpLEubGaDzOw2M5tqZhvMbKmZvWRmI7bR/mIz+9bMSs1shpld1lixiSSa9JQk7j13FIft2pnfvDiN+z6cG3ZIIiIiIiLNQqIk5+8BB0Zf3w1cbWZvmtmrwA0EQ9sby/eAg4GHge8DPwQ6ARPMbFR8QzO7OBrfc8ARwDPAHWZ2eSPGJ5JQ0pKTuOOsURy1WxdufPUbbn93FolQmFJEREREpDElSrX2jkCuu8+Mvv8RcBqQCbwOXO/ujdJ7Hr12gcf9oMwsB5gPvOzu50a3JRPMif+fu58X1/YB4Figq7uXb+9aqtYurUlFZRU/f3Yqz3+xmEsP6Mcvj9wFM6v9QBERERGRBLW9au3JTR3MjnD3VcCquPf/Av7VhNeuvm2tmc0EusdtHkPQo/5YteaPAhcA+xGMABARIDkpwt9OGUGbtGTu/mAu60oquPH4YSRFlKCLiIiISOuTEMl5c2NmucAw4MG4zUOjz19Xaz4t+jwEJeciW4hEjOuPG0rbjGT+/d4cNpRW8I9TR5CSlCgzbkREREREGkZCJOfRoeHbUgWsBSYBzzfW8PZq/kWw3vqtcdtyo8+rq7UtrLZfROKYGdeM3YXs9BRu/t+3FJVWcMdZe5CekhR2aCIiIiIiTSYhknOCgmw5QDuggmCIe0eC+NdE2/wEmGNmB7v7om2dyMwOA96qwzXHuftBNRz/K+BM4AfuPrvuH2Gb8VwCXALQq1evnT2dSMK67MD+ZKcnc91/v+a8Bz7jvvPyyU5PCTssEREREZEmkShjR88k6B0/CUh3925AOnAKsI6givpe0W1/quVcnwC71uFxbvUDo8ui/RG4zt2r9+bHeszbV9se6zEvpAbufo+757t7fqdOnWoJXaRlO2vv3tx62u5M/G41Z9/3KauLysIOSURERESkSSRKz/ktwJ/d/YXYBnevAp4zs87ALe6+l5n9Cfjt9k7k7sXAt/UNwMzOAe4A/u7uN9XQJDa3fCiwNG77kOjz9PpeU6Q1Om737rRJTeaH/5nMqXeP57GL9iavbXrYYYmIiIiINKpE6TkfAczZxr45BMXZIEiAq/dc7zQzO4Gg+Nt97n71NpqNJxhuf1a17WcT9Jp/3NBxibRUhw3J46EL9mTJmo2cctd4FhYWhx2SiIiIiEijSpTkfBlw8jb2nQIsj75uy9YF2XaKmR0APAFMAR4ys9Fxj5GxdtE1zH8DnGdmN5rZQWZ2PXAh8Ft31/hckXrYp39HHr94NOtKyjn5rk+YtXx92CGJiIiIiDSaREnObwMuNrOXzew8Mzsy+vwK8AOCYe8A+wNfNPC1DwHSgD0Ier/Hxz1eiG/o7ncBlwOnAm8AZwBXuvu/GzgmkVZh957teOqSMVQ5nHr3eL5atDbskEREREREGoW5e9gx1ImZXUQwn7xH3OZFwB/c/f5omz7ARndfvvUZmr/8/HyfOHFi2GGINDvfFRRx1n2fsqa4nPvPy2fvfh3CDklEREREpN7MbJK759e0L1F6znH3+4De0cfo2OtYYh5tMz9RE3MR2bbeHdrw7GX70CUnnXMf+Iz3vl0RdkgiIiIiIg0qYZJzAA8sdPfPos+J0e0vIjutS046T10ymoF5WVz8yERembok7JBERERERBpMs03OzezEHTimq5mNbox4RCR8HbLS+M/Fo9mjV3v+74kveOrzBWGHJCIiIiLSIJptcg78y8y+NLPLzCx3ew3NbH8zuweYDQxvmvBEJAxt01N4+MK9OGBQJ37x3Ffc+8HcsEMSEREREdlpyWEHsB0DgauB6wkS9W8IljNbCZQSrGfeD8gHcoAPgMPd/ZNwwhWRppKRmsQ95+Tzk6e/5KbXvmFBYTG//f4QUpKa8/1GEREREZFta7bJubsXA9eb2c3ACcBYgkJw3YB0oAD4lmCZtafc/duwYhWRppeaHOGfp4+kR/sM7h43l7mrNvDvM/egXWZq2KGJiIiIiNRbwiyl1hpoKTWRHfPspEVc+/xXdGuXzn3n7cmAzllhhyQiIiIispUWsZSaiMi2nDyqB09csjcbSis44Y6PGTdzZdghiYiIiIjUi5JzEWkRRvXO5b9X7EuP9plc8OBnPPDRPDQySEREREQShZJzEWkxerTP5NnLxnDYrnlc/8p0rn3hK8oqqsIOS0RERESkVkrORaRFaZOWzF1nj+KKg/vzxGcLOef+TyksKgs7LBERERGR7VJyLiItTiRiXDN2F249bXe+WLiG4//9MTOXrw87LBERERGRbVJyLiIt1vEju/PUJaPZWF7JiXd8wrvfLg87JBERERGRGiVEcm5mg8xsr7j3GWb2JzN72cyuDDM2EWneRvZqz0tX7kufjpn84OGJ3PvBXBWKExEREZFmJyGSc+B24OS49zcBPwO6AbeY2RWhRCUiCaFrTgZPXzqGI4d14abXvuHnz06ltKIy7LBERERERDZJlOR8BPAxgJlFgHOBX7j7KOBG4JIQYxORBJCZmsztZ+zB/x06kGcmLeLs+z5l1YbSsMMSEREREQESJznPAQqir0cC7YFno+/fB/qFEJOIJJhIxPjp4YP41xkjmbpoLcfd/jHfLlsXdlgiIiIiIgmTnC8HBkRffw+Y4+4Lo++zgIpQohKRhPT9Ed145rIxVFRVcdIdn/C/r5aGHZKIiIiItHKJkpy/BPzJzP5GMNf8mbh9uwFzQ4lKRBLW8B7teOnK/RiQl83lj0/m2he+YmOZ5qGLiIiISDgSJTn/JfAKMJYgUb8pbt+xwJthBCUiiS2vbTrPXDqGSw/sx38+XcD3b/+I6Us0zF1EREREmp5pSaHmIz8/3ydOnBh2GCKt0kezVvHTp79kTXE5vzpqF87fpw9mFnZYIiIiItKCmNkkd8+vaV9C9JybWcTMkqttG2tmPzOz3UMKS0RakP0GduR/P96f/Qd25A8vT+fChz5XNXcRERERaTIJkZwDTwAPxN6Y2WXA/4C/Ap+a2WFhBSYiLUeHrDTuOy+fPxw7lI/nFHDErR/ywcyVYYclIiIiIq1AoiTno4HX4t5fA9xHsMTa88CvwwhKRFoeM+O8ffrw4hX70j4zhXMf+Iw/vvYNZRVVYYcmIiIiIi1YoiTnnYHFAGY2AOgL3O7u64EHCSq2i4g0mF27tuXlH+3H2aN7cc8Hcznxzo+Zu3JD2GGJiIiISAuVKMn5OqBD9PVBwCp3nxp9XwmkhxGUiLRs6SlJ3Hj8btx9zigWrd7IMf/6iKcnLkSFNEVERESkoSVKcv4J8EszOwa4ii2HuA8AFoURlIi0DmOHduF/P96f4T1y+PmzU7nyiS9Yu7E87LBEREREpAVJlOT85wQ95y8R9JL/Pm7facD4EGISkVaka04Gj180mmvGDub1r5dx1G0fMnF+YdhhiYiIiEgLkRDJubvPcveBQCd3H+Du8+N2/5ggeRcRaVRJEeOKgwfw7GVjSIoYp949ntvenkVFpYrFiYiIiMjOSYjkPMbdC8wsy8x6mllWdNtX7q61jkSkyYzs1Z5X/28/jtu9O7e8PZMz7p3AjGXrww5LRERERBJYwiTnZjbWzCYCa4D5wBoz+8zMDg81MBFplbLTU7jltN255bQRzFi2niNv+4Bfv/AVBRtKww5NRERERBKQJULVYTMbC7wKzAaeAJYBXQnmmw8AjnL3t8KLsGHk5+f7xIkTww5DROppdVEZt749k8c+XUBmShJXHjKA8/ftQ1pyUtihiYiIiEgzYmaT3D2/xn0JkpyPB1YDx7h7Vdz2CPAK0M7d9wkrvoai5Fwksc1esZ6bXv2G92aspFduJr86cheOGNYFMws7NBERERFpBraXnCfKsPYRwL/jE3OA6Ps7gN3DCEpEJN6Aztk8eMFePHLhXqSnRLj88cmcds8Evlq0NuzQRERERKSZS5TkvBRou4192dH9IiLNwgGDOvHa/+3PjccPY86KDRz774/42dNTWLa2JOzQRERERKSZSpTk/H3gBjPrG7/RzHoRrHn+XmNd2MyyzexpM5ttZkVmFitEd3YNbSNm9iszm29mJWY2xcxOaqzYRKT5Sk6KcPbo3rx3zUFcckA/Xp6yhIP/9j63vj2TjWWVYYcnIiIiIs1MoiTnvwBygBlm9oGZPWVm44BZQLvo/saSClQAfwKOBc4EvgEeNbOfVGt7A8HNgtuBI4EJwDNmdlQjxicizVjb9BR+deSuvP3TAzl4l07c+vYsDv7b+zw/eRFVVc2/5oeIiIiINI2EKAgHYGZdgZ8B+wO5QCEwDrjF3ZeGEM94IMvdd4u+7wwsBG5299/FtXsH6OTuw2s7pwrCibR8n80r5IZXpvPV4rWM6JHDb44ZQn6f3LDDEhEREZEmkPDV2psjM3sF6O7uI6PvzwEeAQa5+6y4dhcADwD93H3e9s6p5Fykdaiqcl74YjF/eeNblq8r5ejduvKLI3ahV4fMsEMTERERkUa0veQ8uamDSVQWrIWURDC8/iRgLPCDuCZDCQrTza526LTo8xBgu8m5iLQOkYhx0qgeHLlbF+4eN5e7P5jD69OWcdzu3fjhQQMY0Dkr7BBFREREpIk12+TczN6tR3N390MbLZjAFcC/oq/LgR+7+yNx+3OBNb71UITCuP1bMbNLgEsAevXq1XDRikizl5mazE8OH8SZe/fi7nFz+c9n3/HCF4s5clgXfnjQAIZ1zwk7RBERERFpIs25IFwEsDo+6vw5zOwwM/M6PN6vduhTwJ4Ehd7uA/5lZpfu5GfE3e9x93x3z+/UqdPOnk5EElBe23R++/0hfPyLQ/jhQf35cOYqjvnXR1zw4GdM+q6w9hOIiIiISMJrdXPOzSwTqEsXdbG7L9jOeR4iGN6e6+7lZvZn4MdARnzvuZntBXwKHOPur27vgppzLiIAazeW88gn83ng43msLi5nTL8OXHnIAPbp34Fgho2IiIiIJCLNOY/j7sXAtw1wqonAeUAesIhgbnka0J8t550PiT5Pb4BrikgrkJORwo8OHciF+/Xlic8WcM8Hcznrvk/ZvWc7rjx4AIfu2llJuoiIiEgL05yHtTd3BwIbgBXR968TzEU/q1q7s4Gva6vULiJSXZu0ZC7avx8f/Pxgbjx+GKs2lHLRIxM58rYPeXnKEiq1TrqIiIhIi9Hqes7rKzqvfDTwNkEPeQfgVOBk4JfuXgbg7ivM7B/Ar8xsPTAZOA04BDg2jNhFpGVIT0ni7NG9OW3Pnrz05RLueH82P3riC255ayaXHdSfE0Z2JyVJ91pFREREElmrm3NeX2a2D3AdMJKg4voq4BvglupzyM0sCfgVcDHQBZgBXO/uz9blWppzLiJ1UVnlvP71Mv793mymL11H93YZXHpgP07cowdZabrnKiIiItJcbW/OuZLzZkTJuYjUh7vz/oyV/OvdWUxesIaMlCSO3K0LJ+/Rg9H9OhCJaF66iIiISHOignAiIi2QmXHwLp05aHAnJi9YzbOTFvHKlKU8P3kx3dtlcOIe3Tlpjx706dgm7FBFREREpBYJ1XNuZl0IlkFLr77P3T9o+ogalnrORWRnlZRX8sa0ZTw3eTEfzlqJO+zZpz0n7dGDo4d3JTs9JewQRURERFqthB/WbmbdgUcJKqRvtRtwd09q2qganpJzEWlIS9du5IUvFvPcpEXMWVlEekqEI4Z24aRRPdinf0eSNOxdREREpEm1hOT8JWAMcDPwFVBavY27j2vquBqaknMRaQzuzpcL1/DspEW8PGUJ60oq6JqTzgkju3PSqB7075QVdogiIiIirUJLSM5XA//n7o+GHUtjUnIuIo2tpLySt79ZznOTFjFu5kqqHPbo1Y6TRvXg6N260i4zNewQRURERFqslpCcLwEucPc3wo6lMSk5F5GmtGJdCS98sZhnJy1i1ooNAPTr1IYRPdoxokcOI3q2Y9eubUlPSfhZQyIiIiLNQktIzv8A9Hf3s8OOpTEpOReRMLg7Xy1eywczVzJl0Vq+XLiGleuD2UMpScauXdsyvEcOI3q0Y/ee7ejXKUvz1UVERER2QEtYSm0xcI6ZvQP8Dyis3sDdH2jyqEREWgAzY3iPdgzv0Q4IkvVl60qYsnANXy5cy5SFa/jvF0t4bMICALLSktmte9CzHuth75qTjpkSdhEREZEdlSg951W1NFG1dhGRRlRV5cxdtWFTsj5l0Rq+WbqO8srgb0in7DRG9GhHfp/27Nknl92655CaHAk5ahEREZHmpSX0nPcNOwARkdYsEjEGdM5mQOdsTh7VAwiKy327bH2QrC9cwxcL1/D2N8sBSE+JsEev9uzVN5e9+uQysld7MlIT/h6qiIiISKNJiOTc3b8LOwYREdlSekoSu/cM5qHHrFxfysT5hXw6r5DP5hVy2zuzcA/mru/WPYe9+nZgr77tGdU7l5yMlPCCFxEREWlmEmJYe2uhYe0i0tKs3VjO5O9WR5P1Ar5avJbySscMdu3SNuhZ75vLnn1y6ZSdFna4IiIiIo0qIau1m9lc4AR3n2Jm84DtBeru3r+JQms0Ss5FpKXbWFbJFwtX89m8Qj6fX8ik71ZTUh6UFenXqQ35vdszpGtbhnTLYZeu2bRNV++6iIiItByJOud8HLAu7nXzvIsgIiJ1lpGaxD79O7JP/44AlFVU8fWStUGyPq+Qt6Yv5+mJiza179E+g127tmVI17abnnvmZqgyvIiIiLQ4zbbnvDVSz7mItHbuzvJ1pXyzdB3Tl67b9DxvVRGxP1fZacns0jV7i6R9cJds0lNUcE5ERESat0TtORcRkVbGzOiSk06XnHQO3qXzpu0byyqZsXw905cECfs3S9fx3KRFPFJWCUDEoF+nLHbt2pYBnbLo0zGT3h3a0LdDG3IyNTReREREmr+ESs7NbAQwGEivvs/dH2n6iEREpClkpG5dGb6qylm4ujjaux4k7pO/W83LU5ZscWy7zBR6d2hDnw6Z9OnQZlPi3qdDG9pnpmiIvIiIiDQLCTGs3czaAa8Co2Obos+bgnf3hB/PqGHtIiI7r6S8koWFxcwvKGb+qiLmFxTxXUEx8wuKWLxmI/F/9rLTk+nbsc2m5L13hzb07pBJj/YZdM5OJymixF1EREQaTksY1v5HoANwAPAhcAKwFrgQGAOcHl5oIiLSnKSnJDEwL5uBedlb7SutqGTR6o3RpL2Y7wqC56mL1vDaV0uprNqcuackGV1zMujeLoPu7Tc/92ifQY92mXTJSSc1OdKUH01ERERasERJzscCfwAmRN8vcvdJwPtmdifwY+DcsIITEZHEkJacRP9OWfTvlLXVvvLKKhat3sh30R72xas3smj1Rhav2chHs1axfH3JFr3uZpCXnb4pYY9P4vPaptOhTSrt26SSkqQEXkRERGqXKMl5V2Cuu1eaWQkQ3x3yPPBkOGGJiEhLkZIUoW/HNvTt2KbG/WUVVSxdG03at0jei5m8YDWvTl1KRdXWU8XapifTISuN3Dap5LZJpUP0ObdNKh2yUsltk7bFNlWdFxERaZ0SJTlfBrSLvv6OYCj7+9H3A0KIR0REWpnU5Eh0TnrNyXtllbNifQmLVm9k5fpSCorKKNxQRmFR9HVRGQsLi/ly4RpWF5XVmMgDtElNIjcrlbbpKcEjIzn6vPX77PTkzdsyUshKTSaiefIiIiIJKVGS848IisG9AjwK/M7M+gAVwHnAS+GFJiIiAkmRYI5615yMWtu6O+s2VlBQVEphUdmm5L2wqIyCDWWsLi5j3cZy1pWUM39VMetKylm3sZyi6NJx22IWrAMfS+TbZaaQkxF7Tt30ul1GsD1n0/5U2qQmqXK9iIhIiBIlOf8D0C36+q8ExeFOAzIJEvMfhRSXiIhIvZlZkBhnptCvU92Pq6isYn1JBetLKjYl7MFz/Pvg9drictZuLGf2ig2s2Ri8L6us2ua5kyO2KWGPJe9Z6SlkpSWRmZpMm7RkstKSos/J0W1JZKUlx21Loo1670VERHZIQiyl1lpoKTUREWks7k5JeRVrNpaxJpq4rykOEvottm3cnNhvKK1gQ2kFxaUVtfbax8tMDZL47LTkYOh9tCd/8+tksrc5RD9FvfgiItJiJfRSamaWSjDn/Hx31/B1ERGRHWBmZKQmkZFat6H31VVVOcXllRRFE/aiTYl7JUVl8duCNkWlFawvrYj29JezZM1G1kVfl5RvuwcfIGKQHU3mM1KSSE2OBI+kas/VXydHSEuKkBK3LT0l6N3PSg9uFmSlB7382WkptElLIlnV9EVEpJlo9sm5u5eZWQVQEnYsIiIirVUkYkGSm5ZM3k6eq7SicvPw/I3lWwzTr/66pKKSsooqSiuqKKuoYkNpBWXR1+WVwXNZ5eb9ZZVV1GdQYEZK0laJe/VkPiMlifSUJNKSI6QlJ5GWEjynp2x+nx573tQueJ0cMY0CEBGROmn2yXnUf4GTgTdDjkNERER2UlpyEmlZSXTMSmvwc7s7FVW+KYEvqQh68teXBL37G0qCHv0Nsfdb7AuG8i8oLN5ie+U2KuvXRcTYlLCnxyf5KUmkJ0eq7av+fnPb1CQjYkZSJHiORIyIQdKm10ZSJBghkRRtZ9X2R4xN57Do69h2q+P+pOjNhqRIcB2Lbou91o0IEZEdlyjJ+f+Af5rZswSJ+lJgi7+U7v5uCHGJiIhIM2JmpCQZKUkR2jRA7u/ulFc6JRWVlJZXUVpRSUn0ubSiipLy4Ll003PVpraxffHPJdXeryku23S+kuixsf2JWBZoiwQ+/iZBZPP75IiRlGSkRCLB9kjw3yt4jrWJkJwUbRsxkpMim16nRCLR442kSGTzMdE2seOSN+3bfK7kpGAqRGy0w7ZuiKSnJJGkwoYi0sQSJTl/Lvp8YvQR44BFn5OaOigRERFp2cyM1GQjNTkC6U13XXenrLIqSNzLKymvcqqqnCp3KqucKifutVNVFX3vsXZQWeV4dFvwOmgTO9bjXld5cM34c1ffv+X1N19j0/U8LsZqccQfV14ZvK6ocioqq6ioCt6XV1Zt2l5cVhHXxqmoqoq2iR1btWlf/HENKSXJapy+kJ4S1DNISQqmL2xdByFaJyHJqtVGiK+fsPmmQewmRUpS9RsMm288pGzavvkmRWyQQk03ceK3eVx/Vvz2iAXx6SaESPORKMn5IVTrKRcRERFpqcyCxDAtOQkyUsIOJyHEbi5UVEv8Y8l97Lk0WsOgpHzL0RA1jnSoNqqhNG7UxPqSCgqidQ62qIFQUUVp9HUiSI7YppsMadEbCJvfb2t7MMIgdtNli0d0aklVVbVnD/5bVMYd4+6bp2WYEYmwxfSNpMiW0y1iUzqSjE3HpWy6kRGJ3uCw6OtI3L7oDY6kuNcRIyU5eI7duHKC71FVVZB4BDepgm3x76uidzli7y0uxqRNMUZjjnsdPLb+jJs+W9x0Etv0Gdn0PmnTVBPDImw1XUU1LhJfQiTn7v5+2DGIiIiISPNlFu1xbiZjKWNTIsrikvagaGEl5ZXRXv+4mwZbPgcjAiqiIwXK47bHbjrEi8/HDKth29ZtK6uIFlvcsuhiaUVlUGSxvGrT85qN5ZSWV99eSSSaEEYs+hyp9hz9b7JlcmqkpERIikQwYiMzNo/aqKis2u7Ii/htVVVOeexnEv1Zx0ZitFYpW9yciMS9txq2xb2OrnYRK3gZK2yZFlfkcnNBzC1v0sS2N8TNgfhRO7H/zh7/3zw2mid6Iyh2syR+dNBBgzsn7IiQhEjOzWwucIK7T6lh3zDgJXfv1/SRiYiIiIhsbYspEQ1f+1C2oyruhkZ5ZVVwM6SqivKKYHvsxkd5NJmPFT00NvdSR6JJZvz74BnAtjjG2fImQvUbCpVVUFFVRVXV5ukfsVEGsSQzNrUkfprKpsQzfv8WU082TzupqKyiPHpTp7wi+Fxl0dflsX3R17GimcVlFZRHfw6xm0hb1NBIkNEf1U2/fiyZqQmR5m4lUaLuw7Z/raUDvZsuFBERERERaa4iESMtkkRaomQ6zVRs9EdsKkf1xD32OpbUl1fuXDLvePQmSHR6QNz0heqvk2zzyhGxGyWx12nNZfjMDkikr+y2xqfkA2uaKggzOx14Aljs7j1q2H8x8DOgLzAfuMXd72qq+ERERERERHZW/OiP7LCDaSWabXJuZj8BfhJ968DLZlZWrVkGkAs82UQxtQNuBZZtY//FwN3An4C3gUOBO8zM3P3OpohRREREREREEk+zTc6BucA70dfnAROBldXalALTgfuaKKa/AFMI1lk/LH6HmSUDNwGPuvuvo5vfM7NuwA1mdp+7lzdRnCIiIiIiIpJAmm1y7u4vAi8Csap/17v7vLDiMbN9gbOB4cB1NTQZA3QCHqu2/VHgAmA/4L3GjFFEREREREQSUyTsAOrC3S8IOTFPAe4B/urus7fRbGj0+etq26dFn4c0RmwiIiIiIiKS+BIiOW8GfkFQLf5P22mTG31eXW17YbX9IiIiIiIiIltodcm5mR1mZl6Hx/vR9gOAXwNXuntJI8RziZlNNLOJK1dWn1IvIiIiIiIirUGznXPeiD4Bdq1Du+Lo8z+Bd4EJ0WrtAKmARd+XuvtGNveYtycoGBcT6zEvpAbufg/BkHny8/O3tVyciIiIiIiItGCtLjl392Lg23ocMgTozdbD1Yluuw24is1zy4eyZXIem2s+vbYLTZo0aZWZfVeP2MLQEVgVdhAicfSdlOZI30tpjvS9lOZG30lpjhr7e9l7WztaXXK+A04H0qtt+yUwCjgFWBTdNp7gP+JZBGucx5xN0Gv+cW0XcvdOOxtsYzOzie6eH3YcIjH6TkpzpO+lNEf6Xkpzo++kNEdhfi+VnNfC3SdU32Zm5xMMZ38/rl25mf0GuMPMFhMk6IcAFwI/cveypolYREREREREEo2S8wbk7neZmQM/A64BFhAUkrsj3MhERERERESkOVNyvgPc/fzt7LsbuLvpomly94QdgEg1+k5Kc6TvpTRH+l5Kc6PvpDRHoX0vzV0FwkVERERERETC1OrWORcRERERERFpbpScS63MrKeZPWtma81snZk9b2a9wo5LWgcz62Fm/zKz8WZWbGZuZn1qaJduZn81s6VmtjHa/oAQQpYWzsxONrPnzOy76Hdthpn9ycyyq7Vrb2b3mdkqMysys7fNbLew4paWzczGmtm7ZrbMzErNbJGZPW1mQ6q10990CY2ZvR79O35jte36fSlNwswOin4Hqz/WVGsXyndSyblsl5llAu8CuwDnAecAA4H3zKxNmLFJqzEAOBVYDXy4nXb3AxcDvwWOAZYCb5jZ7o0doLQ6VwOVwLXAEcCdwOXAW2YWATAzA16O7v8RcBKQQvC7s0cYQUuLlwtMAq4Evgf8ChgKTDCz3qC/6RIuMzsDGFHDdv2+lDD8HzAm7nFYbEeY30kVhJPaXAz0Awa7+2wAM5sKzAIuBf4RYmzSOnzg7nkAZnYRwT86t2BmI4AzgQvd/cHotnHANOB64NimC1dage+7+8q49+PMrBB4GDiIIPk5FtgXOMTd3wMws/HAPODnBP8oEGkw7v4E8ET8NjP7DPgWOBn4O/qbLiExs/bALcBPgP9U263flxKGb2paMjsqtO+kes6lNscCE2J/xAHcfR7wMXBcaFFJq+HuVXVodixQDjwVd1wF8CQw1szSGik8aYWqJeYxn0efu0efjwWWxP6oR49bS3AnXr87pakURJ8ros/6my5h+TPwdfQmUnX6fSnNTWjfSSXnUpuhwNc1bJ8GDKlhu0gYhgLz3L242vZpQCrB0HiRxnRg9Pmb6PP2fnf2MrOsJolKWh0zSzKzVDMbSLC06zI296jrb7o0OTPbDzgXuGIbTfT7UsLwuJlVmlmBmf2nWu2N0L6TSs6lNrkEc32rKwTaN3EsItuyve9pbL9IozCz7gTTJ95294nRzbV9J/X7UxrLp0ApMBMYTjAsc0V0n/6mS5Mys1SCm0R/c/cZ22im35fSlNYSTPO5CDgEuIFgvvl4M+scbRPad1JzzkVERHZQ9O75iwTDhi8IORwRCIq8tSWYW341QaHC/dx9fqhRSWv1cyADuCnsQEQA3P0L4Iu4TePM7APgM4K55NeFEliUes6lNqup+e7Qtu4oiYRhe99T2HynU6TBmFkGwfyzfsBYd18Ut7u276R+f0qjcPdv3P3T6NzeQ4Es4JfR3fqbLk0mOkz418BvgDQza2dm7aK7Y++T0O9LCZm7TyYYbbRndFNo30kl51KbaQTzLqobAkxv4lhEtmUa0De6TFC8IUAZMHvrQ0R2nJmlAM8C+cBR7v5VtSbb+925wN03NHKIIrj7GoLff7G6G/qbLk2pH5AOPEaQzMQeEIzqWA3shn5fSvPh0efQvpNKzqU2LwGjzaxfbIOZ9SFYXuClsIISqeZlgvUnT4ltMLNk4DTgTXcvDSswaXmia5k/TjBX7fhtLMXyEtDdzA6MO64t8H30u1OaiJnlEaxpPie6SX/TpSl9CRxcwwOChP1ggptH+n0poTKzfGAwwdB2CPE7ae5eeytptcysDTAF2EgwB8MJCidkA8N1N1OagpmdHH15KHAZ8ENgJbDS3cdF2zwJjAWuIViH8nLgGGCf6HAlkQZhZncSfA9vAl6ptnuRuy+KJvAfAT0JvpOrgV8RFOga4e4LmzBkaQXM7AVgMjAVWAcMIlhTuguwl7vP1N90aQ7MzIGb3P266Hv9vpQmY2aPE/w7cTKwBhhJ8H0rBvZw91VhfieVnEutonOGbgEOBwx4B7hKxWWkqUT/kNdknLsfFG0TKzhzJtCO4B+gv3D395sgRGlFzGw+0Hsbu//g7r+PtssF/gYcTzC0czzwU3ef0vhRSmtjZr8ATgX6EywhuRB4H/hT/N9r/U2XsFVPzqPb9PtSmoSZ/Qo4g+DveCbBcpP/A37n7kvj2oXynVRyLiIiIiIiIhIyzTkXERERERERCZmScxEREREREZGQKTkXERERERERCZmScxEREREREZGQKTkXERERERERCZmScxEREREREZGQKTkXERGRhGRm883ssbDjEBERaQhKzkVERERERERCpuRcREREREREJGRKzkVERKRWZjbCzF4ys9VmttHMPjaz/eP2P2Rmi8xsHzP73MxKosPOf1TDufYys7fNbIOZFZnZO2a2Vw3tDjSzt8xsbbTdFDP7QQ3tTjezb6JtJprZfg3/ExAREWlcSs5FRERku8xsD+ATIBe4GDgJKADeNrNRcU3bAk8BDwPHA+8D/zSz8+PONRwYB7QHzgfOjR43zsxGxLU7DngHSAUuBY4DHgB6Vwtvf+BnwG+A04Ak4BUza7eTH1tERKRJmbuHHYOIiIg0Y2b2DtANGOHuZdFtScDXwAx3P97MHgLOA85w9yfjjn0LGAT0cXc3s2eBw6Lv10TbtAXmA++7+4lmZsA8YBWwl7tXbSOu+UAO0M/dV0e35QOfA2e5+38a9AchIiLSiNRzLiIiIttkZhnAgcAzQJWZJZtZMmDA28ABcc0rgeeqneJJoBfQPfr+AOCVWGIO4O7rgJei1wEYTNBDft+2EvM442OJedRX0edetX86ERGR5kPJuYiIiGxPLsFQ8d8A5dUeVwLtzSz274nV7l5e7fjl0edYcp4LLK3hOssIhroDdIg+L6pDfIXxb9y9NPoyvQ7HioiINBvJYQcgIiIizdoaoAr4N/BITQ3cvSoYiU57M0uplqDnRZ8XR58LgS41nKYLEOsBXxV97l5DOxERkRZJybmIiIhsk7sXmdmHwAhgci3DzJMIisU9GbftdGABm5PzccBRZpbt7usBzCwb+D5BATmAmQRz0C8ys3tcBXJERKQVUHIuIiIitfkp8AHwhpndTzAsvSOwB5Dk7r+MtlsP/MXMOgKzgDMIir+dH5dg3wAcA7xjZn8GHPgFkAlcDxAtHHcV8DzwrpndBawEdgU6u/vvGvnzioiINDnNORcREZHtcvfJwJ4Ey6f9E3gTuA3YjSBpj1lH0FN+HvAicDDwY3d/OO5cU4GDom0fBh4FNgAHuvuUuHYvAodH395PUDDuEoIedRERkRZHS6mJiIjITosupXaYu/cIOxYREZFEpOS8GenYsaP36dMn7DBERERERESkEUyaNGmVu3eqaZ/mnDcjffr0YeLEiWGHISIiIiIiIo3AzL7b1j7NORcREREREREJmZJzERERERERkZApORcREREREREJmZJzERERERERkZApORcREREREREJmZJzERERERERkZApORdJQO99u4JXpy4NOwwREREREWkgWudcJAHd9No3lFZUcvTwrmGHIiIiIiIiDUDJuUiCWbG+hNkrNgBQVFpBmzT9bywiIiIikuiafFi7mfU0s2fNbK2ZrTOz582sVx2PTTezv5rZUjPbaGbjzeyAGtpFzOxXZjbfzErMbIqZnVTLufcxsyozczPbKtsxs+PN7Ivo+b4zs+vMLKmGdvuZ2SfR+JaZ2T/MLKMun0+kLibMLdz0elY0SRcRERERkcTWpMm5mWUC7wK7AOcB5wADgffMrE0dTnE/cDHwW+AYYCnwhpntXq3dDcDvgduBI4EJwDNmdtQ24koB7gaWb2P/WOA54PPo+W4DrgP+WK3dcOAtYEU0vuuAC4CH6vDZROpk/JwCkiIGwMzl60OORkREREREGkJTj4e9GOgHDHb32QBmNhWYBVwK/GNbB5rZCOBM4EJ3fzC6bRwwDbgeODa6rTNwNXCzu/8tevh7ZjYAuBl4rYbTXwMY8ABwbQ37bwY+cvdL4s6XBVxnZre4+7Lo9j8Ai4BT3L08Gk8Z8LCZ/dndJ2/3pyNSBxPmFnDAwI58MqeAmcuUnIuIiIiItARNPaz9WGBCLDEHcPd5wMfAcXU4thx4Ku7YCuBJYKyZpUU3jwVSgceqHf8YsJuZ9Y3faGb9CXq4fxg9P9X29wR2r+F8jwIpBD3psd73I4CnY4l51NNAWR0+n0itlq7dyLxVRew7oCMD87KYoZ5zEREREZEWoamT86HA1zVsnwYMqcOx89y9uIZjU4EBce1Kgdk1tKOG69wFPOPuH2znulSPO3pToTjufP2B9BralQBzariuSL2Nn1MAwOh+HRiUl82s5ZpzLiIiIiLSEjR1cp4LrK5heyHQfieOje2PPa9xd6+lHWZ2NjCKYFj79q7LNq69utp1t9WuMP668czsEjObaGYTV65cuZ0wRILkPCcjhSFd2zIoL5tl60pYW7zVgA8REREREUkwTV6tvbkws1yCOe7XuvuKsOJw93vcPd/d8zt16hRWGJIgxs8tYO++uUQixuC8bABmrtDQdhERERGRRNfUyflqau4h31aveF2Phc0946uBdmZmtbS7kaDa+9Nm1s7M2hEMSwfIiaseH4urpmu3r3bdbbXLjWsnskMWFhazaPVGxvTvAMCgLkFyPkNF4UREREREEl5TJ+fT2DyHO94QYHodju0bXY6t+rFlbJ5jPg1II5gDXr0dcdcZAgwHCggS69XAL6L7VgGPx52P6nGbWR8gM+58cwjmuldvl05Qob62zyeyXePnBvPNY8l5t5x0stKSmaWicCIiIiIiCa+pk/OXgNFm1i+2IZrk7hvdtz0vE1RHPyXu2GTgNOBNdy+Nbn6doOr6WdWOPxv4OlrIDeAq4OBqj4ej+w4jqOCOuy8ApmzjfOXA/6LtyqLXPjUaV8zJBDcLavt8Its1YU4BuW1SGdQ56DE3M1VsFxERERFpIZp6nfN7gSuBF83sOsCBG4CFwN2xRmbWm6An+np3vx7A3b8ws6eAW6PLls0DLgf6Epc4u/sKM/sH8CszWw9MJkjgDyG6Fnq03ZfVgzOzg6Ivx0WXaYu5FnjFzO4GngBGEiTvt8WtcQ7we2ACwVD5fwN9gL8Cz7r7pLr+kESqc3fGzy1gdL9gvnnM4Lxs3pi2DHdn65kcIiIiIiKSKJq059zdiwiS5JkE64Q/TpBkH+Lu8WtCGZBUQ3wXAA8SzBd/FegJHOHuk6u1+3W0zY+BNwh65k9191d2MO7XCHrAR0fP9xPgj8Avq7X7Evge0DUa3x+BR4DzduS6IjHfFRSzdG0JY/p12GL7oLxsVheXs2pDWUiRiYiIiIhIQ2jqnvPYMPGTamkznyBBr759I/DT6GN7x1cSJOc31jO23xP0fte073ng+Tqc4wNgTH2uK1Kb6vPNYwZHi8LNWr6eTtlpTR6XiIiIiIg0jFa7lJpIIhk/p4BO2Wn075S1xfaBecF7zTsXEREREUlsSs5FmrnN8807bDWvvFNWGu0zU5ip5FxEREREJKEpORdp5uasLGLl+tKt5ptDULF9UF42M5dvqOFIERERERFJFErORZq5bc03jxmUl83MZetx96YMS0REREREGpCSc5FmbsKcArq0TadPh8wa9w/qks360gqWri1p4shERERERKShKDkXacbcnQlzCxjTf+v55jGD84KK7SoKJyIiIiKSuJScizRjM5dvoKCorMb55jGDohXbZyk5FxERERFJWErORZqx8XNWAduebw7QLjOVztlpzFimonAiIiIiIolKyblIMzZ+bgE92mfQM7fm+eYxg7tkazk1EREREZEEpuRcpJmqqnI+nVe43SHtMYPyspm1Yj1VVarYLiIiIiKSiJScizRT3yxbx5ri8u0OaY8ZlJdFSXkVC1cXN0FkIiIiIiLS0JScizRT4+dsf33zeINiFduXaWi7iIiIiEgiUnIu0kxNmFtAnw6ZdM3JqLXtwGhyrnnnIiIiIiKJScm5SDNUGZtvXodec4CstGR6tM9g5nJVbBcRERERSURKzkWaoWlL1rK+pILRdSgGFzMoTxXbRUREREQSlZJzkWZo03zzeibnc1ZuoLyyqrHCEhERERGRRqLkXKQZGj+3gP6d2tC5bXqdjxncJYvySue7gqJGjExERERERBqDknORZqa8sorP6zHfPGZg51jFds07FxERERFJNErORZqZrxavpaiskjH9OtbruAGds4gYzNC8cxERERGRhKPkXKSZic03H90vt17Hpack0adDG2ZqrXMRERERkYTT5Mm5mfU0s2fNbK2ZrTOz582sVx2PTTezv5rZUjPbaGbjzeyAGtpFzOxXZjbfzErMbIqZnVRDuwfN7JtoHBui7X5kZklxbQ4yM9/OY3Rc24e20ebWHfxxSSs0YW4Bg/Oy6ZCVVu9jB+VlM3OFknMRERERkUST3JQXM7NM4F2gFDgPcOBG4D0zG+7utVWyuh84GrgGmAtcAbxhZmPc/cu4djcAVwO/BiYBpwPPmNkx7v5aXLsM4F/AnGgsY4HbgAHAj6NtJgNjthFLLvB5te0rgWOrbVtay+cSAaCsoorP5xdy+p51ul+1lUF5Wbw5fRkl5ZWkpyTVfoCIiIiIiDQLdU7Ozaw7cDgwGuhGkNiuAmYA44Bx7l7bGk4XA/2Awe4+O3reqcAs4FLgH9u5/gjgTOBCd38wum0cMA24nmhCbGadCRLzm939b9HD3zOzAcDNwKbk3N1Pr3aZN82sG3Ah0eTc3dcBE6rF0hvYFfi7u1dWO0eZu09AZAd8uXANJeVV9VrfPN6gLtlUOcxZuYGh3XIaODoREREREWkstQ5rN7MDzewVYD7wAHAU0J0gOR9BkAi/Ayw0s9+bWdvtnO5YYEIsMQdw93nAx8BxtYRyLFAOPBV3bAXwJDDWzGJjgMcCqcBj1Y5/DNjNzPrWcp0CoKKWNucABjxcSzuRehk/pwCz+s83jxmcF1Rsn7VcFdtFRERERBLJdpNzM3sV+B9QBJwKdHb3Xu4+yt33c/chQFtgd+AO4BRgjpmN3cYphwJf17B9GjCklliHAvPcvbiGY1MJhqLH2pUCs2toR/XrWCDZzNpF56Wfx3Z68KPOBSa7e02fpbOZrTKzCjObaWa/iJ/DLrI94+euYtcubWmXmbpDx/fp2IaUJFPFdhERERGRBFPbsPaZwA/cfdm2GkSHsk+NPm4ys2OBbY2nzQVW17C9EGhfSyzbOza2P/a8xt29lnYxRwMvR187wXD4G7YVhJmNAQayeU56vC8J5rhPA9KBE4A/RdtftK1zigCUlFcyecEazhnde4fPkZIUoV/HLFVsFxERERFJMNtNzt39J/U9obu/tOPhhOJDYE+CGwqHAlebmbv7r7fR/jyC4fX/qb7D3W+ttuk1M9sAXGVmf3b3WdWPMbNLgEsAevXasSJg0jJMXrCasooq9um/Y/PNYwZ1yeaLBTXdxxIRERERkeaqqZdSW03NPeTb6hWv67GwuWd8NdDOzKyWdgC4+1p3n+ju77j7tcAfgV9GC+BtITqv/VTgVXdfVUu8MU9En/Nr2unu97h7vrvnd+rUqY6nlJZowpwCIgZ79t2x+eYxg/OyWLR6I0WltZVOEBERERGR5qJeybmZjYyuSx6bU71HdPsfzeyIOpxiGsGc8OqGANPrcGzf6HJs1Y8tY/Mc82lAGtC/hnbU4ToTCX4uNRWOO5bgBsGOFIKrPsxeZAvj5xawW/cc2qan7NR5BsaKwq1QUTgRERERkURR5+TczPYDxgO7EAzpjj+2CrisDqd5CRhtZv3iztsH2De6b3teBlIIis7Fjk0GTgPedPfS6ObXCYadn1Xt+LOBr6PV4bfnQIJEem4N+84jWD7u1VrOEe+s6Pmqr4cussnGskq+XLiG0Ts5pB02V2zXvHMRERERkcRR53XOCdYIfwM4HkgCrozbN5mggnlt7o0e96KZXUeQtN4ALATujjWKriM+B7je3a8HcPcvzOwp4FYzSwHmAZcT9HBvSsTdfYWZ/QP4lZmtj8Z2GnAI0bXQo9c4GriAIOlfAGQDRxLM/77b3ZfEBx5dP30scKe7l1f/YNGYHyVY2m02Qe/9CcD50fPNqcPPR1qpid8VUl7pjNnB9c3j9czNJD0lwkxVbBcRERERSRj1Sc73AE50dzez6kO0VwG1Tph29yIzOwS4hSCRNYI10q9y9/gxuEZwA6B6z/4FwE3AjUA7YApwhLtPrtbu18AGgorqXYAZwKnu/kpcmznR898IdAbWALMIbjI8wdbOIvh5bWtI+3qC+ey/APIIRhN8C/wfwTJzIts0fk4ByRFjzz47N98cICliDOycreXUREREREQSSH2S8xKg+nzvmK7A2rqcxN0XACfV0mY+QYJefftG4KfRx/aOryRIum/cTptvgRNrj3hT+1sIbipsa38hwagCkXobP7eA4T1yaJNWn/8lt21gXhYfz65rzUIREREREQlbfQrCfUSwJFhS3LZYD/oPgHcbLCqRVmRDaQVTF61lTAPMN48ZnJfN8nWlrC3eagaGiIiIiIg0Q/VJzn9DMLR9SvS1A+eZ2XvAaOAPDR+eSMv3+fxCKqucMf06Ntg5B3WJFoVb0byHtn+zdB3FZVryTURERESkzsm5u08BDgCWE8zpNjYXhTvQ3Wc0fHgiLd+EOQWkJBmjerdvsHMOilZsn9GMK7avXF/K9//1Ef98Z3btjUVEREREWrh6rXPu7pPd/VCCyuY9gLbufrC7f9Eo0Ym0AuPnFjCyZ3syUpNqb1xH3XLSyUpLbtYV29/+ZjkVVc7/vl6Ke/UakyIiIiIirUu9kvMYdy+JLjWWbmajzCytgeMSaRXWlZTz9eK1DbK+eTwzY1BeVrPuOX9j2jIAvisoVmV5EREREWn16pycm9l1ZvanuPcHAPOBz4BZZjaw4cMTadk+m1tIldMg65tXN7hLNjOXr2+WvdLrSsr5ZHYBJ4zsjhm8/vWysEMSEREREQlVfXrOzwbmxr3/M0FxuOMJ5qHf0HBhibQO4+cWkJocYWSvdg1+7oGds1ldXM6qDWUNfu6d9d63KyirrOKsvXsxqld73pi2POyQRERERERCVZ/kvDswC8DMOgF7Ab9x95eBm4H9Gz48kZZt/JwCRvVqT3pKw803jxkcq9jeDIeMvzltOR2z0tijV3vGDu3CN0vXsbCwOOywRERERERCU5/kvBJIjb4+ACgBPo6+XwnkNmBcIi3emuIyvlm2rkHXN48Xq9je3JLzkvJK3p+xgsOH5BGJGGOHdgE2z0EXEREREWmN6pOcTwPONrMs4EJgnLuXR/f1BFY0dHAiLdmEuYW402jJecesVNpnpjS75Pzj2asoKqtk7NA8AHp1yGTXrm0171xEREREWrX6JOfXA6cCa4FDCeacxxwFTG7AuERavAlzC8hISWJEj3aNcv6gYnt2s6vY/sa0ZWSnJbNP/46bto0dmsekBatZub40xMhERERERMJT5+Tc3d8AdiVI0Ie6+7i43R+wZbIuIrUYP6eA/D7tSU3eoRUN62Rwl2xmLd/QbCq2V1RW8fY3Kzhk185bfO6xQ7vgDm9NV2E4EREREWmd6pUVuPs8d3/O3edU2363u09o2NBEWq6CDaXMWL6+0Ya0xwzKy2Z9aQVL15Y06nXqauJ3qyksKts0zzxmly7Z9O6QqXnnIiIiItJqJdensZklA2MI5pinV9vt7v5gQwUm0pJNmFsINM765vFiReFmLF9Pt3YZjXqtunhj2jJSkyMcOKjTFtvNgsJwD348j3Ul5bRNTwkpQhERERGRcNQ5OTezPYAXgB6A1dDEASXnInUwfu4qstKS2a17TqNeZ1BeFgAzl63n4MGdG/VatXF33py2nAMGdqRN2ta/esYOzeOeD+by3rcrOG737iFEKCIiIiISnvoMa78L2AAcDwwG+lZ79Gvo4ERaqvFzCtizT3uSkxpvvjlAu8xU8tqmMXP5hka9Tl18vXgdi9ds5HvVhrTHjOzZnk7ZaRraLiIiIiKtUn2GtQ8BTnX31xorGJHWYNnaEuasLOK0PXs2yfUG5WU3i+XU3pi2jIjBYbvm1bg/EjG+NySPF75YTEl5JekpSU0coYiIiIhIeOrTbTcTaNNYgYi0BtOWrOWMeyeQFDEO2aVphpkPystm1or1VFaFW7H9jWnL2KtvLrltUrfZZuzQLhSXVfLRrFVNGJmIiIiISPjqk5xfC1xnZr0aKxiRlsrdefzT7zjhjk8oLqvgiYtHM6BzdpNce3BeNiXlVSwsLG6S69Vk7soNzFqxYasq7dWN7teB7PRkXtfQdhERERFpZeo8rN3dXzezg4BZZjYTWL11Ez+wAWMTaRE2lFZw7fNf8dKUJRwwqBO3nDqCDllpTXb9QV2CmwAzl6+nT8dwBr+8MS1Yv7y25Dw1OcKhu3TmnW+WU1FZ1ehz8kVEREREmos6/8vXzH4J/BxYA6wDKqs9qhohPmkhSsor+WbpOqYtWYt7uMOrm9I3S9dx7L8+4pWpS7hm7GAeOn/PJk3MAQZ2jlZsD3He+RvTljG8R06dlnMbO7QLq4vL+Wx+YRNEJiIiIiLSPNSnINxVwN3Ale5euaMXNLOewC3A4QRLsr0NXOXuC+pwbDpwA3A20A74EviFu39QrV0E+AVwKdAFmAFc7+7PVWv3IDAa6E5wo2IOcB9wR/xnNLP3gZpGBfzE3W+tds7jgd8BuwLLgXuBP+3MzyyRFBaVMWflBuas2MDsFRuYs3IDs1duYNHqjcRy8mHd23LemD58f0S3Flv0y9156vOF/O6laeRkpPDExaPZu5HXNN+WNmnJ9GifwYyQKrYvW1vClwvXcM3YwXVqf+DgTqQlR3hz2nL26d+xkaMTEREREWke6pOcZwLP7GRingm8C5QC5xGsjX4j8J6ZDXf3olpOcT9wNHANMBe4AnjDzMa4+5dx7W4ArgZ+DUwCTgeeMbNjqlWbzwD+RZCUOzAWuA0YAPy42rWnEiT78eZX+3xjgeeicf4UGAn8EcgmuFnQIlRVOYvXbNyUfM9ZGUvEiygsKtvULi05Qr9OWYzo0Y6T9uhB/05ZrNlYziOfzOeaZ6fyp/99y5l79eLs0b3pkpMe4idqWEWlFfz6ha/475dL2H9gR245bXc6NnFveXWD87KZFVLP+VvTg/njY4fWXKW9uszUZA4Y1Ik3pi3jd98fgpk1ZngiIiIiIs1CfZLz/wFjCJLrHXUxwXrog919NoCZTQVmESS+/9jWgWY2AjgTuNDdH4xuGwdMA64Hjo1u60yQmN/s7n+LHv6emQ0AbgY2Jefufnq1y7xpZt2AC9k6OV/v7hNq+Xw3Ax+5+yVx180iKKR3i7snbJWrletL+cPL05izsoi5KzdQWrF5FkNum1QGdMpi7NA8+nfKon/nLAZ0yqJ7uwwika0Tq7P37sUncwp46JP5/Pv92dw5bg5HDOvCBfv0YVTv9gmdjH27bB0/fHwy81cVcfX3BvHDgwbU+DNoagPzsvlg1krKK6tIaeJ53K9PW0a/Tm3qVQBv7NAuvDV9OVMXrWVEz3aNF5yIiIiISDNRn+T8VuChaOL0OlsXhMPd59ZyjmOBCbHEPHrMPDP7GDiO7STn0WPLgafijq0wsyeBX5pZmruXEvR+pwKPVTv+MeABM+vr7vO2c50CoKKWz7GV6HD93YFLqu16FPgDcCTwYH3P21xkpibx1eK19O+UxX4DOtC/UxYDOmfRr1PWdpfGqomZse+Ajuw7oCMLCop5dMJ8nvx8Ia9OXcqw7m05f5++HDO8a0INeXd3np64kN++OI22GSk8ftFoxvQPZxh7TQZ3yaK80pm/qoiBeU1TJR5gTXEZE+YWcskB/ep13GG7diYpYrwxbZmScxERERFpFeqTnH8cfb6BoKe6JrVlU0OBF2vYPg04pQ7HznP36utBTSNIxgdEXw8lGDY/u4Z2AEOATcm5BXcbkoAs4FCC4fZ/qeH6I81sLcHw/m+A29z9/mrxAXwdf1D05kNx9LoJq01aMuOuObjBz9urQya/PnoIPzl8EC98sZiHPp7P1c9M4Y+vfZMwQ96LSiv4zX+/5vkvFrPfgGAYe6fscIexVzcompDPWL6+SZPzd75ZQWWV11qlvbp2mamM7pfLG9OW8fMjdmmk6EREREREmo/6JOcXEszL3hm51NDjDhQC7Xfi2Nj+2PMa37okePV2MUcDL0dfO8Fw+BuqtfkAeByYSVCI7lzgPjPr6u43VjtvTTGuruG6AJjZJUR723v1ar1LyGemJnPW3r05c68th7zfNW4OY5vxkPcZy9bzw8cnMW9VET89fBBXHDyApGYwjL26/p2yiBjMbOKicG9MW0aXtukM755T72PHDu3Cb1+cxuwV65tsTXgRERERkbDUZ53zhxoxjjB9COwJ5BD0nF9tZu7uv441cPffVjvmRTN7Afi1md3q7juc8bj7PcA9APn5+a1njbFtqMuQ92NHdCM1Ofz1r4Nh7F+TlZbCYxft3awri6enJNGnQxtmLmu6onAbyyr5YNZKTs3vuUPz7r83JEjO35i2XMm5iIiIiLR4TZ3hrKbmHvJt9YrX9VjY3DO+GmhnW3exVm8HgLuvdfeJ7v6Ou19LUF39l2bWvZZ4ngDSgd3irss2Ymxf/bpSu9iQ90+vPZSbThhGaXkVVz8zhXPu/5QNpfUuC9Bgissq+NnTU/j5s1MZ1bs9r/14v2admMcMystu0rXOx81cSUl5FUfUc0h7TJecdEb0bMcb0xK2jqKIiIiISJ1tNzk3s3+aWb3+ZW1mJ5pZ9SroMbE54dUNAabXcuppQN/ocmzVjy1j8xzzaUAa0L+GdtThOhMJfi59a2kXE+vtjs1p3+LzmVkfgnnqtV1XtiE25P3NnxzA304ZwcTvVnPu/Z+yrqS8yWNZunYjJ97xCc9/sYirDhvIIxfuTefs5j0nPmZQl2zmFxRRUr7DqyHWy5vTltEuM4W9+tY4o6NOjhjahamL1rJkzcYGjExEREREpPmpree8DzDXzJ4ys2PNbKt/ZZtZxMx2N7PfmNkM4E623Uv8EjDazPrFHd8H2De6b3teBlKIKxxnZsnAacCb0UrtEFSSLwfOqnb82cDXtVRqBziQIOGurfL8WcBG4CsAd18ATNnGdcsJlqKTnWBmnDyqB/8+cyRfLV7LWfd+yuq4ddUb28zl6znxjk9YtHojD1+wF1cdNqhZzi/flkF5WVQ5zFnZ+PPOyyurePub5Ry6Sx7JO7F0W2xt9DfVey4iIiIiLdx2/9Xs7scCRwAZwHPASjNbaGaTzWy8mX0LrAcmEaxT/h9goLu/uY1T3gvMJ5izfZyZHUtQvX0hcHeskZn1NrMKM9s019vdvyBYRu1WM7vIzA4FniTo4f5dXLsVBEuy/crMfmpmB5nZncAhwK/irnG0mT1rZueZ2cHRmw93Aj8F7nb3JdF2+5vZq2b2AzM7NDoy4EWCpd3+4O5FcZ/vWuBAM7s7et2fANcRVHZXdtFAjhjWlXvOyWfG8vWcce8EVq4vrf2gnfTZvEJOvvMTKqucpy8dwwGDOjX6NRva4GiV9qYY2j5hbgHrSio2Jdc7ql+nLAZ2zuJ1JeciIiIi0sLVWhDO3T8APjCzrsD3gL2BbgTzrecSVDH/APjQ3atqOVeRmR0C3EKw/rcB7wBXVSuqFlverPrNgwuAm4AbCaqmTwGOcPfJ1dr9GtgA/BjoAswATnX3V+LazIme/0agM7AGmEVQif2JuHZLo+2uBzoS9IJPBc509/h2uPtrZnYywc2C84HlBHPYb9rez0Xq7+BdOvPg+Xty0cMTOe2e8fznotGNtuTaa18t5aqnvqRn+wwevnAverSvPrMiMfTp2IaUJGPGssbvOX9j2jIyUpIa5CbG2KFduOP92RQWlZHbJrUBohMRERERaX5s6xXHJCz5+fk+ceLEsMNIKJ/NK+TChz4nt00q/7l47wZPnB/6eB5/eGU6e/Rqz/3n5dMuM7GTwyNu/YDu7TK4//w9G+0aVVXO6D+9wx692nPXOaN2+nxfLVrL92//iL+cPJxT83s2QIQiIiIiIuEws0nunl/TvvDXoxLZCXv1zeWxi/ZmTXEZp941nvmrimo/qA6qqpyb//ctv395OofvmsfjF+2d8Ik5wMC8bGY08rD2LxetYcX6UsYO27kh7THDurele7sMzTsXERERkRZNybkkvN17tuOJS0ZTUlHFqXePZ9ZOJp9lFVX87Jkp3DVuDmeP7sWdZ48iPSWpgaIN1+C8LBat3khRIy5F98a0ZSRHjEMGN0xybmZ8b2geH8xaFeoSeiIiIiIijUnJubQIQ7vl8OQlo3Hg9HsmMH3Juh06z4bSCn7w8Oe88MVirhk7mBuOG5ZQFdlrMyhaFG7WisaZd+7uvDltOWP6dyAnM6XBzjt2aBfKKqoYN2Nlg51TRERERKQ5UXIuLcagvGyevnQMqckRzrh3AlMWrqnX8SvWl3Da3eP5ZE4Bfz15OFccPACzlpOYAwzuEq3YvqxxhrbPWrGBeauKGDu0S4Oed88+ueS2SeUNDW0XERERkRZKybm0KH07tuHpS8fQNiOZs+/7lInzC+t03JyVGzjxjk+Yt6qI+8/L55QWWnisZ/tM0lMijTbv/I2vl2EG3xvSMEPaY5IixuG75vHetysorahs0HOLiIiIiDQHSs6lxemZm8nTl46hU3Ya59z/GZ/MXrXd9pO+W81Jd35CSXklT14ymoMGd26iSJteJGIM7JzdaGudvz5tGSN7tqNz24Zf1m7ssDzWl1bwyZyCBj+3iIiIiEjY6pycm9lxZnZB3PveZjbezNab2bNmltU4IYrUX9ecDJ68dDQ9czO44KHPeX/GihrbvTV9OWfeO4F2GSk8d/k+DO/RrmkDDcGgvMZJzhcWFjNtyboGH9Ies0//jrRJTVLVdhERERFpkerTc34d0Cnu/T+AHsA9wAHA7xsuLJGd1zk7nScvGcOAzllc/MjEreYrP/7pd1z66ER26ZLNs5fvQ+8ObUKKtGkNysti+bpS1hSXNeh535y+HKDRkvP0lCQO2qUzb01fTmWVN8o1RERERETCUp/kvD8wFcDMMoCjgJ+6+8+Aa4ETGj48kZ2T2yaV/1w8mmHdc/jh45N5ecoS3J1/vDmDX7/wNQcO6sQTl4ymY1Za2KE2mUGxonDLG7Zi+xvTljE4L5s+HRvvJsfYoV1YtaGMyQtWN9o1RERERETCUJ/kPB3YGH29D5AMvBl9PwPo1oBxiTSYnIwUHv3B3ozq3Z4fP/kFZ933Kf98dzan5vfg3nPzyUxNDjvEJjU4upxaQxaFK9hQysT5hYwd2rCF4Ko7eHAnUpMivP61hraLiIiISMtSn+R8PrBf9PVxwCR3Xxt93xlYW9NBIs1BVloyD1+wF/sO6Mgncwr4v0MH8ueThpOc1PpqInbNSSc7LZlZDZicv/3NcqocvtdIQ9pjstNT2HdAB96Ytgx3DW0XERERkZajPl2GdwN/M7MTgN2By+P2jQGmN2BcIg0uIzWJ+8/bk3mrijat990amRkD87KY0YBrnb8xbTk92mcwtFvbBjvntowd2oX3ZnzF9KXrGNotp9GvJyIiIiLSFOrcbejutwHnA+OBC9393rjd2cCDDRuaSMNLTY606sQ8ZnCXoGJ7Q/Q+byit4KNZqxg7tAtm1gDRbd9hQ/KIWHBDQERERESkpajXmF53f9zdf+Tuj1Tbfqm7P9qwoYlIYxmUl83q4nJWbdj5iu3vfbuCssqqRqvSXl3HrDTy++RqSbUGtqCgmEnfFYYdhoiIiEirVZ91zgeZ2V5x7zPM7E9m9rKZXdk44YlIYxgULQr3+Kff7fSSam9MW0aHNqmM6t2+IUKrk7FDu/DtsvXMX1XUZNdsyT6atYqj//khJ905nj+99g3llVVhhyQiIiLS6tSn5/x24OS49zcBPyOo0n6LmV3RkIGJSOPZvWc7hnZry61vzyL/xrc5/8HPeGbiQtZuLK/XeUorKnl/xkoOH5JHUqTxh7THfG9IUBW++tr1Un9PfraA8x/8jG7tMjh9z57c/cFcTr9nAkvXbqz9YBERERFpMPVJzkcAHwOYWQQ4F/iFu48CbgQuafjwRKQxtElL5pUf7cfLV+7HD/bvy6zlG7jm2anseePbXPTw57zwxSLWl9SeqH8yu4ANpRVNNqQ9pmduJkO7tVVyvhOqqpw/v/4tv3z+K8b078Czl4/h5pOG888zRvLt0nUcdduHvD9jRdhhioiIiLQa9anWngMURF+PBNoDz0bfvw9c3XBhiUhjMzN265HDbj1y+OURu/DlwjW8OnUpr361lLe/WUFqcoSDB3fi6OHdOGzXzjWuB//GtGVkpSWzz4AOTR7/EUO78Pe3ZrJiXQmd26Y3+fVjSsormb50HSN7tmuSgngNoaS8kp89PYVXv1rKmXv34vpjh25aVvDYEd0Y2q0tVzw+mfMf/JwrDu7PTw4b1CqXHRQRERFpSvVJzpcDA4CPgO8Bc9x9YXRfFlDRwLGJSBMxM0b2as/IXu259qhdmbxgNa9MXcprXy3ljWnLSU+JcOgueRwzvCsHDe5MRmoSlVXOW9OXc9DgTqQlJzV5zGOHBcn5G9OXc87o3k1+/dKKSp7+fCG3vzeb5etKOX3Pntxw/DBSmnkSu2pDKRc/MpEvF67h10ftykX7993qpkL/Tln894p9+f1L0/j3e3OYOH81/zxjJHkh3gQRERERaenqk5y/BPzJzIYRLKl2d9y+3YC5DRiXiIQkEjHy++SS3yeX3xwzhM/nF/LK1CX876tlvPrVUjJTkzhs1zwGd8mmoKisyYe0xwzsnEXfjm14c9qyJk3OyyureHbSIm5/dzaL12xkzz7t+d6QLjw64TuWrC3hjrP2ICutPr9am86s5eu54KHPWbWhlDvPGsURw7b93y49JYmbTxrOnn1yue6/X3P0Pz/kttNHsu+Ajk0YsYiIiEjrUZ8unl8CrwBjCRL1P8btOxZ4sy4nMbOeZvasma01s3Vm9ryZ9arjselm9lczW2pmG81svJkdUEO7iJn9yszmm1mJmU0xs5NqaPegmX0TjWNDtN2PzCwprk3XaFX6iWa2xsxWmtk727juQ2bmNTxurcvnE2lukiLG6H4duPH43fj02kN5/KK9OW737nw4ayV/fWMGqUkRDhrcKZTYzIwjhnXhw1mrOOf+T3lpyhJKyisb7XoV0aT80L+P41fPf0XH7DQeuXAvnr50DDccP4ybT9yNj2ev4tS7xrN8XUmjxbGjPp69ihPv/ISS8iqeumTMdhPzeCeN6sFLV+5Lu8xUzr7/U259eyaVVd7I0YqIiIi0PubedP/IMrNMYApQClwHOEExuUxguLtvd10kM3scOBq4hqCn/grgSGCMu38Z1+4mgjnwvwYmAacDFwPHuPtrce2eBD4A5kRjGQv8BPiXu/842uYY4J/Ag8AEIBX4YfS6x7r7K3Hnewg4iuBmRbyl7v5dbT+f/Px8nzhxYm3NREJXXlnFJ3MKSDJjv4Hh9aQWl1Vw1/tzeG7yYhav2Ujb9GSO3b0bp4zqyfAeOQ0yB7yyynll6hJue3sWc1cVMbRbW356+CAO2aXzVud/f8YKrnh8MjkZKTx04V6blqwL29OfL+TaF76iX6c2PHD+nvRon1nvcxSXVXDdC1/z/BeL2W9AR245bXc6Zac1QrQiIiIiLZeZTXL3/Br31Tc5N7NcYAyQCxQC4929sI7H/hj4BzDY3WdHt/UFZgE/d/d/bOfYEcCXwIXu/mB0WzIwDZjh7sdGt3UGFgI3u/vv4o5/B+jk7sNrifEJgiQ+O/q+HbDB3Svi2sSuu9zdD4jb/hBwmLv3qMvPozol5yI7pqrK+WROAc9MWsjrXy+jtKKKwXnZnJLfg+NHdqdjVv2TyKoq5/Vpy7jlrZnMWrGBXbpkc9Vhgxg7NG+7Sf/Xi9dy4UOfs7G8krvPHsU+IQ4Dr6py/vbmDO54fw77D+zIv8/ag7bpKTt8Pnfn6YkL+e2L08jJSOGfZ4xkdL+mLwYoIiIikqgaLDk3sxsJ1jaP/5duKfA3d/9NHY5/B0h3932rbR8H4O4HbufY3wC/Adq5e3Hc9j8QDLlv6+6lZnYO8AgwyN1nxbW7AHgA6Ofu87ZznduBs9y9fS2f5Skg3937x217CCXnIqFau7GcV6Yu4emJi5iycA3JEePgXTpzyqgeHLxL51oLtrkHhe5ueXsW3yxdR/9ObfjJ4YM4alhXInVcy33xmo1c8OBnzFtVxF9OHs4JI3foV8JOKSmv5GfPTOHVqUs5Y6+eXH9cwxWr+2bpOq54fDLzC4r42fcGc/mB/ev8sxERERFpzbaXnNe5apGZXQVcC9wPPAYsA7oAZwPXmtlKd/9nLacZCrxYw/ZpwCl1OHZefGIed2wqQSX5adF2pcDsGtoBDAE2JecWdIElEVScPxQ4D/jL9gIxs1SC0QNTa9jd2cxWAe0Iht7fT3DzovEmw4rIJjkZKZy1d2/O2rs3s5av55lJi3h+8mLemr6cjlmpHL97d07J78ngLlsOOXd33p+5klvemsnURWvp0yGTW04bwbEjupNUz8Sze7sMnrlsHy59dCI/eWoKi1dv5IqDBzTZUmsF0Yrskxes4VdH7sIlB/Rr0Gvv2rUtL/1oP371/Ff89Y0ZfDavkFtO253cNqkNdg0RERGR1qY+JYUvA25z95/EbZsBjDOzDQTzsGtLznOB1TVsLyRYN31Hj43tjz2v8a2HBFRvF3M08HL0tRMMh7+hllh+D/QAzqq2/UuCOe7TgHTgBOBPwEDgolrOKSINbGBeNtcetSvXjB3MuBkreWbSQh76ZD73fTSP4T1yOGVUD44d0Z2vl6zl72/OYPKCNfRon8FfThrOiXt036m1vXMyUnj4wr34xbNT+dubM1m8ZiM3HDes0dcLn71iAxc+9DnL15Vw51l7cORuXRvlOllpyfzz9N3Zu28u1788naP/+SG3nzmSUb2r/4oVERERkbqoT3LeB3h1G/teBS7f6WjC8SGwJ5BD0HN+tZm5u/+6psZmdibBMPob3P3D+H3ufmu15q9Fb1xcZWZ/jh9mH3e+S4BLAHr1qlPRehGpp5SkCIcNyeOwIXms2lDKf79YzLOTFvGbF6fx+5enU1nldM1J56YThnHKqJ6kJjdMAp2WnMQtp+1Oj/aZ3P7ebJasKeHfjbjU2idzVnHZo5NITY7w5CWjGdmrtnueO8fMOHt0b3bv2Y4fPj6Z0+6ewHVH78p5+/RpslECIiIiIi1Fff6FWAAMA96uYd/Q6P7arKbmHvJt9YpXP7amxYxj3TSFce3aWTTD3k47ANx9LRCb6P2OmZUBvzGzO9x9cXxbM/s+8BBwf3yxuVo8AVwF5BMUvtuCu98D3APBnPM6nlNEdlDHrDQu2r8fP9ivL18vXsfLU5fQo30Gp+b3JD0lqfYT1JOZcfXYwXRvn8F1//2a0+4ez4Pn70nntukNdo2qKufZSYu49oWv6NsxqMjeM7f+Fdl31LDuObzyf/vx06em8PuXpzNj+Qb+cOzQBrvJISIiItIa1Cc5fwG4wcwKgCfcvSJatfwU4Hrg4TqcIzYnvLohwPQ6HHuCmWVWm3c+BChj8xzzaQQF6/qz5bzzIdHn2q4zkWD9977ApuTczA4FniH4OVxayzlqosRbpBkxM3brkcNuPXKa5Hpn7NWLLjnpXPH4ZE644xMevGDPnVpqbUFBMR/NXsXHc1Yxfk4BhUVl7DugA3ecNYqcjB2vyL6j2qancM85ozZVh5+7cgN3nj1K89BFRERE6qjO1drNLBt4DdgXqCTogc4lKKb2EXCUu2+o5RxXAX8jqKQ+N7qtD0GP8i/d/e/bOXYkMBk4390fjm5LBr4CZrv796PbOgOLgJvc/Q9xx78N5Ln7brXE+FeCivQ93H1JdNsY4C1gHHC8u5dv7xzVzncb8CNgoLvP2V5bVWsXafm+XryWCx76nJLySu4+ZxT79K/bUmsFG0r5ZE4BH0cT8oWFGwHIa5vGvgM6sv/AjhwzvFuDVWTfGf/9YjE/f24qeW3TuP+8nbsJISIiItKSNORSakZQQG1/Nq9zPg74Xw0F2Go6vg0wBdgIXEfQm3wDkA0MjyX3ZtYbmANc7+7Xxx3/JDAWuIag4vrlwDHAPu4+Oa7dzQRDya8lSOhPI+jtPtbdX4m2ORq4gKAY3IJoDEcSzP++x90vj7bbBfgEWAecD5TEfyZ3nxAX86PAkwQ99mkEBeHOB+6OnW97lJyLtA6LVhdzwYOfM7+giL+ePILjR3bfqk1xWQWfzSvk49mr+Gh2Ad8sXQdAdnoyo/t1YL8BHdl3QEf6d2rTLOd3f7FgNZc8OomNZZXcdvruHLprXtghiYiIiISuwZLzBgqmF3ALcDhgwDvAVe4+P65NH4Lk+w/u/vu47RnATcCZBEuVTQF+4e7vV7tGEvAr4GKC5d5mECT6z8a12QX4I0ExuM7AGoIe/DsJhu1XRdudDzy4rc/j7hZtl0uwjvpIIA+oAr6Nbrsjdr7tUXIu0nqsLS7n0scmMmFuIdeMHcwlB/Rj6qI1fDy7gI9mr+KLBaspr3RSkyKM6t2efQd0YN8BHdmte06jV3xvKEvXbuTiRyYybck6fnlEwy/pJiIiIpJomlVyLtum5FykdSmtqOTnz07lxS+XkJYcobSiCjMY2q0t+w7oyH4DOpLfO5eM1IYvVNdUNpZVcvUzU3j1q6WctEcP/njiMNKSE/fziIiIiOyM7SXn2y0IZ2ZV1L2Qmbt746wPJCLSAqUlJ3HrabszvEc75q3awD79OzKmXwfat6AiahmpSdx+5kgGvZPNLW/PZN6qDdx9Tj6dstPCDk1ERESkWaktmb4eVRkXEWk0ZsYP9usbdhiNysz48WEDGZiXxU+f/pLjbv+Ie87NZ1j3pqmULyIiIpIINKy9GdGwdhFp6b5evJaLH5nImuJy/nHqCI7crWvYIYmIiIg0me0Na0+MqkIiItIiDOuew4tX7ssuXbO5/PHJ/POdWegmsYiIiIiScxERaWKds9N54uLRnDiyO/94ayY/euILNpZVhh2WiIiISKhUwE1ERJpcekoSfz91BIO6ZPPn17/lu4Ji7j03ny456WGHJiIiIhIK9ZyLiEgozIzLDuzPvefkM3flBo69/SO+XLgm7LBEREREQqHkXEREQnXYkDye/+G+pCZHOPGOj7niP5P5atHasMMSERERaVJKzkVEJHSDu2Tz8pX7cckB/flgxkq+f/tHnHXfBD6ctVIF40RERKRV2O5SamZ2bn1O5u6P7HRErZiWUhMRgXUl5Tzx6QLu/2geK9aXMrRbWy49sD9HDetCcpLuKW/PyvWlTJxfyOfzV9MxO5WL9+9Hin5mIiIizcb2llKrLTmvqsd13N2T6hucbKbkXERks9KKSl78Ygl3fTCHuSuL6JmbwcX79+OUUT3JSNWfG3fnu4JiPp9fGH2sZt6qIgBSkyOUVVSxe892/OuMkfTMzQw5WhEREYGdS8571+dC7v5dPWOTOErORUS2VlXlvP3Ncu4aN4fJC9bQPjOF8/bpw3lj+tC+TWrY4TWZyirnm6Xr+Hx+IRPnr+az+YWsXF8KQLvMFPJ757JX3/bk98llWLcc3pq+nF8+NxUM/nLScI7crWvIn0BERER2ODmXpqXkXERk29ydid+t5q735/DOtyvISEnitD178oP9+rbInuGS8kqmLFyzqVd88nerWV9aAUD3dhns2SdIxPfqm8uATllEIrbVORYUFPOjJyYzZdFazh7di+uOHkJ6SmKMOnB33p+xkl27ttUSeyIi0mIoOU8QSs5FROpm5vL13D1uLi9+uRgHjhnelUsP6M+Qbm3DDq3e1pWUs6CgmPkFRXxXUMx3BUXMXrGBrxevo6wymF02KC8rSMT75LJn31y6t8uo8/nLKqr46xvfcu+H89ilSza3n7kHAzpnNdbHaRDllVX87qVp/OfTBXTMSuXuc/IZ1bt92GGJiIjstAZLzs3se8DlwGBgq9vY7t5vR4MUJeciIvW1ZM1GHvhoHk98toCiskoOGNSJ/ztkAPl9csMObRN3p6CobFPiPb+gmAWx58JiCovKtmjfKTuNPh0yGdmrPXv2ySW/d/sGGb7/7rfL+dnTUygpr+KG44dx8qgeO33OxrC2uJwf/mcSH88u4NwxvRk3cyVL15bwl5OGc/zI7mGHJyIislMaJDk3s6OAl4G3gcOB14FMYF/gO+BDd7+gQSJupZSci4jsmLXF5Tz26Xc8+PE8Vm0o4/Ahefx87GAG5mU3aRxVVc67365g0oLVQSK+KkjAN0SHowOYQbecDHp3yKR3hzb07pBJn+jrXrmZtElLbrT4lq0t4cdPfsGn8wo5cWR3bjh+WKNer77mrSriBw99zsLVxfzpxOGcPKoHq4vKuOyxSXw6r5ArDu7Pzw4fXOMQ/paqrKKKez6YQ3pKEhftrz4QEZFE11DJ+Xjgc+AnQDmQ7+6TzWwQ8AbwC3d/uoFibpWUnIuI7Jzisgoe/Hg+d70/h6KyCk4Z1ZOrDh9I15y6DwPfEeWVVbz05RLuHDeH2Ss2kBwxeuZmRhPvIOnu0zGTXrlt6JmbQVpyePO+K6ucf74zi3+9O4s+HdrwrzNHMrRbTmjxxIyfU8Blj00iYnD3Ofns1Xfz6Ieyiip+99LXPPHZQsYOzeOW03YnM7X53FRoLLNXrOeqp77k68XrAPj1Ubty8QFK0EVEEllDJeergVMJes4rgDHu/ll033nA1e6+W8OE3DopORcRaRiFRWX8+73ZPDr+O8zggn37cvmB/cnJTGnQ65SUV/LMxIXcNW4ui9dsZHBeNj88uD9H7da12a8vPn5OAVc99QWri8u57uhdOWd0b8zC6ZF+6vMF/PqFr+nTsQ33n5dP7w5ttmrj7jzw8XxuenU6u3Rpy33n5dOtHnPvE4m788j47/jja9/QJi2ZP54wjJenLOXVr5by91NGcFIznZIgIiK1a6jkvAA42d3fM7NlwJXu/mx03+HAi+7e8srlNiEl5yIiDWthYTH/eGsm//1yMW3TU7ji/9u78/ioqruP459fEpKQjRBCCCTsqyC7uFC1bi3iXtxrrd3calvtU61aba1aq13U2vbRWmtbq63U9XHXCipq3diEyL4KgZAACVnJZPs9f9wJDjEkLEkmwPf9Yl535txz7j2T133d4XfPdvxgvn7UgH2esby8upbHPljHw++uYUtFiPH90rnquCGcMCJrv+pyvbUixLVPLuDNZZuZMqoXvz57bJs/wGhJfYNz1ytLeOidNRwzNJP/vWgCaYktn//NZUV8/1/zSewSy0Nfn8j4fgfWRHGFZdVc99RC3l6+meOG9+TX54whKzWRUF093/r7bD5YXcxDX5/ICSN6RbuqIiKyF9oqOH8PeMjd/2ZmLwLpwLkEreiPAv3cfWTbVPngpOBcRKR9LNpYyq9fXcas5Zvp0y2RH35pGNMm5BK7h4H01ooQf39vLX9/by3l1XUcMzST7x43hCMHZUSt1XlfNTQ4D7+7hl+9upReaYn8/sLxHTIzemWojqunz2fGkiK+flR/fnbaSOJ2s7fB8sJyvv3IbArLQvzmnDGcOe7AmCju1U8KuOGZPKpr67nplEP4WpPeDBWhOi788wesKCrnsW8f0akmPhQRkd3TVsH5VUB/d/+xmU0k6N7euGZNPfDVxpZ02TsKzkVE2td7K7dw16tLWZhfyrBeKVx/8ghOGJHVamC9cdt2HnpnNY9/tI5QXQNTRmbz3eMHMyY3vWMq3gHmryvh+4/Pp6C0mmu/PJzLjx3Ubr0ANmzbzncemcOyTWXccvooLpk8YI+PUVxZwxWPzuWjtcX84IQhXHPSsP2q10Kk8upabn1hMU/NzWdMbjfuPX8cg3s2v9zd1ooQ5/zpfbZWhHjyiskMz+7YSQ9FRGTftMs652aWC5xMMGP7DHdfvJvl+gL3Esz4bgRB/jXuvm43yiYCtwNfI2i5/5hgIrq3m+SLAa4HLgeygWXAbe7+dJN8fwOOBHKAGGAV8Bfgfnevb5L3UuBHwEBgLXCvu/+pmTqeBdwCHAIUAg8BdzY9XnMUnIuItD935+W8TfzmtaWs3VrF4QMyuH7qiGZbi1dvruDBWat5Zn4+7nDmuByuPG4QQ7IOzICodHstP3kmj5fyCjh2WE+uPnEo4/qm73EPg5bMX1fCpf+YS6i2nj98dTzHDc/a62PV1DVw8//l8cScfKYems3d543d7yaKm722mB/++2M2btvOVccP4QcnDm11voL1xVWc/cB7mMHTV04mt3v7jypcX1zFoo1lDOuVQv8eyW16TYiIHEzaJTjfy4okAQuAEHAz4MAvCAL8Me5e2Ur5fwKnAtcBq4GrgKkEk9N9HJHvDuBa4CZgLnABcClwmru/HJFvOvA2QVDuwBSC2ej/4O5XR+S7FHgQuJPgYcKJwE+Aq9z9gYh8U4CXgYeBx4HxwC+B+9z9+tb+PgrORUQ6Tm19A9Nnr+e+GSvYUhFiyqheXDdlBEOyUli0sZT731rFy3kFxMfGcMGkvlx67KAOCYKizd3510fruO2FxYTqGuiRHM/xI7I46ZAsjh7ak5R9WHrthQUbufbJBWSlJfDXSya1yVJ37kG3/DteXsKoPmn85euTyO6WuM/HbW81dQ3cN3M5D7y1itzuSdx7/lgm9t/9bupLN5Vx3p/eJzMlgSevOIoeKQntUk9354k567n1hcVU1QTtDF27xDI8O5WRfdI4pHcaI3unMjw7bZ+uDRGRg0VbdWufDzwCPO7uhXtZkauBe4Dh7r4ynDYQWAH82N3vaaHsWIKW8m+5+9/CaXHAImCZu58RTssC1gN3ufstEeVnAj3dfUwrdXycIIhPjTjHRuAVd78kIt9fgTOA3u5eG06bD5S5+xcj8v2M4EFEP3ff1NK5FZyLiHS8ylAdD7+7hgdnraK6roFD+6SxIL+U1IQ4Lj6qP9/8wkB6prZP4NOZlVbV8tbyIt5YWsSbS4soq64jPjaGIwZlcNIhvTjxkKzdfljh7vx+5krunbGcw/p358GLJ7Z5MPnG0kK+/6/5JCfE8dDXD2Ns3/Q2PX5bilwi7bzDcvnZ6aP2KrCds7aYi/7yIcOzU/nXpUe2eXC8raqGG5/J45VPNjF5cA+uPnEon26tYnFBGUvCr7Lquh35+/dIYmTvIGAPXqnkpHfdb+djEBFpD20VnL9M0BXdgZkEgfr/uXv1HlRkJpDo7l9okj4LIDKobabsT4GfAunuXhWRfitwA5Dm7iEzuxj4BzDM3VdE5Psm8FdgkLuvaeE8fwQucvfu4c/HELSuf9ndX4/IdzzwBnBCeAb7vsA64DJ3fygi30CCVv4dDxV2RcG5iEj0bK0I8cc3V/Luii2cNT6Hrx3Zn25dO27m8s6srr6BOZ+WMHNJITOXFLF6S9DRbUR2KiceksWJh/RiXG56s2O+q2vr+fFTC3l+wUamTcjhzmmj222d92WbgoniNpeHuPu8sZw2pk+7nGdvRS6RlhQfy11nj2HKqOx9OubMJYVc9uhcjhyUwV+/ManN/rbvrdzC/zyxgK2VIa798nAuPebzcxC4Oxu2bWdJQfmOYH1xQRmfbt3x3zTSEuN2BOsj+6Rx3PCeZKV2/p4NIiLtpc26tYdbpb9KMOZ7AlAOPA086u5v7kb5TQRLrl3eJP1+4Fx379lC2enAeHcf3iT9PODfwKHuvsjM7gKuAbp6xJczs8OBDwlaxV+KSDcgFkgh6K7+d+DX7n57eP8VwANAH3cvaPK3KCRYUu5/zexk4BVgsru/36SOlQTj2K9r6e+j4FxERPYHqzdXMHNJETOWFDLn0xLqG5zMlHiOHx4E6scMzSQ5IY7N5SEue3QO89dt47opw/nucYPbvRV1a0WIKx6by+y1JVx94lCuOWlop2i5/dwSaWePISutbYLUp+bmc+2TCzh1dG9+f+H4fRoPXlPXwN2vL+PPb69mYGYyv79gPIfmdNujY1SE6li2qYzF4aB98cYylm0qZ3ttPbExxvHDs7hgUl+OG95zt2foFxE5ULQUnO9R/yd3LwJ+B/zOzA4BLiYI1i8xs3x379/KITKAkmbSi4HW1m1pqWzj/sbtNv/8U4em+RqdCrwQfu8E3eFvb3Jemjl3c+dtLl9jWrMDyczsMuAygH79+jWXRUREpFMZ1DOFQT1TuPTYQWyrqmHW8s3MWFLEq4s28eTcfOJjYzhycA9WFVWwtTLEAxdNYOro3h1Stx4pCTz2nSO46dlPuG/mCpZuKuO7xw1hTG63qATp7s6rn2zixmeDJdJuP3PU55ZI21fnTMyluDLEL19eSkZyPLedOWqvjr9qcwVXT5/PJxvK+OoR/bj51EP2aoK9lIQ4JvbP2GkMfX2Ds6KonGfnb+DpuRuYsaSQrNQEzp6Yy3mH9WVgZvIen0dE5ECz14OT3H2Jmd1GMOb7LiC3zWrVsd4BJgHdCFrOrzUzd/ebOuLk7v5n4M8QtJx3xDlFRETaSnpSPGeOy+HMcTnU1jcwe20xbywpYubSIrrEGk9ePpnRuXvW8rqvEuJi+c05YxjWK4Xf/mc5ry0qZHDPZKZNyOWs8TnkpHdt9zosLyznxYUFvLRwI6s2VzI6J1gibUhW80uk7avLjh3M1ooaHnx7NZkpCVx90tDdLuvuTJ+9ntteWExilxgevHjiPne3byo2xhiRncaNU9O49svDeWNpEU/MXs+Ds1bxwFurOHxgBhdM6svUQ3vTNb59hj2IiHR2exWcm9kJBK3m0wi6g39EMJN5a0povoV8V63iTcs21zLf+Fi2OCJfuoUj7BbyAeDupUBjX/KZZlYD/NTM7nf3DRH16g4URBRt7ryN+Zrq3vS8IiIiB5ousTFMHpzJ5MGZ3HzayKjWxcy47NjBnD+pH6/kFfDM/A385rVl/Oa1ZRw5KINp43OZOjqb1MS2m1dgZVFjQF7AiqIKzOCIgRl86+iBnHdY31aXSNtXN0wdwdbKGu6dsZyMlHguPrK1Do1QUlnDDc8s5LVFhRwzNJPfnjuWXm3U3X5XusTGMGVUNlNGZVNYVs1Tc/N5Ys56/ueJBdzy3CLOGNeH8yf1ZXROdHo7iIhEy24H52Z2KMFY868StJKvBe4jGG++ooWikRYBo5pJHwm0tk76IuArZpYUOSFcuGwNsDIiXwIwOCKtMR+7cZ45BGueDwQ2hI9HuN6RwXnT40Xm2zHm3MwGECwVt1vrwIuIiEjb6da1Cxcc3o8LDu/H+uIq/m/+Bp6Zv4EfP72Qnz73CV8elc20CTkcMyRzr8Y/r95cwUsLC3gpr4Clm8oxg0kDMrjtzFGcfGh2h05+ZmbcNW00JZU1/Oy5T8hIiufUMbseTvDuii386MmPKams5eZTD+FbXxjY7KR+7alXWiJXHT+EK784mA/XFPPEnPU8NTeff364jhHZqVwwqS9njc8hPSm+Q+slIhINezJbewNQCjwJ/MPd393jk5ldA/yWYCb11eG0AQRLqd3g7ne3UHY8MA/4hrs/Ek6LA/KAle5+ejgtC8gH7nD3WyPKzwB6ufvoVur4G+BHQK67bzSzLgRLqb3o7t+MyPcX4CsES6nVhNM+Bkrc/fiIfDcDP0NLqYmIiHQK7s7H67fxzLwNvLBwI9uqaslMSeCMsX2YNiGHUX3SWmyxXbulkpfyCnhxYQFLCsoAmDSgO6eO7s3U0b3bveW5Ndtr6rn44Q9ZkL+Nv33jcI4emrnT/lBdPb99bRkPvbOGIVkp3HfBOEb16dihBy0p3V7L8ws28sTs9eRtKCU+LmhpP/+wvkwe3KPDHyCIiLSltlpK7RzgBXcP7UNFkoEFwHaCtb8duB1IBca4e0U4X39gFXCbu98WUX46MAW4DlgDXAmcRjBD+ryIfI0ztv+EIKA/H7gcOMPdXwznORX4JsFkcOvCdZhKMDnbn939yojjXQHcD/wSmAGcEK7/9939fyPynQK8CDwEPA6MJ+ju/4fWZmoHBeciIiIdraaugbeWFfHMvA28sbSImvoGhvVKCcanj8shu1sQaK/bWsVLeQW8lLeRTzYEAfnE/o0BeTa9u7X/OPY9UVpVy3kPvk9+SRWPX3YkY3LTgaDr/Q8e/5jFBWV87ch+3HTKyE49xnvRxlKemL2eZ+dvoKy6jkE9k/njhRMY2Sct2lUTEdkrbbaUWhtVph9wL8Ga6UawZvo17r42Is8AguD7Vnf/eUR6V+AOgq716QSB/vXu/laTc8QCNwKXAtnAMoJA/6mIPCMIgu1JQBawjaAF/wHgcXdvaHLMywla1PsTBPP3uvv9zXy/acAtwAiCpdb+QtCKX9/a30bBuYiISPRsq6rhpbwCnpm3gbmflmAGRw3qQUWojoX5pQCM65vOaWN6c8ro3vTpgInl9kVhWTXT7n+P7bX1PHnFUby/aiu/eGkxSfFx/PrsMZw0sle0q7jbqmvreW3RJn758hJKt9fyq7PHcOa4nGhXS0Rkj3Wq4Fx2TcG5iIhI5/Dp1kqenb+BFxZsJCUhjlPH9Gbqob3pm5EU7artkdWbKzj3T+9TEaojVNfAMUMzufvcsW22xnpHKyqv5qp/zmP22hK+c/RAbpg6Qmuli8h+RcH5fkLBuYiIiLS1vPxSfvTkx5w/qR/fnDxgvx+zXVPXwB0vLeaR9z9l8uAe/OHC8fRISYh2tUREdouC8/2EgnMRERGR3fPU3Hx+8mwePVMS+NPXJjI6t/NMaicisistBefqByQiIiIi+51zJuby9BWTATj7T+/x1Nz8KNdIRGTfKDgXERERkf3S6NxuPP+9LzCxX3eufXIBtzz3CbX1Da0XFBHphBSci4iIiMh+q0dKAo9++3AuPWYgj7z/KRc99CFF5dXRrpaIyB5TcC4iIiIi+7W42BhuOnUk910wjoUbtnH6H95l3rqSaFdLRGSPKDgXERERkQPCmeNyeObKLxAfF8MFD37A4x+ti3aVZBcaGpyGBk1MLRJJwbmIiIiIHDBG9knjhe8dzRGDMrjxmTxufCaPUF19tKslYQ0Nzst5BUz53dsc+vPX+Ou7a6hXkC4CaCm1TkVLqYmIiIi0jfoG5+7/LOP+t1Yxvl86D1w0kexuift0zOraesq219Lg4Hiwdafxv9MeTneHBnc8nEY4rfFz9+Qu9ExJwGz/XnN+T7g7M5YUcc/ry1lSUMbgnsn0Se/KOyu2MCa3G3dOG82oPloOTw58Wud8P6HgXERERKRtvZJXwI+eXEBSfBwPfG0CkwZkAEGwWFVTT3FlDVsrayiuDLG1oobiypqItM/2FVfUUFnTdi3w6UldGJqVwtBeqQzLSmFYr1SG9kolMyW+TYP26tp61m6tZM3mStY0brdU0jU+lq+Mz+HkQ7NJio9rs/M15e7MWr6Ze19fzoL8Uvr3SOLqE4dy5rgcYgxeXFjArS8soqSqlu8cPZBrThpG1/jYdquPSLQpON9PKDgXERERaXvLC8u5/NG5rC+uYkTvVIorgqA7VNf8smvxcTH0SI4nI/wK3ifQIyWetK5diDXDDGIMDCP8DzPDgJiYIL0xxm5Mt3D+ovJqVhRVsKKwnOWFFZRur91x7u5JXRialcrQXo0Be7DtkbzroL22voH8ku2s2VLBmi1V4W0la7dUsWHb9p3yZqUmMCAzmU2l1awrriI5PpZTRvfmnIm5HD4wo80eDLg7763ayj2vL2fupyXkpHflBycOYdqEXLrE7jyytrSqlrteXcLjH62nb0ZX7jhrNMcO69km9RDpbBSc7ycUnIuIiIi0j9Lttdz58hIKy6p3BNo7B9/x9EhOICMlnuT42A7rcu7ubC4PsbywguWF5awoKmdF+H1Zdd2OfN2TugSt7L1S6JeRRGFZiDVbglbw9cVV1EWM205LjGNQzxQGZibv9BqQmUxKQtyO885eW8JTc9fz0sICKmvq6ZeRxNkTcpk2IYe+GUl7/Z0+WlPM3f9ZxodrislOS+R7JwzhvMP6Eh/X8nRXH67eyo3P5rF6cyVnjevDzaeNJDMlYa/rIdIZKTjfTyg4FxEREREIguei8hDLw63rKwrLWVEUBO3l1XUkdolhYGYKAzOTwsF34/sUuid12aOHC1U1dby2aBNPzc3nvyu3AnDUoB6cPTGXqYdmk5ywe93e568r4Z7Xl/POii1kpiRw1fGDufDwfiR22f1u6qG6eu5/cxX3v7WS5IQ4bjrlEM6ZmHtQjc+XA5uC8/2EgnMRERERaYm7U7a9jtTEOGJi2j5gzS+p4tl5G3hqXj6fbq0iKbLb+4CMZs/5yYZS7nl9OW8sLSIjOZ4rvjiIi48csE9jx1cUlvOTZ/OYvbaEowb14JfTRjMwM3lfvppIp6DgfD+h4FxEREREOgN3Z86nJTw1J5+X8gqoCNXRN6MrZ0/I5ewJufTNSGLppjLufX05ry0qpFvXLlx27CAumTxgR9f5fdXQ4EyfvZ47X1lCqK6BH5wwhMuOHdxq93iRzkzB+X5CwbmIiIiIdDaN3d6fnruB/67agjuMyE5lWWE5KfFxfOvogXz7mIGkJXZpl/MXlVVz6wuLeSmvgOG9UvnltNFM7N+9Xc4l0t4UnO8nFJyLiIiISGe2Ydt2np2Xz8ylRRw1qAeXHTuI9KT4Djn3jMWF/Oy5Tygoq+ZrR/TnupOHt9sDAZH2ouB8P6HgXERERERk1ypCddz9n2X8/b21ZKUmcNa4nJ1mpO+ZmqDJ46RTU3C+n1BwLiIiIiLSugXrt3H7i4tZmF9KTf1n69Unx8cysGcyA3okMygzOeJ9Ct2S1Mou0afgfD+h4FxEREREZPfVNzgbt23fseZ75Cu/pIqI5d/JSI5nQI9gublB4aC9f48kslITyEiOJy5WE81J+2spOG+bqRT3rDJ9gXuBLwEGzACucfd1u1E2Ebgd+BqQDnwMXO/ubzfJFwNcD1wOZAPLgNvc/emIPL2BH4TrMQSoBRYCt0Yez8wGAGtaqNaF7j49nPfnwC3N5HnO3c9q7fuJiIiIiMjui40x+mYk0TcjiWOH9dxpX01dA+uKq1izpZK1WypZHd7+d+UWnp6Xv1NeM8hIiiczJYGeqQlkpsSHtwkRacE2Izme2FaWsautb6C8uo7y6lrKq+soC28b08q2f7YvVFdPvx7JDOuVwrBeqQzMTKaLHhQclDo0ODezJOANIARcAjjwC+BNMxvj7pWtHOJh4FTgOmA1cBXwmpkd5e4fR+S7HbgWuAmYC1wAPGlmp7n7y+E8E4Hzgb8BHwDxwHeBt8zsDHd/MZyvADiqmbr8AjgaeK2ZfUcD9RGfi1v5XiIiIiIi0obi42IYkpXCkKyUz+2rqqlj7ZYq1hVXsrmihi3lITZXhNhSHmJLRYi56yrZXB6iurbhc2VjDDKSPwvggZ0C8fLqOrbX1n+uXFNJ8bGkJsYRFxPD8ws27mjlj4sxBmYmMyw7lWFZqQzrlcLQXqkM6JGk1v0DXId2azezq4F7gOHuvjKcNhBYAfzY3e9poexYgpbyb7n738JpccAiYJm7nxFOywLWA3e5+y0R5WcCPd19TPhzOlDh7nUReRqPV+jux7ZQlyRgE/Cau58bkf5zgpbzLpHH3V3q1i4iIiIi0jm4O5U19TsC9s0R280VNTveO5CWGEdaYhdSE+PCr+D9Z2k7f05JjNupdby6tp5VmytYUVjB8sJylhdWsKKonHXFVTSGa/GxMQzqmczQXqkMywoC9mG9UujfI7nVlnzpPDpTt/YzgA8aA3MAd19jZv8FziQI3FsqWwv8O6JsnZlNB24wswR3DwFTCFrBH2tS/jHgr2Y20N3XuPu2picIH+9joNk/VoRpQCrwSCv5RERERERkP2RmpCTEkZIQx4DM5HY9V2KXWEb16caoPt12St9eU8/KonDAXlTOisIK5q8r4YUFG3fkiY+L4ZDeaRw5MIMjBmVw2ICMDl9irrSqlqLyarrGx5KSEEdSfBzxcWrl31MdHZyPAp5rJn0RcG4z6U3LrnH3qmbKxhOMG18UzhcCVjaTD2AkuxhDbmbxBF3YF7ZSl0uAIuDVXexfH27BzwemAz939+2tHFNERERERGSHrvGxjM7txujcnYP2ylDdZ0F7YTkfr9/G3/67lgffXk2Mwcg+aRwxsAeHD8zgiIEZbboWfUWojk82lJKXX8rCDaXk5W9j7damIVrQ0p+UEEtyfBzJCbEkJ8R99j4+juSEOJISYkmJjyMpIY7UhDjG90tnaK/UNqvr/qajg/MMoKSZ9GKg+z6UbdzfuN3mn++v3zRfc34O5AIX7SqDmeUAJwD3NdN1fSVwAzCfYDz9l4EfAhMIJp4TERERERHZJ8kJcYztm87Yvuk70qpr65m3roQPVxfz4ZqtPPbBpzz8btAmOSI7lSMGZnDEoCBgz0xJ2K3zbK+pZ3FBKQvzg2B8Qf42Vm+p3NHVPie9K2Nyu3HepL7kdk9ie00dlaF6KkN1VNY0buuoCtVTWVNHZaiOzeWhHe8ra+qpqdt5XP/QrBSmju7NKaOzGd4r9aBat77DZ2vvrMzsqwSB9e3u/k4LWS8GYoC/N93h7k270r9uZvnA78zsJHef0cx5LwMuA+jXr99e1l5ERERERA5miV1imTw4k8mDMwEI1dWzML+UD1dv5cM1xTwxJ59H3v8UgCFZKTuC9SMHZpCVlkiorp6lBeU7WsMX5peyoqiC+vBMdVmpCYzJTefMcTlBa35Ot90O8ltSW99AVaiekqoa3l6xmZfzCvjjGyv4/cwVDMpMZurobKYe2ptRfdIO+EC9oyeEKwT+z90vb5J+P3Cuu/dsviSY2b+Bce4+vEn6eQTj0A9190Vm9ivgaqBrZOu5mR0OfAic5u4vNTnG6cDTwCPufmkr32ExEHL38a1/4x0T1BUCP3H3O1vKqwnhRERERESkPdTWN5C3oXRHy/qctSVUhIKOwL27JbKlIkRtfRA+ZSTHMzqnG2NzuzE6N50xud3olZbYYXXdXB7iP4s38UreJt5fvZX6BqdfRhJTR2dzyqG9GZPbbb8N1DvThHCNY8KbGgks3o2yXzGzpCbjzkcCNXw2xnwRkAAMZudx5yPD253OY2YnAk8CzxKsi75LZjYJOISgq/qe6rinICIiIiIiIhG6xMYwoV93JvTrzpXHDaauvoHFBWV8uLqYhRtKye3elTE5wfj2nPSuUQ1+e6YmcNER/bnoiP4UV9bw+uJNvJy3iYffWcODs1aTk96VqYdmM3V0b8b3TSfmAJmtvqNbzq8BfgsMc/fV4bQBBEup3eDud7dQdjwwD/iGuz8STosD8oCV7n56OK1xIrY73P3WiPIzgF7uPjoi7SjgdWAWcJa717ZS/z8SBPA57l60m9/5hwSz0J/o7m+0lFct5yIiIiIiIs0rrarl9SWFvJJXwDsrtlBT30B2WiInH5rNKaN7M7F/906/rFxLLecdHZwnAwuA7cDNBK3JtxMsSzbG3SvC+foDq4Db3P22iPLTCZZKu45gxvUrgdOAye4+LyLfXcA1wE8IAvrzCYLqM9z9xXCeEcB7QBnwDaA6sq7u/kGTuscDG4H3GtdUb+b7zQf+ASwLf7cvAd8HZrj71Nb+PgrORUREREREWldWXcvMJYW8nLeJWcs3U1PXQM/UBF76/tFkdWAX/D3Vabq1u3ulmZ0A3As8ChgwE7imMTAPMyCWYOK1SN8E7gB+AaQTBPonRwbmYTcBFQRjz7MJguXzGgPzsCMJZojvDrzZTHWbPnI5FehBy2ubLwO+B/QO1301cBvw6xbKiIiIiIiIyB5IS+zCV8bn8pXxuVSE6nhjaREfrdlKz9R9n6QuWjq05VxappZzERERERGRA1dLLedNW6ZFREREREREpIMpOBcRERERERGJMgXnIiIiIiIiIlGm4FxEREREREQkyhSci4iIiIiIiESZgnMRERERERGRKFNwLiIiIiIiIhJlWue8EzGzzcCn0a5HKzKBLdGuhEgEXZPSGem6lM5I16V0NrompTNq7+uyv7v3bG6HgnPZI2Y2x90Pi3Y9RBrpmpTOSNeldEa6LqWz0TUpnVE0r0t1axcRERERERGJMgXnIiIiIiIiIlGm4Fz21J+jXQGRJnRNSmek61I6I12X0tnompTOKGrXpcaci4iIiIiIiESZWs5FREREREREokzBubTKzPqa2VNmVmpmZWb2jJn1i3a95OBgZrlm9gcze9/MqszMzWxAM/kSzew3ZlZgZtvD+Y+NQpXlAGdm55jZ02b2afhaW2Zmd5pZapN83c3sL2a2xcwqzWyGmY2OVr3lwGZmU8zsDTPbZGYhM8s3syfMbGSTfPpNl6gxs1fDv+O/aJKu+6V0CDM7LnwNNn1ta5IvKtekgnNpkZklAW8AI4BLgIuBocCbZpYczbrJQWMIcB5QArzTQr6HgUuBnwGnAQXAa2Y2rr0rKAeda4F64CfAycADwJXA62YWA2BmBrwQ3v994GygC8G9MzcalZYDXgYwF/ge8GXgRmAU8IGZ9Qf9pkt0mdmFwNhm0nW/lGj4AXBUxOukxh3RvCbj2vPgckC4FBgEDHf3lQBmthBYAVwO3BPFusnB4W137wVgZt8h+E/nTsxsLPBV4Fvu/rdw2ixgEXAbcEbHVVcOAqe7++aIz7PMrBh4BDiOIPg5A/gCcIK7vwlgZu8Da4AfE/ynQKTNuPvjwOORaWb2EbAUOAe4G/2mS5SYWXfgXuCHwL+a7Nb9UqJhibt/sIt9Ubsm1XIurTkD+KDxRxzA3dcA/wXOjFqt5KDh7g27ke0MoBb4d0S5OmA6MMXMEtqpenIQahKYN5od3uaEt2cAGxt/1MPlSgmexOveKR1la3hbF97qN12i5VfAJ+GHSE3pfimdTdSuSQXn0ppRwCfNpC8CRjaTLhINo4A17l7VJH0REE/QNV6kPX0xvF0S3rZ07+xnZikdUis56JhZrJnFm9lQ4EFgE5+1qOs3XTqcmR0NfB24ahdZdL+UaPinmdWb2VYz+1eTuTeidk0qOJfWZBCM9W2qGOjewXUR2ZWWrtPG/SLtwsxyCIZPzHD3OeHk1q5J3T+lvXwIhIDlwBiCbplF4X36TZcOZWbxBA+Jfuvuy3aRTfdL6UilBMN8vgOcANxOMN78fTPLCueJ2jWpMeciIiJ7Kfz0/DmCbsPfjHJ1RCCY5C2NYGz5tQQTFR7t7mujWis5WP0Y6ArcEe2KiAC4+3xgfkTSLDN7G/iIYCz5zVGpWJhazqU1JTT/dGhXT5REoqGl6xQ+e9Ip0mbMrCvB+LNBwBR3z4/Y3do1qfuntAt3X+LuH4bH9p4IpAA3hHfrN106TLib8E3AT4EEM0s3s/Tw7sbPseh+KVHm7vMIehtNCidF7ZpUcC6tWUQw7qKpkcDiDq6LyK4sAgaGlwmKNBKoAVZ+vojI3jOzLsBTwGHAKe6e1yRLS/fOde5e0c5VFMHdtxHc/xrn3dBvunSkQUAi8BhBMNP4gqBXRwkwGt0vpfPw8DZq16SCc2nN88CRZjaoMcHMBhAsL/B8tCol0sQLBOtPntuYYGZxwPnAf9w9FK2KyYEnvJb5PwnGqp21i6VYngdyzOyLEeXSgNPRvVM6iJn1IljTfFU4Sb/p0pE+Bo5v5gVBwH48wcMj3S8lqszsMGA4Qdd2iOI1ae7eei45aJlZMrAA2E4wBsMJJk5IBcboaaZ0BDM7J/z2ROAK4LvAZmCzu88K55kOTAGuI1iH8krgNGByuLuSSJswswcIrsM7gBeb7M539/xwAP8u0JfgmiwBbiSYoGusu6/vwCrLQcDMngXmAQuBMmAYwZrS2cDh7r5cv+nSGZiZA3e4+83hz7pfSocxs38S/D9xHrANGE9wvVUBE9x9SzSvSQXn0qrwmKF7gS8BBswErtHkMtJRwj/kzZnl7seF8zROOPNVIJ3gP6DXu/tbHVBFOYiY2Vqg/y523+ruPw/nywB+C5xF0LXzfeB/3H1B+9dSDjZmdj1wHjCYYAnJ9cBbwJ2Rv9f6TZdoaxqch9N0v5QOYWY3AhcS/I4nESw3+Qpwi7sXROSLyjWp4FxEREREREQkyjTmXERERERERCTKFJyLiIiIiIiIRJmCcxEREREREZEoU3AuIiIiIiIiEmUKzkVERERERESiTMG5iIiIiIiISJQpOBcREZH9kpmtNbPHol0PERGRtqDgXERERERERCTKFJyLiIiIiIiIRJmCcxEREWmVmY01s+fNrMTMtpvZf83smIj9fzezfDObbGazzaw63O38+80c63Azm2FmFWZWaWYzzezwZvJ90cxeN7PScL4FZvbtZvJdYGZLwnnmmNnRbf8XEBERaV8KzkVERKRFZjYBeA/IAC4Fzga2AjPMbGJE1jTg38AjwFnAW8DvzewbEccaA8wCugPfAL4eLjfLzMZG5DsTmAnEA5cDZwJ/Bfo3qd4xwI+AnwLnA7HAi2aWvo9fW0REpEOZu0e7DiIiItKJmdlMoA8w1t1rwmmxwCfAMnc/y8z+DlwCXOju0yPKvg4MAwa4u5vZU8BJ4c/bwnnSgLXAW+4+zcwMWANsAQ5394Zd1Gst0A0Y5O4l4bTDgNnARe7+rzb9Q4iIiLQjtZyLiIjILplZV+CLwJNAg5nFmVkcYMAM4NiI7PXA000OMR3oB+SEPx8LvNgYmAO4exnwfPg8AMMJWsj/sqvAPML7jYF5WF5426/1byciItJ5KDgXERGRlmQQdBX/KVDb5PU9oLuZNf5/osTda5uULwxvG4PzDKCgmfNsIujqDtAjvM3fjfoVR35w91D4beJulBUREek04qJdAREREenUtgENwP8C/2gug7s3BD3R6W5mXZoE6L3C2w3hbTGQ3cxhsoHGFvAt4W1OM/lEREQOSArORUREZJfcvdLM3gHGAvNa6WYeSzBZ3PSItAuAdXwWnM8CTjGzVHcvBzCzVOB0ggnkAJYTjEH/jpn92TVBjoiIHAQUnIuIiEhr/gd4G3jNzB4m6JaeCUwAYt39hnC+cuDXZpYJrAAuJJj87RsRAfbtwGnATDP7FeDA9UAScBtAeOK4a4BngDfM7E/AZuAQIMvdb2nn7ysiItLhNOZcREREWuTu84BJBMun/R74D3AfMJogaG9URtBSfgnwHHA8cLW7PxJxrIXAceG8jwCPAhXAF919QUS+54AvhT8+TDBh3GUELeoiIiIHHC2lJiIiIvssvJTaSe6eG+26iIiI7I/Uci4iIiIiIiISZQrORURERERERKJM3dpFREREREREokwt5yIiIiIiIiJRpuBcREREREREJMoUnIuIiIiIiIhEmYJzERERERERkShTcC4iIiIiIiISZQrORURERERERKLs/wGvgLWBJpIBfQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -654,205 +747,139 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Sample trajectories for evaluation, predict trajectories, and compute MSE across states (without batching, does not work for ensemble)." + "Sample trajectories for evaluation, predict trajectories, and compute MSE across states (without batching, does not work for ensemble). \n", + "This large block is mostly data handling! First, lets collate the data we need!" ] }, { "cell_type": "code", - "execution_count": 285, + "execution_count": 356, "metadata": {}, "outputs": [], "source": [ - "# num_traj = 10\n", - "# eval_data = []\n", - "# one_step = []\n", - "# traj_based = []\n", - "# for i in range(num_traj):\n", - "# traj = one_step_replay_buffer.sample_trajectory()\n", - "# traj_with_params = replay_buffer_traj_val.sample_trajectory()\n", - "# eval_data.append(traj)\n", - " \n", - "# ### rollout one-step model ###\n", - "# states, _, _ = common_util.rollout_model_env(one_step_model_env, \n", - "# initial_obs=traj.obs[0],\n", - "# plan=traj.act)\n", - " \n", - "# true_states = traj.obs\n", - "# one_step_pred_states = states[:-1].squeeze()\n", - "# one_step_errors = np.mean((true_states - one_step_pred_states)**2, axis=1)\n", - "# one_step.append(one_step_errors)\n", - " \n", - "# ### rollout trajectory-based model ###\n", - " \n", - "# # set time indices\n", - "# traj_with_params.act[:,-1] = np.arange(0,len(traj_with_params))+1\n", + "num_traj_eval = num_trials\n", "\n", - "# # construct batch\n", - "# x_data = np.concatenate((traj_with_params.obs,traj_with_params.act), axis=1)\n", - "# x_tensor = torch.from_numpy(x_data).float().to(device)\n", - "# x_tensor = dynamics_model.input_normalizer.normalize(x_tensor)\n", + "# round trajectories to multiple of ensemble size for batching:\n", + "num_traj = int(ensemble_size * np.floor(num_traj_eval/ensemble_size))\n", "\n", - "# with torch.no_grad():\n", - "# states_pred, _ = dynamics_model(x_tensor)\n", - " \n", - "# traj_based_errors = np.mean((true_states - states_pred.numpy())**2, axis=1)\n", - "# traj_based.append(traj_based_errors)\n", + "# for storing data\n", + "eval_data_obs = [] # store observations for both prediction (initial state) and evaluation (full trajectory)\n", + "eval_data_act = [] # store plans here (for one-step model)\n", + "eval_traj_param = [] # store control parameters here for traj-based model\n", + "\n", + "# collect trajectories from buffers\n", + "for i in range(num_traj):\n", " \n", - "# cumulative_errors_os = np.stack(one_step)\n", - "# one_step_median = np.median(cumulative_errors_os,axis=0)\n", + " # base trajectory for computing accuracy\n", + " traj = one_step_replay_buffer.sample_trajectory()\n", + " traj_with_params = replay_buffer_traj_val.sample_trajectory() # doesn't have actions!\n", "\n", - "# cumulative_errors_tb = np.stack(traj_based)\n", - "# traj_based_median = np.median(cumulative_errors_tb,axis=0)" + " # one-step data\n", + " eval_data_obs.append(traj.obs)\n", + " eval_data_act.append(traj.act)\n", + " \n", + " # traj-based data\n", + " traj_with_params.act[:,-1] = np.arange(0,len(traj_with_params))+1\n", + " eval_traj_param.append(traj_with_params.act)\n", + " \n", + "# create array of state trajectories\n", + "true_states = np.stack(eval_data_obs)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Predict trajectories with ensembles, needed correct batch size." + "Now we predict with the models! First we can pass the initial states and plans into the one-step model to unroll trajectories. Note that everything is stacked because the ensembles use batching." ] }, { "cell_type": "code", - "execution_count": 286, + "execution_count": 357, "metadata": {}, "outputs": [], "source": [ - "num_traj_eval = num_trials\n", - "\n", - "# round trajectories to multiple of ensemble size for batching:\n", - "num_traj = int(ensemble_size * np.floor(num_traj_eval/ensemble_size))\n", - "eval_data_obs = []\n", - "eval_data_act = []\n", - "eval_traj_obs = []\n", - "eval_traj_param = []\n", - "one_step = []\n", - "traj_based = []\n", - "for i in range(num_traj):\n", - " \n", - " # base trajectory for computing accuracy\n", - " traj = one_step_replay_buffer.sample_trajectory()\n", - " \n", - " # one-step data\n", - " eval_data_obs.append(traj.obs)\n", - " eval_data_act.append(traj.act)\n", - " \n", - " # traj-based data\n", - " traj_with_params = replay_buffer_traj_val.sample_trajectory()\n", - " traj_with_params.act[:,-1] = np.arange(0,len(traj_with_params))+1\n", - " eval_traj_obs.append(traj.obs)\n", - " eval_traj_param.append(traj_with_params.act)\n", - "\n", - " \n", "### rollout one-step model in batch of trajectories ###\n", "states, _, _ = common_util.rollout_model_env(one_step_model_env, \n", " initial_obs=np.stack([o[0] for o in eval_data_obs],axis=0),\n", - " plan=np.stack(eval_data_act, axis=1))\n", - "\n", - "true_states = np.stack(eval_data_obs)\n", - "one_step_pred_states = np.swapaxes(states[:-1].squeeze(),0,1)\n", - "one_step_errors = np.mean((true_states - one_step_pred_states)**2, axis=-1)\n", - "one_step.append(one_step_errors)\n", - " \n", - "### rollout trajectory-based model in batch ###\n", - "\n", - "# construct batch\n", - "x_data = np.concatenate((traj_with_params.obs,traj_with_params.act), axis=1)\n", - "\n", + " plan=np.stack(eval_data_act, axis=1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We don't need a utility to predict with the trajectory-based model, but in that case we need to do some of the data processing that would be handled in the `mbrl.common_utils`." + ] + }, + { + "cell_type": "code", + "execution_count": 358, + "metadata": {}, + "outputs": [], + "source": [ + "# concatenare initial states with parameters + time index\n", "obs_stack = np.stack([o[0] for o in eval_traj_obs])\n", "param_stack = np.stack(eval_traj_param)\n", "\n", "param_dim = np.shape(param_stack)[-1]\n", "obs_dim = np.shape(obs_stack)[-1]\n", + "\n", + "# set up batching\n", "param_expand = param_stack.reshape(-1,param_dim)\n", "obs_expand = np.repeat(obs_stack[:, np.newaxis, :], trial_length, axis=1).reshape(-1,obs_dim)\n", "\n", + "# to torch\n", "x_data = np.concatenate((obs_expand,param_expand), axis=1)\n", "x_tensor = torch.from_numpy(x_data).float().to(device)\n", + "\n", + "# normalize input data\n", "x_tensor = dynamics_model.input_normalizer.normalize(x_tensor)\n", "\n", + "# predict trajectories\n", "with torch.no_grad():\n", - " states_pred, _ = dynamics_model(x_tensor)\n", - "\n", - "true_states = np.stack(eval_traj_obs)\n", - "states_pred = states_pred.numpy().reshape(num_traj, trial_length, -1)\n", - "traj_based_errors = np.mean((true_states - states_pred)**2, axis=-1)\n", - "traj_based.append(traj_based_errors)\n", - " \n", - "cumulative_errors_os = np.stack(one_step).squeeze()\n", - "one_step_median = np.median(cumulative_errors_os,axis=0)\n", - "\n", - "cumulative_errors_tb = np.stack(traj_based).squeeze()\n", - "traj_based_median = np.median(cumulative_errors_tb,axis=0)" + " states_pred, _ = dynamics_model(x_tensor)" ] }, { - "cell_type": "code", - "execution_count": 287, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(5000, 29)" - ] - }, - "execution_count": 287, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "param_dim = np.shape(param_stack)[-1]\n", - "obs_dim = np.shape(obs_stack)[-1]\n", - "param_stack =param_stack.reshape(-1,param_dim).shape\n", - "obs_expand = np.repeat(obs_stack[:, np.newaxis, :], trial_length, axis=1).reshape(-1,obs_dim)\n", - "\n", - "obs_expand.shape\n", - "obs_stack\n", - "param_stack\n", - "# param_stack.shape" + "Now let's analyze the data!" ] }, { "cell_type": "code", - "execution_count": 288, + "execution_count": 359, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(10, 500)" - ] - }, - "execution_count": 288, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "states_pred.shape\n", - "true_states.shape\n", - "((true_states - states_pred)**2).shape\n", - "one_step_pred_states.shape\n", - "traj_based_errors.shape" + "# Compute one-step errors\n", + "one_step_pred_states = np.swapaxes(states[:-1].squeeze(),0,1)\n", + "one_step_errors = np.mean((true_states - one_step_pred_states)**2, axis=-1)\n", + "\n", + "# compute trajectory-based errors\n", + "states_pred = states_pred.numpy().reshape(num_traj, trial_length, -1)\n", + "traj_based_errors = np.mean((true_states - states_pred)**2, axis=-1)\n", + "traj_based.append(traj_based_errors)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Trajectory-based vs One-step" + "## Trajectory-based vs One-step\n", + "Here we take the errors and plot them over time!" ] }, { "cell_type": "code", - "execution_count": 289, + "execution_count": 361, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -864,9 +891,28 @@ } ], "source": [ + "# cumulative_errors_os = np.stack(one_step).squeeze()\n", + "one_step_median = np.median(one_step_errors,axis=0)\n", + "one_step_90 = np.quantile(one_step_errors, .90, axis=0)\n", + "one_step_10 = np.quantile(one_step_errors, .10, axis=0)\n", + "\n", + "# cumulative_errors_tb = np.stack(traj_based).squeeze()\n", + "traj_based_median = np.median(traj_based_errors,axis=0)\n", + "traj_based_90 = np.quantile(traj_based_errors, .90, axis=0)\n", + "traj_based_10 = np.quantile(traj_based_errors, .10, axis=0)\n", + "\n", + "\n", + "colors = ['#1f77b4', # muted blue\n", + " '#ff7f0e', # safety orange\n", + " '#2ca02c', # cooked asparagus green\n", + " '#d62728', # brick red\n", + " ]\n", + "\n", "fig, ax = plt.subplots(1, 1, figsize=(12, 8))\n", - "ax.plot(one_step_median, label=\"one-step\")\n", - "ax.plot(traj_based_median, label=\"traj-based\")\n", + "ax.plot(one_step_median, label=\"one-step\", c=colors[0])\n", + "ax.plot(traj_based_median, label=\"traj-based\", c=colors[1])\n", + "ax.fill_between(np.arange(len(one_step_median)), one_step_10, one_step_90, color=colors[0], alpha=.33)\n", + "ax.fill_between(np.arange(len(traj_based_median)), traj_based_10, traj_based_90, color=colors[1], alpha=.33)\n", "ax.set_xlabel(\"Predictive Horizon\")\n", "ax.set_ylabel(\"Prediction Error (MSE)\")\n", "ax.legend()\n", From 28308abec466906729ca339005018cd1a715344c Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Mon, 15 Aug 2022 18:54:13 -0700 Subject: [PATCH 08/24] remove unused changes --- mbrl/models/traj_based_mlp.py | 198 -------------------------------- mbrl/types.py | 52 +-------- mbrl/util/replay_buffer.py | 209 +--------------------------------- 3 files changed, 2 insertions(+), 457 deletions(-) delete mode 100644 mbrl/models/traj_based_mlp.py diff --git a/mbrl/models/traj_based_mlp.py b/mbrl/models/traj_based_mlp.py deleted file mode 100644 index 95295827..00000000 --- a/mbrl/models/traj_based_mlp.py +++ /dev/null @@ -1,198 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. -# -# This source code is licensed under the MIT license found in the -# LICENSE file in the root directory of this source tree. -from typing import Dict, Optional, Tuple, Union - -import omegaconf -import torch - -from .gaussian_mlp import GaussianMLP - - -class TrajBasedMLP(GaussianMLP): - """Implements an [optionally] ensemble of multi-layer perceptrons each modeling a Gaussian distribution, with the trajectory based parametrization. - - This model corresponds to a trajectory-based model in the Lambert et al., - CDC 2021 paper https://arxiv.org/abs/2012.09156. The core functionality is to change the prediction paradigm from - - s' = f(s,a) to s' = f(s0, t, theta) - - It predicts per output mean and log variance, and its weights are updated using a Gaussian - negative log likelihood loss. The log variance is bounded between learned ``min_log_var`` - and ``max_log_var`` parameters, trained as explained in Appendix A.1 of the paper. - - This class can also be used to build an ensemble of GaussianMLP models, by setting - ``ensemble_size > 1`` in the constructor. Then, a single forward pass can be used to evaluate - multiple independent MLPs at the same time. When this mode is active, the constructor will - set ``self.num_members = ensemble_size``. - - For the ensemble variant, uncertainty propagation methods are available that can be used - to aggregate the outputs of the different models in the ensemble. - Valid propagation options are: - - TODO(NOL) look into these propagation methods for traj-based model (they at least don't need steps, whcih is different) - - - "random_model": for each output in the batch a model will be chosen at random. - This corresponds to TS1 propagation in the PETS paper. - - "fixed_model": for output j-th in the batch, the model will be chosen according to - the model index in `propagation_indices[j]`. This can be used to implement TSinf - propagation, described in the PETS paper. - - "expectation": the output for each element in the batch will be the mean across - models. - - The default value of ``None`` indicates that no uncertainty propagation, and the forward - method returns all outputs of all models. - - Args: - in_size (int): size of model input. - out_size (int): size of model output. - device (str or torch.device): the device to use for the model. - num_layers (int): the number of layers in the model - (e.g., if ``num_layers == 3``, then model graph looks like - input -h1-> -h2-> -l3-> output). - ensemble_size (int): the number of members in the ensemble. Defaults to 1. - hid_size (int): the size of the hidden layers (e.g., size of h1 and h2 in the graph above). - deterministic (bool): if ``True``, the model will be trained using MSE loss and no - logvar prediction will be done. Defaults to ``False``. - propagation_method (str, optional): the uncertainty propagation method to use (see - above). Defaults to ``None``. - learn_logvar_bounds (bool): if ``True``, the logvar bounds will be learned, otherwise - they will be constant. Defaults to ``False``. - activation_fn_cfg (dict or omegaconf.DictConfig, optional): configuration of the - desired activation function. Defaults to torch.nn.ReLU when ``None``. - """ - - def __init__( - self, - in_size: int, - out_size: int, - device: Union[str, torch.device], - num_layers: int = 4, - ensemble_size: int = 1, - hid_size: int = 200, - deterministic: bool = False, - propagation_method: Optional[str] = None, - learn_logvar_bounds: bool = False, - activation_fn_cfg: Optional[Union[Dict, omegaconf.DictConfig]] = None, - ): - super().__init__( - in_size, - out_size, - device, - num_layers=num_layers, - ensemble_size=ensemble_size, - hid_size=hid_size, - deterministic=deterministic, - propagation_method=propagation_method, - learn_logvar_bounds=learn_logvar_bounds, - activation_fn_cfg=activation_fn_cfg, - ) - - def _forward_ensemble( - self, - x: torch.Tensor, - rng: Optional[torch.Generator] = None, - propagation_indices: Optional[torch.Tensor] = None, - ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]: - - # TODO(NOL) get time index from inputs, which is used at propagation (can be a batch of time) - if self.propagation_method is None: - mean, logvar = self._default_forward(x, only_elite=False) - if self.num_members == 1: - mean = mean[0] - logvar = logvar[0] if logvar is not None else None - return mean, logvar - assert x.ndim == 2 - model_len = ( - len(self.elite_models) if self.elite_models is not None else len(self) - ) - if x.shape[0] % model_len != 0: - raise ValueError( - f"GaussianMLP ensemble requires batch size to be a multiple of the " - f"number of models. Current batch size is {x.shape[0]} for " - f"{model_len} models." - ) - x = x.unsqueeze(0) - - # TODO(NOL) Test these, I think only expectation really makes sense given the model - if self.propagation_method == "random_model": - # passing generator causes segmentation fault - # see https://github.com/pytorch/pytorch/issues/44714 - model_indices = torch.randperm(x.shape[1], device=self.device) - return self._forward_from_indices(x, model_indices) - if self.propagation_method == "fixed_model": - if propagation_indices is None: - raise ValueError( - "When using propagation='fixed_model', `propagation_indices` must be provided." - ) - return self._forward_from_indices(x, propagation_indices) - if self.propagation_method == "expectation": - mean, logvar = self._default_forward(x, only_elite=True) - return mean.mean(dim=0), logvar.mean(dim=0) - raise ValueError(f"Invalid propagation method {self.propagation_method}.") - - def forward( # type: ignore - self, - x: torch.Tensor, - rng: Optional[torch.Generator] = None, - propagation_indices: Optional[torch.Tensor] = None, - use_propagation: bool = True, - ) -> Tuple[torch.Tensor, torch.Tensor]: - """Computes mean and logvar predictions for the given input. - - When ``self.num_members > 1``, the model supports uncertainty propagation options - that can be used to aggregate the outputs of the different models in the ensemble. - Valid propagation options are: - - - "random_model": for each output in the batch a model will be chosen at random. - This corresponds to TS1 propagation in the PETS paper. - - "fixed_model": for output j-th in the batch, the model will be chosen according to - the model index in `propagation_indices[j]`. This can be used to implement TSinf - propagation, described in the PETS paper. - - "expectation": the output for each element in the batch will be the mean across - models. - - If a set of elite models has been indicated (via :meth:`set_elite()`), then all - propagation methods will operate with only on the elite set. This has no effect when - ``propagation is None``, in which case the forward pass will return one output for - each model. - - Args: - x (tensor): the input to the model. When ``self.propagation is None``, - the shape must be ``E x B x Id`` or ``B x Id``, where ``E``, ``B`` - and ``Id`` represent ensemble size, batch size, and input dimension, - respectively. In this case, each model in the ensemble will get one slice - from the first dimension (e.g., the i-th ensemble member gets ``x[i]``). - - For other values of ``self.propagation`` (and ``use_propagation=True``), - the shape must be ``B x Id``. - rng (torch.Generator, optional): random number generator to use for "random_model" - propagation. - propagation_indices (tensor, optional): propagation indices to use, - as generated by :meth:`sample_propagation_indices`. Ignore if - `use_propagation == False` or `self.propagation_method != "fixed_model". - use_propagation (bool): if ``False``, the propagation method will be ignored - and the method will return outputs for all models. Defaults to ``True``. - - Returns: - (tuple of two tensors): the predicted mean and log variance of the output. If - ``propagation is not None``, the output will be 2-D (batch size, and output dimension). - Otherwise, the outputs will have shape ``E x B x Od``, where ``Od`` represents - output dimension. - - Note: - For efficiency considerations, the propagation method used by this class is an - approximate version of that described by Chua et al. In particular, instead of - sampling models independently for each input in the batch, we ensure that each - model gets exactly the same number of samples (which are assigned randomly - with equal probability), resulting in a smaller batch size which we use for the forward - pass. If this is a concern, consider using ``propagation=None``, and passing - the output to :func:`mbrl.util.math.propagate`. - - """ - if use_propagation: - return self._forward_ensemble( - x, rng=rng, propagation_indices=propagation_indices - ) - return self._default_forward(x) diff --git a/mbrl/types.py b/mbrl/types.py index 4ab4be0a..fca4253c 100644 --- a/mbrl/types.py +++ b/mbrl/types.py @@ -64,54 +64,4 @@ def add_new_batch_dim(self, batch_size: int): ) -@dataclass -class TrajTransitionBatch: - """Represents a batch of transitions""" - - obs: Optional[TensorType] - act: Optional[TensorType] - next_obs: Optional[TensorType] - horizon: Optional[TensorType] - rewards: Optional[TensorType] - dones: Optional[TensorType] - - def __len__(self): - return self.obs.shape[0] - - def astuple(self) -> Transition: - return self.obs, self.act, self.next_obs, self.horizon, self.rewards, self.dones - - def __getitem__(self, item): - return TransitionBatch( - self.obs[item], - self.act[item], - self.next_obs[item], - self.horizon[item], - self.rewards[item], - self.dones[item], - ) - - @staticmethod - def _get_new_shape(old_shape: Tuple[int, ...], batch_size: int): - new_shape = list((1,) + old_shape) - new_shape[0] = batch_size - new_shape[1] = old_shape[0] // batch_size - return tuple(new_shape) - - def add_new_batch_dim(self, batch_size: int): - if not len(self) % batch_size == 0: - raise ValueError( - "Current batch of transitions size is not a " - "multiple of the new batch size. " - ) - return TransitionBatch( - self.obs.reshape(self._get_new_shape(self.obs.shape, batch_size)), - self.act.reshape(self._get_new_shape(self.act.shape, batch_size)), - self.next_obs.reshape(self._get_new_shape(self.obs.shape, batch_size)), - self.horizon.reshape(self._get_new_shape(self.horizon.shape, batch_size)), - self.rewards.reshape(self._get_new_shape(self.rewards.shape, batch_size)), - self.dones.reshape(self._get_new_shape(self.dones.shape, batch_size)), - ) - - -ModelInput = Union[torch.Tensor, TransitionBatch, TrajTransitionBatch] +ModelInput = Union[torch.Tensor, TransitionBatch] diff --git a/mbrl/util/replay_buffer.py b/mbrl/util/replay_buffer.py index 7414d758..dd5c46de 100644 --- a/mbrl/util/replay_buffer.py +++ b/mbrl/util/replay_buffer.py @@ -8,7 +8,7 @@ import numpy as np -from mbrl.types import TransitionBatch, TrajTransitionBatch +from mbrl.types import TransitionBatch def _consolidate_batches(batches: Sequence[TransitionBatch]) -> TransitionBatch: @@ -689,210 +689,3 @@ def get_all(self, shuffle: bool = False) -> TransitionBatch: @property def rng(self) -> np.random.Generator: return self._rng - - -class TrajBasedReplayBuffer(ReplayBuffer): - """A replay buffer with support for storing control parameters and time horizion from initial state. Note that next_obs in this case is a time + horizon, rather than plus one. - - This buffer can be pushed to and sampled from as a typical replay buffer. - - Args: - capacity (int): the maximum number of transitions that the buffer can store. - When the capacity is reached, the contents are overwritten in FIFO fashion. - obs_shape (Sequence of ints): the shape of the observations to store. - action_shape (Sequence of ints): the shape of the actions to store. - obs_type (type): the data type of the observations (defaults to np.float32). - action_type (type): the data type of the actions (defaults to np.float32). - reward_type (type): the data type of the rewards (defaults to np.float32). - rng (np.random.Generator, optional): a random number generator when sampling - batches. If None (default value), a new default generator will be used. - max_trajectory_length (int, optional): if given, indicates that trajectory - information should be stored and that trajectories will be at most this - number of steps. Defaults to ``None`` in which case no trajectory - information will be kept. The buffer will keep trajectory information - automatically using the done value when calling :meth:`add`. - - .. warning:: - When using ``max_trajectory_length`` it is the user's responsibility to ensure - that trajectories are stored continuously in the replay buffer. - """ - - def __init__( - self, - capacity: int, - obs_shape: Sequence[int], - param_shape: Sequence[int], - obs_type: Type = np.float32, - hor_type: Type = np.int_, - param_type: Type = np.float32, - reward_type: Type = np.float32, - rng: Optional[np.random.Generator] = None, - max_trajectory_length: Optional[int] = None, - ): - super().init( - capacity=capacity, - obs_shape=obs_shape, - action_shape=param_shape, - obs_type=obs_type, - action_type=param_type, - reward_type=reward_type, - rng=rng, - max_trajectory_length=max_trajectory_length, - ) - self.horizon = np.empty((capacity, 1), dtype=hor_type) - - def add( - self, - obs: np.ndarray, - params: np.ndarray, - next_obs: np.ndarray, - horizon: Union[np.int_, np.float32], - reward: float, - done: bool, - ): - """Adds a transition (s, a, s', h, r, done) to the replay buffer. - - Args: - obs (np.ndarray): the observation at time t. - params (np.ndarray): the policy parameters at time t. - next_obs (np.ndarray): the observation at time t + h. - horizon (int for float): the timestep between current obs and the next obs - reward (float): the reward at time t. - done (bool): a boolean indicating whether the episode ended or not. - """ - self.obs[self.cur_idx] = obs - self.next_obs[self.cur_idx] = next_obs - self.action[self.cur_idx] = params - self.horizon[self.cur_idx] = horizon - self.reward[self.cur_idx] = reward - self.done[self.cur_idx] = done - - if self.trajectory_indices is not None: - self._trajectory_bookkeeping(done) - else: - self.cur_idx = (self.cur_idx + 1) % self.capacity - self.num_stored = min(self.num_stored + 1, self.capacity) - - def add_batch( - self, - obs: np.ndarray, - params: np.ndarray, - next_obs: np.ndarray, - horizon: np.ndarray, - reward: np.ndarray, - done: np.ndarray, - ): - """Adds a transition (s, a, s', r, done) to the replay buffer. - - Expected shapes are: - obs --> (batch_size,) + obs_shape - act --> (batch_size,) + action_shape - reward/done/horizon --> (batch_size,) - - Args: - obs (np.ndarray): the observation at time t. - params (np.ndarray): the policy parameters at time t. - next_obs (np.ndarray): the observation at time t + h. - horizon (int for float): the timestep between current obs and the next obs - reward (float): the reward at time t. - done (bool): a boolean indicating whether the episode ended or not. - """ - - def copy_from_to(buffer_start, batch_start, how_many): - buffer_slice = slice(buffer_start, buffer_start + how_many) - batch_slice = slice(batch_start, batch_start + how_many) - np.copyto(self.obs[buffer_slice], obs[batch_slice]) - np.copyto(self.action[buffer_slice], params[batch_slice]) - np.copyto(self.horizon[buffer_slice], horizon[batch_slice]) - np.copyto(self.reward[buffer_slice], reward[batch_slice]) - np.copyto(self.next_obs[buffer_slice], next_obs[batch_slice]) - np.copyto(self.done[buffer_slice], done[batch_slice]) - - _batch_start = 0 - buffer_end = self.cur_idx + len(obs) - if buffer_end > self.capacity: - copy_from_to(self.cur_idx, _batch_start, self.capacity - self.cur_idx) - _batch_start = self.capacity - self.cur_idx - self.cur_idx = 0 - self.num_stored = self.capacity - - _how_many = len(obs) - _batch_start - copy_from_to(self.cur_idx, _batch_start, _how_many) - self.cur_idx = (self.cur_idx + _how_many) % self.capacity - self.num_stored = min(self.num_stored + _how_many, self.capacity) - - def _batch_from_indices(self, indices: Sized) -> TransitionBatch: - obs = self.obs[indices] - next_obs = self.next_obs[indices] - action = self.action[indices] - horizon = self.horizon[indices] - reward = self.reward[indices] - done = self.done[indices] - - return TrajTransitionBatch(obs, action, next_obs, horizon, reward, done) - - def __len__(self): - return self.num_stored - - def save(self, save_dir: Union[pathlib.Path, str]): - """Saves the data in the replay buffer to a given directory. - - Args: - save_dir (str): the directory to save the data to. File name will be - replay_buffer.npz. - """ - path = pathlib.Path(save_dir) / "replay_buffer.npz" - np.savez( - path, - obs=self.obs[: self.num_stored], - next_obs=self.next_obs[: self.num_stored], - horizon=self.horizon[: self.num_stored], - action=self.action[: self.num_stored], - reward=self.reward[: self.num_stored], - done=self.done[: self.num_stored], - trajectory_indices=self.trajectory_indices or [], - ) - - def load(self, load_dir: Union[pathlib.Path, str]): - """Loads transition data from a given directory. - - Args: - load_dir (str): the directory where the buffer is stored. - """ - path = pathlib.Path(load_dir) / "replay_buffer.npz" - data = np.load(path) - num_stored = len(data["obs"]) - self.obs[:num_stored] = data["obs"] - self.next_obs[:num_stored] = data["next_obs"] - self.horizon[:num_stored] = data["horizon"] - self.action[:num_stored] = data["action"] - self.reward[:num_stored] = data["reward"] - self.done[:num_stored] = data["done"] - self.num_stored = num_stored - self.cur_idx = self.num_stored % self.capacity - if "trajectory_indices" in data and len(data["trajectory_indices"]): - self.trajectory_indices = data["trajectory_indices"] - - def get_all(self, shuffle: bool = False) -> TransitionBatch: - """Returns all data stored in the replay buffer. - - Args: - shuffle (int): set to ``True`` if the data returned should be in random order. - Defaults to ``False``. - """ - if shuffle: - permutation = self._rng.permutation(self.num_stored) - return self._batch_from_indices(permutation) - else: - return TransitionBatch( - self.obs[: self.num_stored], - self.action[: self.num_stored], - self.next_obs[: self.num_stored], - self.horizon[: self.num_stored], - self.reward[: self.num_stored], - self.done[: self.num_stored], - ) - - @property - def rng(self) -> np.random.Generator: - return self._rng From 196431c841e74570e11f1eebb2888fe260aea346 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Mon, 15 Aug 2022 19:13:18 -0700 Subject: [PATCH 09/24] clean PID implementation --- mbrl/planning/linear_feedback.py | 103 ++++++++++++++++++++----------- 1 file changed, 66 insertions(+), 37 deletions(-) diff --git a/mbrl/planning/linear_feedback.py b/mbrl/planning/linear_feedback.py index a937c803..13403906 100644 --- a/mbrl/planning/linear_feedback.py +++ b/mbrl/planning/linear_feedback.py @@ -3,6 +3,8 @@ # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. +from typing import Optional + import numpy as np from .core import Agent @@ -10,71 +12,98 @@ class PIDAgent(Agent): """ - Agent that reacts via an internal set of PID controllers. + Agent that reacts via an internal set of proportional–integral–derivative controllers. + + A broad history of the PID controller can be found here: + https://en.wikipedia.org/wiki/PID_controller. + + Args: + :param dim: dimensionality of state and control signal + :param k_p: proportional control coeff + :param I: integral control coeff + :param D: derivative control coeff + :param target: setpoint + :param state_mapping: indices of the state vector to apply the PID control to. + E.g. for a system with states [angle, angle_vel, position, position_vel], state_mapping + of [1, 3] and dim of 2 will apply the PID to angle_vel and position_vel variables. """ def __init__( self, dim: int, - Kp: np.ndarray, - Ki: np.ndarray, - Kd: np.ndarray, + k_p: np.ndarray, + k_i: np.ndarray, + k_d: np.ndarray, target: np.ndarray, + state_mapping: Optional[np.ndarray] = None, ): - """ - :param dim: dimensionality of state and control signal - :param P: proportional control coeff - :param I: integral control coeff - :param D: derivative control coeff - :param target: setpoint - """ super().__init__() - assert len(Kp) == dim - assert len(Ki) == dim - assert len(Kd) == dim - assert len(target) == dim - + assert ( + len(k_p) == len(k_i) == len(k_d) == len(target) == len(state_mapping) == dim + ) self.n_dof = dim - # TODO: add helper functions for setting and using state_mapping - self.state_mapping = None # can set to run PID on specific variables - + # State mapping defaults to first N states + if state_mapping is not None: + self.state_mapping = state_mapping + else: + self.state_mapping = np.arange(0, dim) - # TODO: fix dimensionality with P - self.Kp = Kp #np.tile(P_value, self.n_dof) - self.Ki = Ki #np.tile(I_value, self.n_dof) - self.Kd = Kd #np.tile(D_value, self.n_dof) + self.k_p = k_p + self.k_i = k_i + self.k_d = k_d self.target = target self.prev_error = 0 - self.error = 0 - # self.cum_error = 0 - # self.I_count = 0 + self.cum_error = 0 + + def act(self, obs: np.ndarray, **_kwargs) -> np.ndarray: + """Issues an action given an observation. + + This method optimizes a full sequence of length ``self.planning_horizon`` and returns + the first action in the sequence. If ``self.replan_freq > 1``, future calls will use + subsequent actions in the sequence, for ``self.replan_freq`` number of steps. + After that, the method will plan again, and repeat this process. + + Args: + obs (np.ndarray): the observation for which the action is needed. - def act(self, obs: np.array) -> np.ndarray: + Returns: + (np.ndarray): the action. + """ if len(obs) > self.n_dof: - obs = obs[:self.n_dof] + obs = obs[: self.n_dof] q_des = self.target q = obs - self.error = q_des - q - P_value = self.Kp * self.error - I_value = 0 # TODO: implement I and D part - D_value = self.Kd * (self.error - self.prev_error) # + self.D*(qd_des-qd) - self.prev_error = self.error + error = q_des - q + self.cum_error += error + + P_value = self.k_p * error + I_value = self.k_i * self.cum_error + D_value = self.k_d * (error - self.prev_error) + self.prev_error = error action = P_value + I_value + D_value return action def _get_P(self): - return self.Kp + return self.k_p def _get_I(self): - return self.Ki + return self.k_i def _get_D(self): - return self.Kd + return self.k_d def _get_targets(self): return self.target def get_parameters(self): - return np.stack((self._get_P(), self._get_I(), self._get_D(), self._get_targets())).flatten() + """ + Returns the parameters of the PID agent concatenated. + + Returns: + (np.ndarray): the parameters. + """ + return np.stack( + (self._get_P(), self._get_I(), self._get_D(), self._get_targets()) + ).flatten() From 2cb94ac1268b31e46fcef62e106a00fda85f9378 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Mon, 15 Aug 2022 19:54:13 -0700 Subject: [PATCH 10/24] minor text changes --- mbrl/planning/linear_feedback.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/mbrl/planning/linear_feedback.py b/mbrl/planning/linear_feedback.py index 13403906..c02ec12a 100644 --- a/mbrl/planning/linear_feedback.py +++ b/mbrl/planning/linear_feedback.py @@ -18,12 +18,12 @@ class PIDAgent(Agent): https://en.wikipedia.org/wiki/PID_controller. Args: - :param dim: dimensionality of state and control signal - :param k_p: proportional control coeff - :param I: integral control coeff - :param D: derivative control coeff - :param target: setpoint - :param state_mapping: indices of the state vector to apply the PID control to. + dim (int): dimensionality of state and control signal + k_p (np.ndarry): proportional control coeff + k_i (np.ndarry): integral control coeff + k_d (np.ndarry): derivative control coeff + target (np.ndarry): setpoint + state_mapping (np.ndarry): indices of the state vector to apply the PID control to. E.g. for a system with states [angle, angle_vel, position, position_vel], state_mapping of [1, 3] and dim of 2 will apply the PID to angle_vel and position_vel variables. """ From 4b251385837648d2dcf411f4a0d1330558f175d2 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Tue, 16 Aug 2022 15:47:28 -0700 Subject: [PATCH 11/24] make batch friendly, add tests --- mbrl/planning/linear_feedback.py | 67 ++++++++++++++++----------- tests/core/test_planning.py | 78 ++++++++++++++++++++++++++++++++ 2 files changed, 118 insertions(+), 27 deletions(-) create mode 100644 tests/core/test_planning.py diff --git a/mbrl/planning/linear_feedback.py b/mbrl/planning/linear_feedback.py index c02ec12a..2981b83a 100644 --- a/mbrl/planning/linear_feedback.py +++ b/mbrl/planning/linear_feedback.py @@ -2,7 +2,6 @@ # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. - from typing import Optional import numpy as np @@ -18,43 +17,45 @@ class PIDAgent(Agent): https://en.wikipedia.org/wiki/PID_controller. Args: - dim (int): dimensionality of state and control signal - k_p (np.ndarry): proportional control coeff - k_i (np.ndarry): integral control coeff - k_d (np.ndarry): derivative control coeff - target (np.ndarry): setpoint + k_p (np.ndarry): proportional control coeff (Nx1) + k_i (np.ndarry): integral control coeff (Nx1) + k_d (np.ndarry): derivative control coeff (Nx1) + target (np.ndarry): setpoint (Nx1) state_mapping (np.ndarry): indices of the state vector to apply the PID control to. E.g. for a system with states [angle, angle_vel, position, position_vel], state_mapping of [1, 3] and dim of 2 will apply the PID to angle_vel and position_vel variables. + batch_dim (int): number of samples to compute actions for simultaneously """ def __init__( self, - dim: int, k_p: np.ndarray, k_i: np.ndarray, k_d: np.ndarray, target: np.ndarray, state_mapping: Optional[np.ndarray] = None, + batch_dim: Optional[int] = 1, ): super().__init__() - assert ( - len(k_p) == len(k_i) == len(k_d) == len(target) == len(state_mapping) == dim - ) - self.n_dof = dim + assert len(k_p) == len(k_i) == len(k_d) == len(target) + self.n_dof = len(k_p) # State mapping defaults to first N states if state_mapping is not None: + assert len(state_mapping) == len(target) self.state_mapping = state_mapping else: - self.state_mapping = np.arange(0, dim) + self.state_mapping = np.arange(0, self.n_dof) + + self.batch_dim = batch_dim - self.k_p = k_p - self.k_i = k_i - self.k_d = k_d - self.target = target - self.prev_error = 0 - self.cum_error = 0 + self._prev_error = np.zeros((self.n_dof, self.batch_dim)) + self._cum_error = np.zeros((self.n_dof, self.batch_dim)) + + self.k_p = np.repeat(k_p[:, np.newaxis], self.batch_dim, axis=1) + self.k_i = np.repeat(k_i[:, np.newaxis], self.batch_dim, axis=1) + self.k_d = np.repeat(k_d[:, np.newaxis], self.batch_dim, axis=1) + self.target = np.repeat(target[:, np.newaxis], self.batch_dim, axis=1) def act(self, obs: np.ndarray, **_kwargs) -> np.ndarray: """Issues an action given an observation. @@ -70,21 +71,33 @@ def act(self, obs: np.ndarray, **_kwargs) -> np.ndarray: Returns: (np.ndarray): the action. """ + if obs.ndim == 1: + obs = np.expand_dims(obs, -1) if len(obs) > self.n_dof: - obs = obs[: self.n_dof] - q_des = self.target - q = obs + pos = obs[self.state_mapping] + else: + pos = obs - error = q_des - q - self.cum_error += error + error = self.target - pos + self._cum_error += error - P_value = self.k_p * error - I_value = self.k_i * self.cum_error - D_value = self.k_d * (error - self.prev_error) - self.prev_error = error + P_value = np.multiply(self.k_p, error) + I_value = np.multiply(self.k_i, self._cum_error) + D_value = np.multiply(self.k_d, (error - self._prev_error)) + self._prev_error = error action = P_value + I_value + D_value return action + def reset(self): + """ + Reset internal errors. + """ + self._prev_error = np.zeros((self.n_dof, self.batch_dim)) + self._cum_error = np.zeros((self.n_dof, self.batch_dim)) + + def get_errors(self): + return self._prev_error, self._cum_error + def _get_P(self): return self.k_p diff --git a/tests/core/test_planning.py b/tests/core/test_planning.py new file mode 100644 index 00000000..7dc9c2ea --- /dev/null +++ b/tests/core/test_planning.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import pytest + +import mbrl.planning as planning + +SEED = 0 + +def create_pid_agent(dim, state_mapping=None, batch_dim = 1): + agent = planning.PIDAgent(k_p=np.random.randn(dim, ), + k_i=np.random.randn(dim, ), + k_d=np.random.randn(dim, ), + target=np.zeros(dim, ), + state_mapping=state_mapping, + batch_dim=batch_dim, + ) + return agent + +def test_pid_agent_one_dim(): + """ + This test covers the creation of PID agents in the most basic form. + """ + np.random.seed(SEED) + pid = create_pid_agent(dim=1) + pid.reset() + init_obs = np.random.randn(1) + act = pid.act(init_obs) + + # check action computation + assert act == pytest.approx(-7.043, 0.1) + + # check reset + pid.reset() + prev_error, cum_error = pid.get_errors() + assert np.sum(prev_error) == np.sum(cum_error) == 0 + + + +def test_pid_agent_multi_dim(): + """ + This test covers regular updates for the multi-dim PID agent. + """ + np.random.seed(SEED) + pid = create_pid_agent(dim=2, state_mapping = np.array([1, 3]),) + init_obs = np.random.randn(4) + act1 = pid.act(init_obs) + next_obs = np.random.randn(4) + act2 = pid.act(next_obs) + assert act1 + act2 == pytest.approx([-6.141, -2.207], 0.1) + + # check reset + pid.reset() + prev_error, cum_error = pid.get_errors() + assert np.sum(prev_error) == np.sum(cum_error) == 0 + + +def test_pid_agent_batch(batch_dim=5): + """ + Tests the agent for batch-mode computation of actions. + """ + np.random.seed(SEED) + pid = create_pid_agent(dim=2, state_mapping = np.array([1, 3]), batch_dim=batch_dim) + + init_obs = np.random.randn(4, batch_dim) + act1 = pid.act(init_obs) + next_obs = np.random.randn(4, batch_dim) + act2 = pid.act(next_obs) + + assert (act1 + act2)[0] == pytest.approx([-7.155, 1.260, 8.679, -0.047, -1.962], 0.1) + + # check reset + pid.reset() + prev_error, cum_error = pid.get_errors() + assert np.sum(prev_error) == np.sum(cum_error) == 0 From ebd5751df7acd9d850b476741b384fbcd65a0090 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Tue, 16 Aug 2022 15:49:05 -0700 Subject: [PATCH 12/24] lint tests --- tests/core/test_planning.py | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/tests/core/test_planning.py b/tests/core/test_planning.py index 7dc9c2ea..5e1267e0 100644 --- a/tests/core/test_planning.py +++ b/tests/core/test_planning.py @@ -10,16 +10,20 @@ SEED = 0 -def create_pid_agent(dim, state_mapping=None, batch_dim = 1): + +def create_pid_agent(dim, + state_mapping=None, + batch_dim=1): agent = planning.PIDAgent(k_p=np.random.randn(dim, ), - k_i=np.random.randn(dim, ), - k_d=np.random.randn(dim, ), - target=np.zeros(dim, ), - state_mapping=state_mapping, + k_i=np.random.randn(dim, ), + k_d=np.random.randn(dim, ), + target=np.zeros(dim, ), + state_mapping=state_mapping, batch_dim=batch_dim, - ) + ) return agent + def test_pid_agent_one_dim(): """ This test covers the creation of PID agents in the most basic form. @@ -39,13 +43,12 @@ def test_pid_agent_one_dim(): assert np.sum(prev_error) == np.sum(cum_error) == 0 - def test_pid_agent_multi_dim(): """ This test covers regular updates for the multi-dim PID agent. """ np.random.seed(SEED) - pid = create_pid_agent(dim=2, state_mapping = np.array([1, 3]),) + pid = create_pid_agent(dim=2, state_mapping=np.array([1, 3]), ) init_obs = np.random.randn(4) act1 = pid.act(init_obs) next_obs = np.random.randn(4) @@ -63,14 +66,14 @@ def test_pid_agent_batch(batch_dim=5): Tests the agent for batch-mode computation of actions. """ np.random.seed(SEED) - pid = create_pid_agent(dim=2, state_mapping = np.array([1, 3]), batch_dim=batch_dim) + pid = create_pid_agent(dim=2, state_mapping=np.array([1, 3]), batch_dim=batch_dim) init_obs = np.random.randn(4, batch_dim) act1 = pid.act(init_obs) next_obs = np.random.randn(4, batch_dim) act2 = pid.act(next_obs) - assert (act1 + act2)[0] == pytest.approx([-7.155, 1.260, 8.679, -0.047, -1.962], 0.1) + assert (act1 + act2)[0] == pytest.approx([-7.155, 1.260, 8.679, -0.047, -1.962], 0.1) # check reset pid.reset() From 55fdec4f1935da9540bb2efcac7f28e390da435d Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Tue, 16 Aug 2022 15:51:12 -0700 Subject: [PATCH 13/24] reset precommits to main --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 953a6e18..f3ac7830 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ repos: hooks: - id: black files: 'mbrl' - language_version: python3 + language_version: python3.7 - repo: https://gitlab.com/pycqa/flake8 rev: 3.9.2 From 8a28b012c4f7ca36771488a34e11f6ca593b0380 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Fri, 19 Aug 2022 10:52:15 -0700 Subject: [PATCH 14/24] make tests deterministic --- .pre-commit-config.yaml | 2 +- tests/core/test_planning.py | 34 +++++++++++++++++----------------- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index f3ac7830..953a6e18 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ repos: hooks: - id: black files: 'mbrl' - language_version: python3.7 + language_version: python3 - repo: https://gitlab.com/pycqa/flake8 rev: 3.9.2 diff --git a/tests/core/test_planning.py b/tests/core/test_planning.py index 5e1267e0..70541c75 100644 --- a/tests/core/test_planning.py +++ b/tests/core/test_planning.py @@ -8,15 +8,13 @@ import mbrl.planning as planning -SEED = 0 - def create_pid_agent(dim, state_mapping=None, batch_dim=1): - agent = planning.PIDAgent(k_p=np.random.randn(dim, ), - k_i=np.random.randn(dim, ), - k_d=np.random.randn(dim, ), + agent = planning.PIDAgent(k_p=np.ones(dim, ), + k_i=np.ones(dim, ), + k_d=np.ones(dim, ), target=np.zeros(dim, ), state_mapping=state_mapping, batch_dim=batch_dim, @@ -28,14 +26,13 @@ def test_pid_agent_one_dim(): """ This test covers the creation of PID agents in the most basic form. """ - np.random.seed(SEED) pid = create_pid_agent(dim=1) pid.reset() - init_obs = np.random.randn(1) + init_obs = np.array([2.2408932]) act = pid.act(init_obs) # check action computation - assert act == pytest.approx(-7.043, 0.1) + assert act == pytest.approx(-6.722, 0.1) # check reset pid.reset() @@ -47,13 +44,12 @@ def test_pid_agent_multi_dim(): """ This test covers regular updates for the multi-dim PID agent. """ - np.random.seed(SEED) pid = create_pid_agent(dim=2, state_mapping=np.array([1, 3]), ) - init_obs = np.random.randn(4) + init_obs = np.array([ 0.95008842, -0.15135721, -0.10321885, 0.4105985 ]) act1 = pid.act(init_obs) - next_obs = np.random.randn(4) + next_obs = np.array([0.14404357, 1.45427351, 0.76103773, 0.12167502]) act2 = pid.act(next_obs) - assert act1 + act2 == pytest.approx([-6.141, -2.207], 0.1) + assert act1 + act2 == pytest.approx([-3.908, -1.596], 0.1) # check reset pid.reset() @@ -65,15 +61,19 @@ def test_pid_agent_batch(batch_dim=5): """ Tests the agent for batch-mode computation of actions. """ - np.random.seed(SEED) pid = create_pid_agent(dim=2, state_mapping=np.array([1, 3]), batch_dim=batch_dim) - init_obs = np.random.randn(4, batch_dim) + init_obs = np.array([[ 0.95008842, -0.15135721, -0.10321885, 0.4105985 , 0.14404357], + [ 1.45427351, 0.76103773, 0.12167502, 0.44386323, 0.33367433], + [ 1.49407907, -0.20515826, 0.3130677 , -0.85409574, -2.55298982], + [ 0.6536186 , 0.8644362 , -0.74216502, 2.26975462, -1.45436567]]) act1 = pid.act(init_obs) - next_obs = np.random.randn(4, batch_dim) + next_obs = np.array([[ 0.04575852, -0.18718385, 1.53277921, 1.46935877, 0.15494743], + [ 0.37816252, -0.88778575, -1.98079647, -0.34791215, 0.15634897], + [ 1.23029068, 1.20237985, -0.38732682, -0.30230275, -1.04855297], + [-1.42001794, -1.70627019, 1.9507754 , -0.50965218, -0.4380743 ]]) act2 = pid.act(next_obs) - - assert (act1 + act2)[0] == pytest.approx([-7.155, 1.260, 8.679, -0.047, -1.962], 0.1) + assert (act1 + act2)[0] == pytest.approx([-5.497, 0.380, 5.577, -0.287, -1.470], 0.1) # check reset pid.reset() From 96876e2f6db2ed755105c0b248e38339f69768ce Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Fri, 19 Aug 2022 10:52:40 -0700 Subject: [PATCH 15/24] make tests deterministic --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 953a6e18..f3ac7830 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ repos: hooks: - id: black files: 'mbrl' - language_version: python3 + language_version: python3.7 - repo: https://gitlab.com/pycqa/flake8 rev: 3.9.2 From e708945a009b1ff7c903460f7eb3fa63064714ec Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Mon, 22 Aug 2022 15:19:30 -0700 Subject: [PATCH 16/24] fix docstring --- mbrl/planning/linear_feedback.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/mbrl/planning/linear_feedback.py b/mbrl/planning/linear_feedback.py index 2981b83a..a7b2ce85 100644 --- a/mbrl/planning/linear_feedback.py +++ b/mbrl/planning/linear_feedback.py @@ -60,16 +60,15 @@ def __init__( def act(self, obs: np.ndarray, **_kwargs) -> np.ndarray: """Issues an action given an observation. - This method optimizes a full sequence of length ``self.planning_horizon`` and returns - the first action in the sequence. If ``self.replan_freq > 1``, future calls will use - subsequent actions in the sequence, for ``self.replan_freq`` number of steps. - After that, the method will plan again, and repeat this process. + This method optimizes a given observation or batch of observations for a one-step action choice. + Args: - obs (np.ndarray): the observation for which the action is needed. + obs (np.ndarray): the observation for which the action is needed either N x 1 or N x B, where N is the + state dim and B is the batch size. Returns: - (np.ndarray): the action. + (np.ndarray): the action outputted from the PID, either shape n_dof x 1 or n_dof x B. """ if obs.ndim == 1: obs = np.expand_dims(obs, -1) From baa128cc2d98a30b6289fb416a7b18077c8cec40 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Wed, 24 Aug 2022 15:12:00 -0700 Subject: [PATCH 17/24] fix notebook (some content wasn't saved on final save) --- mbrl/env/reward_fns.py | 3 + notebooks/traj_based_model.ipynb | 238 +++++++++++++++++++++++++------ 2 files changed, 197 insertions(+), 44 deletions(-) diff --git a/mbrl/env/reward_fns.py b/mbrl/env/reward_fns.py index 690477e0..8260ce8a 100644 --- a/mbrl/env/reward_fns.py +++ b/mbrl/env/reward_fns.py @@ -7,6 +7,9 @@ from . import termination_fns +def no_reward(act: torch.Tensor, next_obs: torch.Tensor) -> torch.Tensor: + return torch.Tensor(0) + def cartpole(act: torch.Tensor, next_obs: torch.Tensor) -> torch.Tensor: assert len(next_obs.shape) == len(act.shape) == 2 diff --git a/notebooks/traj_based_model.ipynb b/notebooks/traj_based_model.ipynb index d06ef9a7..84314f3e 100644 --- a/notebooks/traj_based_model.ipynb +++ b/notebooks/traj_based_model.ipynb @@ -23,7 +23,7 @@ "where $s_t$ is the state of the environment, $a_t$ is the action taken by the agent, and $f_\\theta(\\cdot)$ is a learned model of the world. \n", "A common issue is that the long-term future is predicted with recursive function calls, which is known to lead to compounding error:\n", "\n", - "$$s{t+h}=f_\\theta(\\ldots f_\\theta(f_\\theta(s_t,a_t),a_{t+1}) \\ldots , a_{t+h}).$$\n", + "$$s_{t+h}=f_\\theta(\\ldots f_\\theta(f_\\theta(s_t,a_t),a_{t+1}) \\ldots , a_{t+h}).$$\n", "\n", "As an alternate, the trajectory-based model predicts a direct time horizon in the future $h$. In order to avoid needing to pass in every action to the model, it takes in the control parameters that would define the policy $a_t = \\pi_\\phi()$, understanding that the sequence of actions are often highly correlated. This yields a new formulation as follows:\n", "\n", @@ -38,7 +38,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Setup\n", "In this section we import the needed code from MBRL-Lib, create the environment, and configure our experiment.\n", @@ -66,18 +70,19 @@ } ], "source": [ - "from IPython import display\n", + "\n", "%matplotlib inline\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "import torch\n", "import omegaconf\n", + "import torch\n", "\n", "import mbrl.env.pets_reacher as reacher_env\n", + "import mbrl.env.termination_fns as termination_fns\n", "import mbrl.models as models\n", - "from mbrl.planning import Agent\n", "import mbrl.util.common as common_util\n", + "from mbrl.planning import Agent\n", "\n", "\n", "%load_ext autoreload\n", @@ -227,7 +232,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now we can create an agent by just loading information about the action space from the environment!" ] @@ -235,7 +244,11 @@ { "cell_type": "code", "execution_count": 342, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "agent = create_pid_agent(env.action_space.shape[0])" @@ -243,7 +256,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The agent determines the dimension of the input for trajectory-based model." ] @@ -251,7 +268,11 @@ { "cell_type": "code", "execution_count": 343, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "param_shape = (len(agent.get_parameters())+1,)" @@ -272,7 +293,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Trajectory-based model config\n", "We define the trajectory-based model a little differently than the other examples in this library! You can see we are mapping the parameters in where the actions would normally go in the model. \n", @@ -337,7 +362,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### One-step model config\n", "We train a one-step model as a baseline against the trajectory-based model!" @@ -346,7 +375,11 @@ { "cell_type": "code", "execution_count": 345, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "one_step_config_dict = {\n", @@ -388,14 +421,22 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "----" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Experimentation" ] @@ -570,7 +611,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Create a basic model trainer for our Gaussian MLP." ] @@ -578,7 +623,11 @@ { "cell_type": "code", "execution_count": 349, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "model_trainer = models.ModelTrainer(dynamics_model, optim_lr=1e-4, weight_decay=5e-5)" @@ -586,7 +635,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Create a training & validation dataset." ] @@ -594,7 +647,11 @@ { "cell_type": "code", "execution_count": 350, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "train_dataset, val_dataset = common_util.get_basic_buffer_iterators(\n", @@ -608,7 +665,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Train the model!" ] @@ -616,7 +677,11 @@ { "cell_type": "code", "execution_count": 351, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "train_losses, val_losses = model_trainer.train(train_dataset, val_dataset, num_epochs=50, patience=100)" @@ -624,14 +689,22 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Plotting Results" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Traj-based Model Loss" ] @@ -639,7 +712,11 @@ { "cell_type": "code", "execution_count": 352, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -667,14 +744,22 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Prediction Accuracy" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Initialize an one-step model" ] @@ -682,7 +767,11 @@ { "cell_type": "code", "execution_count": 353, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Create a 1-D dynamics model for this environment\n", @@ -691,7 +780,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Train the one-step model" ] @@ -699,7 +792,11 @@ { "cell_type": "code", "execution_count": 354, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "one_step_model_trainer = models.ModelTrainer(one_step_model, optim_lr=1e-4, weight_decay=5e-5)\n", @@ -717,7 +814,11 @@ { "cell_type": "code", "execution_count": 355, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -745,7 +846,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Sample trajectories for evaluation, predict trajectories, and compute MSE across states (without batching, does not work for ensemble). \n", "This large block is mostly data handling! First, lets collate the data we need!" @@ -754,7 +859,11 @@ { "cell_type": "code", "execution_count": 356, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "num_traj_eval = num_trials\n", @@ -788,7 +897,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now we predict with the models! First we can pass the initial states and plans into the one-step model to unroll trajectories. Note that everything is stacked because the ensembles use batching." ] @@ -796,9 +909,19 @@ { "cell_type": "code", "execution_count": 357, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ + "def no_reward(act: torch.Tensor, next_obs: torch.Tensor) -> torch.Tensor:\n", + " return torch.Tensor(0)\n", + "\n", + "one_step_model_env = models.ModelEnv(env, one_step_model, termination_fns.no_termination, no_reward, generator=generator)\n", + "\n", + "\n", "### rollout one-step model in batch of trajectories ###\n", "states, _, _ = common_util.rollout_model_env(one_step_model_env, \n", " initial_obs=np.stack([o[0] for o in eval_data_obs],axis=0),\n", @@ -807,7 +930,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We don't need a utility to predict with the trajectory-based model, but in that case we need to do some of the data processing that would be handled in the `mbrl.common_utils`." ] @@ -815,11 +942,15 @@ { "cell_type": "code", "execution_count": 358, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# concatenare initial states with parameters + time index\n", - "obs_stack = np.stack([o[0] for o in eval_traj_obs])\n", + "obs_stack = np.stack([o[0] for o in eval_data_obs])\n", "param_stack = np.stack(eval_traj_param)\n", "\n", "param_dim = np.shape(param_stack)[-1]\n", @@ -843,7 +974,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now let's analyze the data!" ] @@ -851,7 +986,11 @@ { "cell_type": "code", "execution_count": 359, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Compute one-step errors\n", @@ -860,13 +999,16 @@ "\n", "# compute trajectory-based errors\n", "states_pred = states_pred.numpy().reshape(num_traj, trial_length, -1)\n", - "traj_based_errors = np.mean((true_states - states_pred)**2, axis=-1)\n", - "traj_based.append(traj_based_errors)" + "traj_based_errors = np.mean((true_states - states_pred)**2, axis=-1)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Trajectory-based vs One-step\n", "Here we take the errors and plot them over time!" @@ -875,7 +1017,11 @@ { "cell_type": "code", "execution_count": 361, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -922,7 +1068,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] } @@ -948,4 +1098,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file From 8f1682aab7a46540fb4cc009262eb4ec07a0af90 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Wed, 24 Aug 2022 15:21:44 -0700 Subject: [PATCH 18/24] add colab to readme --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index 967f1e22..0ddcfbf8 100644 --- a/README.md +++ b/README.md @@ -179,6 +179,11 @@ installation and are specific to models of type We are planning to extend this in the future; if you have useful suggestions don't hesitate to raise an issue or submit a pull request! +## Advanced Examples +MBRL-Lib can be used for many different research projects in the subject area. +We have support for the following projects: +* [Trajectory-based Dynamics Model](https://arxiv.org/abs/2012.09156) Training [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/15lodC9KyzzQCv9hQY3wtAe-yYOdk9vZB?usp=sharing) + ## Documentation Please check out our **[documentation](https://facebookresearch.github.io/mbrl-lib/)** and don't hesitate to raise issues or contribute if anything is unclear! From f6d37451f26ded162f5745123d1ca37fee523a1c Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Wed, 31 Aug 2022 11:40:54 -0700 Subject: [PATCH 19/24] clean PR for mbrl-lib --- .pre-commit-config.yaml | 2 +- mbrl/env/reward_fns.py | 3 - notebooks/traj_based_model.ipynb | 1101 ------------------------------ 3 files changed, 1 insertion(+), 1105 deletions(-) delete mode 100644 notebooks/traj_based_model.ipynb diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index f3ac7830..953a6e18 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ repos: hooks: - id: black files: 'mbrl' - language_version: python3.7 + language_version: python3 - repo: https://gitlab.com/pycqa/flake8 rev: 3.9.2 diff --git a/mbrl/env/reward_fns.py b/mbrl/env/reward_fns.py index 8260ce8a..690477e0 100644 --- a/mbrl/env/reward_fns.py +++ b/mbrl/env/reward_fns.py @@ -7,9 +7,6 @@ from . import termination_fns -def no_reward(act: torch.Tensor, next_obs: torch.Tensor) -> torch.Tensor: - return torch.Tensor(0) - def cartpole(act: torch.Tensor, next_obs: torch.Tensor) -> torch.Tensor: assert len(next_obs.shape) == len(act.shape) == 2 diff --git a/notebooks/traj_based_model.ipynb b/notebooks/traj_based_model.ipynb deleted file mode 100644 index 84314f3e..00000000 --- a/notebooks/traj_based_model.ipynb +++ /dev/null @@ -1,1101 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "# Preview\n", - "\n", - "In this example, we are going to use our toolbox to train and evaluate the [Trajectory-based Dynamics Model](https://arxiv.org/abs/2012.09156) in the reacher environment. Note that the reacher environment in this repository is slightly different than the one used in that paper ([link](https://github.com/natolambert/continuousprediction/blob/master/envs/reacher3d.py))!\n", - "\n", - "## Conceptual Overview\n", - "\n", - "The *Trajectory-based Model* is a alternate type of dynamics model designed for applicatons of model-based reinforcement learning (MBRL) where one would prioritize long-term prediction accuracy (and overcome the well-known [compounding error](http://arxiv.org/abs/2203.09637). This is accomplished by moving away from the standard one-step parametrization of a dynamics model in MBRL.\n", - "\n", - "As a review, state-predictions are often done in a **one-step** manner in MBRL:\n", - "\n", - "$$s_{t+1} = f_\\theta(s_t,a_t),$$\n", - "\n", - "where $s_t$ is the state of the environment, $a_t$ is the action taken by the agent, and $f_\\theta(\\cdot)$ is a learned model of the world. \n", - "A common issue is that the long-term future is predicted with recursive function calls, which is known to lead to compounding error:\n", - "\n", - "$$s_{t+h}=f_\\theta(\\ldots f_\\theta(f_\\theta(s_t,a_t),a_{t+1}) \\ldots , a_{t+h}).$$\n", - "\n", - "As an alternate, the trajectory-based model predicts a direct time horizon in the future $h$. In order to avoid needing to pass in every action to the model, it takes in the control parameters that would define the policy $a_t = \\pi_\\phi()$, understanding that the sequence of actions are often highly correlated. This yields a new formulation as follows:\n", - "\n", - "$$s_{t+h} = f_\\theta(s_t, h, \\phi).$$\n", - "\n", - "This model confers a series of benefits on top of long-term prediction accuracy, including stable uncertainty propagation, fast inference (no more recusion -- just pass in a vector of time), and better sample efficiency.\n", - "\n", - "In this notebook, we show you how the model can be trained almost entirely on built in MBRL-Lib code!\n", - "\n", - "-----" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "# Setup\n", - "In this section we import the needed code from MBRL-Lib, create the environment, and configure our experiment.\n", - "\n", - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 339, - "metadata": { - "pycharm": { - "is_executing": true, - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "\n", - "%matplotlib inline\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import omegaconf\n", - "import torch\n", - "\n", - "import mbrl.env.pets_reacher as reacher_env\n", - "import mbrl.env.termination_fns as termination_fns\n", - "import mbrl.models as models\n", - "import mbrl.util.common as common_util\n", - "from mbrl.planning import Agent\n", - "\n", - "\n", - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "mpl.rcParams.update({\"font.size\": 16})\n", - "\n", - "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Creating the environment\n", - "\n", - "First we instantiate the environment." - ] - }, - { - "cell_type": "code", - "execution_count": 340, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "seed = 0\n", - "\n", - "env = reacher_env.Reacher3DEnv()\n", - "env.seed(seed)\n", - "\n", - "# experiment constants\n", - "trial_length = 500\n", - "num_trials = 10\n", - "\n", - "# constants and random number generation\n", - "generator = torch.Generator(device=device)\n", - "generator.manual_seed(seed)\n", - "\n", - "obs_shape = env.observation_space.shape\n", - "act_shape = env.action_space.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## PID Agent\n", - "\n", - "In this section we add a basic PID agent to the library to use as the control parameters for prediction with the new model." - ] - }, - { - "cell_type": "code", - "execution_count": 341, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "class PIDAgent(Agent):\n", - " \"\"\"\n", - " Agent that reacts via an internal set of PID controllers.\n", - " \"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " dim: int,\n", - " Kp: np.ndarray,\n", - " Ki: np.ndarray,\n", - " Kd: np.ndarray,\n", - " target: np.ndarray,\n", - " ):\n", - " super().__init__()\n", - " assert len(Kp) == dim\n", - " assert len(Ki) == dim\n", - " assert len(Kd) == dim\n", - " assert len(target) == dim\n", - "\n", - " self.n_dof = dim\n", - "\n", - " # TODO: add helper functions for setting and using state_mapping\n", - " self.state_mapping = None # can set to run PID on specific variables\n", - "\n", - " self.Kp = Kp \n", - " self.Ki = Ki \n", - " self.Kd = Kd \n", - " self.target = target\n", - " self.prev_error = 0\n", - " self.error = 0\n", - "\n", - " def act(self, obs: np.array) -> np.ndarray:\n", - " if len(obs) > self.n_dof:\n", - " obs = obs[:self.n_dof]\n", - " q_des = self.target\n", - " q = obs\n", - "\n", - " self.error = q_des - q\n", - " P_value = self.Kp * self.error\n", - " I_value = 0 # TODO: implement I and D part\n", - " D_value = self.Kd * (self.error - self.prev_error) \n", - " self.prev_error = self.error\n", - " action = P_value + I_value + D_value\n", - " return action\n", - "\n", - " def _get_P(self):\n", - " return self.Kp\n", - "\n", - " def _get_I(self):\n", - " return self.Ki\n", - "\n", - " def _get_D(self):\n", - " return self.Kd\n", - "\n", - " def _get_targets(self):\n", - " return self.target\n", - "\n", - " def get_parameters(self):\n", - " return np.stack((self._get_P(), self._get_I(), self._get_D(), self._get_targets())).flatten()\n", - "\n", - "\n", - "def create_pid_agent(action_dim):\n", - " # default is to create a PD controller on the joints of the reacher robot\n", - " P = np.random.rand(action_dim) * 5\n", - " I = np.zeros(action_dim)\n", - " D = np.random.rand(action_dim)\n", - " \n", - " # sample joint angle targets for the end-affector of the reacher\n", - " target = np.random.rand(action_dim) * 2 - 1\n", - "\n", - " agent = PIDAgent(dim=action_dim, Kp=P, Ki=I, Kd=D, target=target)\n", - " return agent" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Now we can create an agent by just loading information about the action space from the environment!" - ] - }, - { - "cell_type": "code", - "execution_count": 342, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "agent = create_pid_agent(env.action_space.shape[0])" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "The agent determines the dimension of the input for trajectory-based model." - ] - }, - { - "cell_type": "code", - "execution_count": 343, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "param_shape = (len(agent.get_parameters())+1,)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Hydra configurations\n", - "\n", - "MBRL-Lib uses [Hydra](https://github.com/facebookresearch/hydra) to manage configurations. For the purpose of this example, you can think of the configuration object as a dictionary with key/value pairs--and equivalent attributes--that specify the model and algorithmic options. Our toolbox expects the configuration object to be organized as follows:" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "### Trajectory-based model config\n", - "We define the trajectory-based model a little differently than the other examples in this library! You can see we are mapping the parameters in where the actions would normally go in the model. \n", - "Additionally, the `\"propagation_method\"` argument is redundant because we can predict entire trajectories with one forward pass!\n", - "The trajectory-based model tends to like bigger batch sizes than one-step models.\n", - "\n", - "Finally, there are some constants that we keep constant with the one-step model too!" - ] - }, - { - "cell_type": "code", - "execution_count": 344, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "ensemble_size = 5\n", - "num_layers = 3\n", - "hid_size = 200\n", - "deterministic = False\n", - "\n", - "# Everything with \"???\" indicates an option with a missing value.\n", - "# Our utility functions will fill in these details using the \n", - "# environment information\n", - "cfg_dict = {\n", - " # dynamics model configuration\n", - " \"dynamics_model\": {\n", - " \"_target_\": \"mbrl.models.GaussianMLP\",\n", - " \"device\": device,\n", - " \"num_layers\": num_layers,\n", - " \"ensemble_size\": ensemble_size,\n", - " \"hid_size\": hid_size,\n", - " \"in_size\": param_shape[0]+obs_shape[0], # control params, horizon, state_0\n", - " \"out_size\": obs_shape[0], # state time 0+h\n", - " \"deterministic\": deterministic,\n", - " \"propagation_method\": \"random_model\",# NOTE not currently used (predicted in one forward pass, no re-samplign)\n", - " # can also configure activation function for GaussianMLP\n", - " \"activation_fn_cfg\": {\n", - " \"_target_\": \"torch.nn.LeakyReLU\",\n", - " \"negative_slope\": 0.01\n", - " }\n", - " },\n", - " # options for training the dynamics model\n", - " \"algorithm\": {\n", - " \"learned_rewards\": False,\n", - " \"target_is_delta\": False, # trajectory based model predicts states directly\n", - " \"normalize\": True,\n", - " },\n", - " # these are experiment specific options\n", - " \"overrides\": {\n", - " \"trial_length\": trial_length,\n", - " \"num_steps\": num_trials * trial_length,\n", - " \"model_batch_size\": 256, # traj based model uses larger batch sizes\n", - " \"validation_ratio\": 0.1\n", - " }\n", - "}\n", - "cfg = omegaconf.OmegaConf.create(cfg_dict)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "### One-step model config\n", - "We train a one-step model as a baseline against the trajectory-based model!" - ] - }, - { - "cell_type": "code", - "execution_count": 345, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "one_step_config_dict = {\n", - " # dynamics model configuration\n", - " \"dynamics_model\": {\n", - " \"_target_\": \"mbrl.models.GaussianMLP\",\n", - " \"device\": device,\n", - " \"num_layers\": num_layers,\n", - " \"ensemble_size\": ensemble_size,\n", - " \"hid_size\": hid_size,\n", - " \"in_size\": \"???\",\n", - " \"out_size\": \"???\",\n", - " \"deterministic\": deterministic,\n", - "# \"propagation_method\": \"random_model\",\n", - " \"propagation_method\": \"expectation\",\n", - " # can also configure activation function for GaussianMLP\n", - " \"activation_fn_cfg\": {\n", - " \"_target_\": \"torch.nn.LeakyReLU\",\n", - " \"negative_slope\": 0.01\n", - " }\n", - " },\n", - " # options for training the dynamics model\n", - " \"algorithm\": {\n", - " \"learned_rewards\": False,\n", - " \"target_is_delta\": True, \n", - " \"normalize\": True,\n", - " },\n", - " # these are experiment specific options\n", - " \"overrides\": {\n", - " \"trial_length\": trial_length,\n", - " \"num_steps\": num_trials * trial_length,\n", - " \"model_batch_size\": 40,\n", - " \"validation_ratio\": 0.1\n", - " }\n", - "}\n", - "\n", - "one_step_config = omegaconf.OmegaConf.create(one_step_config_dict)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "----" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "# Experimentation" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Creating a dynamics model\n", - "\n", - "Given the configuration above, the following two lines of code create a wrapper for 1-D transition reward models, and a gym-like environment that wraps it, which we can use for simulating the real environment. The 1-D model wrapper takes care of creating input/output data tensors to the underlying NN model (by concatenating observations, actions and rewards appropriately), normalizing the input data to the model, and other data processing tasks (e.g., converting observation targets to deltas with respect to the input observation)." - ] - }, - { - "cell_type": "code", - "execution_count": 346, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/nato/miniconda3/envs/mbrl-py39/lib/python3.9/site-packages/hydra/utils.py:32: UserWarning: `OmegaConf.is_none()` is deprecated, see https://github.com/omry/omegaconf/issues/547\n", - " if OmegaConf.is_none(config):\n" - ] - } - ], - "source": [ - "# Create a 1-D dynamics model for this environment\n", - "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Create replay buffers\n", - "\n", - "We can create a replay buffer for this environment using an configuration a built-in method, where `collect_trajectories` is on for easier plotting of results.\n", - "\n", - "Please note, we will create three replay buffers because our use-case pushes the limits of mbrl-lib. \n", - "1. `replay_buffer_traj_train` is a replay buffer where will put all the sub-trajectories used to train the trajectory-based model,\n", - "2. `replay_buffer_traj_val` is a replay buffer storing trajectories with control parameters, used for plotting only.\n", - "3. `one_step_replay_buffer` is a replay buffer mirroring other examples in this library. We can use it for training and plotting one-step model results." - ] - }, - { - "cell_type": "code", - "execution_count": 347, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "collect_full_trajectories = True\n", - "replay_buffer_traj_train = common_util.create_replay_buffer(cfg, \n", - " obs_shape, \n", - " param_shape, \n", - " rng=np.random.default_rng(seed=0), \n", - " collect_trajectories=False)\n", - "\n", - "replay_buffer_traj_val = common_util.create_replay_buffer(cfg, \n", - " obs_shape, \n", - " param_shape, \n", - " rng=np.random.default_rng(seed=0), \n", - " collect_trajectories=True)\n", - "\n", - "one_step_replay_buffer = common_util.create_replay_buffer(one_step_config, \n", - " obs_shape, \n", - " act_shape, \n", - " rng=np.random.default_rng(seed=0), \n", - " collect_trajectories=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Generate and store data\n", - "We can now populate the replay buffer with random trajectories of a desired length, using a modified function based on `util.rollout_agent_trajectories`. The changes are that the tuples are only added to the buffer at the end of the trajectory to add every sub-trajectory for supervised learning." - ] - }, - { - "cell_type": "code", - "execution_count": 348, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "trial = 0\n", - "while trial < num_trials:\n", - " step = 0\n", - " traj = []\n", - " obs = env.reset()\n", - " \n", - " # create a new agent each trial to get a variety of PID parameters\n", - " agent = create_pid_agent(env.action_space.shape[0])\n", - " agent.reset()\n", - " done = False\n", - " while not done:\n", - " action = agent.act(obs)\n", - " next_obs, reward, done, info = env.step(action)\n", - " \n", - " # ADD ONE-STEP DATA\n", - " one_step_replay_buffer.add(obs, action, next_obs, reward, done)\n", - "\n", - " # use a separate replay buffer for evaluating trajectories later (that can store trajectory info)\n", - " replay_buffer_traj_val.add(obs, \n", - " np.concatenate((agent.get_parameters(), np.array([1,]))),\n", - " next_obs,\n", - " reward,\n", - " done)\n", - "\n", - " \n", - " obs = next_obs\n", - " traj.append((obs, step))\n", - " \n", - " # ADD TRAJ-BASED DATA\n", - " # if not the first step, iterate through memory and append each sub-trajectory\n", - " if len(traj[:-1]) > 0:\n", - " for obs_t, t in traj[:-1]:\n", - " replay_buffer_traj_train.add(obs_t, # obs is state_t\n", - " \n", - " # action is control params + hor\n", - " np.concatenate((agent.get_parameters(), np.array([step-t,]))), \n", - " next_obs, # next state is state_t+hor\n", - " reward, # reward not used\n", - " done # done not used\n", - " )\n", - " step += 1\n", - " \n", - " if trial_length and step % trial_length == 0:\n", - " if collect_full_trajectories and not done:\n", - " replay_buffer_traj_val.close_trajectory()\n", - " one_step_replay_buffer.close_trajectory()\n", - " break\n", - " \n", - " trial += 1 \n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Training the Trajectory Based Model" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Create a basic model trainer for our Gaussian MLP." - ] - }, - { - "cell_type": "code", - "execution_count": 349, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "model_trainer = models.ModelTrainer(dynamics_model, optim_lr=1e-4, weight_decay=5e-5)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Create a training & validation dataset." - ] - }, - { - "cell_type": "code", - "execution_count": 350, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "train_dataset, val_dataset = common_util.get_basic_buffer_iterators(\n", - " replay_buffer_traj_train, \n", - " cfg.overrides.model_batch_size, \n", - " cfg.overrides.validation_ratio, \n", - " ensemble_size=ensemble_size, \n", - " shuffle_each_epoch=True\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Train the model!" - ] - }, - { - "cell_type": "code", - "execution_count": 351, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "train_losses, val_losses = model_trainer.train(train_dataset, val_dataset, num_epochs=50, patience=100)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "# Plotting Results" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Traj-based Model Loss" - ] - }, - { - "cell_type": "code", - "execution_count": 352, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(2, 1, figsize=(16, 8))\n", - "ax[0].plot(train_losses)\n", - "ax[0].set_xlabel(\"epoch\")\n", - "ax[0].set_ylabel(\"train loss (gaussian nll)\")\n", - "ax[1].plot(val_losses)\n", - "ax[1].set_xlabel(\"epoch\")\n", - "ax[1].set_ylabel(\"val loss (mse)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Prediction Accuracy" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Initialize an one-step model" - ] - }, - { - "cell_type": "code", - "execution_count": 353, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "# Create a 1-D dynamics model for this environment\n", - "one_step_model = common_util.create_one_dim_tr_model(one_step_config, obs_shape, act_shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Train the one-step model" - ] - }, - { - "cell_type": "code", - "execution_count": 354, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "one_step_model_trainer = models.ModelTrainer(one_step_model, optim_lr=1e-4, weight_decay=5e-5)\n", - "one_step_train_dataset, one_step_val_dataset = common_util.get_basic_buffer_iterators(\n", - " one_step_replay_buffer, # \n", - " batch_size=cfg.overrides.model_batch_size,\n", - " val_ratio=cfg.overrides.validation_ratio,\n", - " ensemble_size=ensemble_size, \n", - " shuffle_each_epoch=True\n", - ")\n", - "one_step_train_losses, one_step_val_losses = one_step_model_trainer.train(one_step_train_dataset, one_step_val_dataset, \n", - " num_epochs=50, patience=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 355, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(2, 1, figsize=(16, 8))\n", - "ax[0].plot(one_step_train_losses)\n", - "ax[0].set_xlabel(\"epoch\")\n", - "ax[0].set_ylabel(\"train loss (gaussian nll)\")\n", - "ax[1].plot(one_step_val_losses)\n", - "ax[1].set_xlabel(\"epoch\")\n", - "ax[1].set_ylabel(\"val loss (mse)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Sample trajectories for evaluation, predict trajectories, and compute MSE across states (without batching, does not work for ensemble). \n", - "This large block is mostly data handling! First, lets collate the data we need!" - ] - }, - { - "cell_type": "code", - "execution_count": 356, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "num_traj_eval = num_trials\n", - "\n", - "# round trajectories to multiple of ensemble size for batching:\n", - "num_traj = int(ensemble_size * np.floor(num_traj_eval/ensemble_size))\n", - "\n", - "# for storing data\n", - "eval_data_obs = [] # store observations for both prediction (initial state) and evaluation (full trajectory)\n", - "eval_data_act = [] # store plans here (for one-step model)\n", - "eval_traj_param = [] # store control parameters here for traj-based model\n", - "\n", - "# collect trajectories from buffers\n", - "for i in range(num_traj):\n", - " \n", - " # base trajectory for computing accuracy\n", - " traj = one_step_replay_buffer.sample_trajectory()\n", - " traj_with_params = replay_buffer_traj_val.sample_trajectory() # doesn't have actions!\n", - "\n", - " # one-step data\n", - " eval_data_obs.append(traj.obs)\n", - " eval_data_act.append(traj.act)\n", - " \n", - " # traj-based data\n", - " traj_with_params.act[:,-1] = np.arange(0,len(traj_with_params))+1\n", - " eval_traj_param.append(traj_with_params.act)\n", - " \n", - "# create array of state trajectories\n", - "true_states = np.stack(eval_data_obs)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Now we predict with the models! First we can pass the initial states and plans into the one-step model to unroll trajectories. Note that everything is stacked because the ensembles use batching." - ] - }, - { - "cell_type": "code", - "execution_count": 357, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "def no_reward(act: torch.Tensor, next_obs: torch.Tensor) -> torch.Tensor:\n", - " return torch.Tensor(0)\n", - "\n", - "one_step_model_env = models.ModelEnv(env, one_step_model, termination_fns.no_termination, no_reward, generator=generator)\n", - "\n", - "\n", - "### rollout one-step model in batch of trajectories ###\n", - "states, _, _ = common_util.rollout_model_env(one_step_model_env, \n", - " initial_obs=np.stack([o[0] for o in eval_data_obs],axis=0),\n", - " plan=np.stack(eval_data_act, axis=1))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "We don't need a utility to predict with the trajectory-based model, but in that case we need to do some of the data processing that would be handled in the `mbrl.common_utils`." - ] - }, - { - "cell_type": "code", - "execution_count": 358, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "# concatenare initial states with parameters + time index\n", - "obs_stack = np.stack([o[0] for o in eval_data_obs])\n", - "param_stack = np.stack(eval_traj_param)\n", - "\n", - "param_dim = np.shape(param_stack)[-1]\n", - "obs_dim = np.shape(obs_stack)[-1]\n", - "\n", - "# set up batching\n", - "param_expand = param_stack.reshape(-1,param_dim)\n", - "obs_expand = np.repeat(obs_stack[:, np.newaxis, :], trial_length, axis=1).reshape(-1,obs_dim)\n", - "\n", - "# to torch\n", - "x_data = np.concatenate((obs_expand,param_expand), axis=1)\n", - "x_tensor = torch.from_numpy(x_data).float().to(device)\n", - "\n", - "# normalize input data\n", - "x_tensor = dynamics_model.input_normalizer.normalize(x_tensor)\n", - "\n", - "# predict trajectories\n", - "with torch.no_grad():\n", - " states_pred, _ = dynamics_model(x_tensor)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Now let's analyze the data!" - ] - }, - { - "cell_type": "code", - "execution_count": 359, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "# Compute one-step errors\n", - "one_step_pred_states = np.swapaxes(states[:-1].squeeze(),0,1)\n", - "one_step_errors = np.mean((true_states - one_step_pred_states)**2, axis=-1)\n", - "\n", - "# compute trajectory-based errors\n", - "states_pred = states_pred.numpy().reshape(num_traj, trial_length, -1)\n", - "traj_based_errors = np.mean((true_states - states_pred)**2, axis=-1)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Trajectory-based vs One-step\n", - "Here we take the errors and plot them over time!" - ] - }, - { - "cell_type": "code", - "execution_count": 361, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# cumulative_errors_os = np.stack(one_step).squeeze()\n", - "one_step_median = np.median(one_step_errors,axis=0)\n", - "one_step_90 = np.quantile(one_step_errors, .90, axis=0)\n", - "one_step_10 = np.quantile(one_step_errors, .10, axis=0)\n", - "\n", - "# cumulative_errors_tb = np.stack(traj_based).squeeze()\n", - "traj_based_median = np.median(traj_based_errors,axis=0)\n", - "traj_based_90 = np.quantile(traj_based_errors, .90, axis=0)\n", - "traj_based_10 = np.quantile(traj_based_errors, .10, axis=0)\n", - "\n", - "\n", - "colors = ['#1f77b4', # muted blue\n", - " '#ff7f0e', # safety orange\n", - " '#2ca02c', # cooked asparagus green\n", - " '#d62728', # brick red\n", - " ]\n", - "\n", - "fig, ax = plt.subplots(1, 1, figsize=(12, 8))\n", - "ax.plot(one_step_median, label=\"one-step\", c=colors[0])\n", - "ax.plot(traj_based_median, label=\"traj-based\", c=colors[1])\n", - "ax.fill_between(np.arange(len(one_step_median)), one_step_10, one_step_90, color=colors[0], alpha=.33)\n", - "ax.fill_between(np.arange(len(traj_based_median)), traj_based_10, traj_based_90, color=colors[1], alpha=.33)\n", - "ax.set_xlabel(\"Predictive Horizon\")\n", - "ax.set_ylabel(\"Prediction Error (MSE)\")\n", - "ax.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file From bc5fe1f397feae0a0018b0d39073ce0e5d10672d Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Wed, 31 Aug 2022 11:41:14 -0700 Subject: [PATCH 20/24] reset precommit file --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 953a6e18..f3ac7830 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ repos: hooks: - id: black files: 'mbrl' - language_version: python3 + language_version: python3.7 - repo: https://gitlab.com/pycqa/flake8 rev: 3.9.2 From 1e971a880579b3050e1c4e043f5dc3ba67aa3d3f Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Wed, 31 Aug 2022 11:45:20 -0700 Subject: [PATCH 21/24] more permament colab link via githubtocolab.com --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0ddcfbf8..3f90efff 100644 --- a/README.md +++ b/README.md @@ -182,7 +182,7 @@ don't hesitate to raise an issue or submit a pull request! ## Advanced Examples MBRL-Lib can be used for many different research projects in the subject area. We have support for the following projects: -* [Trajectory-based Dynamics Model](https://arxiv.org/abs/2012.09156) Training [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/15lodC9KyzzQCv9hQY3wtAe-yYOdk9vZB?usp=sharing) +* [Trajectory-based Dynamics Model](https://arxiv.org/abs/2012.09156) Training [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/natolambert/mbrl-lib-dev/blob/main/notebooks/traj_based_model.ipynb) ## Documentation Please check out our **[documentation](https://facebookresearch.github.io/mbrl-lib/)** From 9ac08b7c204acb8614d9077edaea88164d12f0b1 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Thu, 8 Sep 2022 17:24:38 -0600 Subject: [PATCH 22/24] run precommits --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index f3ac7830..953a6e18 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ repos: hooks: - id: black files: 'mbrl' - language_version: python3.7 + language_version: python3 - repo: https://gitlab.com/pycqa/flake8 rev: 3.9.2 From fe672babdac81f047d35cfd01a20500dab586d18 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Thu, 8 Sep 2022 17:27:22 -0600 Subject: [PATCH 23/24] fix line length --- mbrl/planning/linear_feedback.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/mbrl/planning/linear_feedback.py b/mbrl/planning/linear_feedback.py index a7b2ce85..c071955c 100644 --- a/mbrl/planning/linear_feedback.py +++ b/mbrl/planning/linear_feedback.py @@ -60,12 +60,13 @@ def __init__( def act(self, obs: np.ndarray, **_kwargs) -> np.ndarray: """Issues an action given an observation. - This method optimizes a given observation or batch of observations for a one-step action choice. + This method optimizes a given observation or batch of observations for a + one-step action choice. Args: - obs (np.ndarray): the observation for which the action is needed either N x 1 or N x B, where N is the - state dim and B is the batch size. + obs (np.ndarray): the observation for which the action is needed either N x 1 or N x B, + where N is the state dim and B is the batch size. Returns: (np.ndarray): the action outputted from the PID, either shape n_dof x 1 or n_dof x B. From 6a5bd9dfca4171ba9fb131a686f6b6b1da4ffa38 Mon Sep 17 00:00:00 2001 From: Nathan Lambert Date: Thu, 8 Sep 2022 17:27:45 -0600 Subject: [PATCH 24/24] reset precommits --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 953a6e18..f3ac7830 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ repos: hooks: - id: black files: 'mbrl' - language_version: python3 + language_version: python3.7 - repo: https://gitlab.com/pycqa/flake8 rev: 3.9.2