diff --git a/.gitignore b/.gitignore
index 534a3a27..7b35a78b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,4 +2,9 @@ __pycache__/
 data/
 report.html
 models/tinyphysics_*.onnx
-*.swp
+venv/
+comma_steer_command/
+PPO_control/checkpoints
+PPO_control/results
+PPO_control/training_logs
+*.swp
\ No newline at end of file
diff --git a/PPO_control/ActorCritic.py b/PPO_control/ActorCritic.py
new file mode 100644
index 00000000..ae330e7a
--- /dev/null
+++ b/PPO_control/ActorCritic.py
@@ -0,0 +1,109 @@
+import logging
+from typing import Tuple, List, Union
+
+import torch
+import torch.nn as nn
+from torch.distributions import Normal
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+class ActorCritic(nn.Module):
+    def __init__(self, obs_dim: int, obs_seq_len: int, target_dim: int, action_dim: int, has_continuous_action: bool, action_scale: float=1):
+        super().__init__()
+        self.obs_dim = obs_dim
+        self.obs_seq_len = obs_seq_len
+        self.target_dim = target_dim
+        self.action_dim = action_dim
+        self.has_continuous_action = has_continuous_action
+        self.action_scale = action_scale
+        self.rng = np.random.default_rng()
+
+        self.feature_lstm = nn.LSTM(input_size=self.obs_dim, hidden_size=16, num_layers=2, batch_first=True)
+
+        if self.has_continuous_action:
+            self.actor = nn.Sequential(
+                nn.Linear(16 + self.target_dim, 128),
+                nn.Tanh(),
+                nn.Linear(128, 128),
+                nn.Tanh(),
+                nn.Linear(128, 128),
+                nn.Tanh(),
+                nn.Linear(128, self.action_dim),
+                nn.Tanh()
+            )
+            self.log_std = nn.Parameter(torch.zeros((self.action_dim), dtype=torch.float32))
+        else:
+            self.actor = nn.Sequential(
+                nn.Linear(16 + self.target_dim, 128),
+                nn.Tanh(),
+                nn.Linear(128, 128),
+                nn.Tanh(),
+                nn.Linear(128, 128),
+                nn.Tanh(),
+                nn.Linear(128, self.action_dim),
+                nn.Softmax(dim=-1)
+            )
+
+        self.critic = nn.Sequential(
+            nn.Linear(16 + self.target_dim, 128),
+            nn.Tanh(),
+            nn.Linear(128, 128),
+            nn.Tanh(),
+            nn.Linear(128, 128),
+            nn.Tanh(),
+            nn.Linear(128, 1)
+        )
+
+        # Init all hidden layer weight to orthogonal weight with scale sqrt(2), bias to 2
+        # Init value output layer weight with scale 1, policy output layer with scale 0.01
+        for param in self.named_parameters():
+            if param[0].endswith('weight'):
+                if param[0].startswith('feature_lstm'):
+                    nn.init.orthogonal_(param[1], gain=1)
+                else:
+                    nn.init.orthogonal_(param[1], gain=np.sqrt(2))
+            elif param[0].endswith('bias'):
+                nn.init.zeros_(param[1])
+        nn.init.orthogonal_(list(self.critic.parameters())[-2], gain=1)
+        nn.init.orthogonal_(list(self.actor.parameters())[-2], gain=0.01)
+
+    def forward(self, past_obs, target):
+        condition, _ = self.feature_lstm(past_obs)
+        condition = condition[:, -1]
+        x = torch.hstack([condition, target])
+        action_logit = self.actor(x)
+        value = self.critic(x)
+
+        if self.has_continuous_action:
+            return Normal(action_logit.flatten(), torch.exp(self.log_std)), value
+        else:
+            return action_logit, value
+
+    def act(self, past_obs: torch.Tensor, target: torch.Tensor, eval: bool=False) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        with torch.no_grad():
+            self.eval()
+            action_logit, value = self.forward(past_obs, target)
+        
+            if self.has_continuous_action:
+                # Continuous case
+                if eval:
+                    action = action_logit.mean
+                    action_prob = torch.exp(action_logit.log_prob(action)).cpu().numpy()
+                    action = action.cpu().numpy() * self.action_scale
+                else:
+                    action = action_logit.sample()
+                    action_prob = torch.exp(action_logit.log_prob(action)).cpu().numpy()
+                    action = action.cpu().numpy() * self.action_scale
+            else:
+                # Discrete case
+                action_logit = action_logit.cpu().numpy()
+                if eval:
+                    action = action_logit.argmax(axis=1)
+                    action_prob = action_logit[np.arange(len(action)), action]
+                else:
+                    action = (action_logit.cumsum(axis=1) > self.rng.random(action_logit.shape[0])[:, np.newaxis]).argmax(axis=1) # Inverse transform sampling
+                    action_prob = action_logit[np.arange(len(action)), action]
+            
+        return action, action_prob, value.flatten().cpu().numpy()
+
diff --git a/PPO_control/ExperienceBuffer.py b/PPO_control/ExperienceBuffer.py
new file mode 100644
index 00000000..e2a9c424
--- /dev/null
+++ b/PPO_control/ExperienceBuffer.py
@@ -0,0 +1,70 @@
+import logging
+from typing import Union, List, Tuple
+
+import torch
+from torch.utils.data import Dataset
+import numpy as np
+
+from PPO_Loss import calculate_value_target_vec, generalized_advantage_estimation_vec
+
+logger = logging.getLogger(__name__)
+
+class PPOExperienceBuffer(Dataset):
+    def __init__(self, discount_factor: float=0.99, td_decay: float=0.9) -> None:
+        super().__init__()
+        self.actions = []
+        self.observations = []
+        self.targets = []
+        self.samples = torch.zeros((0, 4))
+        self.discount_factor = discount_factor
+        self.td_decay = td_decay
+    
+    def __len__(self) -> int:
+        return self.samples.shape[0]
+    
+    def __getitem__(self, idx) -> Tuple[Union[int, float], torch.Tensor, torch.Tensor, torch.Tensor]:
+        return self.actions[idx], self.observations[idx], self.targets[idx], self.samples[idx]
+
+    def batch_add_trajectory(self, observation: torch.Tensor, target: torch.Tensor, action: torch.Tensor, action_p: torch.Tensor, reward: torch.Tensor, value_estimate: torch.Tensor) -> None:
+        """
+        Add a batch of trajectories to the buffer.
+
+        Args:
+            observation (batch_size, episode_len): Batch observation at each time step
+            target (batch_size, episode_len): Batch target at each time step
+            action (batch_size, episode_len): Batch actions taken during the episode.
+            action_p (batch_size, episode_len): Batch action probabilities corresponding to each action.
+            reward (batch_size, episode_len): Batch rewards received for each step.
+            value_estimate (batch_size, episode_len+1): Batch value estimates, including the estimate for the final state.
+
+        Raises:
+            ValueError: If input lengths are inconsistent with the episode length.
+
+        Note:
+            The length of value_estimate should be one more than the other inputs to include the final state estimate.
+        """
+        
+        episode_len = action.shape[1]
+
+        if action_p.shape[1] != episode_len:
+            raise ValueError(f'action_p length mismatch. episode length: {episode_len}, action_p length: {action_p.shape[1]}')
+        if reward.shape[1] != episode_len:
+            raise ValueError(f'reward length mismatch. episode length: {episode_len}, reward length: {reward.shape[1]}')
+        if value_estimate.shape[1] != episode_len + 1:
+            raise ValueError(f'value_estimate length mismatch. expected length: {episode_len + 1}, actual length: {len(value_estimate)}')
+        
+        self.actions += action.flatten().tolist()
+        self.observations += [x for x in observation.flatten(0, 1)]
+        self.targets += [x for x in target.flatten(0, 1)]
+
+        value_target = calculate_value_target_vec(reward, value_estimate, self.discount_factor)
+        gae = generalized_advantage_estimation_vec(reward, value_estimate, self.discount_factor, self.td_decay)
+        
+        batch_trajectory = torch.cat([action_p.unsqueeze(2), value_estimate[:, :-1].unsqueeze(2), value_target.unsqueeze(2), gae.unsqueeze(2)], dim=2)
+        self.samples = torch.vstack([self.samples, batch_trajectory.flatten(0, 1)])
+
+    def reset(self):
+        self.actions = []
+        self.observations = []
+        self.targets = []
+        self.samples = torch.zeros((0, 4))
\ No newline at end of file
diff --git a/PPO_control/PPO_Loss.py b/PPO_control/PPO_Loss.py
new file mode 100644
index 00000000..684e70a8
--- /dev/null
+++ b/PPO_control/PPO_Loss.py
@@ -0,0 +1,92 @@
+from typing import Tuple
+
+import torch
+
+def actor_loss(action_p: torch.Tensor, action_p_old: torch.Tensor, advantage: torch.Tensor, clip_eps: float) -> torch.Tensor:
+    eps = 1e-8
+    r = action_p / (action_p_old + eps)
+    L_clip = torch.mean(torch.min(r * advantage, torch.clip(r, 1 - clip_eps, 1 + clip_eps) * advantage))
+    return -L_clip
+
+def value_loss(value: torch.Tensor, value_target: torch.Tensor) -> torch.Tensor:
+    L_value = torch.mean((value - value_target) ** 2)
+    return L_value
+
+def generalized_advantage_estimation(reward: torch.Tensor, value: torch.Tensor, discount_factor: float, decay: float) -> torch.Tensor:
+    '''
+    reward: batched rewards for each time step (batch_size, T)
+    value: batched value estimation for each time step plus last state (batch_size, T+1)
+    '''
+    eps = 1e-8
+
+    advantage = torch.zeros_like(reward)
+    last_adv = 0
+    for t in reversed(range(reward.shape[1])):
+        delta = reward[:, t] + discount_factor * value[:, t + 1] - value[:, t]
+        advantage[:, t] = delta + discount_factor * decay * last_adv
+        last_adv = advantage[:, t]
+    
+    # Normalize across batch
+    advantage = (advantage - advantage.mean()) / (advantage.std() + eps)
+
+    return advantage
+
+def calculate_value_target(reward: torch.Tensor, value: torch.Tensor, discount_factor: float) -> torch.Tensor:
+    '''
+    reward: batched rewards for each time step (batch_size, T)
+    value: batched value estimation for each time step plus last state (batch_size, T+1)
+    '''
+    eps = 1e-8
+
+    v_target = torch.zeros_like(reward)
+    last_reward = value[:, -1]
+    for t in reversed(range(reward.shape[1])):
+        v_target[:, t] = reward[:, t] + discount_factor * last_reward
+        last_reward = v_target[:, t]
+
+    v_target = (v_target - v_target.mean()) / (v_target.std() + eps)
+
+    return v_target
+
+def calculate_value_target_vec(reward: torch.Tensor, value: torch.Tensor, discount_factor: float) -> torch.Tensor:
+    '''
+    reward: batched rewards for each time step (batch_size, T)
+    value: batched value estimation for each time step plus last state (batch_size, T+1)
+    '''
+    T = reward.shape[1]
+    eps = 1e-8
+
+    # Calculate discounted sum of rewards
+    discount_factors = discount_factor ** torch.arange(T, dtype=torch.float32, device=reward.device)
+    future_discounted_rewards = torch.cumsum((reward * discount_factors.unsqueeze(0)).flip(1), dim=1).flip(1)
+    v_target = future_discounted_rewards / discount_factors
+
+    # Add the discounted final value estimate
+    v_target = v_target + torch.outer(value[:, -1], (discount_factor * discount_factors).flip(0))
+
+    v_target = (v_target - v_target.mean()) / (v_target.std() + eps)
+    
+    return v_target
+
+def generalized_advantage_estimation_vec(reward: torch.Tensor, value: torch.Tensor, discount_factor: float, decay: float) -> torch.Tensor:
+    '''
+    reward: batched rewards for each time step (batch_size, T)
+    value: batched value estimation for each time step plus last state (batch_size, T+1)
+    '''
+    T = reward.shape[1]
+    eps = 1e-8
+    
+    # Calculate delta
+    delta = reward + discount_factor * value[:, 1:] - value[:, :-1]
+    
+    # Calculate discount factors
+    discount_factors = (discount_factor * decay) ** torch.arange(T, dtype=torch.float32, device=reward.device)
+    
+    # Calculate advantages
+    advantage = torch.cumsum((delta * discount_factors.unsqueeze(0)).flip(1), dim=1).flip(1)
+    advantage = advantage / discount_factors.unsqueeze(0)
+
+    # Normalize across batch
+    advantage = (advantage - advantage.mean()) / (advantage.std() + eps)
+    
+    return advantage
\ No newline at end of file
diff --git a/PPO_control/experiment.ipynb b/PPO_control/experiment.ipynb
new file mode 100644
index 00000000..3e484d99
--- /dev/null
+++ b/PPO_control/experiment.ipynb
@@ -0,0 +1,442 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import os\n",
+    "from typing import Tuple, Callable, List\n",
+    "from pathlib import Path\n",
+    "import random\n",
+    "from functools import partial\n",
+    "sys.path.insert(1, os.path.abspath('..') )\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "from torch.utils.data import DataLoader\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from PPO_Loss import *\n",
+    "from ActorCritic import ActorCritic\n",
+    "from ExperienceBuffer import PPOExperienceBuffer\n",
+    "from controllers import ppo\n",
+    "from tinyphysics_sim import TinyPhysicsModel, TinyPhysicsSimulator, CONTROL_START_IDX\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Simulator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def episode_rollout(model: TinyPhysicsModel, data_paths: List[str], buffer: PPOExperienceBuffer, policy_model: ActorCritic, n_episode: int, episode_len: int, path_boundary: float, device: torch.device):\n",
+    "    files = random.sample(data_paths, n_episode)\n",
+    "    controller = ppo.Controller(policy_model, device)\n",
+    "    sim = TinyPhysicsSimulator(model, [pd.read_csv(f) for f in files], controller=controller, episode_len=episode_len + 1)\n",
+    "    lat_cost, jerk_cost, total_cost = sim.rollout()\n",
+    "\n",
+    "    # Calculate rewards\n",
+    "    deviation = np.abs(sim.target_lataccel_histories[:, CONTROL_START_IDX:] - sim.current_lataccel_histories[:, CONTROL_START_IDX:])\n",
+    "    rewards = 1 - deviation / path_boundary\n",
+    "    rewards[rewards < 0] = -1\n",
+    "    rewards = torch.from_numpy(rewards)\n",
+    "    if rewards.shape[1] != episode_len + 1:\n",
+    "        print(f\"reward length doesn't match episode_len+1: rewards len:{len(rewards)}, episode_len+1:{episode_len+1}\") \n",
+    "        return\n",
+    "\n",
+    "    buffer.reset()\n",
+    "    \n",
+    "    # Leave the value of last step for future reward estimation\n",
+    "    # Convert from list of episode_length of batch history to tensor of (batchsize, episode_len, ...)\n",
+    "    observation_history = torch.cat([x[:, None] for x in controller.observation_history[-episode_len-1: -1]], dim=1)\n",
+    "    target_history = torch.cat([x[:, None] for x in controller.target_history[-episode_len-1: -1]], dim=1)\n",
+    "    action_history = torch.column_stack(controller.action_history[-episode_len-1: -1])\n",
+    "    action_prob_history = torch.cat([x[:, None] for x in controller.action_prob_history[-episode_len-1: -1]], dim=1)\n",
+    "    value_history = torch.column_stack(controller.value_history[-episode_len-1:])\n",
+    "\n",
+    "    buffer.batch_add_trajectory(observation_history,\n",
+    "                                target_history,\n",
+    "                                action_history,\n",
+    "                                action_prob_history,\n",
+    "                                rewards[:, :-1],\n",
+    "                                value_history)\n",
+    "\n",
+    "    return buffer, rewards, lat_cost, jerk_cost, total_cost"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Training loop"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train(policy_model: ActorCritic, optimizer: optim.Optimizer, run_rollout: Callable, episode_len: int, path_boundary: float, n_steps: int, n_episode: int, n_epoch: int, batch_size: int, clip_eps: float, c1: float, c2: float, device: torch.device):\n",
+    "    reward_history = []\n",
+    "    lat_cost_history = []\n",
+    "    jerk_cost_history = []\n",
+    "\n",
+    "    total_loss_history = []\n",
+    "    actor_obj_history = []\n",
+    "    critic_loss_history = []\n",
+    "    entropy_obj_history = []\n",
+    "\n",
+    "    for i_step in range(n_steps):\n",
+    "        # Run simulation\n",
+    "        buffer, rewards, lat_cost, jerk_cost, total_cost = run_rollout(policy_model, n_episode, episode_len, path_boundary, device)\n",
+    "        print(f'Training step {i_step:>3}: average_reward: {rewards.mean(): .4f}, lat_cost: {lat_cost: .2f}, jerk_cost: {jerk_cost: .2f}')\n",
+    "        # Record policy's performance at each step\n",
+    "        reward_history.append(rewards.mean().item())\n",
+    "        lat_cost_history.append(lat_cost)\n",
+    "        jerk_cost_history.append(jerk_cost)\n",
+    "\n",
+    "        # Start training loops\n",
+    "        data_loader = DataLoader(buffer, batch_size=batch_size, shuffle=True, num_workers=16, pin_memory=True)\n",
+    "        policy_model.train()\n",
+    "        for i_epoch in range(n_epoch):\n",
+    "            print(f'Training step {i_step:>3}, epoch {i_epoch:>3}:', end='')\n",
+    "\n",
+    "            epoch_total_loss_history = []\n",
+    "            epoch_actor_obj_history = []\n",
+    "            epoch_critic_loss_history = []\n",
+    "            epoch_entropy_obj_history = []\n",
+    "\n",
+    "            for i_batch, data in enumerate(data_loader):\n",
+    "                actions, observations, targets, transitions = data\n",
+    "                actions = actions.type(torch.int)\n",
+    "                observations = observations.to(device)\n",
+    "                targets = targets.to(device)\n",
+    "                transitions = transitions.to(device)\n",
+    "\n",
+    "                optimizer.zero_grad()\n",
+    "\n",
+    "                action_prob_new, value_estimates = policy_model(observations, targets)\n",
+    "                action_prob_new = action_prob_new[torch.arange(actions.shape[0]), actions]\n",
+    "                value_estimates = value_estimates.flatten()\n",
+    "\n",
+    "                loss, actor_obj, critic_loss, entropy_obj = ppo_loss(action_prob_new, transitions[:, 0], transitions[:, 3], value_estimates, transitions[:, 2], clip_eps, c1, c2)\n",
+    "                loss.backward()\n",
+    "                optimizer.step()\n",
+    "\n",
+    "                epoch_total_loss_history.append(loss.item())\n",
+    "                epoch_actor_obj_history.append(actor_obj)\n",
+    "                epoch_critic_loss_history.append(critic_loss)\n",
+    "                epoch_entropy_obj_history.append(entropy_obj)\n",
+    "\n",
+    "            total_loss_history.append(np.mean(epoch_total_loss_history))\n",
+    "            actor_obj_history.append(np.mean(epoch_actor_obj_history))\n",
+    "            critic_loss_history.append(np.mean(epoch_critic_loss_history))\n",
+    "            entropy_obj_history.append(np.mean(epoch_entropy_obj_history))\n",
+    "\n",
+    "            print(f' total_loss: {total_loss_history[-1]: 0.3f}, actor_obj: {actor_obj_history[-1]: 0.3f}, critic_loss: {critic_loss_history[-1]: 0.3f}, entropy_obj: {entropy_obj_history[-1]: 0.3f}')\n",
+    "        \n",
+    "        if i_step % 10 == 9:\n",
+    "            torch.save({\n",
+    "                'step': i_step,\n",
+    "                'model_state_dict': policy_model.state_dict(),\n",
+    "                'optimizer_state_dict': optimizer.state_dict(),\n",
+    "                'reward_history': reward_history,\n",
+    "                'lat_cost_history': lat_cost_history,\n",
+    "                'jerk_cost_history': jerk_cost_history,\n",
+    "                'total_loss_history': total_loss_history,\n",
+    "                'actor_obj_history': actor_obj_history,\n",
+    "                'critic_loss_history': critic_loss_history,\n",
+    "                'entropy_obj_history': entropy_obj_history\n",
+    "            }, f'./checkpoints/exp1_step{i_step + 1}.pt')\n",
+    "\n",
+    "    return reward_history, lat_cost_history, jerk_cost_history, total_loss_history, actor_obj_history, critic_loss_history, entropy_obj_history"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Setup and hyperparameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = torch.device('cuda')\n",
+    "tinyphysicsmodel = TinyPhysicsModel('../models/tinyphysics.onnx', debug=False)\n",
+    "policy_model = ActorCritic(obs_dim=3, obs_seq_len=10, target_dim=21, action_dim=ppo.ACTION_DIM, has_continuous_action=False).to(device)\n",
+    "data = Path('../data/')\n",
+    "data_paths = sorted(data.iterdir())[5000:]\n",
+    "data_paths = [str(x) for x in data_paths]\n",
+    "experience_buffer = PPOExperienceBuffer(discount_factor=0.94, td_decay=0.85)\n",
+    "\n",
+    "n_episode = 256\n",
+    "episode_len = 300\n",
+    "path_boundary = 0.07\n",
+    "\n",
+    "optimizer = optim.Adam(policy_model.parameters(), lr=1.5e-4, eps=1e-6)\n",
+    "\n",
+    "batch_size = 1024\n",
+    "n_epoch = 3\n",
+    "n_step = 10\n",
+    "\n",
+    "c1 = 0.5\n",
+    "c2 = 0.01\n",
+    "clip_eps = 0.1\n",
+    "\n",
+    "sim_rollout = partial(episode_rollout, tinyphysicsmodel, data_paths, experience_buffer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_3369320/874236792.py:8: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+      "  policy_params = torch.load('checkpoints/exp0828-2_step1090.pt')['model_state_dict']\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = Path('../data/')\n",
+    "data_paths = sorted(data.iterdir())[:1000]\n",
+    "data_paths = [str(x) for x in data_paths]\n",
+    "dfs = [pd.read_csv(f) for f in data_paths]\n",
+    "device = torch.device('cuda')\n",
+    "tinyphysicsmodel = TinyPhysicsModel('../models/tinyphysics.onnx', debug=False)\n",
+    "policy_model = ActorCritic(obs_dim=4, obs_seq_len=20, target_dim=31, action_dim=1, has_continuous_action=True, action_scale=2).to(device)\n",
+    "policy_params = torch.load('checkpoints/exp0828-2_step1090.pt')['model_state_dict']\n",
+    "policy_model.load_state_dict(policy_params)\n",
+    "controller = ppo.Controller(policy_model, device, eval=True)\n",
+    "sim = TinyPhysicsSimulator(tinyphysicsmodel, dfs, controller=controller, episode_len=400)\n",
+    "lat_cost, jerk_cost, total_cost = sim.rollout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "217.37058447021087"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "total_cost"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 130,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_3369320/2625233957.py:6: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+      "  policy_params = torch.load('checkpoints/exp0828-2_step1220.pt')['model_state_dict']\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = pd.read_csv('../data/00000.csv')\n",
+    "df2 = pd.read_csv('../data/01923.csv')\n",
+    "device = torch.device('cuda')\n",
+    "tinyphysicsmodel = TinyPhysicsModel('../models/tinyphysics.onnx', debug=False)\n",
+    "policy_model = ActorCritic(obs_dim=4, obs_seq_len=20, target_dim=31, action_dim=1, has_continuous_action=True, action_scale=2).to(device)\n",
+    "policy_params = torch.load('checkpoints/exp0828-2_step1220.pt')['model_state_dict']\n",
+    "policy_model.load_state_dict(policy_params)\n",
+    "controller = ppo.Controller(policy_model, device, eval=True)\n",
+    "sim = TinyPhysicsSimulator(tinyphysicsmodel, [df, df2], controller=controller, episode_len=400)\n",
+    "lat_cost, jerk_cost, total_cost = sim.rollout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 131,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "feature_lstm = policy_model.feature_lstm\n",
+    "obs1 = [x[0][None, :] for x in controller.observation_history]\n",
+    "obs2 = [x[1][None, :] for x in controller.observation_history]\n",
+    "past_obs1 = torch.vstack(obs1[20:400]).to(device)\n",
+    "past_obs2 = torch.vstack(obs2[20:400]).to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 134,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with torch.no_grad():\n",
+    "    feature1 = feature_lstm(past_obs1)[0][:, -1]\n",
+    "    feature2 = feature_lstm(past_obs2)[0][:, -1]\n",
+    "\n",
+    "    diffs1 = torch.sqrt_(((feature1[20:] - feature1[:-20]) ** 2).sum(dim=-1)).cpu().numpy()\n",
+    "    diffs2 = torch.sqrt_(((feature2[20:] - feature2[:-20]) ** 2).sum(dim=-1)).cpu().numpy()\n",
+    "    diffsx = torch.sqrt_(((feature2[20:] - feature1[:-20]) ** 2).sum(dim=-1)).cpu().numpy()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 135,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7fa420470fd0>]"
+      ]
+     },
+     "execution_count": 135,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(diffs1, '.')\n",
+    "plt.plot(diffs2, '.')\n",
+    "plt.plot(diffsx, '.')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 136,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(10, 5))\n",
+    "ax.plot(sim.target_lataccel_histories.flatten(), label=\"Target Lateral Acceleration\", alpha=0.5)\n",
+    "ax.plot(sim.current_lataccel_histories.flatten(), label=\"Actual Lateral Acceleration\", alpha=0.5)\n",
+    "ax.plot(sim.action_histories.flatten(), label=\"Action\", alpha=0.5)\n",
+    "# ax.plot([x[2] for x in sim.state_history], label=\"aEgo\", alpha=0.5)\n",
+    "\n",
+    "ax.legend()\n",
+    "ax.set_xlabel(\"Step\")\n",
+    "ax.set_ylabel(\"Lateral Acceleration\")\n",
+    "ax.set_title(\"Rollout\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 137,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "85.89306009010713"
+      ]
+     },
+     "execution_count": 137,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "total_cost"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.get_future_plan(392).shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.save('results/result1.npy', np.array(result, dtype=object), allow_pickle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.load('results/result1.npy', allow_pickle=True)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/PPO_control/hyperparamenters/config0827-1.json b/PPO_control/hyperparamenters/config0827-1.json
new file mode 100644
index 00000000..0ff5ac2f
--- /dev/null
+++ b/PPO_control/hyperparamenters/config0827-1.json
@@ -0,0 +1,15 @@
+{
+    "model_id": "0827-1",
+    "n_episode": 512,
+    "episode_len": 40,
+    "path_boundary": 0.15,
+    "lr": 2E-4,
+    "batch_size": 384,
+    "n_epoch": 3,
+    "n_step": 50000,
+    "c1": 0.5,
+    "c2": 0.01,
+    "clip_eps": 0.2,
+    "discount_factor": 0.93,
+    "td_decay": 0.85
+}
\ No newline at end of file
diff --git a/PPO_control/hyperparamenters/config0827-2.json b/PPO_control/hyperparamenters/config0827-2.json
new file mode 100644
index 00000000..74c87448
--- /dev/null
+++ b/PPO_control/hyperparamenters/config0827-2.json
@@ -0,0 +1,15 @@
+{
+    "model_id": "0827-2",
+    "n_episode": 512,
+    "episode_len": 60,
+    "path_boundary": 0.1,
+    "lr": 2.5E-4,
+    "batch_size": 384,
+    "n_epoch": 4,
+    "n_step": 50000,
+    "c1": 0.5,
+    "c2": 0.001,
+    "clip_eps": 0.2,
+    "discount_factor": 0.91,
+    "td_decay": 0.85
+}
\ No newline at end of file
diff --git a/PPO_control/hyperparamenters/config0828-1.json b/PPO_control/hyperparamenters/config0828-1.json
new file mode 100644
index 00000000..15fab0f9
--- /dev/null
+++ b/PPO_control/hyperparamenters/config0828-1.json
@@ -0,0 +1,14 @@
+{
+    "model_id": "0828-1",
+    "n_episode": 256,
+    "episode_len": 80,
+    "path_boundary": 0.15,
+    "a_lr": 3E-4,
+    "c_lr": 1E-3,
+    "batch_size": 512,
+    "n_epoch": 3,
+    "n_step": 10000,
+    "clip_eps": 0.2,
+    "discount_factor": 0.95,
+    "td_decay": 0.90
+}
\ No newline at end of file
diff --git a/PPO_control/hyperparamenters/config0828-2.json b/PPO_control/hyperparamenters/config0828-2.json
new file mode 100644
index 00000000..ce2179eb
--- /dev/null
+++ b/PPO_control/hyperparamenters/config0828-2.json
@@ -0,0 +1,15 @@
+{
+    "model_id": "0828-2",
+    "n_episode": 512,
+    "episode_len": 80,
+    "path_boundary": 0.15,
+    "a_lr": 3E-4,
+    "c_lr": 1E-3,
+    "batch_size": 1024,
+    "n_epoch": 4,
+    "n_step": 10000,
+    "clip_eps": 0.15,
+    "discount_factor": 0.95,
+    "td_decay": 0.9,
+    "start_logstd": -3
+}
\ No newline at end of file
diff --git a/PPO_control/profile_sim.out b/PPO_control/profile_sim.out
new file mode 100644
index 00000000..f32abcb3
Binary files /dev/null and b/PPO_control/profile_sim.out differ
diff --git a/PPO_control/sim_profile.py b/PPO_control/sim_profile.py
new file mode 100644
index 00000000..768dc509
--- /dev/null
+++ b/PPO_control/sim_profile.py
@@ -0,0 +1,85 @@
+import sys
+import os
+from typing import Tuple, Callable, List
+from pathlib import Path
+import random
+from functools import partial
+sys.path.insert(1, os.path.abspath('..') )
+
+import pandas as pd
+import torch
+import numpy as np
+
+from PPO_Loss import *
+from ActorCritic import ActorCritic
+from ExperienceBuffer import PPOExperienceBuffer
+from controllers import ppo
+from tinyphysics_sim import TinyPhysicsModel, TinyPhysicsSimulator, CONTROL_START_IDX
+
+def find_shortest_path(files):
+    lengths = [pd.read_csv(f).shape[0] for f in files]
+    shortest_idx = np.argmin(lengths)
+    return files[shortest_idx], lengths[shortest_idx]
+
+def episode_rollout(model: TinyPhysicsModel, data_paths: List[str], buffer: PPOExperienceBuffer, policy_model: ActorCritic, n_episode: int, episode_len: int, path_boundary: float, device: torch.device):
+    files = random.sample(data_paths, n_episode)
+    controller = ppo.Controller(policy_model, device)
+
+    # Prevent short paths
+    while True:
+        try:
+            sim = TinyPhysicsSimulator(model, files, controller=controller, episode_len=episode_len + 1)
+        except ValueError:
+            shortest_file, shortest_length = find_shortest_path(files)
+            print(f'Error: The requested array has an inhomogeneous shape after 1 dimensions. Shortest file: {shortest_file}, len: {shortest_length}')
+            files = random.sample(data_paths, n_episode)
+        else:
+            break
+
+    lat_cost, jerk_cost, total_cost = sim.rollout()
+
+    # Calculate rewards
+    deviation = np.abs(sim.target_lataccel_histories[:, CONTROL_START_IDX:] - sim.current_lataccel_histories[:, CONTROL_START_IDX:])
+    rewards = 1 - deviation / path_boundary
+    rewards[rewards < 0] = -1
+    rewards = torch.from_numpy(rewards)
+    if rewards.shape[1] != episode_len + 1:
+        print(f"reward length doesn't match episode_len+1: rewards len:{len(rewards)}, episode_len+1:{episode_len+1}") 
+        return
+
+    buffer.reset()
+    
+    # Leave the value of last step for future reward estimation
+    # Convert from list of episode_length of batch history to tensor of (batchsize, episode_len, ...)
+    observation_history = torch.cat([x[:, None] for x in controller.observation_history[-episode_len-1: -1]], dim=1)
+    target_history = torch.cat([x[:, None] for x in controller.target_history[-episode_len-1: -1]], dim=1)
+    action_history = torch.column_stack(controller.action_history[-episode_len-1: -1])
+    action_prob_history = torch.cat([x[:, None] for x in controller.action_prob_history[-episode_len-1: -1]], dim=1)
+    value_history = torch.column_stack(controller.value_history[-episode_len-1:])
+
+    buffer.batch_add_trajectory(observation_history,
+                                target_history,
+                                action_history,
+                                action_prob_history,
+                                rewards[:, :-1],
+                                value_history)
+
+    return buffer, rewards, lat_cost, jerk_cost, total_cost
+
+if __name__ == '__main__':
+    device = torch.device('cuda')
+    tinyphysicsmodel = TinyPhysicsModel('../models/tinyphysics.onnx', debug=False)
+    policy_model = ActorCritic(obs_dim=5, obs_seq_len=10, target_dim=4, action_dim=ppo.ACTION_DIM, has_continuous_action=False).to(device)
+    data = Path('../data/')
+    data_paths = sorted(data.iterdir())[5000:]
+    data_paths = [str(x) for x in data_paths]
+    experience_buffer = PPOExperienceBuffer(discount_factor=0.95, td_decay=0.85)
+
+    # Run simulation
+    n_episode = 384
+    episode_len = 400
+    path_boundary = 0.07
+    sim_rollout = partial(episode_rollout, tinyphysicsmodel, data_paths, experience_buffer)
+
+    buffer, rewards, lat_cost, jerk_cost, total_cost = sim_rollout(policy_model, n_episode, episode_len, path_boundary, device)
+    print(f'average_reward: {rewards.mean(): .4f}, lat_cost: {lat_cost: .2f}, jerk_cost: {jerk_cost: .2f}')
\ No newline at end of file
diff --git a/PPO_control/tinyphysics_sim.py b/PPO_control/tinyphysics_sim.py
new file mode 100644
index 00000000..3f2ef490
--- /dev/null
+++ b/PPO_control/tinyphysics_sim.py
@@ -0,0 +1,191 @@
+import importlib
+import numpy as np
+import onnxruntime as ort
+import pandas as pd
+
+from collections import namedtuple
+from pathlib import Path
+from typing import List, Union, Tuple, Dict, Callable
+from tqdm import tqdm
+import random
+
+from controllers import BaseController
+
+
+ACC_G = 9.81
+FPS = 10
+CONTROL_START_IDX = 100
+COST_END_IDX = 500
+CONTEXT_LENGTH = 20
+VOCAB_SIZE = 1024
+LATACCEL_RANGE = [-5, 5]
+STEER_RANGE = [-2, 2]
+MAX_ACC_DELTA = 0.5
+DEL_T = 0.1
+LAT_ACCEL_COST_MULTIPLIER = 50.0
+MAX_BATCH_SIZE=1024
+MAX_EPISODE_SIZE=450  # Force fixed length episodes
+
+FUTURE_PLAN_STEPS = FPS * 5  # 5 secs
+
+State = namedtuple('State', ['roll_lataccel', 'v_ego', 'a_ego'])
+FuturePlan = namedtuple('FuturePlan', ['lataccel', 'roll_lataccel', 'v_ego', 'a_ego'])
+
+
+class LataccelTokenizer:
+  def __init__(self):
+    self.vocab_size = VOCAB_SIZE
+    self.bins = np.linspace(LATACCEL_RANGE[0], LATACCEL_RANGE[1], self.vocab_size)
+
+  def encode(self, value: Union[float, np.ndarray, List[float]]) -> np.ndarray:
+    value = self.clip(value)
+    return np.digitize(value, self.bins, right=True)
+
+  def decode(self, token: np.ndarray) -> np.ndarray:
+    return self.bins[token]
+
+  def clip(self, value: Union[float, np.ndarray, List[float]]) -> Union[float, np.ndarray]:
+    return np.clip(value, LATACCEL_RANGE[0], LATACCEL_RANGE[1])
+
+
+class TinyPhysicsModel:
+  def __init__(self, model_path: str, debug: bool) -> None:
+    self.tokenizer = LataccelTokenizer()
+    options = ort.SessionOptions()
+    options.log_severity_level = 3
+    provider = 'CUDAExecutionProvider'
+
+    with open(model_path, "rb") as f:
+      self.ort_session = ort.InferenceSession(f.read(), options, [provider])
+
+  def softmax(self, x, axis=-1):
+    e_x = np.exp(x - np.max(x, axis=axis, keepdims=True))
+    return e_x / np.sum(e_x, axis=axis, keepdims=True)
+
+  def predict(self, input_data: dict, rng: np.random.Generator, temperature=1.) -> np.ndarray:
+    res = self.ort_session.run(None, input_data)[0]
+
+    # we only care about the last timestep
+    probs = self.softmax(res[:, -1] / temperature, axis=-1)
+    assert probs.shape[0] <= MAX_BATCH_SIZE
+    assert probs.shape[1] == VOCAB_SIZE
+    samples = (probs.cumsum(axis=1) > rng.random(probs.shape[0])[:, np.newaxis]).argmax(axis=1) # Inverse transform sampling
+    return samples
+
+  def get_current_lataccel(self, sim_states: np.ndarray, actions: np.ndarray, past_preds: np.ndarray, rng: np.random.Generator) -> np.ndarray:
+    tokenized_actions = self.tokenizer.encode(past_preds)
+    batch_states = np.concatenate((actions[:, :, np.newaxis], sim_states), axis=2)
+
+    input_data = {
+      'states': batch_states.astype(np.float32),
+      'tokens': tokenized_actions.astype(np.int64)
+    }
+    return self.tokenizer.decode(self.predict(input_data, rng, temperature=0.8))
+
+
+class TinyPhysicsSimulator:
+  def __init__(self, model: TinyPhysicsModel, dfs: List[pd.DataFrame], controller: BaseController, episode_len: int=MAX_EPISODE_SIZE) -> None:
+    self.batch_size = len(dfs)
+    self.terminate_step = CONTROL_START_IDX + episode_len
+    self.sim_model = model
+    self.get_data(dfs)
+    self.controller = controller
+    self.reset()
+
+  def reset(self) -> None:
+    self.step_idx = CONTEXT_LENGTH
+    self.current_lataccel_histories = self.target_lataccel_histories.copy()
+    self.current_lataccel = self.current_lataccel_histories[:, self.step_idx - 1]
+    self.futureplan = None
+    self.rng = np.random.default_rng()
+
+  def get_data(self, dfs: List[pd.DataFrame]) -> None:
+    self.state_histories = np.array([np.column_stack([np.sin(d['roll'].to_numpy())[:self.terminate_step + FUTURE_PLAN_STEPS] * ACC_G,
+                                    d['vEgo'].to_numpy()[:self.terminate_step + FUTURE_PLAN_STEPS],
+                                    d['aEgo'].to_numpy()[:self.terminate_step + FUTURE_PLAN_STEPS]]) for d in dfs])
+    self.target_lataccel_histories = np.array([d['targetLateralAcceleration'].to_numpy()[:self.terminate_step + FUTURE_PLAN_STEPS] for d in dfs])
+    self.action_histories = np.array([-d['steerCommand'].to_numpy()[:self.terminate_step + FUTURE_PLAN_STEPS] for d in dfs]) # steer commands are logged with left-positive convention but this simulator uses right-positive
+
+  def sim_step(self, step_idx: int) -> None:
+    preds = self.sim_model.get_current_lataccel(
+      sim_states=self.state_histories[:, step_idx - CONTEXT_LENGTH + 1: step_idx + 1],
+      actions=self.action_histories[:, step_idx - CONTEXT_LENGTH + 1: step_idx + 1],
+      past_preds=self.current_lataccel_histories[:, step_idx - CONTEXT_LENGTH: step_idx],
+      rng=self.rng
+    )
+    preds = np.clip(preds, self.current_lataccel - MAX_ACC_DELTA, self.current_lataccel + MAX_ACC_DELTA)
+    if step_idx >= CONTROL_START_IDX:
+      self.current_lataccel = preds
+    else:
+      self.current_lataccel = self.target_lataccel_histories[:, step_idx]
+
+    self.current_lataccel_histories[:, step_idx] = self.current_lataccel
+
+  def control_step(self, step_idx: int) -> None:
+    actions = self.controller.update(self.target_lataccel_histories[:, step_idx], self.current_lataccel, self.state_histories[:, step_idx], future_plan=self.futureplan)
+    if step_idx < CONTROL_START_IDX:
+      actions = self.action_histories[:, step_idx]
+
+    actions = np.clip(actions, STEER_RANGE[0], STEER_RANGE[1])
+    self.action_histories[:, step_idx] = actions
+
+  def get_future_plan(self, step_idx: int) -> np.ndarray:
+    return np.concatenate([self.state_histories[:, step_idx + 1: step_idx + FUTURE_PLAN_STEPS],
+                           self.target_lataccel_histories[:, step_idx + 1: step_idx + FUTURE_PLAN_STEPS, np.newaxis]], axis=2)
+
+  def step(self) -> None:
+    self.futureplan = self.get_future_plan(self.step_idx)
+    self.control_step(self.step_idx)
+    self.sim_step(self.step_idx)
+    self.step_idx += 1
+
+  def compute_cost(self) -> Tuple[float, float, float]:
+    target = self.target_lataccel_histories[:, CONTROL_START_IDX:]
+    pred = self.current_lataccel_histories[:, CONTROL_START_IDX:]
+
+    lat_accel_costs = np.mean((target - pred)**2, axis=1) * 100
+    jerk_costs = np.mean((np.diff(pred, axis=1) / DEL_T)**2, axis=1) * 100
+    total_costs = (lat_accel_costs * LAT_ACCEL_COST_MULTIPLIER) + jerk_costs
+
+    return lat_accel_costs.mean(), jerk_costs.mean(), total_costs.mean()
+
+  def rollout(self) -> Tuple[float, float, float]:
+    for _ in range(CONTEXT_LENGTH, self.terminate_step):
+      self.step()
+    self.target_lataccel_histories = self.target_lataccel_histories[:, :self.terminate_step]
+    self.current_lataccel_histories = self.current_lataccel_histories[:, :self.terminate_step]
+    self.action_histories = self.action_histories[:, :self.terminate_step]
+    return self.compute_cost()
+
+def get_available_controllers():
+  return [f.stem for f in Path('controllers').iterdir() if f.is_file() and f.suffix == '.py' and f.stem != '__init__']
+
+def run_rollout(data_paths, controller_type, model_path, debug=False):
+  if not isinstance(data_paths, list):
+    data_paths = [data_paths]
+  tinyphysicsmodel = TinyPhysicsModel(model_path, debug=debug)
+  costs = []
+  for i in tqdm(range(0, len(data_paths), MAX_BATCH_SIZE)):
+    controller = importlib.import_module(f'controllers.{controller_type}').Controller()
+    sim = TinyPhysicsSimulator(tinyphysicsmodel, data_paths[i: min(i + MAX_BATCH_SIZE, len(data_paths))], controller=controller)
+    costs += sim.rollout()
+  return costs
+
+# if __name__ == "__main__":
+#   available_controllers = get_available_controllers()
+#   parser = argparse.ArgumentParser()
+#   parser.add_argument("--model_path", type=str, required=True)
+#   parser.add_argument("--data_path", type=str, required=True)
+#   parser.add_argument("--num_segs", type=int, default=100)
+#   parser.add_argument("--controller", default='pid', choices=available_controllers)
+#   args = parser.parse_args()
+
+#   data_path = Path(args.data_path)
+#   if data_path.is_file():
+#     cost, _, _ = run_rollout(data_path, args.controller, args.model_path)
+#     print(f"\nAverage lataccel_cost: {cost[0]['lataccel_cost']:>6.4}, average jerk_cost: {cost[0]['jerk_cost']:>6.4}, average total_cost: {cost[0]['total_cost']:>6.4}")
+#   elif data_path.is_dir():
+#     files = sorted(data_path.iterdir())[:args.num_segs]
+#     costs = run_rollout([str(f) for f in files], args.controller, args.model_path)
+#     costs_df = pd.DataFrame(costs)
+#     print(f"\nAverage lataccel_cost: {np.mean(costs_df['lataccel_cost']):>6.4}, average jerk_cost: {np.mean(costs_df['jerk_cost']):>6.4}, average total_cost: {np.mean(costs_df['total_cost']):>6.4}")
\ No newline at end of file
diff --git a/PPO_control/train.py b/PPO_control/train.py
new file mode 100644
index 00000000..5adc96f0
--- /dev/null
+++ b/PPO_control/train.py
@@ -0,0 +1,218 @@
+import sys
+import os
+from typing import Tuple, Callable, List
+from pathlib import Path
+import argparse
+import json
+import random
+from functools import partial
+
+from torch._prims_common import check
+sys.path.insert(1, os.path.abspath('..') )
+
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+import numpy as np
+
+from PPO_Loss import *
+from ActorCritic import ActorCritic
+from ExperienceBuffer import PPOExperienceBuffer
+from controllers import ppo
+from tinyphysics_sim import TinyPhysicsModel, TinyPhysicsSimulator, CONTROL_START_IDX, MAX_ACC_DELTA
+
+def find_shortest_path(dfs):
+    return np.min([df.shape[0] for df in dfs])
+
+def episode_rollout(model: TinyPhysicsModel, dfs: List[pd.DataFrame], buffer: PPOExperienceBuffer, policy_model: ActorCritic, n_episode: int, episode_len: int, path_boundary: float, device: torch.device):
+    sample_dfs = random.sample(dfs, n_episode)
+    controller = ppo.Controller(policy_model, device)
+
+    # Prevent short paths
+    while True:
+        try:
+            sim = TinyPhysicsSimulator(model, sample_dfs, controller=controller, episode_len=episode_len + 1)
+        except ValueError:
+            shortest_length = find_shortest_path(sample_dfs)
+            print(f'Error: The requested array has an inhomogeneous shape after 1 dimensions. Shortest len: {shortest_length}')
+            sample_dfs = random.sample(dfs, n_episode)
+
+        else:
+            break
+
+    lat_cost, jerk_cost, total_cost = sim.rollout()
+
+    # Calculate rewards
+    deviation = np.abs(sim.target_lataccel_histories[:, CONTROL_START_IDX + policy_model.obs_seq_len:] - sim.current_lataccel_histories[:, CONTROL_START_IDX + policy_model.obs_seq_len:])
+    jerk = np.abs(np.diff(sim.current_lataccel_histories[:, CONTROL_START_IDX + policy_model.obs_seq_len - 1:], axis=1))
+    d_rewards = 1 - deviation / path_boundary
+    d_rewards[d_rewards < 0] = 0
+    rewards = torch.from_numpy(d_rewards)
+
+    if rewards.shape[1] != episode_len + 1 - policy_model.obs_seq_len:
+        print(f"reward length doesn't match episode_len+1: rewards len:{rewards.shape[1]}, episode_len+1:{episode_len + 1 - policy_model.obs_seq_len}") 
+        return
+
+    buffer.reset()
+    
+    # Leave the value of last step for future reward estimation
+    # Convert from list of episode_length of batch history to tensor of (batchsize, episode_len, ...)
+    observation_history = torch.cat([x[:, None] for x in controller.observation_history[-episode_len - 1 +policy_model.obs_seq_len: -1]], dim=1)
+    target_history = torch.cat([x[:, None] for x in controller.target_history[-episode_len-1+policy_model.obs_seq_len: -1]], dim=1)
+    action_history = torch.column_stack(controller.action_history[-episode_len-1+policy_model.obs_seq_len: -1])
+    action_prob_history = torch.cat([x[:, None] for x in controller.action_prob_history[-episode_len-1+policy_model.obs_seq_len: -1]], dim=1)
+    value_history = torch.column_stack(controller.value_history[-episode_len-1+policy_model.obs_seq_len:])
+
+    buffer.batch_add_trajectory(observation_history,
+                                target_history,
+                                action_history,
+                                action_prob_history,
+                                rewards[:, :-1],
+                                value_history)
+
+    return buffer, rewards, lat_cost, jerk_cost, total_cost
+
+def train(policy_model: ActorCritic, actor_optimizer: optim.Optimizer, critic_optimizer: optim.Optimizer, run_rollout: Callable, episode_len: int, path_boundary: float, n_steps: int, n_episode: int, n_epoch: int, batch_size: int, clip_eps: float, device: torch.device, checkpoint=None, start_logstd=None):
+    reward_history = []
+    lat_cost_history = []
+    jerk_cost_history = []
+
+    total_loss_history = []
+    actor_obj_history = []
+    critic_loss_history = []
+    logstd_history = []
+
+    start_step = 0
+    
+    if checkpoint:
+        start_step = checkpoint['step']
+        policy_model.load_state_dict(checkpoint['model_state_dict'])
+        actor_optimizer.load_state_dict(checkpoint['actor_optimizer_state_dict'])
+        critic_optimizer.load_state_dict(checkpoint['critic_optimizer_state_dict'])
+        
+        reward_history = checkpoint['reward_history']
+        lat_cost_history = checkpoint['lat_cost_history']
+        jerk_cost_history = checkpoint['jerk_cost_history']
+        actor_obj_history = checkpoint['actor_obj_history']
+        critic_loss_history = checkpoint['critic_loss_history']
+        logstd_history = checkpoint['logstd_history']
+    
+    if start_logstd:
+        nn.init.constant_(policy_model.log_std, start_logstd)
+        
+    for i_step in range(start_step, n_steps):
+        # Run simulation
+        buffer, rewards, lat_cost, jerk_cost, total_cost = run_rollout(policy_model, n_episode, episode_len, path_boundary, device)
+        print(f'Training step {i_step:>7}: average_reward: {rewards.mean(): .4f}, lat_cost: {lat_cost: .2f}, jerk_cost: {jerk_cost: .2f}, total_cost: {total_cost: .2f}')
+        # Record policy's performance at each step
+        reward_history.append(rewards.mean().item())
+        lat_cost_history.append(lat_cost)
+        jerk_cost_history.append(jerk_cost)
+        
+        # Start training loops
+        data_loader = DataLoader(buffer, batch_size=batch_size, shuffle=True, num_workers=8, pin_memory=True)
+        policy_model.train()
+        for i_epoch in range(n_epoch):
+            print(f'Training step {i_step:>7}, epoch {i_epoch:>3}:', end='')
+
+            epoch_actor_obj_history = []
+            epoch_critic_loss_history = []
+            epoch_logstd_history = []
+
+            for data in data_loader:
+                actions, observations, targets, transitions = data
+                actions = actions.type(torch.float32).to(device)
+                observations = observations.to(device)
+                targets = targets.to(device)
+                transitions = transitions.to(device)
+                
+                # Actor step
+                actor_optimizer.zero_grad()
+                action_dist, value_estimates = policy_model(observations, targets)
+                action_prob_new = torch.exp(action_dist.log_prob(actions / policy_model.action_scale))
+                a_l = actor_loss(action_prob_new, transitions[:, 0], transitions[:, 3], clip_eps)
+                a_l.backward()
+                actor_optimizer.step()
+
+                critic_optimizer.zero_grad()
+                action_dist, value_estimates = policy_model(observations, targets)
+                value_estimates = value_estimates.flatten()
+                c_l = value_loss(value_estimates, transitions[:, 2])
+                c_l.backward()
+                critic_optimizer.step()
+
+                epoch_actor_obj_history.append(a_l.item())
+                epoch_critic_loss_history.append(c_l.item())
+                epoch_logstd_history.append(policy_model.log_std.item())
+
+            actor_obj_history.append(np.mean(epoch_actor_obj_history))
+            critic_loss_history.append(np.mean(epoch_critic_loss_history))
+            logstd_history.append(np.mean(epoch_logstd_history))
+
+            print(f' actor_obj: {actor_obj_history[-1]: 0.3f}, critic_loss: {critic_loss_history[-1]: 0.3f}, logstd: {logstd_history[-1]: 0.3f}')
+        
+        if i_step % 10 == 9:
+            torch.save({
+                'step': i_step,
+                'model_state_dict': policy_model.state_dict(),
+                'actor_optimizer_state_dict': actor_optimizer.state_dict(),
+                'critic_optimizer_state_dict': critic_optimizer.state_dict(),
+                'reward_history': reward_history,
+                'lat_cost_history': lat_cost_history,
+                'jerk_cost_history': jerk_cost_history,
+                'actor_obj_history': actor_obj_history,
+                'critic_loss_history': critic_loss_history,
+                'logstd_history': logstd_history
+            }, f'./checkpoints/exp{model_id}_step{i_step + 1}.pt')
+
+    return reward_history, lat_cost_history, jerk_cost_history, total_loss_history, actor_obj_history, critic_loss_history, logstd_history
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config_path", type=str, required=True)
+    parser.add_argument("--checkpoint_path", type=str, required=False)
+    args = parser.parse_args()
+    
+    with open(args.config_path) as f:
+        config = json.load(f)
+
+    checkpoint = None
+    if args.checkpoint_path:
+        checkpoint = torch.load(args.checkpoint_path)
+
+    print(f"Start training with checkpoint: {args.checkpoint_path}, config: {args.config_path}")
+
+    global model_id
+    model_id = config['model_id']
+    n_episode = config['n_episode']
+    episode_len = config['episode_len']
+    path_boundary = config['path_boundary']
+    a_lr = config['a_lr']
+    c_lr = config['c_lr']
+    batch_size = config['batch_size']
+    n_epoch = config['n_epoch']
+    n_step = config['n_step']
+    clip_eps = config['clip_eps']
+    discount_factor = config['discount_factor']
+    td_decay = config['td_decay']
+    start_logstd = config['start_logstd'] if "start_logstd" in config else None
+
+    device = torch.device('cuda')
+    tinyphysicsmodel = TinyPhysicsModel('../models/tinyphysics.onnx', debug=False)
+    policy_model = ActorCritic(obs_dim=4, obs_seq_len=20, target_dim=31, action_dim=1, has_continuous_action=True, action_scale=2).to(device)
+    data = Path('../data/')
+    data_paths = sorted(data.iterdir())[5000:]
+    data_paths = [str(x) for x in data_paths]
+    dfs = [pd.read_csv(f) for f in data_paths]
+    experience_buffer = PPOExperienceBuffer(discount_factor, td_decay)
+
+    actor_optimizer = optim.Adam(list(policy_model.actor.parameters()) + list(policy_model.feature_lstm.parameters()) + [policy_model.log_std], a_lr, eps=1e-6)
+    critic_optimizer = optim.Adam(policy_model.critic.parameters(), c_lr, eps=1e-6)
+
+    sim_rollout = partial(episode_rollout, tinyphysicsmodel, dfs, experience_buffer)
+
+    result = train(policy_model, actor_optimizer, critic_optimizer, sim_rollout, episode_len, path_boundary, n_step, n_episode, n_epoch, batch_size, clip_eps, device, checkpoint, start_logstd)
+    np.save(f'results/result_{model_id}.npy', np.array(result, dtype=object), allow_pickle=True)
+    
\ No newline at end of file
diff --git a/car_trajectory.ipynb b/car_trajectory.ipynb
new file mode 100644
index 00000000..49fd00ea
--- /dev/null
+++ b/car_trajectory.ipynb
@@ -0,0 +1,124 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tinyphysics import TinyPhysicsModel, TinyPhysicsSimulator, CONTROL_START_IDX\n",
+    "from controllers import pid, pidf\n",
+    "from matplotlib import pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from scipy import signal\n",
+    "\n",
+    "ACC_G = 9.81\n",
+    "\n",
+    "sns.set_theme()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\\dot x = v_{long} \\cdot cos(\\theta)$\\\n",
+    "$\\dot y = v_{long} \\cdot sin(\\theta)$\\\n",
+    "$\\dot\\theta = \\frac{a_{lat}}{v_{long}}$\n",
+    "\n",
+    "\n",
+    "$x_{t+1} = x_t + v_{long, t} \\cdot cos(\\theta) \\cdot \\Delta t$\\\n",
+    "$y_{t+1} = y_t + v_{long, t} \\cdot sin(\\theta) \\cdot \\Delta t$\\\n",
+    "$\\theta_{t+1} = \\theta_t + \\frac{a_{lat, t}}{v_{long, t}} \\cdot \\Delta t$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict_trajectory(datapath):\n",
+    "    df = pd.read_csv(datapath)\n",
+    "    t = df[\"t\"].to_numpy()\n",
+    "    vEgo = df[\"vEgo\"].to_numpy()\n",
+    "    roll_la = np.sin(df[\"roll\"].to_numpy()) * ACC_G\n",
+    "    target_la = df[\"targetLateralAcceleration\"].to_numpy()\n",
+    "    target_level_la = target_la - roll_la\n",
+    "\n",
+    "    # Assume starting at (0, 0) with 0 head angle.\n",
+    "    theta = np.insert(np.cumsum(target_level_la[:-1] / vEgo[:-1] * np.diff(t)), 0, 0)\n",
+    "    x = np.insert(np.cumsum(vEgo[:-1] * np.cos(theta)[:-1] * np.diff(t)), 0, 0)\n",
+    "    y = np.insert(np.cumsum(vEgo[:-1] * np.sin(theta)[:-1] * np.diff(t)), 0, 0)\n",
+    "\n",
+    "    return x, y, theta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "datapath = 'data/00009.csv'\n",
+    "x, y, theta = predict_trajectory(datapath)\n",
+    "\n",
+    "plt.plot(theta)\n",
+    "plt.legend(['Theta'])\n",
+    "plt.title('Head angle')\n",
+    "plt.show()\n",
+    "\n",
+    "plt.plot(x, y)\n",
+    "plt.xlabel('X Position')\n",
+    "plt.ylabel('Y Position')\n",
+    "plt.title('Car Trajectory')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/controllers/mpc.py b/controllers/mpc.py
new file mode 100644
index 00000000..51c2f043
--- /dev/null
+++ b/controllers/mpc.py
@@ -0,0 +1,137 @@
+from . import BaseController
+import numpy as np
+from typing import List, Tuple
+
+ACC_G = 9.81
+
+class Controller(BaseController):
+  """
+  A PIDF controller with bycicle dynamic model feedforward
+  """
+  def __init__(self,):
+
+
+    self.alpha = 0.9697
+    self.lag = 2
+    self.action_history = []
+    self.error_history = []
+    self.la_history = []
+    self.last_state = None
+
+    # Debug
+    self.predict_la_history = []
+    self.target_la_history = []
+    self.delta_action_history = []
+
+  def optimize_mpc(self, x_0: float, n: int, plan: List[float], W_d: List[float], W_j: List[float]) -> Tuple[List[float], float]:
+    '''
+    Model:
+        dx = alpha * du
+        x: state (lataccel)
+        u: input (steer command)
+
+    Params:
+        alpha: steer to lataccel coefficient
+        x_0: initial lataccel
+        u_0: last control
+        n: size of prediction horizon, same as control horizon
+        plan: lataccel targets for the length of prediction horizon
+        W_d: Weights for deviation error
+        W_j: Weights for jerk error (len n-1)
+    
+    Return:
+        control: optimal control for the control horizon
+        prediction: predicted future states following the optimal control
+        obj: objective value for the optimal control
+    '''
+
+    # Solve for minima of objective function using closed form solution to gradient
+    upper_alpha = np.triu(self.alpha * np.ones((n, n)))
+    lower_alpha = np.tril(self.alpha * np.ones((n, n)))
+    W_j = np.array(W_j)
+    d1 = -2 * W_j # Off diagonal of DuJ
+    d0 = np.zeros(n)
+    d0[: -1] += 2 * W_j
+    d0[1: ] += 2 * W_j
+    DuJ = np.diag(d0) + np.diag(d1, 1) + np.diag(d1, -1)
+    plan = np.array(plan)
+    W_d = np.array(W_d)
+    A = 2 * upper_alpha @ np.diag(W_d) @ lower_alpha + DuJ
+    b = 2 * upper_alpha @ np.diag(W_d) @ (plan - x_0)
+    control = np.linalg.solve(A, b)
+    prediction = x_0 + lower_alpha @ control
+
+    L_d = (W_d * (prediction - plan) ** 2).sum()
+    L_j = (W_j * np.diff(control, n=1) **2).sum()
+
+    return control, prediction, L_d, L_j
+  
+  def update(self, target_lataccel, current_lataccel, state, future_plan):
+      '''
+      target_la_t
+      state_t
+      action_t
+      action_t-lag-1 & la_t-lag-2 -> la_t-1
+
+      la_history[-1] = la_t-1
+      action_history[-1] = action_t-1
+      last_state = state_t-1
+
+      predict_la[-1] = la_t+lag-1
+
+      '''
+
+      if len(self.action_history) < self.lag + 1 or len(future_plan[0]) < self.lag:
+        action = 0.3 * (target_lataccel - current_lataccel)
+      else:
+        # Get the predicted next actionable state
+        predict_la = current_lataccel - self.last_state[0]
+        for t in reversed(range(1, self.lag + 1)):
+          delta_action = self.action_history[-t] - self.action_history[-t-1]
+          predict_la += delta_action * self.alpha
+        
+        n = 10
+        if self.lag == 0:
+          plan = [target_lataccel - state[0]]
+          plan.extend([future_plan[0][i] - future_plan[1][i] for i in range(min(len(future_plan[0]), n - 1))])
+        else:
+          plan = [future_plan[0][i] - future_plan[1][i] for i in range(self.lag - 1, min(len(future_plan[0]), self.lag - 1 + n))]
+
+        horizon_n = len(plan)
+        control, prediction, L_d, L_j = self.optimize_mpc(predict_la,
+                                                          horizon_n,
+                                                          plan,
+                                                          [0.95 ** i for i in range(horizon_n)],
+                                                          [5 * 1.3 ** i for i in range(horizon_n - 1)])
+        action = control[0]
+
+      self.action_history.append(action)
+      self.last_state = state
+
+      # # Update state history
+      # if self.action_history:
+      #   self.la_history.append(current_lataccel - self.last_state[0])
+
+      # if len(self.action_history) < self.lag + 1 or len(future_plan[0]) < self.lag:
+      #   action = 0
+      # else:
+      #   predict_la = [self.la_history[-1]]
+      #   for t in reversed(range(1, self.lag + 1)):
+      #     delta_action = self.action_history[-t] - self.action_history[-t-1]
+      #     predict_la.append(predict_la[-1] + delta_action * self.alpha)
+
+      #   self.predict_la_history.append(predict_la[-1])
+      #   target_la = future_plan[0][self.lag-1] - future_plan[1][self.lag-1] if self.lag > 0 else target_lataccel - state[0]
+      #   self.target_la_history.append(target_la)
+      #   target_delta_la = target_la - predict_la[-1]
+      #   self.error_history.append(target_delta_la)
+      #   target_delta_action = target_delta_la / self.alpha
+      #   self.delta_action_history.append(target_delta_action)
+      #   target_delta_action = np.clip(target_delta_action, -0.01, 0.01)
+      #   action = self.action_history[-1] + target_delta_action
+      #   # action *= 0.25
+
+      # self.action_history.append(action)
+      # self.last_state = state
+      
+      return action
\ No newline at end of file
diff --git a/controllers/pid.py b/controllers/pid.py
index 6da40a46..57dc184e 100644
--- a/controllers/pid.py
+++ b/controllers/pid.py
@@ -9,10 +9,14 @@ def __init__(self,):
     self.p = 0.3
     self.i = 0.05
     self.d = -0.1
-    self.error_integral = 0
-    self.prev_error = 0
+    self.error_integral = None
+    self.prev_error = None
 
   def update(self, target_lataccel, current_lataccel, state, future_plan):
+      if self.error_integral is None:
+         self.error_integral = np.zeros_like(target_lataccel)
+         self.prev_error = np.zeros_like(target_lataccel)
+         
       error = (target_lataccel - current_lataccel)
       self.error_integral += error
       error_diff = error - self.prev_error
diff --git a/controllers/pid2.py b/controllers/pid2.py
new file mode 100644
index 00000000..fb45ca9c
--- /dev/null
+++ b/controllers/pid2.py
@@ -0,0 +1,20 @@
+from . import BaseController
+import numpy as np
+
+class Controller(BaseController):
+  """
+  A simple PID controller
+  """
+  def __init__(self,):
+    self.p = 0.1
+    self.i = 0.15
+    self.d = 0.05
+    self.error_integral = 0
+    self.prev_error = 0
+
+  def update(self, target_lataccel, current_lataccel, state, future_plan):
+      error = (target_lataccel - current_lataccel)
+      self.error_integral += error
+      error_diff = error - self.prev_error
+      self.prev_error = error
+      return self.p * error + self.i * self.error_integral + self.d * error_diff
diff --git a/controllers/pidf.py b/controllers/pidf.py
new file mode 100644
index 00000000..c41f5168
--- /dev/null
+++ b/controllers/pidf.py
@@ -0,0 +1,86 @@
+from . import BaseController
+import numpy as np
+from scipy.signal import butter, lfilter
+
+ACC_G = 9.81
+
+class Controller(BaseController):
+  """
+  A PIDF controller with bycicle dynamic model feedforward
+  """
+  def __init__(self,):
+
+
+    self.alpha = 0.9697
+    self.lag = 2
+    self.action_history = []
+    self.error_history = []
+    self.la_history = []
+    self.last_state = None
+
+    # Debug
+    self.predict_la_history = []
+    self.target_la_history = []
+    self.delta_action_history = []
+  
+  def update(self, target_lataccel, current_lataccel, state, future_plan):
+      '''
+      target_la_t
+      state_t
+      action_t
+      action_t-lag-1 & la_t-lag-2 -> la_t-1
+
+      la_history[-1] = la_t-1
+      action_history[-1] = action_t-1
+      last_state = state_t-1
+
+      predict_la[-1] = la_t+lag-1
+
+      '''
+      def lowpass_filter(data):
+        nyq = 0.5 * 10
+        normal_cutoff = 2 / nyq
+        b, a = butter(1, normal_cutoff, btype='low', analog=False)
+        return lfilter(b, a, data)
+
+      # Update state history
+      if self.action_history:
+        self.la_history.append(current_lataccel - self.last_state[0])
+
+      if len(self.action_history) < self.lag + 1 or len(future_plan[0]) < self.lag:
+        action = 0
+      else:
+        predict_la = [self.la_history[-1]]
+        for t in reversed(range(1, self.lag + 1)):
+          delta_action = self.action_history[-t] - self.action_history[-t-1]
+          predict_la.append(predict_la[-1] + delta_action * self.alpha)
+
+        self.predict_la_history.append(predict_la[-1])
+        target_la = future_plan[0][self.lag-1] - future_plan[1][self.lag-1] if self.lag > 0 else target_lataccel - state[0]
+        self.target_la_history.append(target_la)
+        target_delta_la = target_la - predict_la[-1]
+        self.error_history.append(target_delta_la)
+        target_delta_action = target_delta_la / self.alpha
+        self.delta_action_history.append(target_delta_action)
+        target_delta_action = np.clip(target_delta_action, -0.01, 0.01)
+        action = self.action_history[-1] + target_delta_action
+        # action *= 0.25
+
+      self.action_history.append(action)
+      self.last_state = state
+      
+      # # Feedforward
+      # target_steer_la = target_lataccel - state[0]
+      # pred_steer = self.predict_steer(target_steer_la, state[1])
+
+      # # PID Feedback
+      # error = (target_lataccel - current_lataccel)
+      # self.error_integral += error
+      # error_diff = error - self.prev_error
+      # self.prev_error = error
+
+      # command = self.f * pred_steer + self.p * error + self.i * self.error_integral + self.d * error_diff
+      # self.steer_command_history.append(command)
+      # self.last_state = state
+
+      return action
\ No newline at end of file
diff --git a/controllers/ppo.py b/controllers/ppo.py
new file mode 100644
index 00000000..8dc33d1a
--- /dev/null
+++ b/controllers/ppo.py
@@ -0,0 +1,69 @@
+from . import BaseController
+import numpy as np
+import torch
+from PPO_control.ActorCritic import ActorCritic
+
+STEER_RANGE = [-1, 1]
+ACTION_DIM = 81
+
+class Controller(BaseController):
+  def __init__(self, policy_model: ActorCritic, device: torch.device, eval: bool=False) -> None:
+    super().__init__()
+    self.device = device
+    self.eval = eval
+    self.policy_model = policy_model
+    self.concat_state_history = []
+
+    # self.p = 0.3
+    # self.i = 0.05
+    # self.d = -0.1
+    # self.error_integral = None
+    # self.prev_error = None
+
+    # For training
+    self.observation_history = []
+    self.target_history = []
+    self.action_history = []
+    self.action_prob_history = []
+    self.value_history = []
+
+  def update(self, target_lataccel, current_lataccel, state, future_plan):
+    steer = np.zeros_like(target_lataccel)
+
+    if self.concat_state_history:
+        self.concat_state_history[-1][:, :, -1] = current_lataccel[:, np.newaxis]
+        # if len(self.concat_state_history) < self.policy_model.obs_seq_len:
+        #   if self.error_integral is None:
+        #     self.error_integral = np.zeros_like(target_lataccel)
+        #     self.prev_error = np.zeros_like(target_lataccel)
+            
+        #   error = (target_lataccel - current_lataccel)
+        #   self.error_integral += error
+        #   error_diff = error - self.prev_error
+        #   self.prev_error = error
+        #   steer = self.p * error + self.i * self.error_integral + self.d * error_diff
+        
+        # else:
+        past_obs = np.concatenate(self.concat_state_history[-self.policy_model.obs_seq_len:], axis=1)
+        past_obs = torch.from_numpy(past_obs).float().to(self.device)
+
+        future_plan = future_plan[:, :9, [0, 1, 3]]
+        target = np.zeros((state.shape[0], 31))
+        target[:, 0] = current_lataccel
+        target[:, 1:3] = state[:, :2]
+        target[:, 3] = target_lataccel
+        target[:, 4: future_plan.shape[1] * future_plan.shape[2] + 4] = future_plan.reshape((future_plan.shape[0], -1))
+        target = torch.from_numpy(target).float().to(self.device)
+
+        action, action_prob, value = self.policy_model.act(past_obs, target, self.eval)
+        steer = action
+
+        self.observation_history.append(past_obs.cpu())
+        self.target_history.append(target.cpu())
+        self.action_history.append(torch.from_numpy(action))
+        self.action_prob_history.append(torch.from_numpy(action_prob))
+        self.value_history.append(torch.from_numpy(value))
+
+    self.concat_state_history.append(np.column_stack([state[:, :2], steer, np.zeros_like(steer)])[:, np.newaxis])
+
+    return steer
diff --git a/controllers/ref.py b/controllers/ref.py
new file mode 100644
index 00000000..1dc47ef9
--- /dev/null
+++ b/controllers/ref.py
@@ -0,0 +1,19 @@
+from . import BaseController
+import pandas as pd
+
+CONTEXT_LENGTH = 20
+
+
+class Controller(BaseController):
+  """
+  A controller that always outputs zero
+  """
+  def __init__(self, datafile) -> None:
+    self.step = CONTEXT_LENGTH
+    df = pd.read_csv(datafile)
+    self.steerCommands = -df['steerCommand'].to_numpy()
+
+  def update(self, target_lataccel, current_lataccel, state, future_plan):
+    command = self.steerCommands[self.step]
+    self.step += 1
+    return command
diff --git a/experiment.ipynb b/experiment.ipynb
index e883203f..84a8eccb 100644
--- a/experiment.ipynb
+++ b/experiment.ipynb
@@ -2,68 +2,842 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/risak/controls_challenge/venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
    "source": [
     "from tinyphysics import TinyPhysicsModel, TinyPhysicsSimulator, CONTROL_START_IDX\n",
-    "from controllers import pid\n",
+    "from controllers import pid, mpc, ref, zero, pidf\n",
     "from matplotlib import pyplot as plt\n",
     "import seaborn as sns\n",
     "\n",
+    "import numpy as np\n",
+    "from scipy import signal\n",
+    "from scipy.ndimage import gaussian_filter\n",
+    "\n",
+    "ACC_G = 9.81\n",
+    "\n",
     "sns.set_theme()\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def plot_rollout(sim):\n",
+    "def plot_rollout(sim, end=1000):\n",
     "  fig, ax = plt.subplots(figsize=(10, 5))\n",
-    "  ax.plot(sim.target_lataccel_history, label=\"Target Lateral Acceleration\", alpha=0.5)\n",
-    "  ax.plot(sim.current_lataccel_history, label=\"Actual Lateral Acceleration\", alpha=0.5)\n",
+    "  ax.plot(sim.target_lataccel_history[:end], label=\"Target Lateral Acceleration\", alpha=0.5)\n",
+    "  ax.plot(sim.current_lataccel_history[:end], label=\"Actual Lateral Acceleration\", alpha=0.5)\n",
+    "  ax.plot(sim.action_history[:end], label=\"Action\", alpha=0.5)\n",
+    "  # ax.plot([x[0] for x in sim.state_history], label=\"roll\", alpha=0.5)\n",
+    "\n",
     "  ax.legend()\n",
     "  ax.set_xlabel(\"Step\")\n",
     "  ax.set_ylabel(\"Lateral Acceleration\")\n",
     "  ax.set_title(\"Rollout\")\n",
+    "  # ax.set_ylim(-0.5, 0.5)\n",
     "  plt.show()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'lataccel_cost': 2.3524906637017517,\n",
+       " 'jerk_cost': 44.20628371954993,\n",
+       " 'total_cost': 161.83081690463752}"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "model = TinyPhysicsModel(\"./models/tinyphysics.onnx\", debug=True)\n",
-    "controller = pid.Controller()"
+    "controller = pid.Controller()\n",
+    "sim = TinyPhysicsSimulator(model, \"./data/00675.csv\", controller=controller, debug=False)\n",
+    "sim.rollout()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "sim = TinyPhysicsSimulator(model, \"./data/00000.csv\", controller=controller, debug=False)\n",
-    "sim.rollout()"
+    "plot_rollout(sim)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
-    "plot_rollout(sim)"
+    "def sim_trajectory():\n",
+    "    dt = 0.1\n",
+    "    vEgo = np.array([x[1] for x in sim.state_history])\n",
+    "    roll_la = np.array([x[0] for x in sim.state_history])\n",
+    "    target_la = np.array(sim.target_lataccel_history)\n",
+    "    actual_la = np.array(sim.current_lataccel_history)\n",
+    "    target_level_la = target_la - roll_la\n",
+    "    actual_level_la = actual_la - roll_la\n",
+    "\n",
+    "    # Assume starting at (0, 0) with 0 head angle.\n",
+    "    theta_trgt = np.insert(np.cumsum(target_level_la[:-1] / vEgo[:-1] * dt), 0, 0)\n",
+    "    x_trgt = np.insert(np.cumsum(vEgo * np.cos(theta_trgt) * dt), 0, 0)\n",
+    "    y_trgt = np.insert(np.cumsum(vEgo * np.sin(theta_trgt) * dt), 0, 0)\n",
+    "\n",
+    "    theta = np.insert(np.cumsum(actual_level_la[:-1] / vEgo[:-1] * dt), 0, 0)\n",
+    "    x = np.insert(np.cumsum(vEgo * np.cos(theta) * dt), 0, 0)\n",
+    "    y = np.insert(np.cumsum(vEgo * np.sin(theta) * dt), 0, 0)\n",
+    "\n",
+    "    plt.figure(figsize=(10, 5))\n",
+    "    plt.plot(x_trgt, y_trgt, label='Target Trajectory', alpha=0.7)\n",
+    "    plt.plot(x, y, label='Actual Trajectory', alpha=0.7)\n",
+    "    plt.xlabel('X Position')\n",
+    "    plt.ylabel('Y Position')\n",
+    "    plt.title('Target vs Actual Trajectory')\n",
+    "    plt.legend()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sim_trajectory()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Controller stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(20, 10))\n",
+    "# ax.plot(sim.target_lataccel_history[102:200], label=\"Target Lateral Acceleration\", alpha=0.5)\n",
+    "# ax.plot(sim.current_lataccel_history[102: 200], label=\"Current Lateral Acceleration\", alpha=0.5)\n",
+    "ax.plot(controller.la_history[2:102], label=\"Controller current la\", alpha=0.5)\n",
+    "ax.plot(controller.target_la_history[:100], label=\"Controller Target Lateral Acceleration\", alpha=0.5)\n",
+    "ax.plot(controller.delta_action_history[:100], label=\"Action\", alpha=0.5)\n",
+    "ax.plot(controller.predict_la_history[:100], label=\"Prediction\", alpha=0.5)\n",
+    "ax.plot(controller.error_history[:100], label=\"Error\", alpha=0.5)\n",
+    "\n",
+    "# ax.plot([x[0] for x in sim.state_history], label=\"roll\", alpha=0.5)\n",
+    "\n",
+    "ax.legend()\n",
+    "ax.set_xlabel(\"Step\")\n",
+    "ax.set_ylabel(\"Lateral Acceleration\")\n",
+    "ax.set_title(\"Rollout\")\n",
+    "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "lag: 5\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "lag: 5\n",
+      "alpha: 1.9313252007416128\n",
+      "beta: -0.1789437933486976\n",
+      "R^2: 0.7022714215145939\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def linear_lsq(x, y, lag):\n",
+    "    length = len(x)\n",
+    "    alpha = np.sum((y[lag:] - y[lag:].mean()) * (x[:length-lag] - x[:length-lag].mean())) / (np.sum((x[:length-lag] - x[:length-lag].mean()) ** 2) + 1e-8)\n",
+    "    beta = y[lag:].mean() - alpha * x[:length-lag].mean()\n",
+    "\n",
+    "    ssr = np.sum((alpha * x[:length-lag] + beta - y[lag:])**2)\n",
+    "    sst = np.sum((y[lag:] - y[lag:].mean())**2) + 1e-8\n",
+    "    r2 = 1 - ssr / sst\n",
+    "\n",
+    "    return alpha, beta, r2\n",
+    "\n",
+    "roll_lataccel_history = [x[0] for x in sim.state_history][100:]\n",
+    "steer_la = np.array(sim.current_lataccel_history)[100:] - np.array(roll_lataccel_history)\n",
+    "steerCommands = np.array(sim.action_history)[100:]\n",
+    "vEgo = np.array([x[1] for x in sim.state_history[100:]])\n",
+    "aEgo = np.array([x[2] for x in sim.state_history[100:]])\n",
+    "\n",
+    "roll_lataccel_history_preset = [x[0] for x in sim.state_history][:100]\n",
+    "steer_la_preset = np.array(sim.current_lataccel_history)[:100] - np.array(roll_lataccel_history_preset)\n",
+    "steerCommands_preset = np.array(sim.action_history)[:100]\n",
+    "\n",
+    "\n",
+    "length = len(steerCommands)\n",
+    "\n",
+    "\n",
+    "corr = signal.correlate(steer_la - steer_la.mean(), steerCommands - steerCommands.mean())[length: length + 20]\n",
+    "lags = signal.correlation_lags(length, length)[length: length + 20]\n",
+    "lag = lags[np.argmax(corr)]\n",
+    "print(f'lag: {lag}')\n",
+    "lag = max(0, lag)\n",
+    "\n",
+    "plt.plot(lags, corr)\n",
+    "plt.show()\n",
+    "\n",
+    "# test_fit = np.array([linear_lsq(steerCommands, steer_la, x)[2] for x in range(lag, lag + 10)])\n",
+    "# lag += np.argmax(test_fit)\n",
+    "\n",
+    "print(f'lag: {lag}')\n",
+    "\n",
+    "# lag=2\n",
+    "alpha = np.sum((steer_la[lag:] - steer_la[lag:].mean()) * (steerCommands[:length-lag] - steerCommands[:length-lag].mean())) / np.sum((steerCommands[:length-lag] - steerCommands[:length-lag].mean()) ** 2)\n",
+    "beta = steer_la[lag:].mean() - alpha * steerCommands[:length-lag].mean()\n",
+    "ssr = np.sum((alpha * steerCommands[:length-lag] + beta - steer_la[lag:])**2)\n",
+    "sst = np.sum((steer_la[lag:] - steer_la[lag:].mean())**2)\n",
+    "r2 = 1 - ssr / sst\n",
+    "print(f'alpha: {alpha}\\nbeta: {beta}\\nR^2: {r2}')\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(10, 5))\n",
+    "ax[0].plot(steerCommands[:length-lag], steer_la[lag:], '.')\n",
+    "x = np.linspace(steerCommands.min(), steerCommands.max(), 2)\n",
+    "ax[0].plot(x, alpha * x + beta)\n",
+    "ax[0].set_xlabel('steer command')\n",
+    "ax[0].set_ylabel('lataccel')\n",
+    "\n",
+    "ax[1].plot(steerCommands[:length-lag], steerCommands[:length-lag] - steer_la[lag:] * alpha + beta, '.')\n",
+    "\n",
+    "# plt.xlim(-2, 2)\n",
+    "# plt.ylim(-3, 3)\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "\n",
+    "# fig, ax = plt.subplots(2, 1, figsize=(7, 10))\n",
+    "# ax[0].scatter(action_history[:-lag], steer_lataccel_history[lag:], marker='.', linewidths=0.5)\n",
+    "# ax[1].scatter(action_history[:100], steer_lataccel_history[lag:100+lag], marker='.', linewidths=0.5)\n",
+    "\n",
+    "\n",
+    "\n",
+    "# plt.xlabel('steer command')\n",
+    "# plt.ylabel('actual lataccel')\n",
+    "# # plt.xlim(-2, 2)\n",
+    "# # plt.ylim(-3, 3)\n",
+    "# plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Lag Correlation analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Maximum correlation occurs at lag: 6\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Normality test p-value: 3.2834940531724147e-06\n",
+      "The residuals do not appear to be normally distributed (p < 0.05)\n",
+      "Coefficients for multiple lagged inputs:\n",
+      "Lag 0: -2.4115143213154067\n",
+      "Lag 1: 2.6319041623126176\n",
+      "Lag 2: -0.3067418068858398\n",
+      "Lag 3: 0.4250562812714189\n",
+      "Lag 4: 0.80685741245954\n",
+      "Lag 5: -1.0461268695791222\n",
+      "Lag 6: 1.826273730717093\n",
+      "\n",
+      "Residual analysis:\n",
+      "Mean of residuals: -1.1866351356317464e-16\n",
+      "Standard deviation of residuals: 0.1278045156072807\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Normality test p-value: 0.022415094006221187\n",
+      "The residuals do not appear to be normally distributed (p < 0.05)\n",
+      "Coefficients for speed and lagged inputs:\n",
+      " 5.787349165217056\n",
+      " 1.801405453021748\n",
+      " -0.2004766219835213\n",
+      "\n",
+      "Residual analysis:\n",
+      "Mean of residuals: 6.829444791965436e-14\n",
+      "Standard deviation of residuals: 0.1311387664925654\n",
+      "\n",
+      "Analyzing relationship at different speeds:\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy import signal\n",
+    "from scipy.stats import pearsonr, normaltest\n",
+    "\n",
+    "# Assuming the data is already loaded as provided in the initial code snippet\n",
+    "roll_lataccel_history = [x[0] for x in sim.state_history][100:]\n",
+    "steer_la = np.array(sim.current_lataccel_history)[100:] - np.array(roll_lataccel_history)\n",
+    "steerCommands = np.array(sim.action_history)[100:]\n",
+    "vEgo = np.array([x[1] for x in sim.state_history[100:]])\n",
+    "aEgo = np.array([x[2] for x in sim.state_history[100:]])\n",
+    "\n",
+    "def analyze_steering_lataccel_relationship(steerCommands, steer_la, max_lag=5):\n",
+    "    # Compute cross-correlation\n",
+    "    cross_corr = signal.correlate(steer_la, steerCommands, mode='full')\n",
+    "    lags = signal.correlation_lags(len(steer_la), len(steerCommands), mode='full')\n",
+    "    \n",
+    "    # Find the lag with maximum correlation\n",
+    "    max_corr_lag = lags[np.argmax(cross_corr)]\n",
+    "    \n",
+    "    # Plot cross-correlation\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    plt.plot(lags, cross_corr)\n",
+    "    plt.title('Cross-correlation between Steering Commands and Lateral Acceleration')\n",
+    "    plt.xlabel('Lag')\n",
+    "    plt.ylabel('Correlation')\n",
+    "    plt.axvline(x=max_corr_lag, color='r', linestyle='--', label=f'Max correlation at lag {max_corr_lag}')\n",
+    "    plt.legend()\n",
+    "    plt.show()\n",
+    "    \n",
+    "    # Compute lagged correlations\n",
+    "    lagged_correlations = []\n",
+    "    for lag in range(max_lag):\n",
+    "        correlation, _ = pearsonr(steerCommands[:steerCommands.shape[0]-lag], steer_la[lag:])\n",
+    "        lagged_correlations.append(correlation)\n",
+    "    \n",
+    "    # Plot lagged correlations\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    plt.plot(range(max_lag), lagged_correlations)\n",
+    "    plt.title('Lagged Correlations between Steering Commands and Lateral Acceleration')\n",
+    "    plt.xlabel('Lag')\n",
+    "    plt.ylabel('Correlation')\n",
+    "    plt.show()\n",
+    "    \n",
+    "    return max_corr_lag, lagged_correlations\n",
+    "\n",
+    "def analyze_speed_lag(steerCommands, vEgo, steer_la, lag):\n",
+    "    lagged_inputs = np.column_stack([steerCommands[:steerCommands.shape[0] - lag], vEgo[lag:]])\n",
+    "    X = np.hstack((np.ones((lagged_inputs.shape[0], 1)), lagged_inputs))\n",
+    "    coefficients = np.linalg.lstsq(X, steer_la[lag:], rcond=None)[0]\n",
+    "\n",
+    "    # Calculate predicted values and residua ls\n",
+    "    y_pred = X @ coefficients\n",
+    "    residuals = steer_la[lag:] - y_pred\n",
+    "\n",
+    "    # Plot residuals\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    plt.scatter(y_pred, residuals)\n",
+    "    plt.title('Residuals vs Fitted Values')\n",
+    "    plt.xlabel('Fitted Values')\n",
+    "    plt.ylabel('Residuals')\n",
+    "    plt.axhline(y=0, color='r', linestyle='--')\n",
+    "    plt.show()\n",
+    "    \n",
+    "    # Histogram of residuals\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    plt.hist(residuals, bins=30, edgecolor='black')\n",
+    "    plt.title('Histogram of Residuals')\n",
+    "    plt.xlabel('Residual')\n",
+    "    plt.ylabel('Frequency')\n",
+    "    plt.show()\n",
+    "    \n",
+    "    # Perform normality test\n",
+    "    _, p_value = normaltest(residuals)\n",
+    "    print(f\"Normality test p-value: {p_value}\")\n",
+    "    if p_value < 0.05:\n",
+    "        print(\"The residuals do not appear to be normally distributed (p < 0.05)\")\n",
+    "    else:\n",
+    "        print(\"The residuals appear to be normally distributed (p >= 0.05)\")\n",
+    "    \n",
+    "    return coefficients, residuals\n",
+    "\n",
+    "def analyze_multiple_input_effect(steerCommands, steer_la, window_size=5):\n",
+    "    # Create lagged versions of steerCommands\n",
+    "    lagged_inputs = np.column_stack([np.roll(steerCommands, i) for i in range(window_size)])\n",
+    "    lagged_inputs = lagged_inputs[window_size-1:]\n",
+    "    steer_la_trimmed = steer_la[window_size-1:]\n",
+    "    \n",
+    "    # Perform multiple linear regression\n",
+    "    X = np.hstack((np.ones((lagged_inputs.shape[0], 1)), lagged_inputs))\n",
+    "    coefficients = np.linalg.lstsq(X, steer_la_trimmed, rcond=None)[0]\n",
+    "    \n",
+    "     # Calculate predicted values and residuals\n",
+    "    y_pred = X @ coefficients\n",
+    "    residuals = steer_la_trimmed - y_pred\n",
+    "    \n",
+    "    # Plot coefficients\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    plt.bar(range(window_size), coefficients[1:])\n",
+    "    plt.title('Effect of Multiple Lagged Steering Commands on Lateral Acceleration')\n",
+    "    plt.xlabel('Lag')\n",
+    "    plt.ylabel('Coefficient')\n",
+    "    plt.show()\n",
+    "    \n",
+    "    # Plot residuals\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    plt.scatter(y_pred, residuals)\n",
+    "    plt.title('Residuals vs Fitted Values')\n",
+    "    plt.xlabel('Fitted Values')\n",
+    "    plt.ylabel('Residuals')\n",
+    "    plt.axhline(y=0, color='r', linestyle='--')\n",
+    "    plt.show()\n",
+    "    \n",
+    "    # Histogram of residuals\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    plt.hist(residuals, bins=30, edgecolor='black')\n",
+    "    plt.title('Histogram of Residuals')\n",
+    "    plt.xlabel('Residual')\n",
+    "    plt.ylabel('Frequency')\n",
+    "    plt.show()\n",
+    "    \n",
+    "    # Perform normality test\n",
+    "    _, p_value = normaltest(residuals)\n",
+    "    print(f\"Normality test p-value: {p_value}\")\n",
+    "    if p_value < 0.05:\n",
+    "        print(\"The residuals do not appear to be normally distributed (p < 0.05)\")\n",
+    "    else:\n",
+    "        print(\"The residuals appear to be normally distributed (p >= 0.05)\")\n",
+    "    \n",
+    "    return coefficients, residuals\n",
+    "\n",
+    "# Analyze the relationship\n",
+    "max_lag, lagged_correlations = analyze_steering_lataccel_relationship(steerCommands, steer_la)\n",
+    "print(f\"Maximum correlation occurs at lag: {max_lag}\")\n",
+    "\n",
+    "# Analyze multiple input effect\n",
+    "coefficients, residuals = analyze_multiple_input_effect(steerCommands, steer_la, 7)\n",
+    "print(\"Coefficients for multiple lagged inputs:\")\n",
+    "for i, coef in enumerate(coefficients[1:]):\n",
+    "    print(f\"Lag {i}: {coef}\")\n",
+    "\n",
+    "# Additional analysis for residuals\n",
+    "print(\"\\nResidual analysis:\")\n",
+    "print(f\"Mean of residuals: {np.mean(residuals)}\")\n",
+    "print(f\"Standard deviation of residuals: {np.std(residuals)}\")\n",
+    "\n",
+    "# Analyze speed and lagged input \n",
+    "coefficients, residuals = analyze_speed_lag(steerCommands, vEgo, steer_la, max_lag)\n",
+    "print(\"Coefficients for speed and lagged inputs:\")\n",
+    "for i, coef in enumerate(coefficients\n",
+    "):\n",
+    "    print(f\" {coef}\")\n",
+    "\n",
+    "# Additional analysis for residuals\n",
+    "print(\"\\nResidual analysis:\")\n",
+    "print(f\"Mean of residuals: {np.mean(residuals)}\")\n",
+    "print(f\"Standard deviation of residuals: {np.std(residuals)}\")\n",
+    "\n",
+    "# Additional analysis: Check if the relationship changes with velocity\n",
+    "low_speed_mask = vEgo < np.median(vEgo)\n",
+    "high_speed_mask = vEgo >= np.median(vEgo)\n",
+    "\n",
+    "print(\"\\nAnalyzing relationship at different speeds:\")\n",
+    "_, low_speed_correlations = analyze_steering_lataccel_relationship(steerCommands[low_speed_mask], steer_la[low_speed_mask])\n",
+    "_, high_speed_correlations = analyze_steering_lataccel_relationship(steerCommands[high_speed_mask], steer_la[high_speed_mask])\n",
+    "\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.plot(range(len(low_speed_correlations)), low_speed_correlations, label='Low Speed')\n",
+    "plt.plot(range(len(high_speed_correlations)), high_speed_correlations, label='High Speed')\n",
+    "plt.title('Lagged Correlations at Different Speeds')\n",
+    "plt.xlabel('Lag')\n",
+    "plt.ylabel('Correlation')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Speed correlation analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fit: 0.969713844592532x + -0.0012270494827752525\n",
+      "Preset Fit: 0.7049x + 0.0013\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAB6IAAAIsCAYAAABY7GcZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gU1cIG8Hd30xM2jRAgkAoJNaFDiIYiCEjv3aigqHwgIFexXGxcRS5eL01FUEFEihcBaUGKAiJFJQREgZAKAUJI72V3vj+WHXazu8km2WRS3t/z8MDOzpk5c2YTduadc45MEAQBREREREREREREREREREREFiKXugJERERERERERERERERERNSwMIgmIiIiIiIiIiIiIiIiIiKLYhBNREREREREREREREREREQWxSCaiIiIiIiIiIiIiIiIiIgsikE0ERERERERERERERERERFZFINoIiIiIiIiIiIiIiIiIiKyKAbRRERERERERERERERERERkUQyiiYiIiIiIiIiIiIiIiIjIohhEExERERERERERERERERGRRTGIJiKiRuXcuXMICgrCuXPnamwfM2fOxMyZM6tUduDAgViyZImFa0SVtWTJEgwcOFDqatSa6nxmASAoKAhr1qypdLlbt24hKCgI33//fZX3TUREREREVNOqes1Tm2rjfgdRZVT3XkNDqQNRY2cldQWIiOqyffv2IS0tDU899ZTUVaFG6saNGzh06BDGjh2LVq1aSV0di9q6dSvs7e0xbtw4qatiUZ999hnatGmDQYMGSV2VeunEiRO4dOkS5s2bJ3VViIiIiAjA999/j9dee018bWNjg5YtWyIsLAwvvvgimjZtKmHtTLPU9catW7ewbt06/Pbbb0hJSYFSqYSvry969+6N+fPnW3x/NencuXPYsmULoqKikJWVhSZNmiAkJATjxo3D448/LnX1GgVjP0/Ozs4ICgpCv379MG7cODg5OVlsf/X1vlZxcTG2bduG3bt3IykpCXK5HJ6enujWrRueeuopBAQEAAAuXLiA06dPIyIiAkqlUuJa6zt37hyefPJJrFq1CkOHDq329hryvYaBAwciOTkZACCTyeDk5IQWLVqgS5cumDBhAkJCQiy2r5SUFOzcuRODBg1C+/btLbZdIjKNQTQRUTn279+PmJiYeveFnRqOGzduYO3atejVq1eDC6K3bdsGV1fXOn2jpirWr1+PIUOGNMiLw9pw4sQJbN26lUE0ERERUR0zf/58tGrVCsXFxfjjjz+wbds2nDhxAvv374e9vb3U1TNgieuNxMRETJgwAba2thg/fjxatWqFe/fu4a+//sKGDRv0gui6fn2zevVqrFu3Dr6+vpg8eTJatmyJzMxMnDhxAvPmzcPKlSsxcuRIqavZaGh/nkpLS3H//n2cP38e77//PjZt2oRPPvkE7dq1s8h+6ut9rfnz5+PkyZMYPnw4Jk6ciNLSUsTFxeHnn39G165dxSA6KioKa9euxdixY+tcEG1pDf1eQ/v27fH0008DAPLy8hAXF4fIyEjs3LkTTz31lN4DHNVx7949rF27Fl5eXgyiiWoJg2giojqsoKCgTl7QE9V3giCgqKgIdnZ2UleFiIiIiKheCA8PR+fOnQEAEydOhIuLC7766iscO3YMI0aMMFomPz8fDg4OtVlNi9q0aRPy8/OxZ88eeHl56b2XlpYmUa0MVXR9ExkZiXXr1mHIkCH46KOPYG1tLb43e/ZsnDp1CqWlpbVVXYL+zxMAzJkzB2fOnMHzzz+PF198EQcPHmy016uXLl3CTz/9hIULF+L555/Xe0+lUiE7O1uimhmq77/j6hJPT0+MHj1ab9nixYvx8ssvY9OmTfDx8cG0adMkqh0RVQfniCaiRis3Nxf/+te/MHDgQHTq1AmhoaF4+umnceXKFQCaOUR+/vlnJCcnIygoCEFBQXpzxhYXF2P16tUYPHgwOnXqhH79+mHFihUoLi422NfevXsxbtw4BAcHo1evXli4cCHu3Lmjt87MmTMxYsQI/Pnnn5g+fTpCQkLwn//8p9xjiI2NxUsvvYQ+ffogODgYQ4YMwccff6y3zl9//YXZs2ejW7du6Nq1KyIiInDx4kW9db7//nsEBQXh999/x7Jly9CnTx/06NEDS5cuRXFxMbKzs/HKK6+gZ8+e6NmzJ1asWAFBEMTy2nlev/jiC2zduhWPPfYYQkJC8Mwzz+DOnTsQBAHr1q1DeHg4goOD8cILLyAzM1OvDkePHsVzzz2HRx55BJ06dcKgQYOwbt06qFQqo+1048YNzJw5EyEhIXj00UexYcMGg/a5e/cuXnzxRXTp0gWhoaF4//33jZ6fhIQEzJs3D2FhYejcuTPCw8OxcOFC5OTklNv+ALBjxw4MGjQIwcHBmDBhAn7//Xej61Xm86L1/fff46WXXgIAPPnkk+LnUDvfk7ltVlZkZCSCgoJw/vx5g/e2b9+OoKAgXL9+HQCQmpqK1157DeHh4ejUqRMeeeQRvPDCC7h161a5+6io3MCBAxETE4Pz58+Lx6U7Z092djb+9a9/oV+/fujUqRMGDx6Mzz//HGq1Wm8/arUamzZtwvDhw9G5c2f07dsXS5cuRVZWlt56AwcOxJw5c3Dq1CnxZ3H79u3lHkNZX3zxBaZMmYLevXsjODgY48aNQ2RkpN46QUFByM/Px+7du8Xj0s75nZycjLfffhtDhgxBcHCwOJSfsbbMzs7G+++/L/5+Cg8PxyuvvIL09HRxnaKiIqxZswZDhgxB586d8cgjj+D//u//kJSUVOn2MVdxcTHef/999OnTB127dsXzzz+Pu3fvGl03JSUFr732Gvr27YtOnTph+PDh+N///lfu9pcsWYKtW7cCgNh+QUFB4vvmnAMiIiIiqh19+vQBAPH77JIlS9C1a1ckJSXh2WefRdeuXbF48WIA5n8vvXz5MmbNmiV+3xs4cKBBLzhztlXR9UZSUpLe92ZTkpKS4OnpaRBCA4C7u7vZ+5P6+mbVqlVwcXHB+++/rxdCaz366KMYMGCA+DotLQ2vv/46+vbti86dO2PUqFHYvXu3XhlL3AfQHse5c+fE4xg5cqR4zfvjjz9i5MiR6Ny5M8aNG4e//vpLr/zVq1exZMkSPPbYY+jcuTPCwsLw2muvISMjQ2+9NWvWICgoCImJiViyZAl69OiB7t2747XXXkNBQYHeuuZe81R0T6kqQkND8eKLLyI5ORk//PCD3nuxsbGYP38+evXqJbbHsWPHyt1eefe1iouLsWrVKowbNw7du3dHly5dMG3aNJw9e7bCes6ZMwePPfaY0fcmT56sNyrA6dOnMXXqVPTo0QNdu3bFkCFDKrzXdfPmTQBAt27dDN5TKBRwdXUFoDmvK1asAAA89thj4jHqXmObcz8OAKKjozFr1ix0794dISEhmDFjBv744w+9dbSfoxs3buDll19Gz549LRKM8l6DaXZ2dlixYgVcXFzw2Wef6d2LrEodzp07hwkTJgAAXnvtNbEtv//+ewDA77//jvnz56N///7ivbv3338fhYWFFj0uosaGPaKJqNF66623cPjwYcyYMQMBAQHIzMzEH3/8gdjYWHTs2BHPP/88cnJycPfuXfHC19HREYDmy84LL7yAP/74A5MmTUJAQACuX7+OzZs3IyEhAZ988om4n08//RSrVq3CsGHDMGHCBKSnp+Obb77B9OnTsWfPHr2hgzIzM/Hss89i+PDhGDVqlN6FbVlXr17F9OnTYWVlhcmTJ8PLywtJSUk4fvw4Fi5cCACIiYnB9OnT4ejoiNmzZ8PKygo7duzAzJkz8c033xjMsbJs2TI0bdoU8+bNQ3R0NHbs2IEmTZogKioKLVq0wMKFC3Hy5El88cUXCAwMxJgxY/TK79u3DyUlJZg5cyYyMzOxceNGLFiwAH369MG5c+fw7LPPIjExEd988w0+/PBDfPDBB2LZ3bt3w8HBAU8//TQcHBxw9uxZrF69Grm5uXj11Vf19pOVlYXZs2dj8ODBGDZsGA4fPoyVK1ciMDAQ/fr1AwAUFhYiIiICd+7cwcyZM9GsWTPs3bvX4KKquLgYs2bNQnFxMWbMmIGmTZsiJSUFP//8M7Kzs9GkSROT5+C7777D0qVLxYD/5s2beOGFF+Ds7IwWLVqI61Xm86KrZ8+emDlzJrZs2YLnn38e/v7+ACAOQVWZNtPVv39/ODg44NChQ+jVq5feewcPHkTbtm0RGBgIAJg3bx5u3LiBGTNmwMvLC+np6Th9+jTu3LlT7lDhFZV7/fXX8d5778HBwUF8wlk7t1xBQQFmzJiBlJQUTJkyBS1atEBUVBT+85//IDU1FW+88Ya4n6VLl2L37t0YN24cZs6ciVu3bmHr1q3466+/sG3bNr2bLPHx8Xj55ZcxefJkTJo0CX5+fibrb8zXX3+NgQMHYuTIkSgpKcGBAwfw0ksvYf369ejfvz8AYMWKFXjzzTcRHByMSZMmAQC8vb0BaG6qRUVFYfjw4WjevDmSk5Oxbds2PPnkkzhw4IA4+kFeXh6mT5+O2NhYjB8/Hh06dEBGRgaOHz+OlJQUuLm5QaVSiU/MDx8+HE8++STy8vJw+vRpXL9+XdxnZdrHHG+88QZ++OEHjBgxAt26dcPZs2fx3HPPGax3//59TJo0CTKZDNOnT4ebmxtOnjyJN954A7m5uSaHhZs8eTLu3buH06dPizcUKnsOiIiIiKh2aEMJFxcXcVlpaakY5rz66qtij05zvpempaVh1qxZcHV1xXPPPQelUolbt27hyJEjevs1Z1vlXW8AEL+PHj9+vNxj9PLywpkzZ3DmzBmEhoaaXK8uX98kJCQgLi4O48ePN2vu4cLCQsycORNJSUmYPn06WrVqhcjISCxZsgTZ2dmIiIjQW7869wEAzfDnL7/8MqZMmYJRo0bhyy+/xPPPP4933nkHH3/8MaZOnQoA+Pzzz7FgwQJERkZCLtf0rfr1119x8+ZNjBs3Dh4eHoiJicHOnTtx48YN7Ny5EzKZTG9fCxYsQKtWrbBo0SL89ddf+O677+Dm5oZ//OMf4jrmXvNUdE+pqkaPHo3//Oc/+OWXX8RrypiYGEydOhWenp549tlnxev5uXPnYs2aNRg8eLDRbZV3Xys3NxffffcdRowYgYkTJyIvLw//+9//MHv2bHz33XflDlk8bNgwvPrqq7h06RKCg4PF5cnJybh48SJeeeUVsd5z5sxBUFAQ5s+fDxsbGyQmJuLChQvltkHLli0BaD5b3bp1g5WV8Qhj8ODBSEhIwP79+/Haa6+JAbWbmxsA8+/HnTlzBs8++yw6deqE//u//4NMJsP333+PiIgIfPvtt3rHCAAvvfQSfHx8sHDhQr1gtKp4r6F8jo6OGDRoEP73v//hxo0baNu2bZXrEBAQgPnz52P16tWYPHkyunfvDuDhQw+RkZEoLCzE1KlT4eLigkuXLuGbb77B3bt3sXr1aosdE1GjIxARNVLdu3cX3nnnnXLXee6554QBAwYYLN+zZ4/Qrl074bffftNbvm3bNiEwMFD4448/BEEQhFu3bgnt27cXPv30U731rl27JnTo0EFv+YwZM4TAwEBh27ZtZtV/+vTpQteuXYXk5GS95Wq1Wvz3iy++KHTs2FFISkoSl6WkpAhdu3YVpk+fLi7btWuXEBgYKDzzzDN65SdPniwEBQUJS5cuFZeVlpYK4eHhwowZM8RlN2/eFAIDA4U+ffoI2dnZ4vKPPvpICAwMFEaNGiWUlJSIyxctWiR07NhRKCoqEpcVFBQYHOM///lPISQkRG89bTvt3r1bXFZUVCSEhYUJ8+bNE5dt2rRJCAwMFA4ePCguy8/PFwYPHiwEBgYKZ8+eFQRBEP766y8hMDBQOHTokMH+y1NcXCyEhoYKo0eP1qvfjh07hMDAQL32MffzIgiCMGDAAOHVV18VXx86dEivvrrMbTNjFi1aJISGhgqlpaXisnv37gnt2rUT1q5dKwiCIGRlZQmBgYHCxo0by91WWeaWGz58uF47aa1bt07o0qWLEB8fr7d85cqVQvv27YXbt28LgiAIv/32mxAYGCj88MMPeuudPHnSYPmAAQOEwMBA4eTJk2Ydw6uvvmrws1+2vYuLi4URI0YITz75pN7yLl266J1DU+UFQRCioqIMPs+rVq0SAgMDhR9//NFgfe3P5//+9z8hMDBQ+Oqrr0yuU5n2mTFjhtFzoevvv/8WAgMDhbfffltv+aJFi4TAwEBh9erV4rLXX39dCAsLE9LT0/XWXbhwodC9e3exLbS/O3bt2iWu88477wiBgYFG62DuOSAiIiIiy9FeL/76669CWlqacOfOHeHAgQNCr169hODgYOHu3buCIGi+QwcGBgorV67UK2/u99IjR44IgYGBwqVLl0zWpTLfcU1dbwiC5vrA2LV+WdevXxeCg4OFwMBAYfTo0cKyZcuEI0eOCPn5+Qbr1tXrm6NHj5q8djBGey29d+9ecVlxcbEwefJkoUuXLkJOTo4gCJa5D6A9jgsXLojLTp06JQQGBgrBwcF69zu2b99ucG1s7Bpr//79QmBgoN719+rVq4XAwEDhtdde01t37ty5Qq9evcTXlbnmMeeekjHan6fyPufdu3cXxowZI76OiIgQRowYodd2arVamDx5svD444+Ly86ePWvQRqbua5WWlhrcN8jKyhL69u1r0E5l5eTkCJ06dRKWL1+ut3zDhg1CUFCQeN6++uorITAwUEhLSyt3e2Wp1Wrx3k/fvn2FRYsWCd98843B/S9BEISNGzcKgYGBws2bN/WWm3s/Tq1WC48//rjB/bCCggJh4MCBwtNPPy0u036OFi1aZNZxaM9HRfebGvu9BkHQ/C547rnnTL6v/SwdPXq02nW4dOmSwX0ILWNtuX79er3PNRFVHofmJqJGS6lUIjo6GikpKZUuGxkZiYCAAPj7+yM9PV38ox2aTDuM1JEjR6BWqzFs2DC99Zo2bQofHx9xPS0bGxu9IYxMSU9Px2+//Ybx48eLT4pqaZ/4ValUOH36NAYNGoTWrVuL7zdr1gwjRozAH3/8gdzcXL2yEyZM0HtiODg4GIIgiMPWAJphkDp16iQOlaRr6NChej2ItU+Njho1Su8J1uDgYJSUlOi1ve7cR7m5uUhPT0ePHj1QUFCAuLg4vf04ODjozRtjY2ODzp0769Xp5MmT8PDwwNChQ8Vl9vb24pOjWtonwn/55ReDIbnK8+effyItLQ1TpkyBjY2NuHzs2LEGvajN/bxUVmXarKxhw4YhLS1Nb3juw4cPQ61W44knnhC3b21tjfPnz1dqeKWqltOKjIxE9+7doVQq9dqrb9++UKlU+O2338T1mjRpgrCwML31OnbsCAcHB4N2bdWqFR599NFK10f3uLSysrKQk5OD7t27GwwPZ075kpISZGRkwNvbG0qlUm8bP/74I9q1a2f0qXbtz+ePP/4IV1dXzJgxw+Q6lW2fipw4cQIA9IYYBGDQI0IQBPz4448YOHAgBEHQ2/cjjzyCnJycKg9XV91zQERERERV99RTTyE0NBT9+vXDwoUL4ejoiLVr18LT01NvPW0PVi1zv5dqr6N+/vlnlJSUGK2Dpb7jHj9+vMLe0ADQtm1b7NmzB6NGjUJycjK+/vprzJ07F3379sXOnTvN2pfU1zfa635tT9iKaK+ldef9tra2xsyZM5Gfny/WV6s69wEAoE2bNujatav4WjtyW58+ffTud2iX6173614fFBUVIT09XVzP2DXHlClT9F736NEDmZmZYhuZe80DVO+eUkUcHByQl5cHQDNy3tmzZzFs2DDxuj89PR0ZGRl45JFHkJCQUKU6KBQK8V6GWq1GZmYmSktL0alTpwqvr5ycnBAeHo5Dhw7p9Qg+ePAgunTpIp43bY/jY8eOGQxDXx6ZTIYvvvgCCxYsgFKpxP79+/Huu+9iwIABWLBggVlzRJt7P+7vv/9GQkICRo4ciYyMDHG9/Px8hIaG4rfffjOoe9nPUXU19nsN5tD+/tL+XNRUHXTbMj8/H+np6ejatSsEQeB9B6Jq4NDcRNRoLV68GEuWLEH//v3RsWNH9OvXD2PGjNELbU1JTExEbGysyaG50tLSAGiGwBIEAY8//rjR9coOL+Tp6akXapqivfDSDp9sTHp6OgoKCowOzxUQEAC1Wo07d+6IQ9oAMAi1tReTusNMa5cbCxiNrVfe8qysLLG9Y2Ji8N///hdnz541CMjLztXcvHlzgyG2nJ2dce3aNfF1cnIyfHx8DNYr2x6tW7fG008/ja+++gr79u1Djx49MHDgQIwaNarcYblv374NAPDx8dFbbm1tbfAZMvfzUlmVabOywsPD0aRJExw8eFCs18GDB9G+fXuxjWxsbLB48WJ8+OGHCAsLQ0hICPr3748xY8bAw8PD5LarWk4rMTER165dM9le2rmLEhMTkZOTY3a7ljeUuDl++uknfPrpp/j777/15vYu+xkzpbCwEOvXr8f333+PlJQUvQt23fOVlJRk8neG7jp+fn4mhygDKt8+FUlOToZcLheH4tLSDhmvlZ6ejuzsbOzYsQM7duwwui3d+acqo7rngIiIiIiqbunSpfDz84NCoUDTpk3h5+cnDpGsZWVlhebNm+stM/d7aa9evTBkyBCsXbsWmzZtQq9evTBo0CCMHDlSvE629Hdcc/j5+eHf//43VCoVbty4gZ9//hkbN27EP//5T7Rq1Qp9+/Ytt7zU1zfah6+1AU5FtNfSZc+tdooo7bWwVnXuA5S3XtnPkfY4dEPIzMxMrF27FgcPHjRoH2PXxGXveWiD0qysLDg5OZl9zQNU755SRfLz88Wp2pKSkiAIAlatWoVVq1YZXT8tLc3ggRBz7N69G19++SXi4+P1Hv4w57P1xBNP4OjRo4iKikK3bt2QlJSEK1eu4PXXX9db57vvvsObb76Jjz76CKGhoRg8eDCGDh1q8Pkqy8bGBi+88AJeeOEF3Lt3D7/99hu+/vprHDp0CFZWVli5cmW55c29H5eQkAAA5U5vlpOTA2dnZ/F1de8tlNXY7zWYQ/v7SxtI11Qdbt++jdWrV+P48eMG9z3L3ncjIvMxiCaiRuuJJ55Ajx49cOTIEZw+fRpffPEFNmzYgDVr1ojzDJuiVqsRGBgozrFTlvaCSa1WQyaTYcOGDVAoFAbrOTg46L3WffJOCqYuBCq6QNAydozlldd+Oc7OzsaMGTPg5OSE+fPnw9vbG7a2trhy5QpWrlxp8PSpqf1U1ZIlSzB27FgcO3YMp0+fxrJly7B+/Xrs3LnT4OK3Ksz9vFRGZdusLBsbGwwaNAhHjhzBW2+9hbS0NFy4cAGLFi3SW++pp57CwIEDcfToUfzyyy9YtWoVPv/8c2zevBkdOnQwuf2qlgM07RUWFobZs2cbfd/X11dcz93d3eQFqHZeKK3q/Hz9/vvveOGFF9CzZ0+89dZb8PDwgLW1NXbt2oX9+/ebtY333ntPnGeqS5cuaNKkCWQymcXmlSqrsu1jyf0Cmh4QY8eONbpOUFBQpbdriXNARERERFUXHByMzp07l7uOjY2NwfWfud9LZTIZVq9ejYsXL+Knn37CqVOn8Prrr+Orr77Cjh074OjoKNl3XEBzHRoUFISgoCB06dIFTz75JPbt21dhEC319Y02RL1+/bpZ61dWVe8DVFTe1HLd8gsWLEBUVBRmzZqF9u3bw8HBAWq1GrNnzzZ6jWVuncxRnXtK5bl79y5ycnLEMFx7ffXMM8+Y7AFfNjg3x969e7FkyRIMGjQIs2bNgru7OxQKBdavX290BLyyBgwYAHt7exw6dAjdunXDoUOHIJfL9Uals7Ozw9atW3Hu3Dn8/PPPOHXqFA4ePIgdO3bgyy+/NPveTrNmzTB8+HA8/vjjGDFiBCIjI7F8+fJyw1Jz78dpz/0rr7xicl7ssvfubG1tzaq3OXivwTwxMTEAHnYGqYk6qFQqPP3008jKysLs2bPh7+8PBwcHpKSkYMmSJZXq1U9E+hhEE1Gj1qxZM0yfPh3Tp09HWloaxo4di88++0y8aDD19KG3tzeuXr2K0NDQcp9Q9Pb2hiAIaNWqldGeyVWlfcK2vAtJNzc32NvbIz4+3uC9uLg4yOVygyePpXL+/HnxSeaePXuKy2/dulXlbXp5eeH69esQBEHvHBlrDwDiDYUXX3wRFy5cwNSpU7Ft2zYsXLjQ6PraJ6kTExP1nsAsKSnBrVu30K5dO3GZuZ8XY0ytb4k2GzZsGHbv3o0zZ84gNjYWgiBg2LBhBut5e3vjmWeewTPPPIOEhASMGTMGX375ZYVPIFdUrryfr/z8/Apv6Hh7e+PMmTPo1q1bjT/EcfjwYdja2uKLL77QG7Vg165dldrGmDFjsGTJEnFZUVGRwZP63t7e4kWWKd7e3oiOjkZJSQmsra1NrmPJ9vHy8oJarUZSUpJej4Cyw8C7ubmJNwkrOofGmPpcWOIcEBEREVHtq+z30i5duqBLly5YuHAh9u3bh8WLF+PgwYOYOHFipbZVk6PmdOrUCQBw7969Cvcn9fWNn58f/Pz8cOzYMeTl5VU4RLeXlxeuXbsGtVqtF9xqv/eX7VUslaysLJw5cwbz5s3D//3f/4nLtT1cq8Lcax6tiu4pVcXevXsBAI888giAh/d/rK2tLX591bp1a6xdu1ZvndWrV5u1XQcHB/Tv3x+RkZF47bXXcPDgQfTo0cOgZ7ZcLkdoaChCQ0Px2muv4bPPPsPHH3+Mc+fOVfp4rK2tERQUhISEBGRkZMDDw6Pcnztz7sdp29fJyalK7VtdvNdQsby8PBw9ehQtWrQQR2aoTh1MfWauX7+OhIQEfPjhhxgzZoy4/PTp01WuOxFpcI5oImqUVCqVwRcyd3d3NGvWTG8YHHt7e6PDOQ0bNgwpKSlG54QqLCxEfn4+AODxxx+HQqHA2rVrDZ5CFAQBGRkZVaq/m5sbevbsiV27dhkMi6Xdj0KhQFhYGI4dO6YXTt6/fx/79+9H9+7dxaGtpKa9uNVto+LiYnz77bdV3mZ4eDju3buHyMhIcVlBQYHBOcvNzUVpaanessDAQMjlcr3PQlmdOnWCm5sbtm/frrfe7t27DeYrMvfzYoy9vT0Aw2HFLNFmffv2hYuLCw4ePIhDhw4hODhYbxixgoICFBUV6ZXx9vaGo6NjuW1jbjl7e3ujczsNGzYMUVFROHXqlMF72dnZ4vkaNmwYVCoVPvnkE4P1SktLzZo3ylwKhQIymQwqlUpcduvWLRw7dsxgXQcHB6P7NvYU9pYtW/S2CWh+b1y9ehVHjhwxWF97vh9//HFkZGRg69atJtexdPuEh4eLdda1efNmvdcKhQJDhgzB4cOHjT4sU9Gw3NrPfNn6VeYcEBEREVHdYe730qysLIPrZm0PRe11RGW+45q63gA0w88mJSVVWPfff//d6HzV2rmEdQOuunx9M3/+fGRmZuLNN980uP4FgF9++QU//fQTAM33/tTUVBw8eFBv/1u2bIGDg4Peg9BSMtWbtuz1SWWYe81j7j2lyjpz5gw++eQTtGrVCqNGjRK326tXL+zYsUPvwQctc66vjN3X0raf7s9cdHQ0Ll68aHZ9n3jiCdy7dw/fffcdrl69avBge2ZmpkGZsj/TxiQkJBjc6wI0Py9RUVFwdnYWe7yaumdi7v24Tp06wdvbG19++aXR4eurOq2UuXivoXyFhYV45ZVXkJmZieeff14MkatTB1P3HIzdZxMEAV9//XW1j4OosWOPaCJqlPLy8tCvXz8MGTIE7dq1g4ODA3799VdcvnxZ7wnCjh074uDBg/jggw/QuXNnODg4YODAgRg9ejQOHTqEt956C+fOnUO3bt2gUqkQFxeHyMhIbNy4EZ07d4a3tzcWLFiAjz76CMnJyRg0aBAcHR1x69YtHD16FJMmTcKsWbOqdAxvvvkmpk6dirFjx2Ly5Mlo1aoVkpOT8fPPP4tP0C5YsAC//vorpk2bhmnTpkGhUGDHjh0oLi7GP/7xD4u0pSV07doVzs7OWLJkCWbOnAmZTIa9e/dWawihSZMmYevWrXj11Vdx5coVeHh4YO/evQZPSp49exbvvvsuhg4dCl9fX6hUKuzdu1cM00yxtrbGggULsHTpUkREROCJJ57ArVu38P333xvMCWXu58WY9u3bQ6FQYMOGDcjJyYGNjQ369OljkTaztrbG4MGDceDAARQUFBjMiZSQkICnnnoKQ4cORZs2baBQKHD06FHcv38fw4cPN7ldc8t17NgR27ZtwyeffAIfHx+4ubkhNDQUs2bNwvHjx/H8889j7Nix6NixIwoKCnD9+nUcPnwYx44dg5ubG3r16oXJkydj/fr1+PvvvxEWFgZra2skJCQgMjISb7zxht6wYNXRr18/fPXVV5g9ezZGjBiBtLQ0fPvtt/D29tabm1x7XGfOnMFXX32FZs2aoVWrVuI82Xv37oWTkxPatGmDixcv4tdff4WLi4te+VmzZuHw4cN46aWXMH78eHTs2BFZWVk4fvw43nnnHbRr1w5jxozBnj178MEHH+DSpUvo3r07CgoKcObMGUydOhWDBg2yePu0b98eI0aMwLfffoucnBx07doVZ8+eRWJiosG6L7/8Ms6dO4dJkyZh4sSJaNOmDbKysnDlyhWcOXMG58+fN7mfjh07AgCWLVuGRx55BAqFAsOHD6/UOSAiIiKiusPc76W7d+/Gtm3bMGjQIHh7eyMvLw87d+6Ek5OTGBBW5juuqesNQDOVEAAcP3683Lpv2LABV65cweDBg8XpZf766y/s2bMHLi4uiIiIENety9c3TzzxBK5du4bPPvsMf/31F0aMGIGWLVsiMzMTp06dwpkzZ/DRRx8BACZPnowdO3ZgyZIluHLlCry8vHD48GFcuHABr7/+ep15oN3JyQk9e/bExo0bUVJSAk9PT5w+fbpaI6uZe81j7j2l8pw8eRJxcXFQqVS4f/8+zp07h9OnT6Nly5b49NNP9YZ/fuuttzBt2jSMHDkSkyZNQuvWrXH//n1cvHgRd+/exQ8//GByP6bua/Xv3x8//vgj5s6di/79++PWrVvYvn072rRpU+7D8rr69esHR0dHfPjhh0bvoaxbtw6///47+vXrBy8vL/Earnnz5ujevbvJ7V69ehWLFy/Go48+ih49esDZ2RkpKSnYs2cP7t27h9dff10MX7XXjx9//DGeeOIJWFtbY8CAAWbfj5PL5Vi2bBmeffZZjBgxAuPGjYOnpydSUlJw7tw5ODk54bPPPjOrPUz58ccfjfaqHzt2LO816EhJSRHvZ+bn5yM2NhaRkZFITU3FM888gylTpojrVqcO3t7eUCqV2L59OxwdHeHg4IDg4GD4+/vD29sbH374IVJSUuDk5ITDhw9bNFgnaqwYRBNRo2RnZ4epU6fi9OnT+PHHHyEIAry9vcUv91rTpk3D33//je+//x6bNm2Cl5cXBg4cCLlcjnXr1mHTpk3Yu3cvjhw5Ant7e7Rq1QozZ87Ueyr6ueeeg6+vLzZt2oR169YB0MwJHBYWhoEDB1b5GNq1a4edO3di1apV2LZtG4qKitCyZUu9J1Dbtm2LrVu34qOPPsL69eshCAKCg4Px73//GyEhIVXet6W5urris88+w4cffoj//ve/UCqVGDVqlHjRXhX29vbYtGkT3nvvPXzzzTews7PDyJEjER4erjc3V1BQEB555BH89NNPSElJgb29PYKCgrBhwwZ06dKl3H1MnjwZKpUKX3zxBVasWIHAwEB8+umnWLVqld56lfm8lOXh4YF33nkH69evxxtvvAGVSoWvv/4avXv3tkibPfHEE/juu+8gk8kMnl5u3rw5hg8fjjNnzuCHH36AQqGAv78//vvf/5Yb0ptbbu7cubh9+zY2btyIvLw89OrVC6GhobC3t8eWLVuwfv16REZGYs+ePXBycoKvry/mzZuHJk2aiNt499130alTJ2zfvh0ff/wxFAoFvLy8MGrUKHTr1s3sdqhIaGgo/vWvf2HDhg14//330apVKyxevBjJyckGF4dLlizB0qVL8d///heFhYUYO3YsQkJC8MYbb0Aul2Pfvn0oKipCt27dxAtOXY6Ojti6dSvWrFmDI0eOYPfu3XB3d0doaKg4zJn24YRPP/0U+/fvx48//ggXFxd069ZNb/5lS7fP+++/D1dXV+zbtw/Hjh1D79698fnnnxsMPde0aVN89913WLduHY4cOYJt27bBxcUFbdq0weLFi8vdx+OPP46ZM2fiwIED+OGHHyAIAoYPH16pc0BEREREdYs530t79eqFy5cv4+DBg7h//z6aNGmC4OBgrFy5Uu9hX3O/45q63qiMOXPmYP/+/fjtt9+wb98+FBYWwsPDA8OHD8eLL76oV6+6fn2zcOFC9OnTB1u2bMG2bduQlZUFpVKJkJAQfPLJJ3jssccAaO6XbNmyBStXrsTu3buRm5sLPz8/fPDBBxg3bly16mBpH330Ed577z18++23EAQBYWFh2LBhg8m5lM1hzjWPufeUyqMdAtva2houLi4IDAzE66+/jnHjxhmE/W3atMGuXbuwdu1a7N69G5mZmXBzc0OHDh0wd+7ccvdj6r7WuHHjcP/+fezYsQO//PIL2rRpg3//+9+IjIws98FhXba2thg4cKA4V7q7u7ve+wMHDkRycjJ27dqFjIwMuLq6olevXgaf+7J69uyJ+fPn49SpU/jqq6+QkZEBR0dHtG/fHosXL9a7rxAcHIyXXnoJ27dvx6lTp6BWq3Hs2DE4ODiYfT+ud+/e2LFjBz755BN88803yM/Ph4eHB4KDgzF58mSz2qI8Bw4cMLpc+zuC9xo0/v77b7zyyiuQyWRwdHREixYtMGDAAEycOBHBwcEG61e1DtbW1li+fDn+85//4O2330Zpaan4++2zzz7DsmXLsH79etja2mLw4MGYPn06Ro8eXaVjIiINmVATM9YTEREREREREREREREREVGjxTmiiYiIiIiIiIiIiIiIiIjIohhEExERERERERERERERERGRRTGIJiIiIiIiIiIiIiIiIiIii2IQTUREREREREREREREREREFsUgmoiIiIiIiIiIiIiIiIiILIpBNBERERERERERERERERERWRSDaCIiIiIiIiIiIiIiIiIisigrqSvQ0AiCALVakLoalSaXy+plvRsKtr+02P7SYvtLj+dAWmx/abH9pcdzIK3abn+5XAaZTFZr+yOqqvp0bc/fo9LjOZAW2196PAfSYvtLj+dAWmx/abH9pSfFOajMtT2DaAtTqwWkp+dJXY1KsbKSw9XVEdnZ+SgtVUtdnUaH7S8ttr+02P7S4zmQFttfWmx/6fEcSEuK9ndzc4RCwSCa6r76cm3P36PS4zmQFttfejwH0mL7S4/nQFpsf2mx/aUn1TmozLU9h+YmIiIiIiIiIiIiIiIiIiKLYhBNREREREREREREREREREQWxSCaiIiIiIiIiGpMbGwsnn76aXTp0gVhYWFYsWIFiouLyy1z7949rFixAqNHj0bXrl0RHh6Ol19+GcnJyQbrpqSkYN68eejatSt69eqFN954A7m5uTV1OERERERERGQmzhFNRERERERERDUiKysLERER8PX1xZo1a5CSkoLly5ejsLAQS5cuNVnuypUrOHLkCMaPH4+QkBBkZGTg008/xcSJE7F//364ubkBAEpKSjB79mwAwEcffYTCwkJ8+OGHePnll7F+/fpaOUYiIiIiIiIyjkE0EREREREREdWI7du3Iy8vD2vXroWLiwsAQKVS4Z133sGcOXPg6elptFz37t1x6NAhWFk9vG3RrVs39O/fH3v27MEzzzwDADh8+DBiYmJw8OBB+Pv7AwCUSiVmzZqFS5cuITg4uGYPkIiIiIiIiEzi0NxEREREREREVCNOnjyJ0NBQMYQGgGHDhkGtVuP06dMmyymVSr0QGgCaN28ONzc33Lt3T2/7QUFBYggNAGFhYXBxccGJEycsdyBERERERERUaewRTUREREREREQ1Ii4uDuPHj9dbplQq4eHhgbi4uEptKz4+HmlpaQgICNDbvm4IDQAymQx+fn6V3n5ZVlZ1/9l9hUKu9zfVPp4DabH9pcdzIC22v/R4DqTF9pcW21969eEcMIgmIiIiIiIiohqRnZ0NpVJpsNzZ2RlZWVlmb0cQBCxbtgzNmjXD8OHD9bbfpEmTam+/LLlcBldXxyqXr21Kpb3UVWj0eA6kxfaXHs+BtNj+0uM5kBbbX1psf+nV5XPAIJqIiIiIiIiI6rQ1a9bg7Nmz2LhxIxwcHGp8f2q1gOzs/BrfT3UpFHIolfbIzi6ASqWWujqNEs+BtNj+0uM5kBbbX3o8B9Ji+0uL7S89qc6BUmlvdi9sBtFEREREREREVCOUSiVycnIMlmdlZcHZ2dmsbezcuRPr1q3Dv/71L4SGhhpsPzc31+j2W7RoUbVKP1BaWn9upqlU6npV34aI50BabH/p8RxIi+0vPZ4DabH9pcX2l15dPgd1d9BwIiIiIiIiIqrX/P39DeZqzsnJQWpqqsHczsYcOXIEb7/9NubPn48JEyaYtX1BEBAfH2/W9omIiIiIiKjmMIgmIiIiIiIiohoRHh6OX3/9FdnZ2eKyyMhIyOVyhIWFlVv23LlzWLRoESZOnIi5c+ea3P7Vq1eRkJAgLjtz5gwyMzPRr18/ixwDERERERERVQ2DaCIiIiIiIiKqEVOmTIGjoyPmzp2LX375Bbt27cKKFSswZcoUeHp6iutFRERg8ODB4uvY2FjMnTsXvr6+GD16NC5evCj+SUpKEtcbMmQI2rZti3nz5uGnn37CwYMH8frrr6N///4IDg6u1WMlIiIiIiIifZwjmoiIiIiIiIhqhLOzMzZv3oz33nsPc+fOhaOjIyZMmICFCxfqradWq6FSqcTX0dHRyMnJQU5ODqZOnaq37tixY7F8+XIAgLW1NTZu3Ihly5Zh0aJFsLKywuDBg/H666/X/MERERERERFRuRhEExEREREREVGNCQgIwKZNm8pdZ8uWLXqvx40bh3Hjxpm1fU9PT6xZs6aq1SMiIiIiIqIawqG5iYiIiIiIiIiIiIiIiIjIohhEExERERERERERERERERGRRXFobiIiIqpTomJScTUxE+18XNC1rYfU1SEiIiIiIiKieoL3FIiI6hb2iCYiIqI6IyomFWt2XcaxP25iza7LiIpJlbpKRERERERERFQP8J4CEVHdwyCaiIiI6oyriZmQywC1AMhlwLWkTKmrRERERERERET1AO8pEBHVPQyiiYiIqM5o5+MiXjCqBSDI20XqKhERERERERFRPcB7CkREdQ/niCYiIqI6o2tbD8wb3xnXkjIR5M35nIiIiIiIiIjIPLynQERU9zCIJiIiojqla1sPXiwSERERERERUaXxngIRUd3CobmJiIiIiIiIiIiIiIiIiMiiGEQTEREREREREREREREREZFFMYgmIiIiIiIiIiIiIiIiIiKLYhBNREREREREREREREREREQWxSCaiIiIiIiIiIiIiIiIiIgsikE0ERERERERERERERERERFZFINoIiIiIiIiIiIiIiIiIiKyKAbRRERERERERERERERERERkUQyiiYiIiIiIiIiIiIiIiIjIohhEExERERERERERERERERGRRTGIJiIiIiIiIiIiIiIiIiIii2IQTUREREREREREREREREREFsUgmoiIiIiIiIiIiIiIiIiILMpK6gpYQmxsLJYtW4aoqCg4Ojpi9OjRWLBgAWxsbEyWuXfvHjZt2oTTp08jKSkJTZo0Qc+ePbFo0SJ4eXnVYu2JiIiIiIiIiIiIiIiIiBqWeh9EZ2VlISIiAr6+vlizZg1SUlKwfPlyFBYWYunSpSbLXblyBUeOHMH48eMREhKCjIwMfPrpp5g4cSL2798PNze3WjwKIiIiIiIiIiIiIiIiIqKGo94H0du3b0deXh7Wrl0LFxcXAIBKpcI777yDOXPmwNPT02i57t2749ChQ7CyetgE3bp1Q//+/bFnzx4888wztVF9IiIiIiIiIiIiIiIiIqIGp97PEX3y5EmEhoaKITQADBs2DGq1GqdPnzZZTqlU6oXQANC8eXO4ubnh3r17NVVdIiIiIiIiIiIiIiIiIqIGr94H0XFxcfD399dbplQq4eHhgbi4uEptKz4+HmlpaQgICLBkFYmIiIiIiIiIiIiIiIiIGpV6PzR3dnY2lEqlwXJnZ2dkZWWZvR1BELBs2TI0a9YMw4cPr1adrKzqV76vUMj1/qbaxfaXFttfWmx/6fEcSIvtLy22v/R4DqTF9iciIiIiIiKimlTvg2hLWbNmDc6ePYuNGzfCwcGhytuRy2VwdXW0YM1qj1JpL3UVGjW2v7TY/tJi+0uP50BabH9psf2lx3MgLbY/EREREREREdWEeh9EK5VK5OTkGCzPysqCs7OzWdvYuXMn1q1bh3/9618IDQ2tVn3UagHZ2fnV2kZtUyjkUCrtkZ1dAJVKLXV1Gh22v7TY/tJi+0uP50BabH9psf2lx3MgLSnaX6m0Zw9sIiIiIiIiokai3gfR/v7+BnNB5+TkIDU11WDuaGOOHDmCt99+G/Pnz8eECRMsUqfS0vp5E02lUtfbujcEbH9psf2lxfaXHs+BtNj+0mL7S4/nQFpsfyIiIiIiIiKqCfX+UfTw8HD8+uuvyM7OFpdFRkZCLpcjLCys3LLnzp3DokWLMHHiRMydO7emq0pERERERERERERERERE1CjU+yB6ypQpcHR0xNy5c/HLL79g165dWLFiBaZMmQJPT09xvYiICAwePFh8HRsbi7lz58LX1xejR4/GxYsXxT9JSUlSHAoRERERERERERERERERUYNQ74fmdnZ2xubNm/Hee+9h7ty5cHR0xIQJE7Bw4UK99dRqNVQqlfg6OjoaOTk5yMnJwdSpU/XWHTt2LJYvX14r9SciIiIiIiIiIiIiIiIiamjqfRANAAEBAdi0aVO562zZskXv9bhx4zBu3LgarBURERERERERERERERERUeNU74fmJiIiIiIiIiIiIiIiIiKiuoVBNBERERERERERERERERERWRSDaCIiIiIiIiIiIiIiIiIisigG0UREREREREREREREREREZFEMoomIiIiIiIiIiIiIiIiIyKIYRBMRERERERERERERERERkUUxiCYiIiIiIiIiIiIiIiIiIotiEE1ERERERERERERERERERBbFIJqIiIiIiIiIiIiIiIiIiCyKQTQREREREREREREREREREVkUg2giIiIiIiIiIiIiIiIiIrIoBtFERERERERERERERERERGRRDKKJiIiIiIiIiIiIiIiIiMiiGEQTEREREREREREREREREZFFMYgmIiIiIiIiIiIiIiIiIiKLYhBNREREREREREREREREREQWxSCaiIiIiIiIiIiIiIiIiIgsikE0ERERERERERERERERERFZFINoIiIiIiIiIiIiIiIiIiKyKAbRRERERERERERERERERERkUQyiiYiIiIiIiKjGxMbG4umnn0aXLl0QFhaGFStWoLi4uMJyW7duxZw5c9CnTx8EBQUhMjLSYJ1z584hKCjI4M/ChQtr4lCIiIiIiIioEqykrgARERERERERNUxZWVmIiIiAr68v1qxZg5SUFCxfvhyFhYVYunRpuWX37t0LAOjXrx/27NlT7roffPAB/P39xdeurq7VrjsRERERERFVD4NoIiIiIiIiIqoR27dvR15eHtauXQsXFxcAgEqlwjvvvIM5c+bA09Oz3LJyuRy3bt2qMIhu27YtOnfubMGaExERERERUXVxaG4iIiIiIiIiqhEnT55EaGioGEIDwLBhw6BWq3H69Olyy8rlvGVBRERERERUn/GqjoiIiIiIiIhqRFxcnN6Q2QCgVCrh4eGBuLg4i+3nueeeQ/v27REeHo4PP/wQhYWFFts2ERERERERVQ2H5iYiIiIiIiKiGpGdnQ2lUmmw3NnZGVlZWdXefpMmTTB79mz07NkTtra2OHv2LL788kvExcVh/fr11dq2lVXdf3ZfoZDr/U21j+dAWmx/6fEcSIvtLz2eA2mx/aXF9pdefTgHDKKJiIiIiIiIqF7q0KEDOnToIL4ODQ1Fs2bN8O677+LSpUsIDg6u0nblchlcXR0tVc0ap1TaS12FRo/nQFpsf+nxHEiL7S89ngNpsf2lxfaXXl0+BwyiiYiIiIiIiKhGKJVK5OTkGCzPysqCs7Nzjexz2LBhePfdd/Hnn39WOYhWqwVkZ+dbuGaWp1DIoVTaIzu7ACqVWurqNEo8B9Ji+0uP50BabH/p8RxIi+0vLba/9KQ6B0qlvdm9sBlEExEREREREVGN8Pf3N5gLOicnB6mpqQZzR9c1paX152aaSqWuV/VtiHgOpMX2lx7PgbTY/tLjOZAW219abH/p1eVzUHcHDSciIiIiIiKiei08PBy//vorsrOzxWWRkZGQy+UICwurkX0eOHAAANC5c+ca2T4RERERERGZhz2iiYiIiIiIiKhGTJkyBVu2bMHcuXMxZ84cpKSkYMWKFZgyZQo8PT3F9SIiInD79m0cOXJEXHb58mUkJycjPT0dABAdHQ0AcHNzQ69evQAAixcvho+PDzp06ABbW1ucPXsWmzZtwqBBgxhEExERERERSYxBNBERERERERHVCGdnZ2zevBnvvfce5s6dC0dHR0yYMAELFy7UW0+tVkOlUukt27p1K3bv3i2+/vLLLwEAvXr1wpYtWwAAbdu2xb59+/Dll1+ipKQEXl5eeP755/Hcc8/V8JERERERERFRRRhEExEREREREVGNCQgIwKZNm8pdRxss61q+fDmWL19ebrk5c+Zgzpw51akeERERERER1RDOEU1ERERERERERERERERERBbFIJqIiIiIiIiIiIiIiIiIiCyKQTQREREREREREREREREREVkUg2giIiIiIiIiIiIiIiIiIrIoBtFERERERERERERERERERGRRDKKJiIiIiIiIiIiIiIiIiMiiGEQTEREREREREREREREREZFFWUldASKihioqJhVXEzPRzscFXdt6SF0dIovg55qIiIiIiIiIiIiIzMEe0URENSAqJhVrdl3GsT9uYs2uy4iKSZW6SkTVxs81EREREREREREREZmLQTQRUQ24mpgJuQxQC4BcBlxLypS6SkTVxs81EREREREREREREZmLQTQRUQ1o5+MihnVqAQjydpG6SkTVxs81EREREREREREREZmLc0QTEdWArm09MG98Z1xLykSQN+fSpYaBn2siIiIiIiIiIiIiMheDaCKiGtK1rQeDOmpw+LkmIiIiIiIiKUXFpOJqYiba+fABaSIiorqOQTQRUTXxAoiIiIiIiIiIqOZFxaRiza7LkMuAI7/fxLzxnXkvhoiIqA7jHNFERNWgvQA69sdNrNl1GVExqVJXiYiIiIiIiIioQbqamAm5DFALgFwGXEvKlLpKREREVA4G0URE1cALICIiIiIiIiKi2tHOx0W8B6MWgCBvF6mrREREROVgEE1EVA28ACIiIiLJqEshL0gAVHniIpuUvXA51w9uJ9sBgiBd3YiIiIhqQNe2Hpg3vjMG9WjNYbmJiIjqAc4RTURUDdoLoGtJmQjy5hzRREREZHnywtuwyjoHRX4CFAXaP/GQF96ETFAhs+sulDQdDACQqQthnR2lKVecArVtcymrTkRERGRxXdt68P4LERFRPcEgmoiomngBRHVFVEwqriZmop0PH4ogIqo31CWQF97SCZgTIC9IQIH3XJS69AIAWKefgPLKHKPFBbkt5CVp4usS10eRFfItVPa+UFu718ohEBEREREREREZwyCaiIjqLAar5ouKScWaXZchlwFHfr/JIcqIiOoKQYCsNAOK/ASo7Lwg2HoCAKzTjqHJ3wvFXs1llbiGi0G0yjEQJc69oXLwhcpe80dt76f527Y5IHs445LariWK7VrWzrFRnfbkk0/ihRdeQGhoqNH3z549i08++QRff/11LdeMiIiIiIiIGosGEUTHxsZi2bJliIqKgqOjI0aPHo0FCxbAxsam3HJbt27FyZMnER0djYyMDKxatQpDhw6tpVoTEVF5GKxWztXETHGucrkMuJaUyfYiIqpl8sLbsEk9pNezWVGQAHlpFgAgp/1/UdjqGQCAIHeAoiDhwb/txIBZZe8LtYMvSlz7itstde6OzF5Hav14qH47f/48Jk6caPL99PR0/Pbbb7VYIyIiIiIiImps6n0QnZWVhYiICPj6+mLNmjVISUnB8uXLUVhYiKVLl5Zbdu/evQCAfv36Yc+ePbVQWyIiMheD1cpp5+OCI7/fFNssyNtF6ioRETUcggBZSToUBfGakDk/XgyZC1s9jaLmEwAAioJ4NLm60OgmVDbNAaFUfF3apDMyev4Itb0v1DbN9Ho1E1mKTCYz+V5iYiIcHR1rsTZERERERETU2NT7IHr79u3Iy8vD2rVr4eLiAgBQqVR45513MGfOHHh6epZbVi6X49atWwyiiYjqGAarldO1rQfmje+Ma0mZCPLmUOZERJWmLoKiIAmKgnio7LyhcmoHALDKugDnP0ZCrsoxWqzUuacYRKscAlDUdBhUDr5Qiz2c/aCy9wYUDvoFrZxQ6tKnRg+JGp/du3dj9+7d4utPP/0UO3fuNFgvJycH165dQ3h4eG1Wj4iIiIiIiBqZeh9Enzx5EqGhoWIIDQDDhg3DW2+9hdOnT2PcuHEmy8rl7HVARFRXMVitvK5tPdhORERmkBWnwv7Wl5phs/MfDJ9ddBsyCACAfN+Xkdf2LQCA2raZGEKrbFs+mJ/5Qcjs4ItSZTdxu2rb5sjuuqP2D4jogYKCAmRkZIiv8/LyjF73Ojg4YMqUKZg7d25tVo+IiIiIiIgamXofRMfFxWH8+PF6y5RKJTw8PBAXFydRrYiIzBcVk4qriZlo58OwtSwGq0REVCmqQigKk/SGztb+KfIci3z/VwAAMlUBHGP/ZVBcUDhqgmZrV3GZ2rYl0vv+DpWdN6Cwq7VDIaqKadOmYdq0aQCAgQMH4o033sBjjz0mca2IiIiIiIiosar3QXR2djaUSqXBcmdnZ2RlZUlQI8DKqn71tFYo5Hp/U+1i+0tL6va/cD0Va3ZdhlwGHPn9JhZMCkG3wMYTvErd/sRzIDW2v7TY/tKr9DkQBMiK70GeHw9FfgLUdi1Q6t4PACAruAWXn9uZLKpu0v7h93Sn1ihq9STU9j5QOfhp5ml28IVg4wE8mFP34YWSHHBuV/8vnIzgz0DDdvz4camrQERERERERI1cQ7yfIim5XAZXV0epq1ElSqW91FVo1Nj+0pKq/ePuxkEul0GtFiCXyxB/NxeP9faVpC5S4udfejwH0mL7S4vtLz29cyCoAdmDYLQkF7j0JpAb9/CPquDhuj7TgDZPaP7tHADIrACFPeDkX+ZPAGyc28HGUed7evjmmj+weoI/Aw2XSqVCZGQkzp07h7S0NMyfPx9BQUHIycnBmTNn0K1bNzRt2lTqahIREREREVEDVe+DaKVSiZycHIPlWVlZcHZ2rvX6qNUCsrPza32/1aFQyKFU2iM7uwAqlVrq6jQ6bH+NC9dT8XdCOtr7utVqj2Cp29+/eRNNCC3T/P7wa+6EjIy8Wq+HVKRuf+I5kBrbX1psf4kIAmRFdyHPj4d1USLsS2+hOCMG8vx4yPPjUeLeH/khGzXrqlVwub4WMkH1sDjkUNu3gtreF6W2gSjU+X9TNjAOgrWr2KtZTzGA4sbzf6w5pPgZUCrt2QO7lmRnZ2P27Nm4dOkSHBwcUFBQgBkzZgDQzBG9bNkyjBkzBosWLZK4pkRERERERNRQ1fsg2t/f32Au6JycHKSmpsLf31+SOpWW1s8bmSqVut7WvSFozO0fFfNweOrD529i3vjOtT4vsFTtH+zvjnnjO+NaUiaCvF0Q7O/eKD8HjfnzX1fwHEiL7S8ttn8NUOVBUZAIRX4CFIUJUFu5oqjlVM176hI0/SkIMjxscxudovK8OJ3zIUd+wBtQW7lC5eCrmb/ZrjUg1ymhe+7kLoBKACDU0IE1TPwZaJhWrlyJmJgYfPHFF2jfvj369u0rvqdQKDBkyBCcOHGCQTQRERERERHVmHofRIeHh+Ozzz7Tmys6MjIScrkcYWFhEteOiMxxNTFT0yNYAOQy4FpSZq0H0VLq2tajUR0vERE1AIIastIcCNYPRiASBDS58jwU+bFQFCRAXnxPb/USlz4Pg2i5NVT2vpBBDbWDL6xd2iJf0Qqltj5Q2ftC5eCrVzbfb3EtHBBRw3Ps2DHMnDkTYWFhyMjIMHjf19cXu3fvlqBmRERERERE1FjU+yB6ypQp2LJlC+bOnYs5c+YgJSUFK1aswJQpU+Dp6SmuFxERgdu3b+PIkSPissuXLyM5ORnp6ekAgOjoaACAm5sbevXqVbsHQtSItfNxwZHfb4phdJC3i9RVIiIiIgCK3L+gyI+HoiBeEzAXJEBRkABFQSJKld2Q2fOwZkWZDNYZp6EoTBLLqq1coLL3g8rBF6VNQvS2mxF2AZDJYWUlh6urI4oy8tgjl8jCcnJy0KpVK5Pvl5aWQqVSmXyfiIiIiIiIqLrqfRDt7OyMzZs347333sPcuXPh6OiICRMmYOHChXrrqdVqg4vsrVu36j0B/uWXXwIAevXqhS1bttR85YkIgKZHsO7w1FL0Dr5wPRVX4tLRzkea/ZcnKiYVVxMz62TdiIioHhNUkBfd0QyfXRAPeUE8ILNBfsAScRXnqAlQFN4yWlxeeFPvdV6btyDIraG294XK3kczV7MpMs4RTFTTvL29ceXKFZPvnz59GgEBAbVYIyIiIiIiImps6n0QDQABAQHYtGlTuesYC5aXL1+O5cuX11CtiKgyKjM8taWD2XN/3sF/d0ZDLgOO/C7NHNWm6M6fXdfqRkREdZ+sNBuy4lSoHR6GTU3+fB5WWeehKEiCTCjWW19l66UXRJc26QK1TTPN3Mz2flDZPxw+W22r39OyqMXEmj0YIqqUCRMmYOXKlejduzf69OkDAJDJZCguLsa6detw6tQpvPvuuxLXkoiIiIiIiBqyBhFEE1HjURPB7KXY+3V2jurGPn82ERGZxyrzHKxyrz4YPjv+wfDZCZCXpENl1wrpj/4lrisvSIRV/g0AgCCzgsrOG2oHX80w2vZ+gCAAMhkAILvLt5IcDxFVX0REBG7cuIFFixZBqVQCABYvXozMzEyUlpZi8uTJmDiRD5AQERERERFRzWEQTUT1Sk0Es8EBTfHDybgqzVFd08Nmc/5sIiKSlWSVmZ85AbLSHOR03iiu4xSzFNaZZ4yXVxcB6lJArvnqn9/mTeQLKk0vZzsvQKaoleMgotolk8mwbNkyjBkzBocPH0ZiYiLUajW8vb0xbNgw9OzZU+oqEhERERERUQPHIJqI6pWaCGZ7d2qBBZNC8Fd8eqXmqK6NYbPrwvzZRERUw9SlkBfdgrzwDkpdQ8XFTlf+D7ap+yAvyTAoIkCOnI6fAHIbAECJSygEhaNm2Gx7P6gcfB8Mp+0DwUqpV7bENaxmj4eI6pQePXqgR48eUleDiIiIiIiIGiEG0USNTE334K1pNRXMdgv0QLC/e6XK1Naw2ZWZP5uIiOo26/STsMr6Q+zZrCiIh7zwJmSCCgLkuP9YKiC3BgDIhCIxhFbbeDwImR/8cfAHBLW43by2b0txOERUzxQUFODAgQMoLi5Gv3794OXlJXWViIiIiIiIqAFjEE3UiNRGD97aUFeCWamGza7vDxMQETVI6hLIC2/qBMwJUOQnQF6YiMyeR8Vw2S75a9jd3WlQXJDbQmXvA1lJOgRbTwBAvt8ryPdZAJW9D2DlVKuHQ0T13+uvv45Lly5h//79AIDi4mJMmjQJMTExAIAmTZpg8+bN6NChg5TVJCIiIiIiogaMQTRRI1JbPXilUtsBrRTDZjeUhwmIiOodQYCsJP1ByJyIomajxDmXHa/+A/Y3N0AGtdGi8sJbUDv4AQBK3MIB4EGvZj+o7f00Q2jbNgdkcr1yKse2NXhARNTQnTt3DqNGjRJf79+/HzExMVi5ciXatWuHefPmYe3atfjkk08krCURERERERE1ZAyiiRqRyvbgNRXsWjrwtcT2pApoa7t3dkN/mICIqK6wTjsOm7TjUBQkQP6gh7O8NFt8P+2Ry1Db+wAABKsmkEENQW6nN3y22kEzX7Pa5uHv6UKvJ1Ho9WStHw8RNT7379/XG3r76NGj6NSpE0aMGAEAmDRpEr744gupqkdERERERESNAINookakMj14TQW7lg58q7q9suF1YwlopRoOnIioQRB7NcdDUZAA66JEQHULThkxkOfHI7NHJNT2rQEA1hm/wCFxtcEmVLYtoLb3hUxVIC4r8H4Bha2fg9qmmUGvZiIiqdjb2yMnJwcAUFpaivPnz2PGjBni+46OjuL7RERERERERDWBQTRRI2NuD15Twa6lA9+qbM9YeN1Y5muWYjhwqj2c/5vIAtRFUBQkQVEQD3lBAoo8x0OwcQcAOMT+C47xKwyKWD/4W1EQLwbRJa6PIl+Vr+nZbK/p2ayy9wYU9gblBRsPCDV2QEREVdOxY0fs3LkTvXv3xvHjx5GXl4eBAweK7yclJcHd3V3CGhIREREREVFDxyCaiIwyFeyWXW5tJce2ozFVDs6qEiAbC6+nPNa20czXXNvDgVPt4PzfRGYSBACC2PPYOv0E7O5shzz/wfDZRbch04mFVY4dUOL2CABAbdcaAmRQ27aEyt4XgqMfbN0CkSfzQrGtN0qdOorlStwHoMR9QK0eGhGRJS1YsACzZ8/G+PHjIQgChgwZguDgYPH9I0eOoFu3bhLWkIiIiIiIiBo6BtFEBMCwJ6apnre6y62t5DhwJrFawVlVeviaCq85XzPVZ/w8EelQFUJRkCj2albo/slPQFa371Hi2hcAoMiPg93trXrFBYWjOE+zoLATlxe2mITCFpOBB8usrOSwdXVEcUYeSkvVtXd8RES1oHPnzjh06BAuXLgApVKJXr16ie9lZ2dj2rRpesuIiIiIiIiILI1BNBGZ7IlpKtjVLt92NMYiwVllA+S6Mjx1YxkOvLLqQv3qQh0qi/N/U6MiCJAV33sQLsdDkZ+AoubjoXJsCwCwu70VTa4uNFlcXhAPPAiiS1z6IC/gTTF4Vjn4QbBuCshkhgWNDKtNRNSQubm5YdCgQQbLlUolIiIiJKgRERERERERNSYMoomoyj0xpQzO6sLw1FIE4pYYvrk6IW1FZevC8NJ1oQ5VUVcesCCyGFU+AJkY/lplnoVD/Mdiz2aZukB/dXtvMYhWOfhCrWiimZvZwfdhyCzO1+zzsJxTe+Q7ta+1wyIiqk9UKhUiIyNx7tw5pKWlYf78+QgKCkJOTg7OnDmDbt26oWnTplJXk4iIiIiIiBooBtFEVOVAmcFZ/RsOvDohrTlly6tfbfVSrs9DXNeFByyIKkNWmg1FzhVNr2ad4bPl+QlQFN9FdqfPUdRiyoN1c2F7/5BYVoAcarvWYtCstvcV3ytxG4C0AbeM92omIiKzZGdnY/bs2bh06RIcHBxQUFCAGTNmAAAcHBywbNkyjBkzBosWLZK4pkRERERERNRQMYgmomoFynUtODMVdtbHoZqNqW4v9OqEtOaUNVW/2uylzCGuiSxIlaeZqzk/QZyvubjZKJS4PQoAsM48C+eoCSaLKwpvif8ubRKMnHYfPwye7VoDchvjBWVyix4GEVFjtHLlSsTExOCLL75A+/bt0bdvX/E9hUKBIUOG4MSJEwyiiYiIiIiIqMYwiCYiAHUvUK4KU2FnfR2q2ZiKHhqoKHCvTkhrTllT9avNXsrsqU9UCYIa8qI7EOS2EGw0Q7Mqci6jyd8LNT2bi+8ZFrFpKgbRKns/vWGzHw6drRlSW7ByfVjOthkKW8+qneMiIiIcO3YMM2fORFhYGDIyMgze9/X1xe7duyWoGRERERERETUWDKKpwWkoPV+p8kyFnbU9VHNNfwZNPTRgTuBe3d7v5pQ1Vr/a7qVcEw9W8HcL1WeykixYZ5x6MHR2vGbo7IIEKAoSIROKkRfwT+T7/0OzstwW1lnnxbJqKxdN4OygCZlLXB72qFM5tkX6I5dq+3CIiMgMOTk5aNWqlcn3S0tLoVKparFGRERERERE1NiYHUSvXbu20huXyWSYO3dupcsRVVVD6vnaUNVkmGcq7Cy7/F5GPqJiUmvksyHlZ9DcwF23l7Lua2PKnq+qBrz1vZcyf7dQnSaoIC+6A0V+AuQPgmZFQQKK3R9DUctpAAB50V04R08zXlxmBVlptvhaZe+DrOCvH/Rs9oFg7Wq0HBER1W3e3t64cuWKyfdPnz6NgICAWqwRERERERERNTbVCqJlMhkAQBAEg+WCIDCIplpX2z1fqXLMCfOqE1SbCju1y09F38HFG/dxKTYNF2+kYd74zujZ3tNixwcAp6JvA6j9z2BUTCpSM/PF/ZbX69jcUNXS4Wt5IfaF66n46UIyZBDwaEjLOvdzy98tJDVZaTbkBQmA3B4qx7YAAHnBTThfGA1FQRJkQrFBGUFuLwbRKntvlCi7PRg6208cOltl7wu1rRcg1/lKKLdFseeYWjgqshSO2EBExkyYMAErV65E79690adPHwCaa/Xi4mKsW7cOp06dwrvvvitxLYmIiIiIiKghMzuIvnr1qt7rlJQUPPfcc2jbti0iIiLg5+cHAIiLi8PmzZsRGxuL9evXW7a2RBWo7eF/qXIqCvMsEXyaCjtNDdFdmSC6ohv9UTGpuHgjTXxdW59B3XYDgOCApng0pIXJtjM3VK2t8PXcn3fw353R4mvtQwJ1KUzh7xaqNap82N39HxT58ZA/6NmsKEiAvCQdAFDg9RRyO6wGAKht3GGVfwMAIMisobL3fjg/s70fSp17PNyuwh6ZvX+u7aOhWsARG4jIlIiICNy4cQOLFi2CUqkEACxevBiZmZkoLS3F5MmTMXHiRIlrSURERERERA1ZleeIfuedd+Dj44OVK1fqLQ8ODsZHH32E+fPn491338W6deuqXUkic9W34X+jYlJx/WYmenZsgUAvpdTVqXFlw7yUjAK9IbJrOvisTphozo1+3foDQJc2TWtlnuKy7dbM1b7c/ZrbDrUVvl6Kva/3Woa61+O4vv1uobpJVpKpCZUfhMuK/ARYFSYALcKA1q8+WEtAk7/+z2h5tbU7INP56qZwQGaPSKjsWkNt1xKQKWr8GKju4YgNRGSKTCbDsmXLMGbMGBw+fBiJiYlQq9Xw9vbGsGHD0LNnT6mrSERERERERA1clYPos2fPYvHixSbf79Onj0FITVQbqjqHbW3TDTYPn7+JBZNCEOzvLnW1atTDIbJv4+KNNFyOvY/oG/fFULemg8/qhInm3OgvW/9HQ1pYtP6mwvDKtpu57aC7nrWV3Kw5pasiOKApfjgZJ74WUDd7HNeX3y0kIXUp5EW3oMhPgCC3RalrqGa5qgDuJ4MgL800Xs5aDrR+8G+FIwo9x0GwdoPK3u/h8Nn2PhCsDB9YKnHtWyOHQvUHR2wgImMKCgrwj3/8A48//jhGjRqFHj16VFyIiIiIiIiIyMKqHETb2tri4sWLmDZtmtH3o6KiYGtrW+WKETV0esGmXIa/EzMafBAN6A6RnWYQ6pYNSAFg29EYi855WTZMvHA9FXF34+DfvEm57W/Ojf6arr+pMLwqAbu5oap2HVO9wS0xL2nvTi2wYFIIfr6QDNTiHNGcU5WqRVDDPuG/4tDZioIEyAtvQiaoAADF7gOR5bpHs67CXuzJrLbxeDB0tuYPnPzh2KKb3qZzgjfV3nFQvccRG4jIGHt7e/z6668IDw+XuioAgNjYWCxbtgxRUVFwdHTE6NGjsWDBAtjY2JRbbuvWrTh58iSio6ORkZGBVatWYejQoQbrpaSkYNmyZfjll19gbW2NwYMH47XXXoOTk1NNHRIRERERERGZocpB9MiRI7FlyxYolUrMmDED3t7eAICkpCRs2bIF+/fvx8yZMy1WUaKGRi/YVAto7+MqdZVqTXmhrjYgNXfOy+qEieI+5DKo1UK582pWphdxZepfGea0W9njs0TQaioAL3uMIW2aIrycuanL0y3Qo1YfxOCcqmSSugTywpt6AbMiXzOctsrBDznBmzXryeRwSFwDeUmaXnFBbqsJme189JZn9DoCtY0nYKV/Q9zKSg5HV0cgI69GD4saNo7YQETGdO/eHVFRUZg0aZKk9cjKykJERAR8fX2xZs0apKSkYPny5SgsLMTSpUvLLbt3714AQL9+/bBnzx6j65SUlGD27NkAgI8++giFhYX48MMP8fLLL2P9+vUWPRYiIiIiIiKqnCoH0YsXL0ZGRga++eYbbN26FXK5HACgVqshCAKGDx9e7tDdRI2dNti8fisLPTs0R6CXEqWlaqmrVSvMCXXNGQq7umGiuA+1YNa8mpW50V8Tc3ZWptebJYNWUwF42Tmxo29ohlofHuqD4hK1GIDXxZ7HnFO1ERMEyErSxZAZAIqajxffdj/VDvLiVKNFZaocvdcFrTU3vTW9m/2htveF2tYTkMkNyqodAix0AEREROZZunQpZs2ahY8//hhTp05F8+bNJanH9u3bkZeXh7Vr18LFxQUAoFKp8M4772DOnDnw9PQst6xcLsetW7dMBtGHDx9GTEwMDh48CH9/fwCAUqnErFmzcOnSJQQHB1v6kIiIiIiIiMhMVQ6ibWxs8O9//xuzZs3CiRMncPv2bQCAl5cXwsPD0a5dO4tVkqih6trWAz3be8LV1REZjaw3XEWhro21HGoBkD0IC+9l5CMqJlWvTNkw8VT0nUoFnmLA+qBHtCXn1aypOTvNDcMtGbSaCsC1x6hLBuDAmUQxAB8e6qP3uq70PK7M+amLQTpVQFABMoX40iF2Oaxy/4RcO4R2abb4XqlDW70gWmXXCrLSHL3hs9UOvpr5mu399HaTH/BGzR8LERFRFY0aNQoqlQqff/45Pv/8cygUCoOhsGUyGf74448arcfJkycRGhoqhtAAMGzYMLz11ls4ffo0xo0bZ7Ks9oH3irYfFBQkhtAAEBYWBhcXF5w4cYJBNBERERERkYSqHERrtWvXjqEzUSUw1KpYVEwqDpxJhAyA8KC37aXYNFy8kaYXZJYNEy/euF+peYy7tvXAgkkhiL+bC7/mTlUeGtrY9qWes9PSQbixAFx7jKeib+PijTRxXzKdAPxyXFqd7Hls7vnhEN51l6z4PhQF8VDkPwiXdYbSFhSOyOh7XlzXJvUQrHOi9MqrbFtAbe+LUscgveVZ3X6AYKXUfJCJiIjqsSFDhkBWB/4/i4uLw/jx4/WWKZVKeHh4IC4uziLb1w2hAU3A7ufnV+3tW1lVHIRLTaGQ6/1NtY/nQFpsf+nxHEiL7S89ngNpsf2lxfaXXn04B9UOoi9evIhz584hLS0N06ZNg6+vLwoKChAXFwdfX184Ojpaop5EDYKxUKtne9ND0dVVFYXp1Q3byw75LIPxIFM3TLyXkY9LsWkVzmNcNkjsFuiBx3r7IiMjz6yh0cseW3nb1w1va/sBBN22sbaS42piprhcty4AqlUv3TmxtfvS9oBWC0Bnf3ckpeRavGe4JZjTu5xDeEtIXQRFQZIYMMtKc1Hgt1B82/nCWFjnRBstKshtAUEtDpFd4P0cCktzoLbX9mz2BhT2xstaO1v+WIiIiCSwfPlyqasAAMjOzoZSqTRY7uzsjKysLItsv0mTJhbfvlwug6tr/bmfoVQa/25DtYfnQFpsf+nxHEiL7S89ngNpsf2lxfaXXl0+B1UOoouLi7Fo0SIcO3YMgiBAJpNhwIAB8PX1hVwuxzPPPIOnnnoKL7zwgiXrS1SvGQu16lsQXVGwa4kepGV78wqAySBTNwjV7ZVrbB7j6gaJxo6tNuayrirtPnT3XXaobAAWqZduqOvfUqnX07js66qQaiSBmhpinSDO1SzYPByJwCF2OawzTmp6OBcmQwbh4epyOxT4LhB7Kqsc/CEvvq8zdLbuHz9oHmHRKGo5vbaOioiIiBoItVpAdna+1NWokEIhh1Jpj+zsAqhUFT9YS5bHcyAttr/0eA6kxfaXHs+BtNj+0mL7S0+qc6BU2pvdC7vKQfSqVavw888/4+2330bv3r0xdOhQ8T1bW1sMHToUx44dYxBNpKMhhFoVBa+WCH7LDpsMoMIgs6J5jLXDRVtXY3g93WOTyYC9v8Sjs7+7eKymzml12yQqJhWnom9DgAzhIS0qVbbsvnWHygZM9zY3Vgdzg+CyPY3NndfaFKmCfO0xDw/1QUmpulJBOofgf0ieHw+rvOuQF8SLQ2crChKgyE8AIOD+wLtiuGyV+ydsMn4Ry6oVTg96MWv+QF0EKOwAADmdvxJ7PBMREZFx6enp2LBhA06cOIHk5GQAgJeXF/r164dZs2ahadOmNV4HpVKJnJwcg+VZWVlwdq7+SCRKpRK5ublGt9+iRYtqbducEZPqCpVKXa/q2xDxHEiL7S89ngNpsf2lx3MgLba/tNj+0qvL56DKQfSBAwcwZcoUTJ48GRkZGQbvBwQEIDIyslqVI2poLDlvcF3tIVrR++bW21iYWdE2TM1jrO0FLANw4Ewi/FsqxV7U129momfHFgj0Mhwu0NSxA5q5q2+m5CIpJbfCoLI6DyBoQ1it6Bv3KxXElt132aGyy+ttXrYOur2qi0vUtfbZk2J4bN1jVguoVJs3qnmlBQHy4hTN8Nn58Q96Mt9Cboe1YrjsdP0N2KbuN14cMshK7kOw0bRPQavZKGo2GioHTa9mwdrd9FzNDKGJiIjKFRMTg6eeegppaWkICQkRHx5PSEjAV199hb1792LTpk0IDAys0Xr4+/sbzNWck5OD1NRUg7mdq7r969ev6y0TBAHx8fEICwur9vaJiIiIiIio6qocRKelpSEoKMjk+wqFAoWFhVXdPFGDVd3eoYBlg67KBtoVhenlvW+JeldlG8UlaoMgE3g4ZPXh8zexYFIIgv3dy91OWdpBg5NTczF/QojJ9arzAMKp6NsGy/b/mmD2HN0A0KWNOwAZHn3Qm1p3qGyg4t7mej3BAb2hvWsjZJViJIHqhN8Nbl5pVT4UBYlQObYTQ2GHuH/D9u53UBQkQqYuMCiS1+YtCLbNAAClTh005csMn63p6ewNyG3FciXu/WvlkIiIiBqDd999FyqVCjt37kRwcLDee5cuXcKzzz6L9957D1u2bKnReoSHh+Ozzz7Tmys6MjIScrncIkFxeHg4fvjhByQkJMDX1xcAcObMGWRmZqJfv37V3j4RERERERFVXZWD6BYtWhg81azrwoUL8Pb2rurmiagcxoIu7fLK9FKtajBcUZhu6v3yAjpzA/GqhHxlg8x7GflIySh4uB25DH8nZlQYROvuW9fFG2mIikk1Ojf01cRM2FjLq9yDWIBhb9D4OzlIuJujd860+8rIKcTv11IhKzMHtFoAHg3RDE1YXm9zY8q2n6yWQ9bKBPmWGimgOuF3fR2CX57zF2wz/tAbOltekABFcQoA4H6/OAg2muE7ZSXpsMq7CgAQIIfartXDgNnBF5ApxO3mt3kT+W3erPXjISIiauwuXbqEOXPmGITQABAcHIwnn3wSn3/+eY3XY8qUKdiyZQvmzp2LOXPmICUlBStWrMCUKVPg6ekprhcREYHbt2/jyJEj4rLLly8jOTkZ6enpAIDo6GgAgJubG3r16gUAGDJkCNavX4958+Zh0aJFKCgowIoVK9C/f3+jx05ERERERES1p8pB9IgRI/DVV1/h8ccfF586lj3oKbVz504cOnQIL7/8skUqSUT6ygZd1lbycgNlU+FcbffcNBXQVSYQr2rI16WNO7LyihF/JweXYtMezpEsA9RqATZmzB0tzjeNh72hAU0v4bJtpz0mmUwzjLcMD48NgNkBdXhIC0TfuG+wXNCZpzrudrY49Lig875Wdc+vbhBsbSUXe0TXZshqzkgClhwpoDq92C05BL/FqPKgKEiEIj8BioJ4TcBckICcjp8BVpr62d7aDLuEdUaLq62cIS9KgepBEF3oNRPFTQdpgme71oDcptYOhYiIiMzj7u4OW1tbk+/b2trC3b1yIwJVhbOzMzZv3oz33nsPc+fOhaOjIyZMmICFCxfqradWq6FSqfSWbd26Fbt37xZff/nllwCAXr16iT25ra2tsXHjRixbtgyLFi2ClZUVBg8ejNdff72Gj4yIiIiIiIgqUuUg+vnnn0d0dDRmzJgBf39/yGQyfPDBB8jKysLdu3fRr18/PPXUUxasKhFplQ26KuppbCqcq+2em6YCuquJmWIvW1kFgWllQ76yc/3q9ub1ad4E8XdyAAD7TifAt3mTCnt6zxvfGXt/icfNlNyHoS8M265s72ntuvt/TUD8nRyjAbWxfWv3eSr6Di7euC+GzTLoz1NdNhwvq7rnVzcI1h3au06ErA9Y+sGK6gyjb4kh+CtFUENedAeKggSUKLsCCgcAgH3iWjgk/Bfy4ntGi+UXxAMOmnqqlF1Q7NZff+hsBz+o7H0hWLvqlVM5dYDKqUPNHhMRERFVy5NPPolvvvkGo0aNgoeH/veSlJQUbNu2DU8++WSt1CUgIACbNm0qdx1jQ4QvX74cy5cvr3D7np6eWLNmTVWrR0RERERERDWkykG0jY0NNm7ciB9++AGHDx+GWq1GcXExgoKCsGDBAowePVrsIU0kNUsN11uXlA26TAXK5YVzNdVzs7z2NhbQ2VjLxR68woMe3uWpTMhXdn5jQXg4VHXZ4PZU9J0Kt6t9X7e38/BQH4NyYu9pmX7v5Pg7OWI9AE0dKgpNtce760QsLseloZmLPe5lFohhuG6obSqM7tKmqcXOb62HrGaqr0NiV5Yi5zJs0k9oejbnPxhGuyARMqEYAJDR62eUOnfTrCyTiyG02tr1Qcjs92B+Zl+o7FpDO4h2sddU5HtOluCIiIiIqCYIggAHBwc8/vjjGDRoEHx8fAAACQkJOHbsGLy9vSEIAr766iuxjEwm4wPlREREREREZDFVDqIBzUXq6NGjMXr0aEvVh8jiLDlcb11VXqBcUThn6VCxKu1dXKLW6+mbnJqLbUdjLPLgQNnjHx7qg5JSNYK8XXAq+naZtQ1jXGOhujkBvu46MbcykXAnRz801gmPzQlNo2JSxSGxk1JyMTzUB0kpuQbHZW0lF//WHUJbOz90Q1Ynh8SuDEEFeeFtcY5meUG8+O+c9qugaqIZ1t0m/QScrhsONSnIrKC2aw2ZKk9cVtRsLEpcwqCy94Fg7VJbR0JERER1wIcffij+e9++fQbvX7t2TW8dgEE0ERERERERWVa1gmii+qC250GWiqlAubbDOXPau2y4W3bu5Ys30iCXpVXrwQHdfZR3/BdvpIn7fTSkpcE21uy6DMAwVDcnwNeuI84XDU343CPIA25KOzE01tZLW2djc0eXbdeSUnWF57WuDqFdk+pqb20tWWm2Zn7m/ASUuPSGYOsJALC7tRlOVxdBJpQYLafIvyEG0aXKrij0HAe1vWbYbJXDg6G0bb0Auf5/62q7FlDbNfyHEIiIiMjQsWPHpK4CERERERERNXJVDqIrmktKJpPB1tYWzZs3R+/evTFkyBBYWTH3ptrXEIfrrexQ47UZzpVt73sZ+YiKSRX3v+tELA6cSTSYG3l4qA8OnEkUt6MNXE9F36nwWHediMXl2DR0DnDH+H4BRntlT3msrUG5rm09sGBSCOLv5sKvuROC/d313i/bY/pU9G2jofqp6NsQIEN4SAuTDwNoj08mA36/lmoQsOuF1dD0mNZtH2Of44rOa10PZRs6Rc6fsLu7S69ns7wkXXw/K3gLij01I4qobdwhE0ogyKyhsvd+OHT2g7C5xKW3WK7ENQwlrmG1fjxERERUv3h5eVVq/fz8fHz55ZcYM2YMWrVqVUO1IiIiIiIiosakysmwIAhISUlBUlISnJ2dxYvc5ORkZGVlwcfHB05OToiOjsbOnTvx+eef46uvvoKbm5vFKk9kjno/XK+OqJhUnIy+g+gb9+vsUOPa9j4VfQcXb9zHpdg0XLyRhnnjNb05tWGzdhhubY/p4hK1GLJqqQXgYgXHqg22ASDpXi4A6G1L2ysbgNFAu1ugBx7r7YuMjDyUlqrF5VExqbiV+nCIYw39ee91e0wDQPSN+0YD5quJmUjNzC+3p7huj2fg4VzW2vUa0ue4vpOVZD4YOvvB/Mz5CVA8CJtzAz9AcbMnAACK/Dg4JHxkUF5t3RQqB19AbiMuK3brj7RHrkBt1xKQKQzKEBEREdW0/Px8rFu3Dt27d2cQTURERERERBZR5SD6pZdewty5c7F8+XKMHDkSCoXmxrlKpcIPP/yADz/8EB9++CFCQkKwe/du/POf/8R//vMfLFu2zGKVJzJXQ+gZWjb0rMtDjXdt62F0iG7duZEBTRhtbSXHtqMxsLGWi+uqBaBLm6YABFyKTSv3WC/Hpum9/jMuDaMe8dPrPWxtJa/UvNVi72T93NlgnuWriZkGZXXrqNszWxswm+qZX3Z4cpmR9erC57iyvfHrJXUJ5IW3xF7MJS69oXLqAACwubcfztHTTBZV5N8Q/13apBMKWj8r9mpW2ftCbe8DwaqJYUErJ6itnCx+KERERESVIQhCxSsRERERERERmanKQfSKFSswbtw4jBkzRm+5QqHA2LFjcf36dXzwwQfYsWMHxo0bh4sXL+L48ePVrS9Ro1W2x6wMdXuocVNDoh/5/aYYRvcI8sCBM4niOsNDfQzmTNbMF236WDsHuIs9oQGgk7+7Qe/hys4Trru+TAZ4N3PCqEf8DMpoj1GXbh3L7teneROo1AI6P6ijLt06l507uq4wNuS5buhebwJqQQCgFnseK/Kuwz5x7cPhswtvQiaoxNVzA99HwYMgWm3XWvO3TTMxXH4YMvui1Km9WE7t4I/cdoY9oomIiIiIiIiIiIiIGoMqB9HXrl3D6NGjTb7fqlUrfPvtt+Lrjh07Yvfu3VXdHVGjVzbYDWnjjkdDWtbZ0M/UUNJlA2KZTuBbUqrWm8u57DYAYNvRGL2wc3y/AADA+b9S4OhgDf+WSrGsbttUNE/4heupuBKXjnY+LgZtbSyE1q2fZi5pGR4tM0d02e3E38mBXAYkpeTCv6XSaIhrbC7rilQlBK5KGVOBfnkBtWTUpZAXJuoMnZ2gN5x2vv+rKPD5PwCATJUH++RNesUFuS1U9j6agNm2pbi81KkjUgfeARSOtXk0RERERERERERERET1TpWDaA8PD0RGRmLq1KmQy+V676nVahw6dAhNmzYVl2VmZsLZ2bnqNSVq5KozR7C5oaOle7Vqw+ComFS9AFm77bjb2Q+H6X4whHZ52zAVdvq3VOLAmUSkZRdiza7LBkFoeW134Xoqfv3zMs7/laK3bXPbWrd+p6Jv42T0HYQ/CKR195uSUYDLsfctHuJWpby5Zcp+Hkz1cq9sj3OLEATIStL1AuZSZTeUuA8AAFjlXILr+f4miysKEsR/qxwCkOf/6oNezX4PwufmgMzw8wi5FarxXycRERERERERERERUaNR5bvpTz/9NN577z1MnToVEydOhLe3NwAgMTER3333HS5fvow333xTXD8yMhLBwcHVrzFRI1aVOYIrEzpWNxA1FmKXt93iEvXDOZGh6RFtSnlhp7lBaNkp78S5oB+81i0/5bG2lepdrDt/d/SN++Jx6gbV0Tfumx3imvtQQFVCYHPKmDpvxgJ6UwF1tamLIVMXQrDS9HKXFybD6dqrYq9meWm23ur5rZ8Xg2iVvQ8Euf3DobMdNENna177QWXvLZYTrJTID3jDMnUmIiIiIiIiIiIiIiIA1Qiip0+fDplMhtWrV+PNN9+ETKaJcgRBgIuLC958801Mnz4dAFBcXIzXXnsNXl5elqk1EZnN3KCyOr1aywub9eZbBrD3l3gAKLeHrTHlrWtjLRe3X/Y9bU9l7VzTuvUrO+82jJTX3Y6pYPhqYqbB+mXbrzIhbmUeCqhKCGxOGVOfB2MPQ1Sntz7UxcD9P2Gd8hdscuPFkFkzV/MtFHi/gLyg5QAAQW4H23s/6BVX2bZ8OD+zSy9xuWDthvsD72rGfCciIiIiIiIiIiIiolpXrfFFp02bhokTJ+LPP//E7du3AQAtW7ZEp06dYG1tLa5nY2ODXr16mdoMEdUgc4PK6vRqLS/E1m5X2/P55r1cveGzKzMEtrF1o2JSceBMImQyTY/n4aE+4nu7TsTiwJlEcRtl6yces1wGtVpAlzZNDeZ51t2ODJpguEuZ+bm129FV3jDjxo7rVPSdBy1UuYcCqhICm1Omsp8Hk731VYVQFN6EouBByJyfgFKnDijymgEAkJVkAcf7wMnEdhWFyeK/BWs35LT7CGo7b6gc/KCyaw0o7I0XZABNRERERERERERERCSpak90aW1tja5du6Jr166WqA8RWZi5QWV1erWaCi21vYiHh/rgclwabt7LhWBGD9vyjgV42AO5bK9muezh8N7agLos3fp1beuBBZNCEH83F37NnRDs726wvu52tB2no2+k4eKNNL3ht+eN74z9vyYg/k4OZDKIZYpL1EZ7Uev2sAaAiw+G7b54Iw3DQ33E4ykvBNbdxpTH2lbYfmV7dVcl+DfYlrczuvkAMnUR1PatNW+W5sI5aqKmV3PRbcgg6JUt8hguBtGCTVNAGYQSRVNxGO3YLHdcve+KZq07oGNQu4cFZTIUtn62wuNsSCw9bzsRERGRKW5ubjh27Bg8PPidg4iIiIiIiCyjykH0b7/9Vu77MpkMNjY2aN68OZo1a1bV3RCRBZgb9lZlDmptubKhpe7w0uoHPZWTUnKNhqsVhW3a922s5ThwJlFvyGpTIfjVxEyxl7SWsR7P3QI98FhvX2Rk5KHUyBzVxrYjwLCnsjYUT7ibA+HBMOG6vaiHh/rAv6XS6HGEtGlqEKZX9FCAseG7tfU1FXxXdg5wvc+DoILN/SOQFyQg/c7fUCZdwSjbu2gelwK7xCIUNRuJ7JCtmnUVjrDOjoJMnQ8AUCucdOZn9kWpc/eHO5HJgBFXkfug/aNiUrHm8IPPzR93MG9800YbwFZ33nYiIiJqXNauXVvpMjKZDHPnzgUAyOVyTqdFREREREREFlXlIHrmzJnivNAV8fHxwfz58/HEE09UdXdEVMeVDbGN9VQ2FlZr528GjIdtZQNtWZkhq6c81rbcuZe1IbJfiyZGh92uSNntAKZ7KttYy8V1tLm19m9tD2ljxyGDYNADuqKHAsq276noO2KvamPtWO5w34IAeXHKg6Gz48U5mlV2rZDf5p+aBwESMjBX9iQUQiGaAPDROXQBMshU+Q8XyGTIDv4KapumUNn7QbB2N3uobG3wr22jysxV3tBUZ952IiIianyMBdHaa3ZBEAyWC4KgF0QTERERERERWVqVg+iNGzdi5cqVKC4uxqRJk+Dt7Q0ASExMxHfffQc7Ozu88MILSE5Oxo4dO/Dyyy9DLpdj6NChFqs8UX1Ql4fWrcm6GeuprDu0dtztbKNDZ+//NUGvTrphnAwQh/YuO8R2eXMvX7xxH4l3c/TmpjZX2d7eAEz2VC4uUYtzYZui1gbVOsfxaEhLPBrSssJh0XXPV9n21cTBD9vpVPRtvXbs0NoW1/5Mgp2iGNfz2ojH4nKuH6xyr0KmLjDYX0mTYJwWnhcfBOju1xVtvJQosGqNg5cVuFfcHLeLPDFx+AB0CfQq83kaVm67atft6O+Gx3o7isv1wnzB+FzbUpDi57g687YTERFR43P16lW91ykpKXjuuefQtm1bREREwM/PDwAQFxeHzZs3IzY2FuvXr5eiqkRERERERNRIyISyj0ab6YMPPsDFixexZcsW2NjY6L1XVFSEmTNnomfPnvjHP/6BoqIijB8/Hra2tti1a5dFKl5XqVRqpKfnSV2NSrGyksPV1dHk0MRUdWV78xoLQaVqf3PqVlH5ioK5qJjUcofrLjvktZbucN63UvMQ/aCnr3ZZSana7Hmstx2NwbE/boq9Sgf1aK03n7Il2197fOZSOlrj0eCWGN8vwOxt654v4GEorhvsh7ueRCu7ZDS3vQtP2xT4ON2HI+4DAO6hHS76HhDbzvXXnrDKuwYBcqjtWkPl8HAIbZVjEDZfCjLafhWd2/I+T2XXffPpXgj0UqK0VI1tR2Nw9PebEKAJ1Af3bG3W/Nc1qbo/K9Xdd1Xmba8M/h8gLba/tNj+0uM5kJYU7e/m5giFom48aNbQvfjii7CyssLq1auNvj9//nyoVCqsW7eulmtWP9SXa3v+HpUez4G02P7S4zmQFttfejwH0mL7S4vtLz2pzkFlru2r3CN63759eOGFFwxCaACwtbXFyJEj8dlnn+Ef//gHbG1tMWrUKHzyySdV3R1RvVSXhtbddSIWl2PT0DnAHeP7BVSrbubOXVvecN3a3s1l6Q7LrJ1HGQCCA9zxaEjLSrefjbVcbyjsmuxV2rWtB4aH+uD8XylIzSoUj7VLG03dtx2Nwf2sQnH97LwSHDiTiFupeQivYNjwq4mZcFAUwMM6BS3sUmCfeBI9WuWin1sCkO+AqyX/FIP9KS12orX9LYNtqK2c4dKkmd5+cjpthNqqCS7cssPfSXmwUctRnKHWPGDQzAM21rEm20/3/FXm81R23cuxaQj0UgKom72Apfw5ruq87URERERnz57F4sWLTb7fp08frFy5shZrRERERERERI1NlYPogoIC3L9/3+T7qampyM9/OGdokyZNIJfXzJPvsbGxWLZsGaKiouDo6IjRo0djwYIFRkNyXYIgYMOGDfj222+Rnp6O9u3b47XXXkOXLl1qpJ7U+EgRqhnrqbzrRKzYWzbpXm6162YqmKuol7ThcNIPdWnjDi8PJzF81obV2n00c3UoN5Aztu+omFQcOJMoht7DQ30M6tmzvWe52zBnP7rv6YfnTfXmpTY1HHn0jfuIvnEf88Z1RHfvUigKEiAryUJxsyfEdWbaPIv5XS48LCQAuKn5p9rKBe18PhLb9kxmH1zJzUJKUXPcLfZESlFztOvQHWMHdDfYd6kyRPNgwfeXxWHFZQ8eMBge6mOy/co+iFCZz1PZdTsHuIvvlR0KvS6EsHUxHCciIiKqiK2tLS5evIhp06YZfT8qKgq2tra1XCsiIiIiIiJqTKocRPfu3Rtff/01unTpggEDBui9d/z4cXz99dfo06ePuOzvv/+Gl5dX1WtqQlZWFiIiIuDr64s1a9YgJSUFy5cvR2FhIZYuXVpu2Q0bNmD16tVYvHgxgoKCsHXrVjzzzDPYu3cvWrdubfG6UuNT26GaqZ7Kl2PT9Nb7My4N4/sFVLluxoI5c3pJ67ZHSkYBLsfe1wuax/cLgH9LJa4lZcLaSq4XSpcX/pnad9nAvKRUbbDugklyPNbbEReuG9+GbvAMoNxjLLu/Zq72eu9rh+DW9pge6HYcbR1voLntXTS3TUGLxHtQJJYAANTWrkhr9jC0dnRyA4qAAjij2MYbtq5tobZ/OIx2V7emYtu6eH8oht7acHmoj7fJ9tOtN/Bw/urLcWkG7WfsOK8lZWLKY23N/jzpfg46+Lmhd6cWyMjI03u/LgTQWnUxHCciIiKqyMiRI7FlyxYolUrMmDED3t6a74NJSUnYsmUL9u/fj5kzZ0pcSyIiIiIiImrIqhxEL126FE8++SRefPFFeHp6isHtzZs3kZKSgpYtW+Kf//wnAM2c0Xfu3MHEiRMtU2sd27dvR15eHtauXQsXFxcAgEqlwjvvvIM5c+bA09PTaLmioiKsX78ezzzzDJ566ikAQPfu3TF06FB88cUXePvtty1eV2qcajNUM9VTuXOAu9gTGgA6+bubVTdTvX+1Q1BfjktDZ393dG3rgW1HY8wavli7z6iYVL25n7VBs26dtKF0ReHf1cRMsfe0DA/3XTYwv5eRj5SMAr16/p2Ygcd6++LvhHSD+gP6wXOXNu7lHmM7Hxcc+z0BzWzS0czmLga4XoXDjW1QFCRoejmXZmN8v98xvl8AomJS4RfzPtpan9c7FkFmBZWdN9QOvoC6GJBrRnbI6bAGgsIRgrWmnYqNtINu23Vt62F2+2nbSbdHtFoAOvu7Iykl1+AcmeohXJnPunZdK6v6MUdkXQvHiYiIiCqyePFiZGRk4JtvvsHWrVvFEcrUajUEQcDw4cPLHbqbiIiIiIiIqLqqHES3bNkS+/btw/bt2/HLL78gOTkZABAQEICIiAhMnjwZDg4OADRDgm3YsMEyNS7j5MmTCA0NFUNoABg2bBjeeustnD59GuPGjTNa7sKFC8jNzcWwYcPEZTY2Nhg8eDCOHDlSI3UlQ+YMhUzmMxUQanvi/hmXhk7+7uLr8pTXw1l3COqkFE3AfS+zQAxozRm+2JxepsbCP2OfGRtrObQjfQsArB+Em9p9nIq+g4s37uNSbJrY61dbTxsrOTbsvQwba4Ve/Y2F1oAMagFwlOehmW0KAuU3YJd0DIXez4v7++KRVWhacFKzk7QHf3TISrMhWCnRta0H7BwiEJfcHfHZTaFsFgT/tl2gtm2JqNgMzTHGZonHqLbTH1EiKiYVp6JvQ4DM5PzS2mVXEzP1Xpd3Lqyt5CgpVYvnxFiYzR7CRERERHWfjY0N/v3vf2PWrFk4ceIEbt++DQDw8vJCeHg42rVrJ3ENiYiIiIiIqKGrchANAPb29nj66afx9NNPW6o+lRYXF4fx48frLVMqlfDw8EBcXFy55QDA399fb3lAQAA2b96MwsJC2NnZWb7CJDJnKOeGxJKhe3k9lU0FhOP7BYgBtDl1Mda7Wrv8XubDgFYGlJkX2R2PhrTUG9baxlqO4hK1+LfufgXB6O6NHvOp6Nu4eCPN4DNTXKKGTKbZlkxnCGltm5Q9luAAdzRzdYC1lRz7TidALpdBrRYwPNQHyal5uHQjRS+0Hux+DF2UUQjxyIaNcxLsoWkLlAK4BpwvGIIrN0vRzscFj7q3hZB8Bip7H6jtfR4Mne2n+dvBF4LcQaxboddMNPECgh+8VsO8nwvtOlrRN+6Xu545P2Omevzq9mDfdjRGPHfmhtxEREREJK127doxdCYiIiIiIiJJVCuIrguys7OhVCoNljs7OyMrK6vccjY2NrC1tdVbrlQqIQgCsrKyqhxE15ehZrUUCrne37Xl+k39cPD6rSz0bG98KPX6ruz8wwsmhaBboCa4q2z7l7ctAOjZ3rPcdqyovFZHfze93tW2NgqxXNlexTKd8+jp7oie7T3F/WiHe9aSPdjvyDBfTQhspB4Xrqfi74R0tPd1Q7dAD71tAYafmbJ17eDnpvdzWPb9/t1aQaHKxtlzv6KvSzya295FC9u76FCSBWfnW3DsdhdTLm5FkWAH/5ZNMLBlMjoJv+iNh51Z4oyUYk8U2Xhj074oZKs0vdGtJyyC2u81/J2YhfYt3PTaVoaKf+ma83Nx/WamQbtq19NtO1PbKtu+FTH2mQFg1ueoIlX9/VPZYyDTpPo/gDTY/tJi+0uP50BabP/G4eLFizh37hzS0tIwbdo0+Pr6oqCgAHFxcfD19YWjo6PUVSQiIiIiIqIGqlpBdGpqKv73v//hr7/+Qk5ODtRqtd77MpkMmzdvrlYF6xu5XAZX1/p5Ia9U2tfq/np2bIHD52+KvVF7dmheb9uuInF348TjlMtliL+bi8d6++qtY277625LBuDMlbsG2zLl3J938MPp+IfBsYm6AMBjvR1xOy0fv1+9hx7tmqGwRKV3DD3bN0NzdyfYWsux81iMwXnUracu4cF+ryRkGG2Tc3/ewX93RkMul+Hw+Zt48+leiLubY7AttQBxX4/1doSToy0ux6ahc4A7endqAahLgPybQG4cHnOPQ/uhl3A4LwId2rQCAGQcW4wlnkcA3YxXu3kZ4GmTgqRCH8TdzoGi70TAJQxw8selu02wbGcqiuAAtVpAr46eyFbfg/pB1+795+7h+k3NQzDa+vfu1MKs8wM8/LnQznlt7OdCu44uZydbrN19GeevpIhtN+mxtuJ51p6b68nZBu3bu1MLnPvzDi7F3kdwQFOD+hr7/AoQKvxMV0Zlfv8Y+4xUpo3JuNr+P4D0sf2lxfaXHs+BtNj+DVNxcTEWLVqEY8eOQRAEyGQyDBgwAL6+vpDL5XjmmWfw1FNP4YUXXpC6qkRERERERNRAVTmIvnr1Kp588kkUFhbCz88P169fR5s2bZCdnY2UlBR4e3ujefPmlqyrUUqlEjk5OQbLs7Ky4OzsXG654uJiFBUV6fWKzs7OhkwmK7dsedRqAdnZ+VUqKxWFQg6l0h7Z2QVQqdQVF7CQQC8lFkwKwd+JGWjv44pALyUyMvJqbf+1yb95E01gJ9N8RvyaO4nHWl77G+v1qd0WoMlNz11JwbFzCRX2Cv3upxvYdzpBfC0zUpey+955LAYAEJechZFhvnrH0MzFHoWFxfBr7mb0PGrraaxHtFotoKOvK+KSswza5Lcrd8Rlchnw21930d7H9eG+BaBrYFP0C2mJII9SHD97A38lZqO9rxumBpxBUcxmZF1KQBPchRwqcb8tAYx7JALqJkr8Y91pPGrTHBklLrhb5Im7Rc2RUuSJu8Waf9s4t8GtQmsAmp7Ex24GoXm7kQCA1m2AORNSxeMFgPNXUsT9aENorQOn4xDoZThqg6lznJtXJJ5bAMjNKzI4P9qfnRMXkwEArTycxHMFPGy7rNwijAzzxaXYNAQHuCPQS4mtP14zaN/cvCJNsCsDfjgZZ9C72djnV3c/5X2OKlKV3z/GPiPltTGVT6r/A0iD7S8ttr/0eA6kJUX7K5X27IFdS1atWoWff/4Zb7/9Nnr37o2hQ4eK79na2mLo0KE4duwYg2giIiIiIiKqMVUOoj/66CM4ODhgz549sLOzQ9++ffH6668jNDQUhw4dwttvv42VK1dasq5G+fv7G8wFnZOTg9TUVIP5n8uWA4D4+Hi9+bLi4uLQsmXLas0PXVpaP2+iqVTqWq97sL87gv3dAdTfdjNHsL+73tzNwf7uBser2/5l50M+fP7h/L7B/u4IadMU0TfuA9AEpX/Fp4vtaExUTKpeCA0ATZV2aOnhZPK8/3QhWe/1zZRc8RjEuZV16jZ5QBsAwG9/p4jzT+uuX1Kq1vu7sEiF4aE+KClV67VJYGsXTU/5B6Fzp+bF6OJ8ER8O/hMF6TFo5XAPboo7QHwcrONy8N2VNUguaq3pGdvrEnqrTot1LhFsUGTjDWvnAKjsfVEq2OK7YzFIySjA/zAO/0vRn19e257BzZtCjftiz3EruUyvjXQ/twDQpY07om+kQTDYGiCoBZSWqvXm5QYgzp2tnV9b245l57M2dW6D/d2hUqlxNTETSSm5ekOma3tTW8ll4nlKvJsD3+ZNDNo3sJUzrsSll7tPY59fAEY/06bmH69oXvLK/P4xdgwN+fdHbZHi/wB6iO0vLba/9HgOpMX2b5gOHDiAKVOmYPLkycjIyDB4PyAgAJGRkRLUjIiIiIiIiBqLKgfRFy5cwOzZs9GyZUtkZmYCAIQHQ9MOGzYMf/zxB1asWIFvvvnGIhU1JTw8HJ999pneXNGRkZGQy+UICwszWa5bt25wcnLCoUOHxCC6pKQEP/74I8LDw2u0ztQwVBSsldW1rYdZ60XFaObj1dKGg9eSMsXy4SEtEH3jvhjEBXm7lLvNq4mGcwqnZhUiLbsQ0TfuiyG3LplBrCqIx7DtaIxecKmtm7bu2nmD543vjCmPtTV6fJryAhaNaYUuzRKhuHsCioIEPFqcALtRsxB9xwlB3i7oqdgExwvvQTzCMgMOeNjcx63C1pDJgKPJwThT+BLuFHribnFzZJa4QA253vFdjj0vHqFWYGtnXL+ZJR7ToyEt4OXhiANnEiEDcOBMIvxbKk2ev0dDWooPDeiGwcKD98q2C6Azvzb027Gdj4vefNamzq1+O0JvmyFt3PFoSEuDUPtaUiamPNZW7wEBbSCuXcfUPo19fssuM3b+TX0uzPlZMKVrWw+9ELw62yIiIiJqqNLS0hAUFGTyfYVCgcLCwlqsERERERERETU2VQ6i1Wo1mjZtCkAzzLVCoRADaQAICgrCrl27ql3BikyZMgVbtmzB3LlzMWfOHKSkpGDFihWYMmUKPD0fTv4aERGB27dv48iRIwA0Q5HNmTMHa9asgZubGwIDA7Ft2zZkZmZi1qxZNV5vqt8sHazp0g0PtcqGg5UJ4qJiUpGamQ8BD8NR3xZNkHQ3x2jIraUNV3UDVS1TYamx4LNrgDMUBUlQ2TYHrJxwNTETj7iexsTm36G5bQocbhYA+tMdI6TLSLTv0BUAUJoSiFLHdshQt8SZBAekFHviTpEn7ha1wL2iZigSNEPrCwJQ6tQRx5Kb6W2r7PF1DnBH0r1c8f2e7Zph6bOhOHYuAX/Fp4vh7L3MAqNhuzG658PaSo5bqXmQQcCjIS0NgnvgYfgsk2nqre15bW0lN/vclm3r4AB3NHN1MChj7Dxp39cNsnV7pxvbpzkPXhg9/209TC6vDnMf7CAiIiJqrFq0aGEwepiuCxcuwNvbuxZrRERERERERI1NlYPoVq1a4datWwAAuVyOVq1a4cyZM3jiiScAaC5qmzRpYplalsPZ2RmbN2/Ge++9h7lz58LR0RETJkzAwoUL9dZTq9VQqVR6y5599lkIgoAvv/wS6enpaN++Pb744gu0bt26xutN9VtNBGta2t6p2gC4S5umeDSkRYW9UY3RDcwBIOTBtgD9ENJUD1hTgWjXth4YHuqDy3Fp6Ozv/v/s3Xl8VOXd///3mZnsZBICYRMCJOxIFkUR1youoFasVKVuuFWrVYvW9narWovrrXWh/dXeLnVpcanWrSqI2tblq1gkibiwBkJkDQnJTPZZzu+PIUP2ZTIzJ8vr+XjwgDnr51wnCZl5n+u6lDcxXba67/WDIR9p8PD/amTcbg2P26UJRrniP9glQ6Yq8l6VZ+hJio2xqcHwKjNxa/B4exuGaFf9cA0eMUWpw6fIlzg+uK5h+Hw1DJ+vF97fqA+2lzRrm5ZWry/VabPHantptQra6TG+4LgsSdLXRWU6OHOIzt3fY/uQSeny+fzt9jKOcdj0wvsbmwWxbYWzTfdvDO9bBvdmk+POnJyu1etLW/W87uzetjxmY+jd1XvY8mvY4/W32Xu95RDiHT140d4DCl3t5R0u3R2tAAAAoD86/fTT9Ze//EUnn3yyxo0bJ0kyjMAbg5dfflnvvvuufvnLX1pYIQAAAACgvws5iD766KO1fPnyYOD7k5/8RPfdd59KSkpkmqa++OILXXLJJWErtCNZWVl65plnOtzm+eefb7XMMAxdeeWVuvLKKyNUGfqrSAVr+RtLA8NB7+8pe9rsscHgNBQtw0bJbDV/c0e9boOBqK9O9uqN2rqpQK49GzTYtl05ZRu1pfpHevuzKcoc5dQRgz5R9t7rlX1QkwPsf/bDtCfJ5gnMS9fg8etr9wz9duNt2lU/QqUN6ao342QzpBNTxmhh1sTWhah1mzcGzt+XVqmssi4Y7m4vrVZ6akKwh29jD+eiHS41ePyaMjZVC47LarNd2+plLEkV1Q2tglhJrXrFt/eAQtPgflhqgjw+M9hjOtSHGrrac7q9ULuzr+GWQ3+3HEK8rWO2V1NXal2zoVTfFJX3ODyO5GgFAAAAfcnPfvYzFRYW6oILLlBmZqYMw9C9996ryspK7dq1S8cdd5wuvvhiq8sEAAAAAPRjIQfRP/vZz3TaaafJ4/EoJiZGixYtUk1Njd577z3ZbDZdffXVBLzotyI1R21bvVQ70lnPz5ZhY2Ae47LW8zebpoyGUtlrt8gfnyF/fKDXdMzelUr+9jrZ6nfIkKm0xgP7JQ2W8l25Wlc9Reu3VeiwwyarYfDR8iWMkz9hnHyNfxLHy4wZGhh/OlhTmvZ501r1Ou4o0G+vzVsGpk17Qp82e2xwnmdTgRK606P3oPRBevuz4uD6pkGs2WRO5c7mdw4+YCBp2+6q4IMGx+SM6tFDDT0Znrqzr+GmX4uN9Xb1PrUXUrdX66qvd+qRlwvDEh5/XLhDUmRGKwAAAOhLYmNj9eSTT+rNN9/UihUr5Pf71dDQoMmTJ2vx4sWaP39+sIc0AAAAAKAXME3JVy05BlldSdiEHESnpKQoJSUl+NowDF199dW6+uqrw1IY0Nt1dWjs7gwR3J1Qsis9P5uGjbv31Wrt5r1Kc5Rq9uBVSt/6spzVFbLXbpW9ZqsMf40kyT3lYdWNCcyTbtoHyV6/XZLUoERtrxmmXfXD98/TPELfVB8crNPrnKjKme90eo0tA1BJXQ70G9s8f2Nps2GyG4+3Z1+NvtpcFgwh1xaVNRtm2+xmj96W83U39gpurLvlvWov3G15nKZ1LJwzMSIPNXRFR1/DbfVA72gO6Z74avPeVqF+KOfI31iqgk1lwdfRGAYcAACgNzMMQ/Pnz9f8+fOtLgUAAAAA0JRpylZXLIerQDGuQjnc+XK4CuVNzlbloW9YXV3YhBxEA+hYKEMEd6endashnYvLdegYr2y1W2Wv3RIImGu36vjarTpi2uX6vOp4FW7aqxHxe3TFmCcDByk9cDxThvzxo5udw+vM1r7DP5QvYbzWbPVp6T++bhZMppVWabC634uiZQDandCxvXZtDKgDvb4DNc7IHBLogawDPaK726N35eqS4P7jRibr9CPHBdc33qsYh00fFe7Ux4U7dEzOqFZzLTeGuu3V0ZOezZESqV7/bcnOGqo3Pyrq8AGMrjzU0TLwz50wtNe1KwAAAAAAAABgYHMWXqSY8n/L5q1otc5R9U2gN1s/GcGqy0H0zTff3O2DG4ahe+65p9v7Af1BT+b+bXc7X43stcWy127VzJHJWrn/2FkJG3S1zpX94/o2d/OkzlbexHN07YIZKilO0O6EU5ScPjk4fHZgKO0MyRbbfEd7krwpMwN1TVKrnsyN8yYXbtob1rl42wsd8zeW6o2PtwSD3Jbt2lZ4mjnKGQyLQ+nRO25ksrbudMswpC073a3qm5yRqqWvrg1uX7CprFVbNK0r1DqsEK2AfNbBI7X4nBx9u6W8zXbp6kMdLXtxH5MzMuK1AwAA9FYXXXRRh+sNw1BcXJxGjBihWbNm6ZRTTpHDwbPqAAAAANAjpl/2ms1yuPLlcBfK4SqQ4XWp4oiPg5sY3n2yeStkGjHyDjpYXmeOvM5ceZNz5B00vd+E0FI3guhVq1Z1++DMN4XerLvDZndXT+b+lSSjfo8Svn8iOHS2rXar7A27g+tzx/1S1y64Wuu3VSh71BDZv6+XKZv88WPkSxzXLGT2JudIahos/l3V+4+Tv7FU6woqNGVsZZeHxpakF97fGByq2lDHQXv+xlJ9VLhTrup6OZPidGzOyA63bSt0bFze2KtY+89d7qrTY68UypQRPG7LELijc20oqdBh00dq0kHONuto1Dic9seFO4PzUK9cXaLcCUOa7ddeW3QW6jb9epQU0a/N3uiQSenKzhzS5rquPtQRzV7cAAAAvZ1pmtq9e7e2bdumlJQUHXTQQZKk7du3q7KyUmPHjtWgQYNUWFiol19+Wf/3f/+nv/zlL0pLS7O4cgAAAADoexKK/6jYPW/J4f5KNl9Vq/WGp1xmTOD9VvWEO1RtxMg7aGrrDoL9TJeD6A8//DCSdQBRFcqw2d3VbijmrQr2arbXbpGjvljylMhZuUl1w3+smqybJEmGv05JRfe3Oq7fkSJfwnj5Y4cob+z+cNP0q2xsgfzxY5S/uSIQYjpTlTe+8zmsQ2mH/I2l2rS9IhgIm5JiHLYOz3GAu8Me1OuKK4I9no0moWPLYZelQOi7ev2B8cW70zO76bWv+KJEeROH6ujsAwF5e/NDS2az5ZXVDc2Oa6r7Dx20vA+SIvq1GU3heOCjOw919MZhzgEAAKzwi1/8Qj//+c9133336Yc//KHsdrskyefz6c0339T999+v+++/Xzk5OXrttdf0m9/8Rr///e+1ZMkSiysHAAAAgF7I75W9er0c7gI5XAVyuNcG5nK2xUmS7NUbFFvx/yRJpi1B3uSD9/dyzpXHmSvTkRI8VONItANB1Mbdqqqq0t13363LL79cWVlZ0Tot+rBI9lgOddjsLjF9stXvlL1mq45I3KrDcw+SZ0hgzmBb7TYN+eTgNnezS7JXrw++9scfpNqDLlVJzVBt2pemwSOnaOLkPJkxg1vvbNjkT8zsdrAcSju0DpYDgbHH62/3HG1p71yxMTaZ+0Ne0zwQcLcMIw1Dwe26ctyW/vn/tko6ECjnb9yr/I0HguzgvM77z9M4P7QUGH670Zadbp02e6y2l1ZLMnVMzqhufy21FbI3/vvjwp1dPl6ke/l3V7ge+KCnMwAAQPc98MADOuuss3TmmWc2W2632/WjH/1IGzZs0L333quXXnpJZ511lgoKCngAHQAAAACaiCn/SHG7XwsMse3+Woa/rtl6h/sbeVMOkSTVjTpPntTD5XXmyZc4SbIx9ZEUxSC6rq5Or7/+us444wyCaHQq0j2Wezpstvze4A8Rw+tW0sY7ZK/dP3x27TYZ5oFesnUjzpZnyPGB3eJGyTQcMu2D5EsYL1/iOClpvOKHTpbbHKWG+AkHzmHY9XHMrVr6/tpgndfGeZU3sf2yuhssh9IObfUUNjvYt/EcLbW3fYPHHxx+29CBgLvlPMtvf1bc5v5duYZX/7M5ON9zU03bLG9iuk6bPVZvf1YsQwfmh86bmK6cCUNVuGmv1KTG636c3el529PyPjRVsGmv8jeWdvkBgWj2pO4s+A7nAx/0dAYAAOie9evXa/78+e2uHz16tJYtWxZ8PX36dL322mvRKA0AAAAAeg9/vRxV3wZ6ObsKVTP+evkTxkqSHK58JXz/1IFN7cnyJmcHejo7c+Xbv50keVNnyZs6K+rl93ZRjePNtrovAm2IaI9ldaGHpWnKVleyf/js/QFzzZbg64Yhc+Se8WRgU1u84rf/RYbpO7C74ZAvPkP+xHHyJjcJKG0Olf1gq0zHgfmIHQ6b4gcnybuvWv4WvYojHSw3tsPHhTtkqmtzurc8R86EIR32Am4MdFd9u1t2m6GRQ5J0TAdzRHd0DU3DyO9Lq4NhsCSlp8Rr4YkTWx23rbB07eYytdTW+Ro8/jbbf3R6UvDcHQ1L3pGWdTX9evy4cEew17XRxa//SH/PtFV/Z8F3jx/4AAAAQMjS09O1fPly/eQnP5HN1vz3Vb/fr3fffVdDhw4NLquoqFBKSkrLwwAA0KbGzzWmZ6Zpzqwkq8sBgH6pt42A2V/YaksUu3fF/uG1C+Wo+laG6Qmu96Qdrfr9AbMn7TjVjL1O3uScQPCcmCUZ3c8DBjL6haNXikaAdci4WM0cUSt7zXeyb90qf+wQ1Y86P7DS9Crtk2wZanu4aXvt1gMvbDGqnnCHzJg0+RLGyZcwTv64Ue0Ou9A0hO5M097E3QmWuzuEccGmMtmMrs2x3JVzNP0PUpLe/qw4eC/POWFCp/s0Pb4kvfD+xlb/2R6bM1KFm/YGj9syhM7fWBoMdFuGpTOyhmjbnqrgtkdlj9SghBhNGp3S7BjttX+Dxx8csrujYcnb016I23juoh2uYBBtmlK5q66jwzWrNVqhb1eCb4bUBgAAsM4ll1yi3/3ud/rJT36is88+WxkZGZKk4uJi/f3vf9fatWt12223Bbdfvny5srNDH+UHADBwtPxcY1BSnCYd5Gy1DeEJAITOihEw+x1fjRzutXK4CuQZfKR8yTMkSQ53gZLX3dBsU3/MYHmTA72cvUmTg8sbez4jdATR6JXCEmD5vTK8lTJjhwRem6aSv75c9prNgV7OnvJmm3tSZh0Iom0x8iVmBg6zP1xuHErblzAuOCxDo9pxi7tfXwt//9cmFW7cqxlZQ7TguNCHr+/KEMZN3wy0DBQ/LtzZ6RuFjs7R8j/InAlDOw0s2/pPdeGciR3+Z9vR10jLeaxbnruxfb8uKlP2hKG64qwc7dtXLW8XA+Wehr6dhbgNnuZ1rF5f2unw3NEOfbvaBgypDQAAYI3zzz9fhmHoscce02233SbDCIyAZJqmUlNTddttt+n88wPvfxoaGnTzzTfroIMOsrJkAEAf0fJzjbWby5oF0YQnANBz0R4Bs8/z1SnGtUYOd0FwiG179fpgZ8PqrNtUsz+I9jrz1DBkjjzOvGBPZ398RqDXGcKOIBq9VlcDLIerULba/cNm12yVff+/bXUl8qYcporDVgQ2NAzFVHwue92B+Yr9senBXsze5Jxmx9135JdR+8Hz/Dvf6q1Pt0pSsKfuguOyIvKfTcs3A6fNHhs8vt8MzEnckzcKLWs2ZDY7fluBZXvX2XI+6o8Ldzarp72vkZb7Sa3PveC4LC04LkuODobV/rhwR6vXjefsSejbWYjb1rzab3yyRZJaBe5NHxqIZugb6eCbJ6cBAOgZ/i+FJJ133nk6++yz9fXXX2vHjsDvtqNGjdLBBx+smJiY4HaxsbE6/PDDrSoTANDHtPxcY0bWkGbrCU8AoOeY9rB9hqdSDvdamY5keZ2BXMdes0mpq+e22tYXO3z/kNqZwWX++NGqPOS1qNU70BFEo3fze5rN1Wyv3SrTiFXNhANDyDkLfyJ73fdt7m6rax4kVk/8nUxb3P7weazkGNT+uaP49Mvqdbubvf66qEwLjsvq8n823fmgseWbAY/XHwwU9+yr0Veby3r0RqFlzcfkjNIxOaNaBZZNa27vOlsGsgWb9rbqGdzWtbcV5J42e2yH17JmQ6m+KSpvdpzW82YfeN1Zr/CO7kdnIW7jvNpvf1YcXFayu0pLX10bfDigK08XR/oD6EgF3zw5DQBAz/B/KZqKiYlRXl6e8vLyrC4FANBPNP1cY9r4NM06eKT27asOric8AYCeY9rDAMOzTw5XYWAuZ1d+4O+azZKkupHnyX3w45IkX9IU+RLGy5s0JTictjc5V/74kVaWD0U5iDbo1o6WTFOGd59sDWXyJU0MLk5ee6liKv4rW11Jq3mafXEHNQuivc5D5Y8bFezZ7EscHxxO2x/X/IdM/YizInIZPQ38Zk4ZrqLtruDrgzMDT5J2dT7m7nzQ2NabgcZAMX9jaXBO5VDfKLRXc1tDZzetub19cicMUeGmMplqHY53NNdyy/06msd51dc79cjLha2O0zgPdaNjcjr/T6ur96OzELdx+PDGMNpU4NmIrvYW78sfQPPkNAAAPcP/pZCk//73vx2uNwxDsbGxGjFihIYNGxalqgAAfUlHn3c1fq7R1khzhCcAEB4DbdpDo6FMNk/5gazIV6Mh/x7fKiOSJF/8GPlj0g4ssDlUfnRhlCpFd0Q1iDZNs/ONEHa9ZVi+mH2fyl71ney1xYGhs/f3cLZ5K+WLH63yY74Nbmur2yF73f4AzhYvX8LYYNDsT8yUTDPYY9mV87wl19MoHIHfhadOU22dR19t2quDM5vPEd3Zfzbd/aCxozcD4XqjEErNC+dMbHOfY3JGtRuOd3TtHe3X0leb97Z5nFDaI5wf/DZ4/DIUCKGlwJd9V3uL9+UPoCP15HRXfhb2lp+XAAD0BL2QIEkXXnhhlx8GHzt2rK677jqdeuqpEa4KANBX9PTzroEWngAAusdoKFWMK39/b+f9czrXbZMndfaB6VbtifIlTZThr5c3OVceZ06wp7MZO6TjE6DXCEsQvWfPHpWXlysjI0OJiYltbjN06FCtW7cuHKdDN0SlV6RpyvCUB+dmttdula1mqwxfldzZzwQ3S9p0l2IqPmv3GPJ7JVvgS7J64p2qNk35E8bJHzdcMtqfx9dq4Qr8zj5+gn50TGbnG7YQygeNHb0ZiMYbhe7U3FEY3NFxWu4nSS+8v7HNgDE7a6je/Kio3eN0NhR4qNfWlraGLG8Mo5sOL95Zb/G+/AF0JJ6c7upQ5n21FzkAAE3RCwmS9OSTT+rBBx9UQ0ODzjnnHGVkZEiSiouL9fe//13x8fG66qqrtH37dr300kv65S9/KZvNprlzW8+rBgAYePryA+4AgN7F8FTKjEkJvk5d9QPFuNa0vbGvpllHxH2zPpLsCdEoExHSoyD6/fff14MPPqji4kDP1aefflqzZ89WeXm5Lr30Ul1zzTU68cQTw1IoQhO2Xxr99bLXbpOtfqc8accGFyd/c5Vid78pm8/dahdTNrn9DZItVpLUMPgo+R2p8iWOCw6d7UsYH5irucUPEm/qEd2v0SJWB36hfNAYyZ6hXdmvcQ7ktUVlmpE5pNPjN67/qHCnPi7coWNyRgWX5UwYKkNms2VN9+vqfMp5E4fKNNs+TtNr6/w4oX/w25Uhy5u2b0e9vqPxAXQkew+H+4GIrvws5E02AKA/oRcSPv74Y8XFxenll19WbGxss3XnnXeeLrzwQhUUFOhXv/qVfvKTn2jBggV64oknCKIBAJKs/7wLANAHmaZs9TvkcBXs7+Uc6OksmSo/bmNwM3/sMJky5EucEOzhHPg7u1lgLYkQuh8IOYj+8MMPde211yo3N1enn366/vCHPwTXpaWlafjw4Xr11VcJoi0Wyi+NMWUfKqZydXDobHvtVtnqtsuQKVM27Z1TKtliAhubvmAI7ds/T3MwZE4cpwODCks1E24P/wX2ApEK/LoT8nXng8ZI9gzt6n75G0uDcx9v210lKTAMdXvX2njcRgWbynTa7LF6+7Pi4Nf2MTmj2q2ro4BxzYbS4PzQPTlOU6F+8NvZkOVdnVu7p3W0peXXY1/rPdyVn4W8yQYAAP3JW2+9pauuuqpVCC1JcXFx+uEPf6jHH39cv/rVrxQXF6czzjhD/9//9/9ZUCkAoDdihBUAQIdaTMWbtPF2xW//q2yeva03lU1GQ6nM2MD/JVVTHpIZ85RMR3JUSoW1Qg6i//jHP2rmzJl6/vnntW/fvmZBtCTl5ubqpZde6nGB6JmmvzROHZ2gQ0btk710TbOQ2V63TTrtwDAI8TuWKX7Xy62OZdqT5EsYJ8OzT2bcMElSzfhfq2b8jfLFZ0j2+KhdV28T7h4nkQz5QukZ+nHhji6F4l0Naj8u3NHsdWOg3N61riuuaPbakLS2qKzLvVc7Chi/21oum82Q32/26Did6cqDBZ0dvztza4dTW1+Pfa33cFfeQPMmGwAA9Ce1tbXau7f1h0CNSktLVVNTE3ydnJwsm633TokEAIg+RlgBAEgK9HSu3SqHu0AxrkI5XPlyuNeq8rivJCUFtvE3yObZK9Owy5c0RV5nrjzBns4HS/ak4OH8CWOsuQ5YIuQgeuPGjbrpppvaXT906FCVlZWFeniEUd7EdB3jvVcJ256UtrWzUU2JpEC43JD2A5m22CbDZ4+TL3G8zJihwXH5G/mSJkS2+AEqkiFfKD1DA8M/l3Uainc1qDVltFrW0bU2HvfA/tKMzCHatruq2bnaC3s7ChinjkvTii9Cn6+6q8Ocd+XBgs6CUKt67Lb19dgXew935Q00b7IBAEB/MWvWLD333HPKzc3V8ccf32zdhx9+qOeee05HHHFgSqTvvvtOBx10ULTLBAAAANBLxe5+TQnfPy2Hq1A2b0Wr9Q73V9KwkZKkutGXqX7EAnkHHcxw2mgm5CA6ISFBtbW17a4vKSlRampqqIdHmPljBgf+tg+SP2G8fIkHQmYNylRy/DDJE9i2/qALVH/QBdYV28tFcl7cRpEM+brTM/Tjwh36vrRaZZV1XQrFm+7XVtjc6NickSrc1Lx3RkfXeuC4O6Um80FnjnIGr0NSh2FvewHjIZPSddslh+u/3+7SpNEp3Qoquxowd+fBgo6CUKt67Lb19UjvYQAAgN7t9ttv10UXXaSrr75aw4cP15gxgV4HJSUl2r17t0aNGqXf/OY3kqT6+nrt3LlTZ599tpUlAwAAAIgm0y97zaZAD2dXoRzuAlVNeVC+QdMkSbb6PYot/09gUyNW3kHTAz2cnbnyJudIKTOCh/IlTbTkEtD7hRxEz5o1S6+//roWLVrUal1paalefvnlVk9dwzq1GVerNuNqmTFprXo1Oxw2yZEkqdqa4rooGgFwV2qIxry4kQ75utrrs2BTmQwj0APZUNdD8UAPaqlw094226jl9Unq9Frbqrnpskdf+UpSaL3IZx08UpMOcsrr9XdpeynwtfDGx1tkdCFgDueDBZHssdtZj/LGBwGiUQsAAAB6ZtSoUXrrrbf04osv6pNPPtH27dslSVlZWVq0aJHOPfdcJSYmSgrMGf3EE09YWS4AAACAKLC7v1H8jucU4yqQ3b1WNl9Vs/UxlV8Gg+iGoSfKbVsaCJ4HTZVssc22ddiZ2gedCzmIXrx4sc4991z9+Mc/1ty5c2UYhj755BN9/vnneumll2Sapn7+85+Hs1b0gBk7xOoSeiTcAXCooXY058XtSsgXyXC+6bUahpQxbJDOOHp8p+fpahu1vL6e3s+mPawjPVR049ejof0hfScBc1/oPdyV77GCTXtlMwIPGpw2e6waPH5LHwwBAABAxxISEnTJJZfokksusboUAAAAANHi98pevU4OV4Fi3AWqHzZfnrRjJEm2+h1K3Pan4KamLVHe5BnyOnPkcebJM/jYA4dJzFJdYlbUy0f/EnIQnZmZqWXLlunuu+/Wo48+KtM09dRTT0mSDj/8cN1xxx0aPXp02ArFwBbOALgnobYV8+K2Fza3vI7cCUOCQ1aHQ8trPThziNYVV0jqODTuqI0iFZx/VLiz2evxI5PbPH53zt/RtuuKK4IhtNS1kL639x7u7Hus5YMJb39WHPGRATrTG0ZJAAAAQOc2b96sJUuWKD8/X0lJSZo/f74WL16s2NjYDvczTVNPPPGEli1bpvLyck2dOlU333yzcnNzg9usWrVKF110Uat9Tz31VD388MPhvhQAAACg1zE85Yrb88/9Q2wXyFH1jQx/XXC9aU8OBtFe5yGqybhK3uTAENu+pEmSYbeqdAwAIQfRkjRx4kQ988wzqqysVHFxsUzT1JgxY5SWlhau+gBJ4Q2AexJqR7tna0ehedPrkKTCTWUq2FQWtlCw6bXGOGxdDh7bGnb7hfc3Kjam68foLqPJcNGSlJLU+gOt7jyA0Nm2sTG2Zmc8OHNIt66lNwaonX2PtVzfOFR7pEcGaE+0hskHAADoy0pLS/XKK6/o22+/ldvtlt/ffCoawzD07LPPRrSGyspKLVq0SOPGjdPSpUu1e/du3Xfffaqrq9Ptt9/e4b5PPPGEHnvsMd14442aPHmy/va3v+nSSy/VG2+8EZzzutG9996rzMzM4OvBgwdH5HoAAAAAy/jr5XB/I4e7QL74DHmGnihJMjz7lPztNc03dTjlTc6RNzlHDUMOTKNrxg5R9eT7o1o2BrYeBdGNUlJSlJ2dHY5DAW0KZwDc01A7mj1bOwrNG6+jkanwh4KN1/rC+xu7Fd437tc0LGzsSRuJ8PKYnFGB+awVaIdjcka12qattpSkDSUVOmx6YI7ojrZtWmuDxx+YO3v/NXm6Obd0bwxQO/sea+/BhGiNDNBSNIfJBwAA6IvWrVuniy66SHV1dRo/frw2bNigCRMmyOVyaffu3crIyNCIESMiXseLL76o6upq/eEPf1Bqaqokyefz6be//a2uvPJKDR8+vM396uvr9ec//1mXXnqpLr74YknSoYceqrlz5+qpp57SnXfe2Wz7iRMnasaMGRG8EgAAACCKTJ8crjWBHs6uQjncBXJUfSvD9EqS6oafFQyi/QmZqh86V76kyYH5nJNz5EvMlAzmcIb1Qg6iX3/99U63iYuL04gRIzR9+vROh9wCOhOuALgvzNfbqKPQvPE6Pi7cGZy7NxKhYP7GUu2pqA0Gft0ZbrvZcM4KBLeRqLMr97RlW8Y4bMFAeMUXJfrhUeNUV+/TlLGp3e4d3J1r6c0BamffY03XZ45yWvo9ZMUw+QAAAH3JQw89pMTERL3++uuKj4/XkUceqVtuuUWzZ8/Wu+++qzvvvFMPPvhgxOv46KOPNHv27GAILUnz5s3THXfcoU8//VRnnXVWm/utWbNGVVVVmjdvXnBZbGysTjrpJK1cuTLSZQMAAADR46uWw/21DH+dPGnHBZaZXqX+d64M09NsU39MWiBsTpl5YKFhyJX3chQLBrou5CD6pptukmEYkgLzNjXVdLlhGBo0aJCuuOIK/fSnP+1BqUD49DTUjtbQyl3ppdrY8zgSoWDT3ruSlJ3VfB7qlr17T5s9Vg0ef7BdWoaF40cmKyUpNqxzWTfqSojatC1bznn81qdbJQWuY9jgBCUnxmhoSrxOP3Jch72Du9vm/SVAtXrO6770QAkAAIAV1qxZo8svv1yjRo1SRUWFpAPv3efNm6cvv/xSDzzwgP76179GtI6ioiItWLCg2TKn06n09HQVFRV1uJ+kZsNtS1JWVpaeffZZ1dXVKT4+Prj8iiuuUEVFhdLT03XaaafpF7/4RbP1AAAAQG9geN1yuNcG5nN2F8rhKpC9eoMM+eVJzlXFER8FNrTFyZN2rEzZ5HXmyOvMkzc5R/74MYEPtIE+okc9om+66Salpqbq/PPPV0ZGhiSpuLhYf/vb3+R2u/Wb3/xGZWVlev755/X73/9eSUlJOu+888JWPBBuXQmYoz20clcCv0iFgi177w4bnNjsPC3D3LbmgG7aa7t4l1t+s+2hszsTjvC/ZTs1DYSb2rOvVpLkrvGoaIerzfOF2uaRClB747zTkWZ1GA4AANCb+f1+DR06VFIg+LXb7cFAWpImT56sV199NeJ1uFwuOZ3OVstTUlJUWVnZ4X6xsbGKi4trttzpdMo0TVVWVio+Pl7Jycm6/PLLddhhhykuLk6ff/65nn76aRUVFenPf/5zj2p3OHr/UIZ2u63Z34g+7oG1aH/rcQ+sRftbj3tgrV7f/p5K2Wu2ypeSE1zk/PRY2Ws2t9rUHzdCZuJYOexGMGiuPvyNZtvY9v/pLXp9+w8AfeEehBxEP/vssxoyZIieeuqpZssnT56sk046SZdffrleeeUV3X333TrhhBN03nnn6YUXXiCIRq/V1YC5Zfj6xidbJKnXB2Itg8quBJed9d6NjbE1G3bbUOshp/MmpmtdcUVwfmgjhOGoG++NoQM9rxcclxVyW0gHAuEN31eqaEelNpa0/SHY10VlbZ6rJ8FvuAPU3jrvNAAAAKwzevRoff/995Ikm82m0aNH67PPPtOpp54qKdBjOjk52coSw2LatGmaNm1a8PXs2bM1bNgw3XXXXfrqq6+UnZ0d0nFtNkODByeFq8yIczoTrC5hwOMeWIv2tx73wFq0v/W4B9bqFe1fXy7ty5fKv9z/Z41UtUmKcUo/3ndgvuahh0h766W0Q6XBhwT+TjtEtoSRipXUFye57RXt30+t+nqnvtq8V9lZQzXr4JHtbteb70HIQfT777+v66+/vs11hmHohBNO0KOPPqq7775bNptNp5xyih5++OGQCwUiratz9zaGs4YRCF9Ldldp6atrlTthSESGnA6HtobQbqv3cksd9d7N31iqtz8rDrbDzMnpWr2+tM3QOjbGpsYR/M398zN3x7riikDYvf/1258VK3OUs8dtnTcxXYdNHa4N211a8pcv2tzm4MwhrZb1tuC3N887DQAAAGscffTRWr58efB9+09+8hPdd999KikpkWma+uKLL3TJJZdEvA6n0ym3291qeWVlpVJSUjrcr6GhQfX19c16RbtcLhmG0eG+8+bN01133aWvv/465CDa7zflctWEtG802e02OZ0Jcrlq5fP5rS5nQOIeWIv2tx73wFq0v/W4B9ayqv2NhjKZsQc+N0786grFbV/W5rY+R6rcu7fKjBseWDD1z5KtRdxcJ6muOkLVRg5f/5G1ZkOpHnm5UDZDevOjIi0+J0eHTGr+ub9V98DpTOhyL+yQg2i/368tW7a0u37Lli3y+w9cdFtDagG9SVfn7m0MZ9/4ZItKdlcFw9HCTWUq2FRmeSjZlpZB5dqisi4Hl+313m15zDRnfLuhdYPHHwySDUkeb/d+IDbem0ah9KruyKyDR2rxOTn695rtKti0N7h85uT0NntD97bgt7/MOw0AAIDw+dnPfqbTTjtNHo9HMTExWrRokWpqavTee+/JZrPp6quv1pVXXhnxOjIzM1vNBe12u1VaWtpq/ueW+0mBzxamTJkSXF5UVKRRo0ZFZf5nbzfft1jJ5/P3qXr7I+6BtWh/63EPrEX7W497YK1Itr9Rv0cx7gI5XPv/uAtlryvR3uM2y4wNfCbsiwn0VPUljJNn/1zOXmeuvMk5BwLrYH0Oyd+/vlb4+o+Mb4rKm+UQ324pV3YbHeek3n0PQg6iTzjhBL3wwgsaO3aszj777GDIXF9fr5dfflkvvvii5s2bF9w+Pz8/OI800Bt1Z+7exnVLX10bXGYqfKFkuOf7bRlUzsgcom27q3oUXLYVfrYXWvc0KM2bmB7sxd3YAzvcYeshk9Jb/WBPc7b94VZvC34jNe80AAAA+q6UlJRmvYYNw9DVV1+tq6++Oqp1HHvssXr88cebzRW9fPly2Ww2HXXUUe3ud8ghh2jQoEF69913g0G0x+PRe++9p2OPPbbDc7799tuSpBkzZoTpKgAAADAgmGZwfub4759WYtEDstfvaHNTR9U6edICn8PWjP25asZdJzNmcNRKRf/X23KIUIUcRN96660qKSnRkiVLdP/99ys9PfANV1paKo/Ho+zsbN16662SAuF0fHx8VIb9Qt8X7hC2O7ozd29j+Pdx4U4VbNobth8GkRj2ua2gMnOUs0fBZXeD+4627co9X3BcVo9r7kx3e8V3Vks0v5bDPe80AAAAEA4LFy7U888/r5///Oe68sortXv3bj3wwANauHChhg8fHtxu0aJF2rFjh1auXClJiouL05VXXqmlS5cqLS1NkyZN0gsvvKCKigpddtllwf1uvPFGjR07VtOmTVNcXJw+//xzPfPMMzrxxBMJogEAANA205StfnuTXs4FcrgK5cr5q7ypswLbGDGy1++QKUO+pInyJufu7+WcK68zW6bDeeBwsUMtuhD0Z/2lA5phmo0zt3afaZpauXKlPvnkE23fvl2SdNBBB+noo4/WiSeeKJute/PA9gc+n1/l5X1rLH+Hw6bBg5O0b1+15V33m4awflO9cpjrtuRvLA35h0HL9n/h/Y364MuSYK/cE2eO0cI5EyNUeXR0FMhafc9btn9P7mVTjdfVOCT5abPHtjnMt5UPXvQGvennz0DFPbAW7W8t2t963ANrWdH+aWlJXZ5HCt1z8803d3sfwzB0zz33RKCa5jZv3qzf/e53ys/PV1JSkubPn6/rr79esbEH5sa78MILtX37dn344YfBZaZp6v/+7/+0bNkylZeXa+rUqbr55puVl5cX3ObPf/6z3nrrLW3fvl0ej0cHHXSQfvjDH+qKK65odvzu6ivv7fk5aj3ugbVof+txD6xF+1uPe2Ct7ra/o2KVkoruk8NVKJtnb6v17sn/q7qMwPQ1Rv0e2Ws2y5s8Q3IMCnvt/QFf/9az6h505719yD2ipcCb1pNPPlknn3xyTw4DBPW2uXe7Kpy9UfvLcAuNgoHs/h7eLQPZcN7zcIS64bqX64orgiG0JL39WbEyRzmbHbuxbaTw9X4HAADAwLRq1apu72PsH3Yw0rKysvTMM890uM3zzz/faplhGLryyis7nMu6s/UAAAAYQExTttotitk/l7PDVaDa0ZeqYfh8SZJhehVb9kFgU8MuX9JUeZy5wfmcvckHRtQx44bJGzfMkssA+pMeBdFAuPW3EDYU/WW4hUbriiuC8zpLgUB2d3mNBifHa8rY1LDd80gMad4TjdfVyGgjZP+ocGezfT4u3Nnn7zcAAACs0bQnMQAAADBg1OxQwroHZKvIl8NdKJu3stlq76CpwSDak5wj95TfB4LnQQdL9ngrKgYGlJCDaNM09dJLL+mVV15RSUmJXC5Xq20Mw9C3337bowIxsPS3EDZUvWG+33ANGd0ykJWk1etLgz2kcyYM1Wmzx8rj9ffonve23vR5E9N12uyxevuz4mAQ3zJkN9RyZoSQZ0oAAAAAeqSqqkp33323Lr/8cmVltZ5SBgAAALCM6ZO9epMc7nw5XIXyJh+s+lHnB1fHb3n0wKa2OHkHTQ/O6ewZfOSB4zgGqW7M5dGsHBjwQg6iH3jgAT3zzDOaOnWqzjjjDKWkpISzLgxgvSGEtZrV8waHs3dx00C2qcYe0oWb9qpw094e92COjbHJbwZ6HveW3vQLjstS5ihnuw9WHJMzSgWbyoJDeB+TM8qSOgEAAIC6ujq9/vrrOuOMMwiiAQAAYC1/g+J2/V0OV6Fi3AVyuNfK8FUHV9cPnXsgiE4Yqbrxi+VJmCiPM0e+pKmSLcaiwgG0FHIQ/frrr+vkk0/Wo48+2vnGALqsNwwxHe7exY1zQrcMoxvZjMCw1KGG7/kbSwM9jxUIuE+bPbbXPMzQ0YMVjAAAAACA3sQ0GaEHAAAAUeT3yF69TjGuApmG7UC4bNiVvO7GZuGzaUuU15ktT3KOPIOPPnAMw1DtlCXyev1RLh5AV4QcRNfV1enII4/sfEMA3dIbhpiOxFzdTXsHxzhs2l5apYJNZcFzFGzaG3L43rLNPH3olw5GAAAAAAAAAAAwENjdXymmco0c7kI5XPlyVH0jw18vSfImTWoWRNeNOk+mEROYzzk5V76kiZJht7B6AKEIOYiePXu21q5dq3PPPTec9QADXiRC4O6KVE/dlqFr/sZSrd9WoT37avTV5rKQw/fe0GYAAAAAAAAAAEm+OjmqvpGtrkQNw88MLnZ+faUcVd8029TvSJE3OUdeZ15guEvDkCRVTXkomhUDiJCQg+g77rhDl19+uR5//HGde+65Gjx4cDjrAgas3jJcczR66jaeI39jabPe0d0Nkq1qs7bm8rZ6fm8AAAAAAAAAiBpfjRzur+VwF8jhKlCMq1D26u9kmF6ZtjjtTT8tOGdzQ9qx8scOk9eZI29yrjzOXPkTxkmGzdprABAxIQfRc+fOlWmaevTRR/Xoo48qLi5ONlvzHxaGYejLL7/scZHAQBPt4ZrzN5bq48IdMmXo2JyRUQ9QwxEkW9FmLefylmT5/N4AAAAAAAAAEBHeKjmqvpE35fBgz2Xn1z9V3J63Wm3qjxkirzNXhrdCZmzgM9LqyfdHtVwA1gs5iD7llFNk7P9BA6DvagxUGxVu2mtJgNrX5kpuay5vc/+/rZzfGwAAAAgV7/EBAD3FSHFA/2F4XXK41wbmcnYVyOEulL16gwyZKjv6a/kTMiRJ3uQcxVSskseZGxxi2+vMlT/uoGBYDWDgCjmIvu+++8JZBwCLrCuuaLWMALVz7c1LHcpc1bxJAwAAQG9gmqbVJQAA+rC2Ro/jcw6gbzA8FTLtCZItTpKUsOX3GrTpzja39cWNlK1+ZzCIrhl3vWrG/4rQGUCbQg6iAVgj3KFlY6DaVEcBan8MTVd9vVP//WanJo3p+jW1N5x4d4cY500aAAAAIm3Pnj0qLy9XRkaGEhMT29xm6NChWrduXZQrAwD0J22NHsdnHEDvY3jKAz2cXYVyuAsU48qXvXarKg55U54hP5CkYMjsix8tb3KuvPt7O3ucuTLjhjc/4P75nwGgLT0Oonft2qVvv/1Wbre7zaenzzzzzJ6eAsB+kQgtGwPVjwt3SDJ0TAdzRPfH0HTNhlI98nKhbIa04ovuXVNbw4l3d4hx3qQBAAAgUt5//309+OCDKi4uliQ9/fTTmj17tsrLy3XppZfqmmuu0YknnmhxlQCA/qK90eMAWMj0S4ZNkhRT9oGSv10se11xm5vaazYGg+j6oXO197gimbFDo1UpgH4q5CC6vr5e//M//6P33ntPfr9fhmEEg+im80oRRAPhE6nQsqvhaX8MTb/bWi5j/zUZiv418SYNAAAAkfDhhx/q2muvVW5urk4//XT94Q9/CK5LS0vT8OHD9eqrrxJEAwDCpr3R44BQ9MdRGSPNqN+tGFe+HO7C/T2eC1ST+WvVjb5EkmQ6BgdDaF/CeHn2z+UcmNc5R2ZM2oGDOQbJ1CArLgNAPxNyEP373/9eK1eu1OLFi5WXl6cLL7xQ9913n4YNG6Znn31We/bs0f333x/OWoEBz+rQ0urzR0JsjF2NgzmYkmIctqienzdpAAAAiIQ//vGPmjlzpp5//nnt27evWRAtSbm5uXrppZcsqg4A0F91d6Q4oC39cVTGSLHVFmvQul/J4S6UvX5nq/UOV0Hw397k6ao49J/yJmfLjEmNXpEABrSQg+gVK1borLPO0hVXXKF9+/ZJkoYPH67Zs2fryCOP1EUXXaS//e1v+u1vfxu2YoGBzurQ0urzR0KDxyfDkExTMgzJ4/VHvYa+9iaNJ1IBAAB6v40bN+qmm25qd/3QoUNVVlYWxYoAAAC6pj+Oyhgy05St7ns53AVyuPLlcBXKM/hI1Y7/ZWC1w6m4vcsD/5ZNvqRJ8jpzmszrnH3gWLY4edKOteIqAAxgIQfRZWVlys4O/BCLj4+XJNXW1gbXn3LKKfrjH/9IEA2EmdWhpdXnD7ep49K04ov+1cs7kngiFQAAoG9ISEho9h69pZKSEqWmpkavIAAAgC7qj6Mydou/Xkmb75PDHQiebZ7mDw8aZsOBIDpmsNzT/iBv0iR5k2dI9iQrKgaAdoUcRA8dOjTYEzohIUEpKSnasmVLcH1VVZXq6+t7XiEARNAhk9J12yWH67/f7tKk0SmEqp3giVQAAIC+YdasWXr99de1aNGiVutKS0v18ssv6/jjj7egMgBAX8UIaYiW/jgqYyumX7baLYrZP5ezaU9UTdbNgXVGrOK3/0U2T3lgU8Mh76Bp++dyzpU3ZWazQ9UddFG0qweALgs5iM7OztaaNWuCr48//ng99dRTSk9Pl9/v1zPPPKPc3Nxw1NipDz/8UI888oi2bNmiUaNG6YorrtCCBQs63KehoUGPPPKICgsL9c0336i2tlafffaZ0tLSolIz+rZo/+Id6fMN9DcSsw4eqUkHOeW1YFjuvmbAP5EKAADQRyxevFjnnnuufvzjH2vu3LkyDEOffPKJPv/8c7300ksyTVM///nPrS4TANBHMEIaoq2/jcooSbG7X1dM5X/lcBXI4S6UzesKrvPFj2kSRBuqGX+jTHtiIHweNF2yx1tUNQD0TMhB9IUXXqjly5eroaFBsbGx+sUvfqH8/Hz9+te/liRlZGTo1ltvDVuh7Vm9erWuueYa/fjHP9Ytt9yizz//XLfeequSkpI0d+7cdverq6vT3//+d82YMUOHHnqoPvnkk4jXiv4h2r94R/p8XTn+QA+qccCAeCIVAACgH8jMzNSyZct0991369FHH5VpmnrqqackSYcffrjuuOMOjR492uIqAQDRFupnPIyQBnSR6ZO9eoMcrgLZ6neqdvwNwVWJWx9VjOvLA5va4uQdNF1eZ568yTmSaUqGIUmqHXtN1EsHgEgIOYieOXOmZs48MATEyJEj9e6772rDhg2y2WzKzMyUwxHy4bvsT3/6k7Kzs3XXXXdJko444giVlJToscce6zCIdjqd+uKLL2QYhv7xj38QRKPLwvWLd+Mv/tMz0zRnVvtzd0T6F/3Ojt/bnnglFLdef3wiFQAAoD+aOHGinnnmGVVWVqq4uFimaWrMmDGMBAYAA1RPPuNhhDSgbbaqDdK+QiXs/Fz2igI53Gtl+GskSaZhV23GVZI9QZJUP2KBvCmHyJOcJ68zR76kKZItxsryASDiwpoU22w2TZkyJZyH7FBDQ4NWrVqlG2+8sdnyU089Vf/85z/1/fffd/iEt7H/6SL0D9EKKMPxi3fLX/wHJcVp0kHOiJ2vI50dvzc98drbQnEAAACgL0hJSVF2drbVZQAALNaTz3gYIQ0Dnr9Bjqrv5HAXqm7U+ZJhlyTFb7pP2vmymg6cbdqT5E2eIU9yrgxfjcz9QTS9nAEMRD0Oojdt2qSSkhJVVla2uf7MM8/s6SnatW3bNnk8HmVmZjZbnpWVJUkqKipiqLEBIpoBZU9+8W4My0srapr94r92c1m7QXSkf9Hv7PjhCt7D8ZBApELxVV/v1H+/2alJY3gjBQAAgP7h9ddf73SbuLg4jRgxQtOnT1dsbGzkiwIAWKqnn/EwQhoGDH+9HFXfBuZydhXI4S6Qw/2NDLNBkuRJmSXfoMmSJG/akYrz7VZd4gw1DMqRNzlXvqQJwaAaAAa6kIPobdu26Ve/+pW++uormabZ5jaGYUQ0iG4Mv53O5gFe4+v2wvFIczhslpw3VHa7rdnffdGGkuYB5YbvK3XY1OERO99hU4d3+/hrNhwIy/37v2Ua/z0ja0iH7R/K+bqjo+MfNnW4Fp9j03fF+zR17GAdMql7bziaXvfK1SVafE5Ot4/RaHpmWrM3TNPGp/X4+61g0179/sUC2QxDK77oWX3ovv7w86ev4x5Yi/a3Fu1vPe6BtWj//u2mm24KjgLW8j170+WGYWjQoEG64oor9NOf/jTqdQIAoodezUAbfLVyVH0tX9JkmY5ArpC45UElFd3falO/I0Xe5BwZ/trgsoaMy5WU8wvV7quW1+uPWtkA0FeEHETffvvt2rBhg2655RbNnDmzVRgcKrfbrT179nS63ZgxY8JyvnCz2QwNHtz+fL+9mdOZYHUJITts+kit+KJENpshv9/UYdNG9Lr7ULSrKFifzWZo5tThGjkkSTOyhmjWwSOtLq9Dc2Ylac6scSHt2/K6t+yqCvlYc2YlaVBSnNZuLgtbu23aEb76ELq+/POnv+AeWIv2txbtbz3ugbVo//7p9ddf10033aTU1FSdf/75ysjIkCQVFxfrb3/7m9xut37zm9+orKxMzz//vH7/+98rKSlJ5513nsWVAwAiiV7NGNB8NXK418rhKlCMO9Db2V69TobpU2XuS2pInydJ8ibnyh8zWN7kXHmdufI4c+VNzpE/YbzEdJ8A0C0hB9Fr1qzRlVdeqQsvvDCc9Wj58uW67bbbOt3unXfeUUpKiqRAeN2Uy+WSpOD6aPL7TblcNVE/b0/Y7TY5nQlyuWrl8/XNp7YmHeTU4nNygr12Jx3k1L591VaX1UzmiORA2GkEvk6OnD5ch0xKD/ZA6cvt35GW1z1+xKAe3ZtJBzmDw5iH4x5PGOXcX58RlvrQPf3h509fxz2wFu1vLdrfetwDa1nR/k5nAj2wo+TZZ5/VkCFD9NRTTzVbPnnyZJ100km6/PLL9corr+juu+/WCSecoPPOO08vvPACQTQAAOgXDK9bkhns5Ry7559yFl4gQ61/7/XHDJHhqQi+bkifq7LjthI6A0AYhBxEDx48WMnJyeGsRZJ09tln6+yzz+7Stg0NDYqJiVFRUZGOOeaY4PKioiJJajV3dLT01SE4fD5/n61dkrIzhyg7c4ik3nkPsjOHNBv+KDtzSLM6+3r7t6ez67Za7oShuu2Sw/Xfb3dp0uiUXlffQNFfv/77Eu6BtWh/a9H+1uMeWIv275/ef/99XX/99W2uMwxDJ5xwgh599FHdfffdstlsOuWUU/Twww9HuUoAAICeMzyVcri/ksNdKIcrP9DTuWaTqifdo9qxP5ck+RKzZMgvX+xweff3cPY68+R15sgfd1Dz0Jn5nQEgbEIOohcuXKg333xT559/vux2a34wx8bGatasWVqxYoUWLVoUXP7OO+8oKytLo0ePtqQudF3+xlKtK67QlLEDY16ajoY/WrOhVN8UlffLtujtwz7NOnikJh3k5ANYAAAA9Bt+v19btmxpd/2WLVvk9x/4/Tc2NlZxcXHRKA0AACB0pl8yAiPs2Ks3yVlwthw1m9vc1F5bFPy3L2mSyo7dIH/ciKiUCQAI6HIQ/d577zV7PX78ePn9fs2fP18LFizQiBEj2gykTz755J5X2YGrrrpKF110ke68807NmzdPq1at0j//+c9WT3JPmzZNZ555pu65557gsv/85z+qra3V119/LUn617/+paSkJE2YMEETJkyIaN0IhNBLX10rmyGtXF2iaxfM6NVhZSSt+nqnHnm5kLYAAAAAEBYnnHCCXnjhBY0dO1Znn312MGSur6/Xyy+/rBdffFHz5s0Lbp+fnx+cRxq900B7kBsAAKOhTI79cznHuArlcBeoYejJqpryoCTJFz9K9pot+/89pklP51x5knNlxg1rcjA7ITQAWKDLQfR1110nwzBkmqYkNfv3/fff3+Y+hmHou+++C0OZ7Zs5c6aWLl2qRx55RK+88opGjRqlJUuWNHtDLUk+n6/Z096S9Nvf/lbbt28Pvr7lllskSddcc42uvfbaiNYNaV1xRWDeYFOyGdL6bRUD9s30V5v30hYAAAAAwubWW29VSUmJlixZovvvv1/p6YH3F6WlpfJ4PMrOztatt94qKRBOx8fH65JLLrGyZHSAB7kBAAOGv0HOtZcEhteuK2m12uHKP/DCnqiKme/KlzRJZuyQKBYJAOiqLgfRzz33XCTr6JE5c+Zozpw5HW6zfv36Vss+/PDDSJWELpgyNlUrV5cEA9jJGalWl2SZ7KyhevOjItoCAAAAQFikpqbqhRde0MqVK/XJJ58EH8I++uijdfTRR+vEE0+UzRYY1jIuLk5Lliyxslx0gge5AfR20ZpyLpqjQzASReTY6ncF53J2uAtlOlLlPvjx/Stj5ahcI3t94HcXb0JmoKezM1fe5Fx5ndnNjuUdPDva5QMAuqHLQfThhx8eyTowAOVNTNe1C2Zo/bYKTc4Y2L/QzTp4pBafk6Nvt5QP+LYAAAAAEB6GYejkk0+O+JRZiDwe5AbQm0Vryrlojg7BSBThl7D1UcXs+yTQ07lhd7N1/pghkmlKhiFJqpryvzIdKfImZ8uMSbGiXABAmHQ5iG6poqJCu3bt0pQpU9pcv379eo0YMUIpKfxHgfblTUznl7j9DpmUruxMhpABAAAAADTHg9wAerNoTTkXzdEhGIkiBKYpW13J/l7OBbLX75R7+p+Cq2P3vqfYfR8HNpVNvqRJTeZ0zpNkSgoE0Q3DTrfgAgAAkRByEH3vvfdqy5Ytevnll9tcf8cddygzM1P33HNPyMUBAAAAAIDuM01TL730kl555RWVlJTI5XK12sYwDH377bcWVIdQ8CA3gN4qWlPORXN0CEai6JqYsn8rtvxfwSG2bZ7yZuurJt0rMyZVklQ3+lLVDztjf/h8sGRPsqBiAEC0hRxEf/755/rJT37S7vrjjz9eL774YqiHBwAAAAAAIXrggQf0zDPPaOrUqTrjjDMYrQwABgCr5jSO1pRz0RwdgpEomjD9stcUyeEulMNdqOqsWyVbnCQpbverStj+7IFNDYe8g6btn8s5RzJswXX1IxZEvXQAgPVCDqLLy8s1ePDgdtenpqaqrKws1MMDAAAAAIAQvf766zr55JP16KOPWl0KACAKIjmncVcC7mhNORfN0SEG6kgUttoSxVT8PzlchXK4C+RwfyWb98DIKvXDz5LXmStJahh6siTbgSG2k6cHQ2oAAKQeBNHp6ekdDuH1zTffKC0tLdTDAwAAAACAENXV1enII4+0ugwAQJREak7jSAbcsJjpk716gxyuAjUMmSMzbpgkKW7X3zVo053NN7XFyTvoYHmduTLticHlDcN+qIZhP4xm1QCAPibkIPrEE0/UsmXLdOyxx2rOnDnN1r3//vv6xz/+oYULF/a4QAAAAAAA0D2zZ8/W2rVrde6551pdCgAgCiI1p3GkAm5Emd8je/V6OVwFinEX7J/Tea0Mf60kyTXjGdWPOEuS5E05XJ6UWfI6c+Rx5smbnCNf0mTJFmPlFQAA+qiQg+hrr71Wn332ma655hpNmTJFEydOlCRt3LhR69atU1ZWlq677rqwFQoAAAAAALrmjjvu0OWXX67HH39c5557bodTawEA+r5IzWkcSsBt1VzV2M/fIEfVd/LHDpE/frQkKbb0baV8dVHrTe2D5E3OlmlPCC7zpB2tisNXRq1cAED/FnIQnZycrJdeeklPPvmkVq5cqRUrVkiSMjIydPXVV+uyyy5TYmJiJ0cBAAAAAADhNnfuXJmmqUcffVSPPvqo4uLiZLPZmm1jGIa+/PJLiyoEAIRbJOY07m7AzVDeUeark8q+U+z3/0/xFfmBeZ2rvpFhNqhqwh2qHf9LSZLXmSu/wxmYx7lxPmdnnnyJWZJh6+Qk1uLBBgDo20IOoiUpMTFR1113XZd6Pns8HhUUFGjKlClKTk7uyWkBAAAAAEAHTjnlFBmGYXUZAIB+oDsBN0N5R5CvVoavWmbsUEmSvXqjUj+bJZleJbXY1O9IleFvOPA6fqzKfrCt14fOLfFgAwD0fT0KorujsrJSF110kZ5++mnNnj07WqcFAAAAAGDAue+++6wuAQB6rf7ew7Kj64v0tUdqrupI6NVfB75qOdxrA3M6uwrkcBfKXr1OdSPPU9X0PwY2SRgnGXYpNkWe5Fx5BuXI48wN9H6OHys1fSDNMCT1vQfUeLABAPq+qAXRkmSaZjRPBwAAAAAAAABB/b2HZUfXF41rj9Rc1Z3pbqjcq74OTF8gUJYkv0eDPz9a9ur1MuRvtam9tvjAC1uMKn/wrVKHj1dVRY283tbb93V96cEGAEDbohpEAwAAAACA6Nm1a5e+/fZbud3uNh8OP/PMM6NfFABYqL/3sOzo+qJ17d2dq7qnPZNDCZWt+jowPJVyuAsDczm7A3M6++NGqHLm24ENbDGS6ZEhv3yxIwLzOTtz5U3e39M5bmSz45lxw5v3fO5nrHqwAQAQPgTRAAAAAAD0M/X19fqf//kfvffee/L7/TIMIxhEN507miAawEDT33tYdnR9vfHaw9EzOZRQOdptMei7GxRT9qEctUWt1vnrd0mmPzh/syv7GZmxw+SPGxHRmvqK7j7YAADoXQiiAQAAAADoZ37/+99r5cqVWrx4sfLy8nThhRfqvvvu07Bhw/Tss89qz549uv/++60uEwCirr/3sOzo+sJ97fkbS/XJVzsVE2vXkdNHKDtzSLf3f+PjLTJ62DM5lFA53G1hNJTJ4cqXw12oGFehbPU7VHH4+8H1ttriYAi9u36YNtdkKn38UUoff6S8ztxgCC1JvuTsHtUCAEBvQhANAAAAAEA/s2LFCp111lm64oortG/fPknS8OHDNXv2bB155JG66KKL9Le//U2//e1vLa4UAKKvv/ew7Oj6wnXtjT2ZG33xze5u9WZu3N+QZErBMDrUnsm5E4ZIMnRMzsgu19DTtojb8YLi9rwlh7tA9rrvW6036ncHhs6WVDv+l3qn7Ed6tXCQKr1O2QzpxCFjtHDoxJDPDwBAX2DrfBMAAAAAANCXlJWVKTs70KMqPj5eklRbWxtcf8opp2jlypWW1AYA6PvWFVe0WrZ+W+tlHe1vM/aH0JIyhg0KaVjuxkC7cFOZCjbtVdEOV7f274ytbqdiS99V4uZ75SxYKHmrguscrjWKK/1nMIT2Jk5Q3fAFqpq4RBWHviXTkRLc1jP4SCWNOyUYQveWodEBAIg0ekQDAAAAANDPDB06NNgTOiEhQSkpKdqyZUtwfVVVlerr660qD0CI8jeWal1xhaaM7X9DSqNvaRwOu6nuBKsth9M+4+jxIX1NryuuCPaqlqS3PytW5ihnyN8fDle+Yve8LYe7QA5XoewNu5uvd6+Vd/BsSVLD8B/JnzBWXmeevMkzZDqcHR67vw8LDwBAW6IWRCcnJ+vee+/VxIkMNwIAAAAAQCRlZ2drzZo1wdfHH3+8nnrqKaWnp8vv9+uZZ55Rbm6udQUC6LbGnp82Q1q5uiSk3qNAuDSGqp+s3amYGIeOnD5cPp9fL7y/sUsPSoQrlG0ZiBtdmWfaNGWr2yaHq0AOd6HqRl0gf2KmJCmm4nMlbXngwKayyTdoirzJOfI6c+VPyAiu8ww+Up7BR3ar3p4OB87DKACAvqbHQbTH41FRUZHcbrdM02y1/rDDDpMkxcXF6Uc/+lFPTwcAAAAAADpx4YUXavny5WpoaFBsbKx+8YtfKD8/X7/+9a8lSRkZGbr11lstrhJAdzQOZew3JVtXwjYgwvImpuuwqcM1eHCSPli1tdmDEjkThurYTuZr7kko2zSQPW32WL39WbEMQzLbGPLaaChTbPl/gr2cHe4C2Tz7gut9iVmq3x9ENww+SrWjLpTXmSNvcq6+3D1C35bUa8rQVOVlWPv91tbDKIdNHW5pTQAAdCbkINrv9+uhhx7SsmXLVFdX1+523333XainAAAAAAAAIZg5c6ZmzpwZfD1y5Ei9++672rBhg2w2mzIzM+VwMFsX0Je0HMqY+WXRm3y3tTz4tSlJhZv2qnDT3oj03G8rkL12wQytLy5X3qhKZQ/6t7zuafIlT5ckxVSulnPtxc2OYRox8g6aLq8zR76EzOByX3K2qqb/8cB5Xus9oxC09TAKQTQAoLcL+V3n448/rqeeekrnnnuuDj30UP3617/WjTfeKKfTqWXLlskwDP3qV78KZ60AAAAAACBENptNU6ZMsboMACFiftmBqy8Mxzx1XJpWfNF8zmjDkN74ZIskhbXudcUVchg+jYjboYlJm5W+9e+anrpVJ9q+km27W9ouVY//lWr2B9EeZ548zkP2z+UcGGLbO2iqZIvr9Dy9aRQCHkYBAPRFIQfRr732mubNm6ff/va32rcvMJTJ9OnTNXv2bJ155plauHChPv/8cx15ZPfmyQAAAAAAAOGxadMmlZSUqLKyss31Z555ZnQLAtAjPZ1fFn1PX5kb/JBJgQclPi7coYJNZcFhskt2V2npq2t7VrffK3vNBkmGfIOmasrYVH2zdpf+NP3aA9tUBP4ybfHyJs+QP25kcJUZN0wVs/7d7dP2tuCXh1EAAH1RyEH0rl27dPnll0uSYmNjJUkNDQ3B12eccYb+8pe/6IYbbghDmQAAAAAAoKu2bdumX/3qV/rqq69kmmab2xiGQRANAL1cb+uV25HGByXyN5bqjU+2qGR3lUx1XHer3t5+j+zV3ynGVSiHK18Od6Ec7q9l+GtVN3yB3Nl/CWx32smqLh6ihrixiht2WKCXc3KufEmTJVt4pp7ojcEvD6MAAPqakP9XTk1NVU1NjSQpKSlJgwYNUklJ8+FXXC5Xz6oDAAAAAADddvvtt2vDhg265ZZbNHPmTDmdTqtLAgCEoLf1yu2KxqC0sSd3e3UXbNiuZW99qn3eoVq5ukTXnTVFc76fKZuvqtW2XiNJssUcOMek4aqZWCQZhrwRuxKCXwAAeirkIHratGlau3Zt8PWsWbP07LPPaurUqTJNU88995wmT54cliIBAAAAAEDXrVmzRldeeaUuvPBCq0vR5s2btWTJEuXn5yspKUnz58/X4sWLg6Ortcc0TT3xxBNatmyZysvLNXXqVN18883Kzc1ttt3u3bu1ZMkSffLJJ4qJidFJJ52km2++WYMGDYrgVQFAdES7V2645qNuVXdmshyVq+VwFcrhLpDDVagT3F9rXNY43bDuQdkMaV1JtY5PHC/VFcubnKMdvkn6e0GKttRm6fu6kbpmQY7ymp7EMHp8vQAAILJCDqLPOeccvfbaa2poaFBsbKyuv/56nX/++brgggtkmqZSUlJ00003hbNWAAAAAADQBYMHD1ZycrLVZaiyslKLFi3SuHHjtHTpUu3evVv33Xef6urqdPvtt3e47xNPPKHHHntMN954oyZPnqy//e1vuvTSS/XGG29ozJgxkiSPxxOcNuyhhx5SXV2d7r//fv3yl7/Un//854hfH4CBKVxhbVf1tFduV+sN23zUfo9kiwnW7cw/R7H/WinD9LXaNC2mTHbDL59p0+SMVFWMfVNmzGDJsOnN9zfqk4qSPjEseV8X7a/pnupr9QLAQBZyED1nzhzNmTMn+HrChAl6//33tWrVKtntduXl5Sk1NTUcNQIAAAAAgG5YuHCh3nzzTZ1//vmy2+2W1fHiiy+qurpaf/jDH4KfEfh8Pv32t7/VlVdeqeHDh7e5X319vf785z/r0ksv1cUXXyxJOvTQQzV37lw99dRTuvPOOyVJK1as0MaNG/XOO+8oMzNTkuR0OnXZZZfpq6++UnZ2dqQvEcAAE7awNgryN5bq48IdKthU1qV6Q5qP2lsl7clX3PbPVLvtM8VWfyWnbZ8qT9hyoMeyLU6G6ZM/ZkhwLmePM1deZ66+LEnQnPjKYG9vs8mhIzUseV8IMaNZY1/6mpb6Xr0AMNCFHES3JTk5WSeeeGI4DwkAAAAAADrx3nvvNXs9fvx4+f1+zZ8/XwsWLNCIESPaDKRPPvnkiNb10Ucfafbs2c0eVJ83b57uuOMOffrppzrrrLPa3G/NmjWqqqrSvHnzgstiY2N10kknaeXKlc2OP3ny5GAILUlHHXWUUlNT9Z///IcgGkDYhRTWWqAxrGvUlXq7E/wmbH1E8Tv+Knv1RkmmEiUlBk8mrfsuX1OmHSJJqp5wu6om3SN//OhWw2nnTZLyJg1r8xzdHZa8K+FtT0LMSIXDLY8b7aC1r3xNN+pr9QLAQNflIHrHjh0hnWDUqFEh7QcAAAAAALrmuuuuk2EYMs1AX7Km/77//vvb3McwDH333XcRrauoqEgLFixotszpdCo9PV1FRUUd7iepWcAsSVlZWXr22WdVV1en+Ph4FRUVtdrGMAyNHz++w+MDQKgi1Us33JqGdY06q7dp8Dv9IJsOGfKtdq/+VNqXr9GODao96kOZsUMkSTbPPjmqNwR2TBilLbUT9PnOkdpYnaUttRN0iDFIU6YFVvuSJrY6V1dD3a4OS97V8LarIWa0wuG2jhvtoLWvfE036mv1AsBA1+Ug+oQTTpDR4om1roj0m1oAAAAAAAa65557zuoS2uRyueR0OlstT0lJUWVlZYf7xcbGKi4urtlyp9Mp0zRVWVmp+Ph4uVyuNufC7uz4XeFw2Hq0fzTY7bZmfyP6uAfWsqL9D5s6XIvPsem74n2aOnawDpnUO3tiTs9MaxbW5U0aquNyD+qwXkfpB/pB3TOaE1cge8kWqURKbVzplTZs+FjjcgMjWXhGnyf3kKOlwXlKHjZeW/9brGVfFgTPNy1zSLs/R9dsaB6+Lj4np9N2XLOhVN9tLdfUcWltbruhpHl4u+H7Sh02tfX0Dy3bZdr4tFZ1tlVfV4/fXW0dtys1NgrH90Bf+Zpu1Nvq5f8Ba9H+1qL9rdcX7kGXg+h77rknpCAaAAAAAABE1uGHH251Cf2KzWZo8OAkq8voMqczweoSBjzugbWi3f5zZiVpzqxxUT1nd82ZlaRBSXFau7lMM7KGaNbBIwMr6kql8i+lfWsCfx/8G2lwbmBd2R5p12vBY7iNUVpbPlabajJVVDtB4xMnKq/xZ+PgmVr19UH66rO9ys7aqeMPG6vEhNjW52tD0a4i2WyG/H5TNpuhLbuq2mzPVV/v1Feb9yo+xq6XP9gom83Qii9KdNslh7c6/mHTR2rFFyXB4x42bUSbP8fbbZdO6uvq8burrePOOnhkpzW21NPvgb7wNd1Ub6yX/wesRftbi/a3Xm++B10Ootubt6mr/H6/du3apaFDhyo2NrZHxwIAAAAAAO2rqKjQrl27NGXKlDbXr1+/XiNGjFBKSkpE63A6nXK73a2WV1ZWdnhup9OphoYG1dfXN+sV7XK5ZBhGcF+n06mqqqo2jz9yZOcf3LfH7zflctWEvH+02O02OZ0Jcrlq5fP5rS5nQOIeWIv279ikg5yakrpXsTv+qIb3C+Vw5ctWt73ZNtXJx6hBgaGzbfGzFDPpLvlS8uRz5ujLrT49srow2DP3mJEjtG9ftaRAr+FHXi6UzTD05kdFumFhrnInDNWkgwKjYDRu15bMEcmBkNcI/LwdP2JQq+0PHD9wbkMK7vPfb3cFz9P0WhefkxPsJTvpIGe7NUw6yNlhnW3V153jd0d7x+2sxkZ8D1iPe2At2t9atL/1rLoHTmdCl3thdzmI7qny8nLNmTNHTz/9tGbPnh2t0wIAAAAAMODce++92rJli15++eU2199xxx3KzMzUPffcE9E6MjMzW83V7Ha7VVpa2mpu55b7SdKWLVuahelFRUUaNWqU4uPjg9tt2LCh2b6maWrLli066qijelS719t3Pkzz+fx9qt7+iHtgrQHf/qYpW/1OOVwFcrgL9G31DH22Z4qmjE3V4UNKlLDp7mabexMnyOvMlTc5Tw0pR8vX2HZx49QwdnFwu+xMBeeMnpyRquzMIcF2/qaofH9IHOg1/M2Wch08Lq1Lcz9nZw5pddz/fre72X4Hji8ZhmTuH7rab0qTRqe0eb+zM4coOzMwh3VPvh7aqs/r9Yft+G2dr6fHHfDfA70A98BatL+1aH/r9eZ7ELUgWgq8GQQAAAAAAJH1+eef6yc/+Um7648//ni9+OKLEa/j2GOP1eOPP95srujly5fLZrN1GBQfcsghGjRokN59991gEO3xePTee+/p2GOPbXb8N998U1u3btW4ceMkSZ999pkqKip03HHHRe7CAMBK3irFlv9LDle+HK5CxbgLZGsoDa7+fvcZen/7pVq5ukTX/2icjhx5rrzJOfI68+RNniHT4ezg4M3lTUxvM1CeMjb1wDzGflNTxw5W/sbmcytfu2BGu2F00+O2tV+z45vSabPHyuP1a3JG+wF3OLV33QAAoHuiGkQDAAAAAIDIKy8v1+DBg9tdn5qaqrKysojXsXDhQj3//PP6+c9/riuvvFK7d+/WAw88oIULF2r48OHB7RYtWqQdO3Zo5cqVkqS4uDhdeeWVWrp0qdLS0jRp0iS98MILqqio0GWXXRbc75RTTtGf//xnXXvttbrhhhtUW1urBx54QD/4wQ+UnZ0d8esDgIgyTdnqiuVwFch0pMoz5AeSJJu3UimF5zffVDZVxUzQFzsP0rdV02Tu70n8zfc+zZjzRNhLy5uYrmsXzNCG7yt12LQRmnSQU88vXx8Mjm2GtH5bRZfC3HXFFa32WzhnYrNeyYTCAAD0TQTRAAAAAAD0M+np6fr222/bXf/NN98oLS0t4nWkpKTo2Wef1e9+9zv9/Oc/V1JSkn784x/r+uuvb7ad3++Xz+drtuynP/2pTNPU008/rfLyck2dOlVPPfWUxowZE9wmJiZGTz75pJYsWaIbbrhBDodDJ510km655ZaIXxsAdFeHw1abpuw1m+VwF+4fYjvwt81bIUmqTz81GET740apYfCx8iWM3T/Edo68yQfrhX9t1/vFJTIPHFKTM1Ijdj15E9N12NThGjw4Sfv2VbfqxdzVc7e3H72SAQDo+wiiAQAAAADoZ0488UQtW7ZMxx57rObMmdNs3fvvv69//OMfWrhwYVRqycrK0jPPPNPhNs8//3yrZYZh6Morr9SVV17Z4b7Dhw/X0qVLe1IigAGgK3MXR/r8jcNPv7+6WL8+I1nTR0ne1Fn7t/Br8OdHyfDXNtvPNGLkHXSwvIOmHVhoGKqc+c9W52gMdA1JpgLDWUfzWht7SXe3F3Oo+wEAgN6PIBoAAAAAgH7m2muv1WeffaZrrrlGU6ZM0cSJEyVJGzdu1Lp165SVlaXrrrvO4ioBIDq6M3dx2Jk+2as3SFtX6KdjvlBmQpGyEouUsL1O3oop2nfkF4HtDLs8KYfJ8FXtn8s5V15nTiCAtsV26VS9IdANtRdzuHo/W/3AAQAAaI4gGgAAAACAfiY5OVkvvfSSnnzySa1cuVIrVqyQJGVkZOjqq6/WZZddpsTERIurBIDoaGsO4oiElH6vbHXb5E/MDC5KXXWCYtz5OlmShh3Y1GfEy4wZLJk+ybBLkioPfSswsXOIBnIIm7+xVB8X7lDBpjJrHjgAAABtIogGAAAAAKAfSkxM1HXXXdelns8ej0cFBQWaMmWKkpOTo1AdAERPqHMXd8jvkb36O8W4CvbP6Vwgh/trSYb2Hr9dsgU+dvUNmixHzQZ5k7O1wzdJG6oylTTyME2cekRwm6AehtCW9fq2WOO1N4r4AwcAAKDLQgqi6+rq9PDDD2vWrFk64YQTurRPYmKirrnmGo0ZMyaUUwIAAAAAgAiprKzURRddpKefflqzZ8+2uhwAA0yke/L2eMhqf71kxAaD4qQNtyph259lmA2tN7Uny1b/vfwJ4yRJVZP/V+7pf5IMuxIl5fbsUtptq3D0+u6rPaqbXnujsD1wAAAAeiSkIDo+Pl4vvfSSJkyY0OV9GoNoAAAAAADQ+5im2flGABBm0erJ2+U5iH21clR9E+jl7CqQw10oR9W3Kj+6UP740ZIk054sw2yQ35EamMc5OUdeZ668ybnyJWZKhi14ODMmJWzX0FFb9bTXd1/uUd3y2nMnDNUxOSP7TP0AAPRnIQ/NPX36dG3YsCGctQAAAAAAAAAYQKI2f3Mn4na9qsQtD8le/Z0M09dqvcP1lRr2B9F1By1S3chz5E8Y3+lw2uHsZdxRW4Xa67uxvj0Vtb3iPoTSXj3u8Q4AACIm5CD6lltu0RVXXKFJkybpRz/6kRwOppsGAAAAAAAA0HURmb+5Ld4qOdxrFePO39/buVBVU38vz+CjAutNnxxVX0uS/DFD5XXmyrO/l7PXmSt//IHpBv3xI7t0ynD3Mm6vrZqGtwvnTOzy8ZrW1zisdcTvQxfrWbm6RKfNHqsGj7/NULplYN3lHu8AACCqQk6Pb7rpJhmGodtvv11LlizR8OHDFRcX12wbwzD05ptv9rhIAAAAAAAAIFz66ly4/VEke7Pa3V8rcesjcrgLZK/eKEPNpyBwVK4JBtENaT9QZc4L8jpz5I87qNOezl0R7t7ebbVVT8LulvVlZw3RsMGJYb8PXf1+a1qPYUhvf1bc5nX15WHEAQAYaEIOolNTU5Wamqrx48eHsx4AAAAAAAAgYgixep8e9WZt2CfH3k8VU1Eghytf9cN/pIbh8yVJhr9O8bteDm7qixsVnMvZ68yRJ+Ww4Dozbpgahp3Wo+toKRK9vVu2VU/C7pb1HZMzKuzfC935fmtZj6G2r6u3DOcOAAA6F3IQ/fzzz4ezDgAAAAAAACDiCLH6NsNTrvjvn1GMq0AOd6FUu0XJTdabMYODQbR30HRVZ90WGGY7OVdm3LCo1hqNuYt7EnZHo77ufL81rSfGYQv2iG55XVEbzh0AAPQYEzsDAAAAAABgwCDE6huMhlLFuPLlcBXKlzBG9SMXBlaYpgZturPZtr6EcfImB+Z09qQdc2CFPUE1mb+OXtFtiPTcxT0NkyNdX3e/35rWkznK2eZ1RSNABwAA4dGjILqqqkrLli3TqlWrVFZWprvuukvZ2dmqqKjQa6+9phNOOEFjx44NV60AAAAAACACkpOTde+992rixIlWlwJEHCFWL2T6FLt3pRyuAjncBXK4CmSv3xFc3ZB2fDCINmOHqHb0ZfIljJWZmqfksUfJVR0rr9dvVfWWi3SY3BM9+X5r77qY4x0AgL4j5CB6165duuCCC7Rr1y6NHTtWRUVFqq6ulhSYP/rFF1/U9u3bddttt4WtWAAAAAAA0HUej0dFRUVyu90yTbPV+sMOC8yPGhcXpx/96EfRLg+wTG8O7vo105StfoccrgIZ/lrVj/jx/hU2JX99hWzeigObypAvaaK8yTnyDD662WGqpj4sSXI4bFJskrT/M0n0Tl39futKwMwc7wAA9C0hB9EPPPCAqqur9frrrystLU1HHnlks/Unnnii/v3vf/e0PgAAAAAA0E1+v18PPfSQli1bprq6una3++6776JYFYCBxlZbIocrXw53QWBOZ1eBbJ69kiRf/NgDQbRhqH74mTL8dfI6c+VNzpU3eYZMR3IHR0d/0tWAmTneAQDoW0IOoj/99FMtWrRIEyZM0L59+1qtHzNmjHbu3Nmj4gAAAAAAQPc9/vjjeuqpp3Tuuefq0EMP1a9//WvdeOONcjqdWrZsmQzD0K9+9SurywTQX5imbLVbZa/ZLM/QE4OLnYUXKMad33xTwy5f0lR5nLmS3yvZAh9PVk17LJoVo5fpasDMHO8AAPQtIQfRdXV1SktLa3d9dRSHxPnwww/1yCOPaMuWLRo1apSuuOIKLViwoMN9vvrqK73wwgtavXq19uzZo+HDh+uUU07RVVddpcTExChVDgAAAABA+L322muaN2+efvvb3wYfHp8+fbpmz56tM888UwsXLtTnn3/eanQzAOiU6Ze9pig4l7PDXSiHq1A2b4VMw6G9x++Q7PGSJG/qYZJ8gR7Ozlx5nTnyDjpYsidYew3odboaMDPHOwAAfUvIQXRWVpb++9//auHChW2uf//99zVt2rSQC+uq1atX65prrtGPf/xj3XLLLfr888916623KikpSXPnzm13v3fffVfFxcW6/PLLNW7cOG3atEmPPfaYCgsL9dxzz0W8bgAAAAAAImXXrl26/PLLJUmxsbGSpIaGhuDrM844Q3/5y190ww03WFYjgD7A9Mles1m+xAmSYZMkJX9zleJ3vtB6UyNW3uTpsjWUyp8wRpJUNfl/JcOIasnom7oTMDPHOwAAfUfIQfSiRYt00003afLkyZo3b54kyTRNFRcX6w9/+IMKCgq0dOnSsBXanj/96U/Kzs7WXXfdJUk64ogjVFJSoscee6zDIPqnP/1psx7ds2bNktPp1I033qivv/5aBx98cMRrBwAAAAAgElJTU1VTUyNJSkpK0qBBg1RSUtJsG5fLZUVpAHorv1f2mo2BOZ1dBYpxF8rh/kqGr1rlR34pX9JESZJ30DSZtnh5kw+WNzlHXmeePM5c+ZKmSLbY5sckhEY3EDADAND/hBxEz58/Xzt27NCjjz6qRx55RJJ0+eWXyzRN2Ww2XX/99TrxxBM7PkgPNTQ0aNWqVbrxxhubLT/11FP1z3/+U99//71Gjx7d5r5tDSve2IN7z5494S8WAAAAAIAomTZtmtauXRt8PWvWLD377LOaOnWqTNPUc889p8mTJ1tYIQBL+T2Bv20xkqT475/WoPU3y/DXttrUtCXKVrctGETXjvmpajOuDu4LAAAAtCfkIFqSrrrqKs2fP1/vvfeeiouL5ff7lZGRoZNPPlljxowJV43t2rZtmzwejzIzM5stz8rKkiQVFRW1G0S35csvv5SkVscDAAAAAKAvOeecc/Taa6+poaFBsbGxuv7663X++efrggsukGmaSklJ0U033WR1mQCiwd8gR9V3++dz3j+vc9XXcmX/VQ3ppwQ2iU2X4a+V3z5I3uTswFzOybnyOvMCAbRhP3A8e6JFF4LeatXXO/Xfb3Zq0phUSdK64gpNGcv8zQAAoIdBtCSNGjVKF198cRhK6b7KykpJktPpbLa88XXj+q4oLy/X0qVLNWfOHI0bN65HdTkcth7tH212u63Z34gu2t9atL+1aH/rcQ+sRftbi/a3HvfAWrR//zZnzhzNmTMn+HrChAl6//33tWrVKtntduXl5Sk1NdW6AgFEnKNilQat+7UcVd/IMBtar69aGwyiPWk/UPmRq5vNBQ10xZoNpXrk5ULZDGnFF4EpIGyGtHJ1ia5dMIMwGgCAAa7HQXRBQYFWrVqlsrIynXfeeRo3bpxqa2tVVFSkcePGKSkpqVvHc7vdXRoaO5w9rj0ej2644QZJ0p133tmjY9lshgYP7t419xZOZ4LVJQxotL+1aH9r0f7W4x5Yi/a3Fu1vPe6BtWj/gSM5OTniU2gBiCJfrRzutXK4C/f3di5U3UEXq27M5ZIk0z5IMe58SZLfkSqvMzfwJzlHHmeu/Anjg4cyHcnyOZItuYyBJH9jab/rLfzd1nLZbIb8fjO4zG8Gwuj12yr6zXUCAIDQhBxENzQ06IYbbtAHH3wg0zRlGIaOP/54jRs3TjabTZdeeqkuvvhiXXXVVd067vLly3Xbbbd1ut0777yjlJQUSYHwuimXyyVJwfUdMU1Tt9xyi7766istW7ZMw4YN61a9Lfn9plyumh4dI9rsdpuczgS5XLXy+fxWlzPg0P7Wov2tRftbj3tgLdrfWrS/9bgH1rKi/Z3OBHpgR8iOHTtC2m/UqFFhrgRAJBn1uzVo4x1yuAtlr14nw/Q1W++r/G8wiPYlTVZl9nPyOnPljx8rGYYVJXeqP4azbcnfWKqlr67td72Fp45L04ovSmQzAgG0pOC/J2ekWlobAACwXshB9KOPPqp///vfuvPOOzVr1izNnTs3uC4uLk5z587VBx980O0g+uyzz9bZZ5/dpW0bGhoUExOjoqIiHXPMMcHlRUVFkro21/P999+vd999V0888YSmTJnSrVrb4/X2zQ/RfD5/n629P6D9rUX7W4v2tx73wFq0v7Vof+txD6xF+/cPJ5xwgowQQqbvvvsuAtUA6AnD65bD/VVwTmdv0jTVjr9ekmTakxS38wUZCiR+/th0eZJzD/R2dh564EA2hxqGn2nBFXRdfw1n27KuuCIY0Pan3sKHTErXbZccrv9+u0uTRgc6Ba3fVqHJGf37wQIAANA1IQfRb7/9thYuXKhzzz1X+/bta7U+KytLy5cv71FxnYmNjdWsWbO0YsUKLVq0KLj8nXfeUVZWlkaPHt3h/v/3f/+nZ555Rg8++KBmz54d0VoBAAAAAIiUe+65J6QgGkAvYPqUUPz/yeHOl8NVKHvNpmDQLEmelFnBIFqOQaqefJ988WMDPZ3jRvbans5d0V/D2bZMGZuqlatL+mVv4VkHj9Skg5zBB9vyJqYrf2OpXnh/Y7/v6Q4AADoWchBdVlamyZMnt7vebrerrq4u1MN32VVXXaWLLrpId955p+bNm6dVq1bpn//8px5++OFm202bNk1nnnmm7rnnHknSW2+9pYceekhnnHGGRo8erYKCguC2GRkZSktLi3jtAAAAAACEw1lnndWj/f1+v3bt2qWhQ4cqNjY2TFUBaMrwlMvhKpTDXSiZftWOv2H/CrsStv1B9vqdwW198aPlTc6R15krT8phzY5Tm9G90Qd7s/4czraUNzFd1y6YMSB6Cw+knu4AAKBjIQfRI0eODA6B3ZY1a9YoIyMj1MN32cyZM7V06VI98sgjeuWVVzRq1CgtWbJE8+bNa7adz+eT339guLlPP/1UkvTmm2/qzTffbLbtvffe2+M38QAAAAAA9BXl5eWaM2eOnn76aUYMA8IkpvwjOSr/qxhXgRyuAtnrioPr/LHpqh13fbA3c+2YK2XIL8/+8NmMtT60i8bczQMpnJUC19vfr1EaWD3dAQBAx0IOok8//XT95S9/0cknn6xx48ZJUnAYsJdfflnvvvuufvnLX4alyM7MmTNHc+bM6XCb9evXN3t933336b777otkWQAAAAAA9BmmaXa+EYDWanfLsedTOao2qy7jZ8HFiZvvUWzF/2u2qS9hvDzOXHmTcyXTJxmBj+aCvaN7iWj2aB0o4exAMpB6ugMAgI6FHET/7Gc/U2FhoS644AJlZmbKMAzde++9qqys1K5du3Tcccfp4osvDmOpAAAAAAAAgHWM+t2Kca2RY38v5xh3gVS/U8n719ePOk+mwylJakifK3/cSHmdefI6c+RNzpEZk2pV6d1Cj1b0xEDr6Q4AANoXchAdGxurJ598Um+++aZWrFghv9+vhoYGTZ48WYsXL9b8+fODPaQBAAAAAACAPsM0ZavfLoerQA1DT5FsMZKkpE2/VcKOv7bY2JAvaZI8yTkyvFXBILp23OLo1hxG9GhFT9HTHQAASD0IoqXAUNzz58/X/Pnzw1UPAAAAAAAAED2mKVvdtkAPZ1eBHO5Ab2ebp0ySVH7EJ/IlZ0uSvCkz5XWtkXf/XM7+wYfIOeYIuaoMeb1+K68irOjRCgAAgHAIOYieM2eObrnllnbnZv7Xv/6lJUuW6IMPPgi5OAAAAAAAACBsTFO22iKZsenBnssJxY9p0MbftN7UcMiXNFU2b5V8+5fVjb5UdaMvDW7jcNikmCRJ1VEoPrro0QoAAICeCjmI3r59u2pqatpdX1NTox07doR6eAAAAAAAACB0pl/2ms2B+ZzdBXK4CuVwF8rmrVRl9vNqGB4Y4c87aLpMI0beQdP3z+WcK68zV95B0yV7vMUXAQAAAPRdPR6auz1r166V0+nsyeEBAAAAAACAzpk+yd8g2RMkSTHl/5Gz4DzZfO7WmxqxstXvCr72pB2nvSfskGxxUSsXAAAAGAi6FUQ/++yzeu655yQFQuh77rlHDz/8cKvtqqqq5HK5dPrpp4enSgAAAAAA0CV1dXV6+OGHNWvWLJ1wwgld2icxMVHXXHONxowZE+HqgDDwe2WvXh+cyznGXSiHe62qx/9ateOvlyT54sfI5nPLtMXLmzxj/5zOefI4c+RLmirZYg4cr+m/AQAAAIRNt4LoIUOGaOLEiZICQ3MPHz5cw4cPb7VdYmKipk+frvPOOy88VQIAAAAAgC6Jj4/XSy+9pAkTJnR5n8YgGujNbHU75PzqQjncX8vw17Za76haG/y3P2G8yo/4TL6kyZKtRwMCAgAAAAhRt34TP/3004O9nC+88EJdffXVmj17dkQKAwAAAAAAoZk+fbo2bNhgdRlA9/jr5aj6NjCXs6tADne+vCkzVTXlocDq2KFyuAplmA3y25PlTc4OzOnszJU3OVe+pIkHjmUY8iVPt+hCgOjL31iqdcUVmjI2VXkT060uBwAAQFIP5oi++eabVVRU1GzZxx9/rMcff1wNDQ06/fTTtWjRoh4XCAAAAAAAuueWW27RFVdcoUmTJulHP/qRHA56hKKXMv0a9N3iQPBc9Y0M09NqfZAtVq7cZfIljJcvMUsybNGtFeil8jeWaumra2UzpJWrS3TtghmE0QAAoFcI+Z3ogw8+qPj4+GAP6ZKSEl1zzTVKTU3VsGHDdN999yk+Pl7nnntu2IoFAAAAAACdu+mmm2QYhm6//XYtWbJEw4cPV1xcXLNtDMPQm2++aVGFGFB8NXK418rhDvR0luFQ1bTHAusMm2LKP5KjNtDZwe9IldeZF+jpnJwrjzO32aEahp4c3doREfTeDa91xRWyGZLflGyGtH5bBe0KAAB6hZCD6HXr1umyyy4Lvn7jjTdks9n02muvKS0tTYsXL9aLL75IEA0AAAAAQJSlpqYqNTVV48ePt7oUDFBx2/+q2H0fy+EqkL16vQwd6NnsdzhVNfWRYI/mmqxbZdpi5XXmyh+fIRmGRVUjGui9G35TxqZq5eqSYBg9OSPV6pIAAAAk9SCIdrvdSk1NDb7+z3/+o6OOOkppaWmSpKOOOkofffRRjwsEAAAAAADd8/zzz1tdAgYAw+uSw/WVHO4C2Wu3BOdylqT43a8qtuyD4Gt/7DB5nLnyJufI68wLDLm9P4iuH3l21GuHdei9G355E9N17YIZWr+tQpMz6GUOAAB6j5CD6PT0dG3evFmStGfPHn3zzTc666yzguurq6tlszFXDwAAAAAAQH/gcOUrpvxjOVz5crgL5KjZ3Gx9deZNMmMDAVjdyHPlSTlcXmeuvMm58seNoKczJNF7N1LyJqYTQAMAgF4n5CB6zpw5+utf/6qGhgYVFhYqNjZWJ510UnD9+vXrNWbMmLAUCQAAAAAAuqeqqkrLli3TqlWrVFZWprvuukvZ2dmqqKjQa6+9phNOOEFjx461ukz0QkZDWXA+59qMKyV7kiQpfsdflVDyRLNtffGj5U3OldeZI+lA0Fw/cmE0S0YfQu9dAACAgSPkIHrx4sUqLy/XG2+8oeTkZN17770aOnSopMCb3eXLl+v8888PW6EAAAAAAKBrdu3apQsuuEC7du3S2LFjVVRUpOrqakmB+aNffPFFbd++XbfddpvFlcJqhqdcjsovFbM/eHa4CmSv2xZc7xl8lLypsyRJDYOPk61+T5MhtnNlxg61qnT0YfTeBQAAGBhCDqKTkpL00EMPtbkuMTFRH330keLj40MuDAAAAAAAhOaBBx5QdXW1Xn/9daWlpenII49stv7EE0/Uv//9b2uKg2Vs9bvkcBXI48yTGTdckhS/4wUN2nBzq229CZnyOnMlW1xwWcPwM9Qw/IxolQsAAACgjws5iO6IzWZTcnJyJA4NAAAAAAA68emnn2rRokWaMGGC9u3b12r9mDFjtHPnTgsqQ1SYpmz1OwM9nN35crgCvZ3tDbskSa7pf1b9qJ9IkjzOQ+RNnCivM0fe5Lz9f2fLjEm18AIAAAAA9AcRCaIBAAAAAIB16urqlJaW1u76xmG60Q+Ypmy122TzO+SPGyFJii1bqZT8H7feVIZ8SZMk48Bczt7Bs7XvqC+jVi4AAACAgYMgGgAAAACAfiYrK0v//e9/tXDhwjbXv//++5o2bVqUq0KPmaZstVvlcBcqxlWgGHeBVFWolPoyVWf+j2qybpUkeQfNkGnY5UuaIq8zV5798zl7k2dI9iRrrwEAAADAgEEQDQAAAABAP7No0SLddNNNmjx5subNmydJMk1TxcXF+sMf/qCCggItXbrU4irRHba67zX4syNl81a0WmcaDtk8B4Zg98eP1N7jd0j2hChWCAAAAADNEUQDAAAAANDPzJ8/Xzt27NCjjz6qRx55RJJ0+eWXyzRN2Ww2XX/99TrxxBOtLRLd4o8bKcP0yDRi5R00XV5njvypeUoafaQqzPHymrHNdyCEBgAAAGAxgmgAAAAAAPqhq666SvPnz9d7772n4uJi+f1+ZWRk6OSTT9aYMWOsLg/dZdi1b9ZH8iWMlWyB0NnhsClpcJK0r1ry+i0uEAAAAACaI4gGAAAAAKCfGjVqlC6++GKry0CY+JImWl0CAAAAAHQZQTQAAAAAAP1UQUGBVq1apbKyMp133nkaN26camtrVVRUpHHjxikpKcnqEgEAAAAA/RRBNAAAAAAA/UxDQ4NuuOEGffDBBzJNU4Zh6Pjjj9e4ceNks9l06aWX6uKLL9ZVV11ldakAern8jaVaV1yhKWNTlTcx3epyAAAA0IfYrC4AAAAAAACE16OPPqp///vfuvPOO7V8+XKZphlcFxcXp7lz5+qDDz6wsEIAfUH+xlItfXWtPviyREtfXav8jaVWlwQL5G8s1Qvvb+T+AwCAbiOIBgAAAACgn3n77be1cOFCnXvuuUpJSWm1PisrSyUlJRGv48MPP9QZZ5yhGTNm6JRTTtGrr77apf3cbrduueUWHX744crLy9N1112nPXv2NNtm6dKlmjx5cqs/L7zwQiQuBRiQ1hVXyGZIflOyGdL6bRVWl4QoC9fDCITZAAAMTAzNDQAAAABAP1NWVqbJkye3u95ut6uuri6iNaxevVrXXHONfvzjH+uWW27R559/rltvvVVJSUmaO3duh/suXrxYmzZt0p133qm4uDg98sgj+ulPf6pXX31VDseBjzLi4+P17LPPNtt3zJgxEbkeYCCaMjZVK1eXBMPoyRmpVpeEKGvrYYTuDtHeGGbbDGnl6hJdu2AGw7wDADBAEEQDAAAAANDPjBw5YqylfwAAQ1JJREFUUkVFRe2uX7NmjTIyMiJaw5/+9CdlZ2frrrvukiQdccQRKikp0WOPPdZhEJ2fn69PPvlETz31lI4++mhJ0vjx43Xqqafqvffe06mnnhrc1mazKTc3N6LXAQxkeRPTde2CGVq/rUKTM5gjeiAKx8MI4QizAQBA38TQ3AAAAAAA9DOnn366XnzxReXn5weXGYYhSXr55Zf17rvv6swzz4zY+RsaGrRq1apWgfOpp56qzZs36/vvv293348++khOp1NHHXVUcFlmZqamTp2qjz76KGI1A2hb3sR0LZwzkeBwgGp8GOHEmWNC7sk8ZWxqMISmZz0AAAMLPaIBAAAAAOhnfvazn6mwsFAXXHCBMjMzZRiG7r33XlVWVmrXrl067rjjdPHFF0fs/Nu2bZPH41FmZmaz5VlZWZKkoqIijR49us19i4qKNH78+GBw3igzM7NVL++6ujodccQRcrlcGjdunC6++GKdc845YbkGh6P3P7tvt9ua/Y3o4x5Yi/aPjsOmDtdhU4e3ua4r9+CwqcO1+Bybvivep6ljB+uQSTzUEC58D1iPe2At2t9atL/1+sI9IIgGAAAAAKCfiY2N1ZNPPqk333xTK1askN/vV0NDgyZPnqzFixdr/vz5rYLecKqsrJQkOZ3OZssbXzeub4vL5VJycnKr5SkpKfr666+DrzMyMnTjjTdq2rRpqq+v11tvvaXf/OY3crvduuyyy3pUv81maPDgpB4dI5qczgSrSxjwuAfWov2t19k9mDMrSXNmjYtOMQMQ3wPW4x5Yi/a3Fu1vvd58DwiiAQAAAADohwzD0Pz58zV//vywHM/tdmvPnj2dbjdmzJiwnK8zLa/rBz/4gTwej/70pz/poosuUkxMTMjH9vtNuVw1PS0x4ux2m5zOBLlctfL5/FaXMyBxD6xF+1uPe2At2t963ANr0f7Wov2tZ9U9cDoTutwLmyAaAAAAAIB+Zs6cObrllls0Z86cNtf/61//0pIlS/TBBx90+ZjLly/Xbbfd1ul277zzjlJSUiQFwuumXC6XJAXXt8XpdGrXrl2tlldWVna4nyTNmzdPK1as0LZt24LDgIfK6+07H6b5fP4+VW9/xD2wFu1vPe6BtWh/63EPrEX7W4v2t15vvgcE0QAAAAAA9DPbt29XTU37PXpramq0Y8eObh3z7LPP1tlnn92lbRsaGhQTE6OioiIdc8wxweWNczy3nDu6qczMTH322WcyTbPZ8OFbtmzRpEmTulUzAAAAAMA6vXf2agAAAAAAELKO5oBeu3Ztq/mbwyk2NlazZs3SihUrmi1/5513lJWVpdGjR7e777HHHqvKykp99tlnwWVbtmzRt99+q2OPPbbD877zzjtyOp3KyMjo2QUAAAAAAHqMHtEAAAAAAPQDzz77rJ577jlJgRD6nnvu0cMPP9xqu6qqKrlcLp1++ukRreeqq67SRRddpDvvvFPz5s3TqlWr9M9//rNVTdOmTdOZZ56pe+65R5KUl5eno48+Wrfccov+53/+R3FxcXr44Yc1efJknXzyycH9zjrrLJ155pnKzMxUXV2d3nrrLb333nu65ZZbejQ/NACgffkbS7WuuEJTxqYqb2K61eUAAIBejiAaAAAAAIB+YMiQIZo4caKkwNDcw4cP1/Dhw1ttl5iYqOnTp+u8886LaD0zZ87U0qVL9cgjj+iVV17RqFGjtGTJEs2bN6/Zdj6fT35/8/nMHnnkEd177726/fbb5fV6dfTRR+u2226Tw3HgY4yMjAw988wz2rt3rwzD0KRJk/S///u/OuOMMyJ6XQAwUOVvLNXSV9fKZkgrV5fo2gUzdNjU1v/PAAAANCKIBgAAAACgHzj99NODvZwvvPBCXX311Zo9e7alNc2ZM0dz5szpcJv169e3WpacnKx77rkn2Eu6LY888khPywMAdMO64grZDMlvSjZDWr+tgiAaAAB0iDmiAQAAAADoZ26++WaVlZU1W/bxxx/r/PPP19lnn61nn33WosoAAH3VlLGpwRDab0qTM1KtLgkAAPRy9IgGAAAAAKCfefDBBxUfHx/sIV1SUqJrrrlGqampGjZsmO677z7Fx8fr3HPPtbhSAEBfkTcxXdcumKH12yo0OYM5ogEAQOfoEQ0AAAAAQD+zbt06HXroocHXb7zxhmw2m1577TX9/e9/1ymnnKIXX3zRwgoBAL1B/sZSvfD+RuVvLO3S9nkT07VwzkRCaAAA0CUE0QAAAAAA9DNut1upqanB1//5z3901FFHKS0tTZJ01FFHqbi42KLqAAC9Qf7GUi19da0++LJES19d2+UwGgAAoKsIogEAAAAA6GfS09O1efNmSdKePXv0zTff6Kijjgqur66uls3GRwIAMJCtK64IzvdsM6T12yqsLgkAAPQzzBENAAAAAEA/M2fOHP31r39VQ0ODCgsLFRsbq5NOOim4fv369RozZoyFFQIArDZlbKpWri4JhtGTM1KtLgkAAPQzBNEAAAAAAPQzixcvVnl5ud544w0lJyfr3nvv1dChQyVJVVVVWr58uc4//3yLqwQAWClvYrquXTBD67dVaHJGKvM+AwCAsCOIBgAAAACgn0lKStJDDz3U5rrExER99NFHio+Pj3JVAIDeJm9iOgE0AACIGIJoAAAAAAAGEJvNpuTkZKvLAAAAAAD0czarCwAAAAAAAAAAAAAA9C8E0QAAAAAAAAAAAACAsGJobgAAAAAAAADoh/I3lmpdcYWmjE1lLmgAABB19IgGAAAAAAAAgH4mf2Oplr66Vh98WaKlr65V/sZSq0sCAAADTJ8Poj/88EOdccYZmjFjhk455RS9+uqrne5TUlKiK6+8Uscee6xmzJiho48+Wtddd522bNkShYoBAAAAAAAAILLWFVfIZkh+U7IZ0vptFVaXBAAABpg+HUSvXr1a11xzjXJzc/XEE09o3rx5uvXWW7V8+fIO96uurtbQoUN1ww036Mknn9RNN92kLVu26KKLLlJ5eXmUqgcAAAAAAACAyJgyNjUYQvtNaXJGqtUlAQCAAaZPzxH9pz/9SdnZ2brrrrskSUcccYRKSkr02GOPae7cue3uN2XKFN19993Nlh188ME65ZRT9Omnn+qHP/xhROsGAAAAAAAAgEjKm5iuaxfM0PptFZqcwRzRAAAg+vpsj+iGhgatWrWqVeB86qmnavPmzfr++++7dbzU1FRJksfjCVeJAAAAAAAAAGCZvInpWjhnIiE0AACwRJ8Nordt2yaPx6PMzMxmy7OysiRJRUVFnR7D7/fL4/Ho+++/1+9+9zuNHDlSJ510UkTqBQAAAAAAAAAAAICBos8OzV1ZWSlJcjqdzZY3vm5c35Ff//rXeuuttyRJGRkZ+stf/qLk5OQe1+Zw9K183263Nfsb0UX7W4v2txbtbz3ugbVof2vR/tbjHliL9gcAAAAAAJHUq4Jot9utPXv2dLrdmDFjwnK+X/ziF7rooou0c+dOPfvss7rkkku0bNkyjRo1KuRj2myGBg9OCkt90eZ0JlhdwoBG+1uL9rcW7W897oG1aH9r0f7W4x5Yi/YHAAAAAACR0KuC6OXLl+u2227rdLt33nlHKSkpkgLhdVMul0uSgus7MmbMGI0ZM0bZ2dk69thjdfLJJ+vJJ5/U7bffHkL1AX6/KZerJuT9rWC32+R0JsjlqpXP57e6nAGH9rcW7W8t2t963ANr0f7Wov2txz2wlhXt73Qm0AMbAAAAAIABolcF0WeffbbOPvvsLm3b0NCgmJgYFRUV6Zhjjgkub5wbuuXc0Z1JSEhQVlaWiouLu7VfW7zevvkhms/n77O19we0v7Vof2vR/tbjHliL9rcW7W897oG1aH8AAAAAABAJffZR9NjYWM2aNUsrVqxotvydd95RVlaWRo8e3a3jVVVVaf369WEb9hsAAAAAAAAAAAAABqpe1SO6u6666ipddNFFuvPOOzVv3jytWrVK//znP/Xwww83227atGk688wzdc8990iSli5dKrfbrUMOOURpaWnavn27nn/+eTU0NGjRokVWXAoAAAAAAAAAAAAA9Bt9OoieOXOmli5dqkceeUSvvPKKRo0apSVLlmjevHnNtvP5fPL7Dww1N23aND3zzDN64403VFNTo+HDh+uwww7To48+So9oAAAAAAAAAAAAAOihPh1ES9KcOXM0Z86cDrdZv359t/cBAAAAAAAAAAAAAISmz84RDQAAAAAAAAAAAADonQiiAQAAAAAAAAAAAABhRRANAAAAAAAAAAAAAAgrgmgAAAAAAAAAAAAAQFgRRAMAAAAAAAAAAAAAwoogGgAAAAAAAAAAAAAQVgTRAAAAAAAAAAAAAICwIogGAAAAAAAAAAAAAIQVQTQAAAAAAAAAAAAAIKwcVhcAAAAAAAAAAIiM/I2lWldcoSljU5U3Md3qcgAAwABCj2gAAAAAAAAA6IfyN5Zq6atr9cGXJVr66lrlbyy1uiQAADCAEEQDAAAAAAAAQD+0rrhCNkPym5LNkNZvq7C6JAAAMIAQRAMAAAAAAABAPzRlbGowhPab0uSMVKtLAgAAAwhzRAMAAAAAAABAP5Q3MV3XLpih9dsqNDmDOaIBAEB0EUQDAAAAAAAAQD+VNzGdABoAAFiCobkBAAAAAAAAAAAAAGFFEA0AAAAAAAAAAAAACCuCaAAAAAAAAAAAAABAWBFEAwAAAAAAAAAAAADCiiAaAAAAAAAAAAAAABBWBNEAAAAAAAAAAAAAgLAiiAYAAAAAAAAAAAAAhBVBNAAAAAAAAAAAAAAgrAiiAQAAAAAAAAAAAABhRRANAAAAAAAAAAAAAAgrgmgAAAAAAAAAAAAAQFgRRAMAAAAAAAAAAAAAwoogGgAAAAAAAAAAAAAQVgTRAAAAAAAgIj788EOdccYZmjFjhk455RS9+uqrne7T0NCgBx54QOeff75yc3M1efJklZeXt7ntmjVrdO655yo7O1vHH3+8/u///k+maYb7MgAAAAAAISCIBgAAAAAAYbd69Wpdc801ys3N1RNPPKF58+bp1ltv1fLlyzvcr66uTn//+98VFxenQw89tN3tiouLddlllyk9PV1//vOftWjRIj322GN6+umnw30pAAAAAIAQOKwuAAAAAAAA9D9/+tOflJ2drbvuukuSdMQRR6ikpESPPfaY5s6d2+5+TqdTX3zxhQzD0D/+8Q998sknbW731FNPafDgwfr973+v2NjY/7+9Ow+Pqsj3P/5JgEAChkVQ1qgJ0y0YQsISyEQSCSAEGEVmWASC7AOacNXxCqh3QAW3C8oiEkAQGFQE2URDGJBRkCUDiOA4grIvQgZZsrAkManfH/zSl6YDBOjOocP79Tw82tV16lR963SfVNXpcxQVFaVTp04pOTlZCQkJ8vPz80i7AAAAAADFwy+iAQAAAACAW+Xm5iotLc1lwbljx47au3evjhw5ctXtfXx8rrmPdevWqU2bNk4Lzh07dlRmZqa2b99+YxUHAAAAALgNC9EAAAAAAMCtDh06pLy8PAUHBzulh4SESJL27dt3U+WfO3dOx44dcyk/ODhYPj4+N10+AAAAAODmcWtuAAAAAADgVhkZGZIu3mb7UoWvC9+/UVlZWUWW7+fnJ39//5suX5LKlr31r90vU8bX6b8oefSBtYi/9egDaxF/69EH1iL+1iL+1vOGPmAhGgAAAAAAXFNWVpb+85//XDNfvXr1SqA2nuXr66OqVStaXY1iCwz0t7oKtz36wFrE33r0gbWIv/XoA2sRf2sRf+vdyn3AQjQAAAAAALim1NRUvfTSS9fMl5KSosqVK0v6v18uF8rMzJQkx/s36o477iiy/NzcXJ0/f/6myy8oMMrMPHdTZZSEMmV8FRjor8zM88rPL7C6Orcl+sBaxN969IG1iL/16ANrEX9rEX/rWdUHgYH+xf4VNgvRAAAAAADgmrp166Zu3boVK29ubq7KlSunffv2qVWrVo70wmc3X/5s5+sVEBCgWrVquTwLev/+/TLG3HT5kvTbb94zmZafX+BV9S2N6ANrEX/r0QfWIv7Wow+sRfytRfytdyv3wa1703AAAAAAAOCV/Pz81KJFC61atcopPSUlRSEhIapbt+5N7yMmJkZffvml8vLynMoPDAxURETETZcPAAAAALg5LEQDAAAAAAC3GzZsmL777juNGTNGaWlpmjx5sj7//HMlJSU55WvYsKFeeOEFp7Svv/5aqamp+te//iVJ+sc//qHU1FTt2bPHkWfgwIE6deqU/vKXv2jTpk2aO3euZs2apaFDh8rPz8/zDQQAAAAAXBW35gYAAAAAAG7XrFkzTZkyRRMnTtSnn36q2rVra+zYsYqPj3fKl5+fr4IC59vIvfzyyzp69KjjdeFCdWJiomMh+5577tGsWbP0xhtvaMiQIapWrZqGDx+uAQMGeLhlAAAAAIDiYCEaAAAAAAB4RJs2bdSmTZur5tm9e7dL2tq1a4tVfpMmTbRw4cIbqhsAAAAAwLO4NTcAAAAAAAAAAAAAwK1YiAYAAAAAAAAAAAAAuBUL0QAAAAAAAAAAAAAAt2IhGgAAAAAAAAAAAADgVixEAwAAAAAAAAAAAADcioVoAAAAAAAAAAAAAIBbsRANAAAAAAAAAAAAAHArFqIBAAAAAAAAAAAAAG7FQjQAAAAAAAAAAAAAwK1YiAYAAAAAAAAAAAAAuBUL0QAAAAAAAAAAAAAAt2IhGgAAAAAAAAAAAADgVqViIXrt2rV65JFH1KhRI7Vv316LFy++7jKefPJJ2e12zZo1ywM1BAAAAAAAAAAAAIDbh9cvRG/dulWJiYkKDw/XzJkzFR8frxdffFGpqanFLuPrr7/Wjh07PFhLAAAAAAAAAAAAALh9eP1C9LRp0xQWFqZXXnlFLVu21NNPP61OnTpp8uTJxdo+NzdX48aN07PPPuvhmgIAAAAAAAAAAADA7cGrF6Jzc3OVlpamDh06OKV37NhRe/fu1ZEjR65ZxqxZsxQYGKiuXbt6qpoAAAAAAAAAAAAAcFvx6oXoQ4cOKS8vT8HBwU7pISEhkqR9+/ZddftffvlFM2bM0EsvvSQfHx+P1RMAAAAAAAAAAAAAbidlra7AzcjIyJAkBQYGOqUXvi58/0pef/11tWvXTuHh4W6tV9my3rW+X6aMr9N/UbKIv7VKQ/y//emEfjxwSg3uraYmthpWV+e6lIb4ezv6wFrE31rE33r0gbWIPwAAJWP7zye06+AZ3X9PFUX8zrvG7QAAADfjlluIzsrK0n/+859r5qtXr95N7eebb77RN998o9TU1Jsq53K+vj6qWrWiW8ssKYGB/lZX4bZG/K3lrfFP+9cxTVy4Q76+Plr1z8N6qX+kWoTWsrpa181b41+a0AfWIv7WIv7Wow+sRfwBAPCc7T+f0JTF38vXR1q99bCS/tiIxWgAAHDbuOUWolNTU/XSSy9dM19KSooqV64s6eLi9aUyMzMlyfF+UcaOHau+ffvK39/fkV+ScnJylJmZ6fIr6+IqKDDKzDx3Q9tapUwZXwUG+isz87zy8wusrs5th/hby9vjv+WHY/L1ufjd4+sjbfn3cdnq3Nj3lxW8Pf6lAX1gLeJvLeJvPfrAWlbEPzDQn19gAwBuK7sOnrk4bjeSr4+0+9AZFqIBAMBt45ZbiO7WrZu6detWrLy5ubkqV66c9u3bp1atWjnSC58Nffmzoy+1f/9+JScnKzk52Sl90qRJmjRpknbu3Kny5cvfQAuk337zzkm0/PwCr617aUD8reWt8bfVq6JV/zzsGNTa6lb2ynZ4a/xLE/rAWsTfWsTfevSBtYg/AACec/89VbR66/+N2+1BVayuEgAAQIm55Rair4efn59atGihVatW6YknnnCkp6SkKCQkRHXr1r3itvPmzXNJ69u3r3r27KmOHTuqXLlyHqkzALhTxO9qKOmPjbT70BnZg3jWFAAAAAAAtxLG7QAA4Hbm1QvRkjRs2DD17dtXY8aMUXx8vNLS0vT555/rnXfeccrXsGFDdenSRa+99pokqUWLFkWWFxQUdMX3AOBWFPG7GgxkAQAAAAC4RTFuBwAAtyuvX4hu1qyZpkyZookTJ+rTTz9V7dq1NXbsWMXHxzvly8/PV0EBt5sDAAAAAAAAAAAAAE/z+oVoSWrTpo3atGlz1Ty7d+++ZjnFyQMAAAAAAAAAAAAAuDpfqysAAAAAAAAAAAAAAChdWIgGAAAAAAAAAAAAALgVC9EAAAAAAAAAAAAAALdiIRoAAAAAAAAAAAAA4FYsRAMAAAAAAAAAAAAA3IqFaAAAAAAAAAAAAACAW7EQDQAAAAAAAAAAAABwKxaiAQAAAAAAAAAAAABuxUI0AAAAAAAAAAAAAMCtWIgGAAAAAAAAAAAAALgVC9EAAAAAAAAAAAAAALdiIRoAAAAAAAAAAAAA4FYsRAMAAAAAAAAAAAAA3IqFaAAAAAAAAAAAAACAW/kYY4zVlShNjDEqKPC+kJYp46v8/AKrq3HbIv7WIv7WIv7Wow+sRfytRfytRx9Yq6Tj7+vrIx8fnxLbH3CjvGlsz/eo9egDaxF/69EH1iL+1qMPrEX8rUX8rWdFH1zP2J6FaAAAAAAAAAAAAACAW3FrbgAAAAAAAAAAAACAW7EQDQAAAAAAAAAAAABwKxaiAQAAAAAAAAAAAABuxUI0AAAAAAAAAAAAAMCtWIgGAAAAAAAAAAAAALgVC9EAAAAAAAAAAAAAALdiIRoAAAAAAAAAAAAA4FYsRAMAAAAAAAAAAAAA3IqFaAAAAAAAAAAAAACAW7EQDQAAAAAAAAAAAABwKxaiAQAAAAAAAAAAAABuxUI0AAAAAAAAAAAAAMCtWIgGAAAAAAAAAAAAALgVC9G3gbVr1+qRRx5Ro0aN1L59ey1evLhY22VlZemFF15QZGSkIiIiNHz4cP3nP/+5Yv7jx48rIiJCdrtdp06dclf1vZ4n479gwQINGDBA0dHRatKkibp37641a9Z4ohm3vL1796p///4KDw9XdHS03nrrLeXm5l5zO2OMZsyYoYceekhhYWHq0aOHvvvuO5d86enpSkpKUkREhCIjI/Xiiy8qOzvbAy3xXp7sg40bN+qZZ55RXFycGjdurI4dO+r9999XXl6eh1rjfTz9GShUUFCgrl27ym63KzU11Y0t8G4lEf+vvvpKPXv2VHh4uJo3b66EhAQdP37czS3xTp6O/9atW5WQkKDmzZurRYsWGjRokH788UcPtMR73WgffPjhh/rzn/+sli1bXvV7hfPw1Xky/pyDAWt5ejxfUFCgOXPmqEOHDgoNDVV0dLT+8pe/uLsZXo05FWsxp1JymFexFnMq1mNexVrMq1iPuRVrleZ5FRaiS7mtW7cqMTFR4eHhmjlzpuLj4/Xiiy8W6yT39NNPa8OGDRozZozGjx+v/fv3a/Dgwfrtt9+KzP/GG28oICDA3U3wap6Of3JysmrXrq0xY8ZoypQpstvteuqpp7R06VJPNuuWk5GRoSeeeEJ5eXmaMmWKnnnmGS1cuFBvvPHGNbedOXOmJk+erH79+mn69OmqUaOGBgwYoMOHDzvy5OXladCgQTpw4IAmTJigMWPG6JtvvmGC5hKe7oMFCxbo7NmzGj58uGbMmKEuXbpoypQp+utf/+rJZnkNT8f/UgsWLFB6erq7m+DVSiL+y5cvV2JioiIjI5WcnKw33nhDoaGhysnJ8VSzvIan479v3z4NHDhQAQEBmjBhgsaNG6eMjAz169dPJ06c8GTTvMbN9MHy5ct1+vRpxcbGXjEP5+Gr83T8OQcD1imJ8fxf//pXzZw5UwkJCZo9e7ZeeOEFVa5c2VNN8jrMqViLOZWSw7yKtZhTsR7zKtZiXsV6zK1Yq9TPqxiUagMGDDA9evRwSnv22WdNfHz8Vbf79ttvjc1mM+vXr3ek7d2719jtdvPFF1+45N+4caOJjIw0s2bNMjabzZw8edI9DfByno5/UXHu37+/6dy5803W3LskJyeb8PBwc/r0aUfaggULTIMGDczx48evuN2FCxdMkyZNzIQJExxpOTk5pnXr1mb06NGOtBUrVhi73W727t3rSFu/fr2x2Wxmx44dbm2Lt/J0HxR1rE+bNs3Y7Xa+b4zn41/o5MmTJjIy0nz66afGZrOZlStXurMZXsvT8T99+rRp0qSJ+fDDDz1Rfa/n6fhPnz7dNGrUyJw/f96RdujQIWOz2czSpUvd2RSvdaN9YIwx+fn5xhhjDh8+fMXvFc7DV+fp+HMOBqzj6fHkxo0bTcOGDc2uXbvcW/FShDkVazGnUnKYV7EWcyrWY17FWsyrWI+5FWuV9nkVfhFdiuXm5iotLU0dOnRwSu/YsaP27t2rI0eOXHHbdevWKTAwUNHR0Y604OBgNWjQQOvWrXPKm5eXp1dffVVJSUmqUqWKW9vgzUoi/tWqVXPZtkGDBle93VdptG7dOkVFRTkdf/Hx8SooKNCGDRuuuN23336r7OxsxcfHO9L8/PzUrl07pzivW7dOdrtdwcHBjrTo6GhVqVJFX3/9tXsb46U83QdXOtaNMVw1J8/Hv9Dbb7+tFi1aqEWLFm6tv7fzdPxXrlypgoIC/elPf/JI/b2dp+Ofl5cnPz8/lS9f3pF2xx13uLcRXu5G+0CSfH2vPRzhPHx1no4/52DAGiUxnly4cKEiIyNlt9vd34BSgDkVazGnUrKYV7EWcyrWY17FWsyrWI+5FWuV9nkVFqJLsUOHDikvL8/p4JKkkJAQSRdvh3Al+/bt03333ScfHx+n9ODgYJft5s2bpzJlyujxxx93U81Lh5KK/+W2bdvmss/Sbt++fS5tDgwMVI0aNa4ZZ0lF9tEvv/yiCxcuXLF8Hx8f3Xfffdfsj9uFp/ugKN9++638/PxUt27dm6h56VAS8d+5c6c+//xzPf/8826seeng6fjv2LFD9913n5YtW6bWrVurYcOGevTRR5mw+f88Hf9OnTopPz9fEydO1OnTp5Wenq7XX39dtWrVUps2bdzcGu90o31wM+VzHv4/no5/UTgHA55XEuPJHTt2KDg4WOPGjVOzZs0UFhamgQMHav/+/W5sifdiTsVazKmULOZVrMWcivWYV7EW8yrWY27FWqV9XoWF6FIsIyND0sUD9lKFrwvfL0pmZmaRV6RUrlzZabv09HRNnTpVL7zwgsqUKeOOapcaJRH/y61YsULbt2/XwIEDb6TKXiszM9MlztK145WZmelyJZZ0sY+MMY5tb7Q/biee7oPLHThwQPPmzVPPnj1VsWLFm6t8KeDp+BcUFOjll19W//79GaQWwdPxP3HihPbv369Jkybpv/7rvzRz5kzVqVNHTz75pH7++Wf3NsYLeTr+9957r+bMmaNPP/1ULVu2VExMjLZs2aIPPviAq3f/vxvtg+spn/PwlXk6/pfjHAyUjJIYT544cUJLlizRd999p/Hjx2vChAk6duyYBg4cyPMSxZyK1ZhTKVnMq1iLORXrMa9iLeZVrMfcirVK+7xKWY/vAW6VlZVVrFsE1atXrwRqI7311luKjo5WVFRUiezParda/C+1a9cujR49Wl27dlXbtm1LfP9AScnOzlZSUpLq1q2rZ555xurq3BYWLVqkX3/9VUOGDLG6KrclY4zOnTun8ePHO64SjYyMVPv27TVz5ky99dZbFtewdNu/f7+SkpIUHR2tLl26KCcnR7Nnz9bgwYO1YMECVa9e3eoqAiWGczBwc2618aQxRvn5+Zo2bZrjfBYSEqJOnTppxYoVpfL2lbdaHzCnUjTmVADP4e85azCvYi3mVazH3MrtjYVoL5OamqqXXnrpmvlSUlJUuXJlSRf/0L9UZmamJDneL0pgYKCOHz/ukp6RkeHYbvv27Vq1apUWLlzoKPP8+fOSpLNnz8rf31/+/v7FaJX3uJXif6mjR49q8ODBCgsL0yuvvHLN+pU2gYGBLnGWrhyvS7fLzc1VTk6O01VbmZmZ8vHxcWwbGBio7OzsIsuvVauWG1rg/TzdB4Vyc3P11FNPKSMjQ5988okCAgLc1wgv5sn4nz17Vm+//baeeeYZ5eXlKS8vz/F5uHDhgrKzs1WpUiX3N8qLlMR3kCS1bNnSkadcuXJq3rw5V+7K8/F/5513VL16daeBaWRkpFq3bq158+bp2WefdWNrvNON9sH1lM95+Mo8Hf9CnIOBm3erjScDAwNVs2ZNp4m/4OBg1axZU3v27LlmPb3RrdQHzKlcGXMqJY95FWsxp2I95lWsxbyK9ZhbsVZpn1dhIdrLdOvWTd26dStW3tzcXJUrV0779u1Tq1atHOlXum//pYKDg7Vp0yYZY5yeqbN//37ZbDbH/+fl5emxxx5z2b5t27bq2LGj3nnnnWLV1VvcSvEvdOrUKQ0cOFB33nmn3n33XZUrV+56mlQqFPWcp6ysLJ04ceKacZYuxvX+++93pO/bt0+1a9dWhQoVHPl++uknp22NMdq/f7+io6Pd1Qyv5uk+kC7exui5557TDz/8oA8//JDB6iU8Gf8jR47ozJkzGj16tEaPHu20/YgRI1S9enVt2LDBja3xPp4+/uvXr3/FMrhtpufjv2fPHoWHhzttW7FiRQUFBenQoUNuaoV3u9E+uJ7yOQ9fmafjL3EOBtzlVhtP1q9fv8gJKan0/o1xK/UBcypXx5xKyWJexVrMqViPeRVrMa9iPeZWrFXa51V4RnQp5ufnpxYtWmjVqlVO6SkpKQoJCbnq8yhiYmKUkZGhTZs2OdL279+vf//734qJiZEktWrVSvPmzXP6N3jwYEnS1KlT9dRTT3mgVd7D0/GXLl4lPXjwYOXl5WnGjBm37dVzMTEx2rhxo+PKaOnilda+vr5X/SJt0qSJKlWqpJUrVzrS8vLy9Pe//90pzjExMdq1a5cOHDjgSNu0aZPOnDmj2NhY9zbGS3m6DyTp5Zdf1j/+8Q+99957stvt7m+EF/Nk/GvUqOHyXf/2229LkpKSkjRlyhQPtcp7ePr4b926tSQ5nRNyc3O1ZcsWPfDAA+5silfydPxr166tH3/8UcYYR1p2drYOHjyoOnXquLk13ulG++B6yuc8fGWejr/EORiwQkmMJ1u3bq09e/boxIkTjrS9e/fq+PHj/I0h5lSsxpxKyWJexVrMqViPeRVrMa9iPeZWrFXq51UMSrUtW7aYBg0amNGjR5vNmzebSZMmGbvdblJSUpzyNWjQwIwaNcopbcCAASY2NtakpKSYL7/80nTu3Nk88sgjJi8v74r7W7x4sbHZbObkyZMeaY+38XT8+/fvbxo2bGiWLl1qtm/f7vTvdnLmzBkTHR1t+vTpY9avX28+/fRT06xZM/Pyyy875evbt69p27atU9r06dNNaGiomTNnjtm4caNJSkoyERER5tChQ448ubm5pnPnzqZz585m7dq15osvvjCxsbFmyJAhJdI+b+DpPpg2bZqx2WzmzTffdDnWs7KySqSNtzJPx/9yhw8fNjabzaxcudIj7fE2JRH/pKQk07JlS7No0SLz1VdfmSFDhphGjRqZXbt2ebx9tzpPx3/16tXGZrOZZ5991nz99ddm9erV5vHHHzdhYWFm//79JdHEW97N9MHOnTvNypUrzYcffmhsNpt54403zMqVK01aWpojD+fhq/N0/DkHA9bx9HgyKyvLtG7d2jz22GNm9erVJiUlxbRv3948/PDD5ty5cyXSxlsdcyrWYk6l5DCvYi3mVKzHvIq1mFexHnMr1irt8yosRN8G1qxZYzp37mweeOAB065dO7No0SKXPDabzYwYMcIpLTMz04waNco0a9bMhIeHm8TERHP8+PGr7otBkytPxt9ms13x3+1mz5495oknnjBhYWEmKirKvPHGGyYnJ8cpT58+fUzr1q2d0goKCkxycrKJiYkxoaGhplu3bubbb791Kf/48eMmMTHRhIeHm2bNmplRo0bxx/plPNkHffr0ueKxvnnzZo+3zRt4+jNwKQZMrjwd/7Nnz5pXX33VtGzZ0oSGhpoePXqYrVu3erRN3sTT8U9JSTF//OMfTZMmTUyLFi1M//79zXfffefRNnmbG+2DESNGFPnd3qdPH6d8nIevzpPx5xwMWMvT4/lDhw6ZP//5zyY8PNxERESYpKQkc+zYMY+1xxsxp2It5lRKDvMq1mJOxXrMq1iLeRXrMbdirdI8r+JjzCW/hQcAAAAAAAAAAAAA4CbxjGgAAAAAAAAAAAAAgFuxEA0AAAAAAAAAAAAAcCsWogEAAAAAAAAAAAAAbsVCNAAAAAAAAAAAAADArViIBgAAAAAAAAAAAAC4FQvRAAAAAAAAAAAAAAC3YiEaAAAAAAAAAAAAAOBWLEQDAOBljhw5IrvdriVLlpT4vpcsWSK73a7vv/++xPdtFbvdrilTplhdDbew8tgBAAAAgFsN4+uSxfgaAG4/Za2uAACg5KxYsUInT55Uv379rK6KJGn16tX65JNP9P333+vs2bOqUqWKmjZtqp49eyoqKsrq6gEAAAAAUCTG1wBuJ8nJyapfv77atm1rdVUAeBl+EQ0At5HPP/9c8+bNs7oaMsZo1KhRSkxM1MmTJ9W/f3+NGTNGvXv31uHDh9WvXz99++23VlcTAAAAAIAiMb4GcDuZPn261qxZY3U1AHghfhENACgx58+fl7+/v2bPnq0lS5boiSee0KhRo+Tj4+PIM2zYMC1btkxly3KKAgAAAACgKIyvgdtP4eceALwJv4gGgFIkOztb48aNU1xcnEJDQxUVFaX+/fvrhx9+UEJCgr766isdPXpUdrtddrtdcXFxjm1zc3M1efJktWvXTqGhoYqNjdVbb72l3Nxcl/0sX75cXbt2VVhYmCIjI/XMM8/o2LFjTnkSEhLUuXNn/etf/1Lv3r3VuHFjvf3227pw4YJmzJih4OBgjRgxwmmQXKhLly4KCwtzvD58+LCGDx+uyMhINW7cWN27d9dXX33ltE1aWprsdrtSUlL07rvvqlWrVoqIiNDw4cOVlZWl3NxcjRs3TlFRUYqIiNCoUaNc2ma32/XKK69o5cqV6tixo8LCwtSjRw/t3r1bkrRgwQK1a9dOjRo1UkJCgo4cOeK0/datWzV8+HA99NBDjhi+9tprunDhglO+kSNHKiIiQunp6XryyScVERGhli1b6s0331R+fr5T3szMTI0cOVJNmzZVs2bNNGLECGVlZbnE7MSJExo1apRiYmIUGhqqBx98UMOGDXOp47Wkp6frhRde0IMPPqjQ0FDFxcVp9OjRLrHKzc3V66+/rpYtWyo8PFxPPfWUTp065ZRnzZo1GjJkiKOstm3baurUqS5tLDxW9uzZo4SEBDVu3FitWrXSzJkzXep39OhRDR06VOHh4YqKitJrr72m9evXy263Ky0tzSnvjh07NHDgQDVt2lSNGzdWnz59tG3btuuKR1GOHj2qMWPGqH379goLC1OLFi00fPjwImO9a9cu9enTR2FhYYqJidF7772nxYsXy263O+UvKCjQlClT9OCDD6px48ZKSEjQnj17FBcXp5EjRzqVmZmZqXHjxik2NlahoaFq166dZsyYoYKCApd8xTl2AAAAALhifM34mvH1/2F87Z7x9aWfrbffflvR0dEKDw/X0KFDi/25l4r/HbNhwwY9/vjjatasmSIiItS+fXtHGYWKU5bdbte5c+e0dOlSx3fe5bEEgCvhcjgAKEVGjx6tVatWqU+fPgoJCdGZM2e0bds27d27V0OHDlVWVpaOHz+uUaNGSZIqVqwo6eIf6cOGDdO2bdvUvXt3hYSE6KefftLcuXN14MABvffee459TJs2TZMmTVJ8fLz+9Kc/6dSpU5o/f7569+6tZcuWKTAw0JH3zJkzGjx4sDp16qRHHnlEd955p7Zt26YzZ86ob9++KlOmzDXb9Ouvv6pnz546f/68EhISVLVqVS1dulTDhg1z/KF8qRkzZqhChQoaMmSIDh48qPnz56ts2bLy8fFRZmamEhMTtWPHDi1ZskR16tRRYmKi0/Zbt27V2rVr1atXL0d5Q4cO1aBBg/TRRx+pV69eysjI0Pvvv68XXnjB6VZsqampunDhgh5//HFVqVJFO3fu1Pz583X8+HFNnjzZaT/5+fkaOHCgwsLC9Pzzz2vTpk2aPXu26tWr59i3MUZPPvmktm3bpp49eyokJESrV6/WiBEjXOKUlJSkPXv2qE+fPqpTp45OnTqlDRs26NixY6pbt+414yxdHCT/6U9/UlZWlrp3767g4GClp6dr1apVunDhgvz8/Bx5x44dq8DAQCUmJuro0aOaO3euXnnlFU2cONGRZ+nSpQoICFD//v0VEBCgzZs3a/LkycrOznZpQ0ZGhgYNGqR27dopPj5eq1at0vjx42Wz2RQbGytJOnfunJ544gmdOHFCffv2VfXq1fX555+7DJAladOmTRo8eLBCQ0OVmJgoHx8fx68EPvroI6eJmOv1/fffa/v27erUqZNq1qypo0eP6uOPP1bfvn31xRdfOK5OTk9P1xNPPCFJGjJkiAICArRo0SKnOBaaMGGC3n//fbVu3VqtWrXSrl27NHDgQOXk5DjlO3/+vPr06aP09HT17NlTtWrV0vbt2/X222/rxIkTevHFFyVd37EDAAAAwBXja8bXjK8vYnzt/vH1tGnT5OPjo8GDB+vkyZOaO3eu+vXrp+XLl6tChQqOfEV97ov7HfPzzz/rz3/+s+x2u4YPHy4/Pz8dPHjQ6Vb9xS3rrbfe0ksvvaSwsDB1795dkhQUFHTD7QdwmzEAgFKjadOm5uWXX77i+0OGDDGtW7d2SV+2bJm5//77zZYtW5zSP/74Y2Oz2cy2bduMMcYcOXLENGjQwEybNs0p3+7du03Dhg2d0vv06WNsNpv5+OOPnfLOnTvX2Gw2s3r16mK1ady4ccZmsznVLTs728TFxZnWrVub/Px8Y4wxmzdvNjabzXTu3Nnk5uY68j777LPGbrebQYMGOZXbo0cPl1jYbDYTGhpqDh8+7EhbsGCBsdlsJjo62mRlZTnSJ0yYYGw2m1Pe8+fPu9R/+vTpxm63m6NHjzrSRowYYWw2m3n33Xed8nbp0sU89thjjterV682NpvNzJw505H222+/mV69ehmbzWYWL15sjDEmIyPD2Gw28/777xcVwmJ7/vnnzf3332927tzp8l5BQYExxpjFixcbm81m+vXr50gzxpjXXnvNNGjQwGRmZjrSiorH//zP/5jGjRubnJwcR1rhsbJ06VJHWk5OjomOjjZJSUmOtNmzZ7scOxcuXDAdOnQwNpvNbN682VHXhx9+2AwYMMCpjufPnzdxcXGmf//+1xMWY7PZzOTJk6/aru3bt7u04dVXXzV2u938+9//dqSdPn3aREZGOh07J06cMA0bNjRPPvmkU5lTpkwxNpvNjBgxwpE2depUEx4ebvbv3++Ud/z48aZBgwbml19+McYU/9gBAAAAUDTG14yvbwbj66Ld7uPrws9Wq1atnD4DKSkpxmazmblz5zrSrvS5L+53zAcffGBsNps5efLkFetT3LKMMSY8PNwpfgBQXNyaGwBKkcDAQO3YsUPp6enXtV1qaqpCQkIUHBysU6dOOf61bNlSkhxXxK5evVoFBQWKj493yle9enXdc889LlfO+vn5qWvXrk5p2dnZkv7vavFr+frrrxUWFqZmzZo50ipWrKgePXro6NGj2rNnj1P+Rx99VOXKlXO8DgsLkzFGf/zjH53yhYWF6dixY/rtt9+c0qOiopyucG7cuLEk6eGHH1alSpWctpcu3tas0KVXrZ47d06nTp1SRESEjDH697//7dK2xx9/3Ol106ZNnW4ntW7dOpUtW9YpX5kyZdSnTx+n7SpUqKBy5crpn//8pzIyMlz2UxwFBQVas2aNWrdurUaNGrm8f/kt3rp37+6U1qxZM+Xn5+vo0aNO9SqUnZ2tU6dOqVmzZjp//rz27dvnVF5AQIAeffRRx2s/Pz81atTIKb7r16/X3XffrTZt2jjSypcv77gat9CPP/6oAwcO6A9/+INOnz7tOE7PnTunqKgobdmyxeU2W9fj0nbl5eXp9OnTCgoKUmBgoFM/r1+/XuHh4WrQoIEjrUqVKvrDH/7gVN6mTZv022+/Oa7UL3R5P0sXP6tNmzZVYGCg02fw97//vfLz87VlyxZJxT92AAAAABSN8TXja8bXjK8lz4yvu3Tp4vQZ6NChg2rUqKGvv/7aKV9Rn/vifscU3lHhyy+/vGIfFbcsALgZ3JobAEqR5557TiNHjtRDDz2kBx54QLGxserSpYvq1at31e0OHjyovXv3Kioqqsj3T548KUk6cOCAjDF6+OGHi8xXtqzzaeXuu+92uU1S4R/aZ8+eLVabfvnlF8dg9VLBwcGO9202myO9du3aTvnuuOMOSVKtWrVc0gsKCpSVlaWqVas60i/PV1jfmjVrFlluZmamU10nT56stWvXugxYCycICpUvX17VqlVzSqtcubLTdkePHlWNGjVcJhXuu+8+p9d+fn567rnn9Oabbyo6OlqNGzfWQw89pC5duqhGjRoqjlOnTik7O1u/+93vipX/8jgXDnAujcfPP/+siRMnavPmzS7tv/xZSjVr1nQZjFeuXNnx/DDpYjyCgoJc8l1+O6gDBw5I0lVvk5WVlaXKlStf8f2ruXDhgqZPn64lS5YoPT1dxhinci+tb3h4uMv2l9f3l19+KTK9SpUqLnU8ePCgdu/efcXPauFzxIp77AAAAAAoGuNrxteMrxlfF+7b3ePre+65x+m1j4+P7rnnHqeLD6SiP/fF/Y7p2LGjFi1apJdeekkTJkxQVFSU2rVrpw4dOsjX1/e6ygKAm8FCNACUIh07dlSzZs20evVqbdiwQbNmzdLMmTM1ZcoUx3OAilJQUCCbzeZ4ttXlCgeJBQUF8vHx0cyZM4t8/lRAQIDT60uvbC1UOMDdvXu32rZtW+y2FVfhH9PFTb90kCPpis/VulJ64fb5+fnq37+/41lMwcHBCggIUHp6ukaOHOly9Wlxnt91Pfr166e4uDitWbNG33zzjSZNmqQZM2Zo7ty5atiwoVv3JV07npmZmerTp48qVaqk4cOHKygoSOXLl9cPP/yg8ePHezQehXV4/vnnna6WvtTlx+r1ePXVVx3PwwoPD9cdd9whHx8fPfPMMy7Hk7sVFBQoOjpagwYNKvL9e++916P7BwAAAG4XjK8ZXzO+ZnxttaI+98X9jqlQoYI+/PBDpaWl6auvvtL69euVkpKiTz75RLNnz1aZMmWKXRYA3AwWogGglLnrrrvUu3dv9e7dWydPntRjjz2m5ORkxcbGulzpWigoKEi7du1SVFTUFfMU5jPGqG7dujd85WfTpk1VuXJlffHFFxo6dOg1B0i1a9fW/v37XdILbz11+ZXDVvnpp5904MABvfnmm+rSpYsjfcOGDTdcZp06dbR582adPXvW6crbouIhXeyfAQMGaMCAATpw4IC6dOmi2bNna/z48dfcV7Vq1VSpUiX9/PPPN1zfS/3zn//UmTNn9O6776p58+aO9EtvjXa96tSpoz179sgY43ScHjp0yClf4S8UKlWqpN///vc3vL8rWbVqlbp06aKRI0c60nJyclyuQq9Tp44OHjzosv3l9S08hg8dOuT064rTp0+7XPkfFBSkc+fOXbNd13vsAAAAAHDF+NoajK+dMb4ufePry9tijNHBgwdlt9uvuW1xv2Okixc5REVFKSoqSqNGjVJycrLeeecdpaWl6fe///11lQUAN4pnRANAKZGfn+/yh/qdd96pu+66S7m5uZIkf39/lzySFB8fr/T0dC1cuNDlvQsXLujcuXOSLj7HqUyZMnr33Xddrkw1xuj06dPXrKe/v78GDRqkvXv3avz48UVe4bp8+XLt3LlTkhQbG6udO3dq+/btjvfPnTunhQsXqk6dOqpfv/4191kSCq9gvrQ9xhjNmzfvhsuMiYnRb7/9po8//tiRlp+fr/nz5zvlO3/+vHJycpzSgoKCVLFiRUffX4uvr6/atm2rf/zjH/r+++9d3r/eK5GLikdubq4++uij6yrnUg8++KDS09P15ZdfOtJycnJcjtvQ0FAFBQVp9uzZRd6irvD2WjeqqMmdv/3tb8rPz3ep73fffacff/zRkXbmzBmtWLHCKV9UVJTKli3r1M+S9OGHH7rsJz4+Xtu3b9f69etd3svMzHQ8k624xw4AAAAAV4yvrcX42rW8y7djfO3d4+tly5Y53WI9NTVVJ06cUExMzDW3Le53zJkzZ1zeL/xVe+GxXNyypIu/fL/0dvEAUFz8IhoASomzZ88qNjZW7du31/3336+AgABt3LhR33//vePK0gceeEApKSl6/fXX1ahRIwUEBCguLk6PPvqoVq5cqdGjRystLU1NmjRRfn6+9u3bp9TUVL3//vtq1KiRgoKC9PTTT2vChAk6evSo2rZtq4oVK+rIkSNas2aNunfvroEDB16zroMGDdKePXs0e/ZspaWlqX379qpevbp+/fVXrVmzRjt37tSCBQskSUOGDNEXX3yhwYMHKyEhQZUrV9ayZct05MgRTZky5Yq3sCppwcHBCgoK0ptvvqn09HRVqlRJq1atuqk/0uPi4tSkSRNHvOvXr6+///3vLpMdBw4cUL9+/dShQwfVr19fZcqU0Zo1a/Trr7+qU6dOxd7fs88+qw0bNighIUHdu3dXSEiITpw4odTUVH300UeO51QVR0REhCpXrqyRI0cqISFBPj4+Wr58+U3dWqtHjx6aP3++/vKXv6hv376qUaOGVqxYofLly0uS4+pdX19fjR07VoMHD1bnzp3VtWtX3X333UpPT1daWpoqVaqk5OTkG67HQw89pOXLl6tSpUqqX7++vvvuO23cuFFVqlRxyjdo0CB99tln6t+/v/r06aOAgAAtWrRItWrV0pkzZxz1rV69uvr27avZs2dr6NChatWqlXbv3q1169apatWqTlclDxw4UGvXrtXQoUP12GOP6YEHHtD58+f1008/adWqVfryyy9VrVq1Yh87AAAAAFwxvrYW42tnjK9L3/i6cuXK6tWrl7p27aqTJ09q7ty5uueee9S9e/drblvc75ipU6dq69atio2NVZ06dXTy5El99NFHqlmzppo2bXpdZUkXv/M2bdqkDz74QHfddZfq1q1b5DPnAeByLEQDQClRoUIFPf7449qwYYP+/ve/yxijoKAgjR49Wr169ZIk9erVSz/++KOWLFmiOXPmqE6dOoqLi5Ovr6+mTp2qOXPmaPny5Vq9erX8/f1Vt25dJSQkON0mbMiQIbr33ns1Z84cTZ06VdLFZ8ZER0crLi6uWHX19fXVW2+9pTZt2mjhwoWaPXu2srOzVbVqVTVv3lz//d//rYiICEkXBxELFizQ//7v/2r+/PnKycmR3W5XcnKyHnroIfcG8SaUK1dOycnJGjt2rKZPn67y5curXbt26t27tx599NEbKtPX11fTpk3Ta6+9ps8++0w+Pj6Ki4vTyJEjnW5PVrNmTXXq1EmbNm3SZ599pjJlyig4OFgTJ05U+/bti72/u+++WwsXLtSkSZO0YsUKZWdn6+6771ZMTEyRzyW6mqpVqyo5OVlvvvmmJk6cqMDAQD3yyCOKiooq1mRKUSpWrKi5c+dq7NixmjdvngICAtSlSxdFREQoKSnJMWCWpBYtWuiTTz7Re++9p/nz5+vcuXOqUaOGwsLC1KNHjxvaf6EXX3xRvr6+WrFihXJyctSkSRN98MEHLs+VqlWrlubNm+c4JqpVq6bevXvL399fY8eOdarvc889pwoVKmjRokXatGmTwsPDNWvWLPXq1Ut+fn6OfP7+/vrb3/6m6dOnKzU1VcuWLVOlSpV07733KikpSXfccYek4h87AAAAAFwxvrYW42tnjK9L3/h66NCh2r17t2bMmKGzZ88qKipKo0ePlr+//zW3Le53TFxcnI4eParFixfr9OnTqlq1qiIjI13aVtzvq5EjR+qvf/2rJk6cqAsXLuixxx5jIRpAsfiYm7l0CgAAwGJz5szR66+/rnXr1unuu++2ujrXNG7cOH3yySfavn37VZ/hlpmZqebNm+vpp5/WsGHDSrCGAAAAAIDbEeNrz0pLS1Pfvn01adIkdejQwbJ6AEBJujXutwIAAFAMFy5ccHqdk5OjTz75RPfee+8tOUi+vL6nT5/WZ599pqZNmzoNki/PJ0lz586VJEVGRnq2kgAAAACA2w7jawBASeDW3AAAlHJnz57VuXPnrpqnWrVqV716+FaRmJio2rVr6/7771d2drY+++wz7du3T+PHj7+ucvLz83Xq1Kmr5gkICFDFihVvprrq0aOHIiMjFRISol9//VWLFy9Wdna2nnzySad8KSkpWrp0qWJiYhQQEKBvv/1Wn3/+uR588EHHs5sAAAAAANZifO2K8bWUm5urjIyMq+YpvB02ANxuWIgGAKCUmz17tt59992r5vnyyy9Vt27dEqrRjXvwwQf16aefasWKFcrPz1f9+vX1zjvvqGPHjtdVzrFjx9SmTZur5klMTFRSUtLNVFexsbFatWqVFi5cKB8fHzVs2FDjxo1T8+bNnfLZ7XaVKVNG77//vs6ePas777xTffv21dNPP31T+wcAAAAAuA/ja1eMr6Xt27erb9++V83z+uuvq06dOh6rAwDcqnhGNAAApdzhw4d1+PDhq+Zp2rSpypcvX0I1sl5OTo62bdt21Tz16tVTvXr1SqhGAAAAAIBbHeNrV4yvpYyMDP3www9XzVO/fn3dddddJVQjALh1sBANAAAAAAAAAAAAAHArX6srAAAAAAAAAAAAAAAoXViIBgAAAAAAAAAAAAC4FQvRAAAAAAAAAAAAAAC3YiEaAAAAAAAAAAAAAOBWLEQDAAAAAAAAAAAAANyKhWgAAAAAAAAAAAAAgFuxEA0AAAAAAAAAAAAAcCsWogEAAAAAAAAAAAAAbvX/AANjvYXe58h8AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 2400x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "R^2: 0.0841670243595306, Adjusted R^2: 0.08045919854722106\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from scipy.stats import norm \n",
+    "\n",
+    "# Visualize the relationship\n",
+    "max_lag = 2\n",
+    "steer_la_change = np.diff(steer_la)\n",
+    "steer_la_change_lagged = steer_la_change[max_lag:]\n",
+    "steer_la_lagged = steer_la[max_lag: ]\n",
+    "steerCommands_change = np.diff(steerCommands)\n",
+    "steerCommands_change_lagged = steerCommands_change[:steerCommands_change.shape[0] - max_lag]\n",
+    "steerCommands_lagged = steerCommands[:steerCommands.shape[0] - max_lag]\n",
+    "vEgo_lagged = vEgo[max_lag+1:]\n",
+    "ratio = steer_la_change_lagged / steerCommands_change_lagged\n",
+    "\n",
+    "steer_la_change_preset = np.diff(steer_la_preset)\n",
+    "steer_la_change_lagged_preset = steer_la_change_preset[max_lag:]\n",
+    "steer_la_lagged_preset = steer_la_preset[max_lag: ]\n",
+    "steerCommands_change_preset = np.diff(steerCommands_preset)\n",
+    "steerCommands_change_lagged_preset = steerCommands_change_preset[:steerCommands_change_preset.shape[0] - max_lag]\n",
+    "steerCommands_lagged_preset = steerCommands[:steerCommands_preset.shape[0] - max_lag]\n",
+    "\n",
+    "X = np.column_stack([np.ones_like(steerCommands_change_lagged), steerCommands_change_lagged])\n",
+    "coefficients = np.linalg.lstsq(X, steer_la_change_lagged, rcond=None)[0]\n",
+    "y_pred = X @ coefficients\n",
+    "residuals = steer_la_change_lagged - y_pred\n",
+    "\n",
+    "X_preset = np.column_stack([np.ones_like(steerCommands_change_lagged_preset), steerCommands_change_lagged_preset])\n",
+    "coefficients_preset = np.linalg.lstsq(X_preset, steer_la_change_lagged_preset, rcond=None)[0]\n",
+    "y_pred_preset = X_preset @ coefficients_preset\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(24, 6))\n",
+    "ax[0].scatter((steerCommands_change_lagged), steer_la_change_lagged, s=4)\n",
+    "ax[0].plot([steerCommands_change_lagged.min(), steerCommands_change_lagged.max()],\n",
+    "           [y_pred[steerCommands_change_lagged.argmin()],y_pred[steerCommands_change_lagged.argmax()]],\n",
+    "           '--', c='orange')\n",
+    "ax[0].set_title('steer commands delta vs steer lataccel delta')\n",
+    "ax[0].set_xlabel('steerCommands_change_lagged')\n",
+    "ax[0].set_ylabel('steer_la_change_lagged')\n",
+    "\n",
+    "ax[1].scatter(steerCommands_change_lagged_preset, steer_la_change_lagged_preset, s=4)\n",
+    "ax[1].plot([steerCommands_change_lagged_preset.min(), steerCommands_change_lagged_preset.max()],\n",
+    "           [y_pred_preset[steerCommands_change_lagged_preset.argmin()], y_pred_preset[steerCommands_change_lagged_preset.argmax()]],\n",
+    "           '--', c='orange')\n",
+    "ax[1].set_title('Preset: Steer Commands Delta vs Steer Lataccel Delta')\n",
+    "ax[1].set_xlabel('steerCommands_change_lagged_preset')\n",
+    "ax[1].set_ylabel('steer_la_change_lagged_preset')\n",
+    "\n",
+    "print(f'Fit: {coefficients[1]}x + {coefficients[0]}')\n",
+    "print(f'Preset Fit: {coefficients_preset[1]:.4f}x + {coefficients_preset[0]:.4f}')\n",
+    "\n",
+    "\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.scatter(vEgo_lagged, (steer_la_change_lagged / steerCommands_change_lagged), s=4)\n",
+    "plt.ylim(-10, 10)\n",
+    "plt.title('steer commands delta / steer lataccel delta')\n",
+    "plt.xlabel('vEgo')\n",
+    "plt.ylabel('ratio')\n",
+    "plt.show()\n",
+    "\n",
+    "# Adjusted R^2\n",
+    "ss_residual = np.sum((steer_la_change_lagged - y_pred) ** 2)\n",
+    "ss_total = np.sum((steer_la_change_lagged - steer_la_change_lagged.mean()) ** 2)\n",
+    "r_squared = 1 - (ss_residual / ss_total)\n",
+    "adjusted_r_squared = 1 - (1 - r_squared) * (y_pred.shape[0] - 1) / (y_pred.shape[0] - 2 - 1)\n",
+    "print(f'R^2: {r_squared}, Adjusted R^2: {adjusted_r_squared}')\n",
+    "\n",
+    "# Plot residuals\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.scatter(y_pred, residuals, s=4)\n",
+    "plt.axhline(y=0, color='r', linestyle='--')\n",
+    "plt.title('Residuals')\n",
+    "plt.xlabel('steerCommands_change_lagged')\n",
+    "plt.ylabel('Residual')\n",
+    "\n",
+    "# Histogram of residuals\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.hist(residuals, bins=30, edgecolor='black', density=True)\n",
+    "xmin, xmax = plt.xlim()\n",
+    "x_axis = np.linspace(xmin, xmax, 30)\n",
+    "plt.plot(x_axis, norm.pdf(x_axis, residuals.mean(), residuals.std()))\n",
+    "plt.title('Histogram of Residuals')\n",
+    "plt.xlabel('Residual')\n",
+    "plt.ylabel('Frequency')\n",
+    "plt.show()\n",
+    "\n",
+    "# # Perform normality test\n",
+    "# _, p_value = normaltest(residuals)\n",
+    "# print(f\"Normality test p-value: {p_value}\")\n",
+    "# if p_value < 0.05:\n",
+    "#     print(\"The residuals do not appear to be normally distributed (p < 0.05)\")\n",
+    "# else:\n",
+    "#     print(\"The residuals appear to be normally distributed (p >= 0.05)\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "venv",
    "language": "python",
    "name": "python3"
   },
@@ -77,7 +851,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,
diff --git a/feedfoward.ipynb b/feedfoward.ipynb
new file mode 100644
index 00000000..b57bc1b8
--- /dev/null
+++ b/feedfoward.ipynb
@@ -0,0 +1,588 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/risak/controls_challenge/venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tinyphysics import TinyPhysicsModel, TinyPhysicsSimulator, CONTROL_START_IDX\n",
+    "from controllers import pid, pidf\n",
+    "from matplotlib import pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from scipy import signal\n",
+    "\n",
+    "ACC_G = 9.81\n",
+    "\n",
+    "sns.set_theme()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def linear_lsq(x, y, lag):\n",
+    "    length = len(x)\n",
+    "    alpha = np.sum((y[lag:] - y[lag:].mean()) * (x[:100-lag] - x[:100-lag].mean())) / (np.sum((x[:100-lag] - x[:100-lag].mean()) ** 2) + 1e-8)\n",
+    "    beta = y[lag:].mean() - alpha * x[:100-lag].mean()\n",
+    "\n",
+    "    ssr = np.sum((alpha * x[:100-lag] + beta - y[lag:])**2)\n",
+    "    sst = np.sum((y[lag:] - y[lag:].mean())**2) + 1e-8\n",
+    "    r2 = 1 - ssr / sst\n",
+    "\n",
+    "    return alpha, beta, r2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lag_vals = []\n",
+    "r2s = []\n",
+    "fits = []\n",
+    "files = []\n",
+    "\n",
+    "data_dir = Path('./data/')\n",
+    "for f in data_dir.iterdir():\n",
+    "    files.append(f)\n",
+    "    df = pd.read_csv(str(f))\n",
+    "    t = df[\"t\"].to_numpy()[:100]\n",
+    "    vEgo = df[\"vEgo\"].to_numpy()[:100]\n",
+    "    aEgo = df[\"aEgo\"].to_numpy()[:100]\n",
+    "    roll_la = np.sin(df[\"roll\"].to_numpy()[:100]) * ACC_G\n",
+    "    target_la = df[\"targetLateralAcceleration\"].to_numpy()[:100]\n",
+    "    steerCommands = -df[\"steerCommand\"].to_numpy()[:100]\n",
+    "    steer_la = target_la - roll_la\n",
+    "\n",
+    "    corr = signal.correlate(steer_la - steer_la.mean(), steerCommands - steerCommands.mean())\n",
+    "    lags = signal.correlation_lags(100, 100)\n",
+    "    lag = np.clip(lags[np.argmax(corr)], 0, 90)\n",
+    "\n",
+    "    test_fits = [linear_lsq(steerCommands, steer_la, x) for x in range(lag, lag + 10)]\n",
+    "    lag_correction = np.argmax([x[2] for x in test_fits])\n",
+    "    lag += lag_correction\n",
+    "    \n",
+    "    lag_vals.append(lag)\n",
+    "    fits.append(np.array(test_fits[lag_correction][:2]))\n",
+    "    r2s.append(test_fits[lag_correction][2])\n",
+    "    # print(f'alpha: {alpha}\\nbeta: {beta}\\nR^2: {r2}')\n",
+    "\n",
+    "    # plt.plot(steerCommands[:100-lag], steer_la[lag:], '.')\n",
+    "    # x = np.linspace(-0.5, 0.5, 2)\n",
+    "    # plt.plot(x, alpha * x + beta)\n",
+    "\n",
+    "    # plt.xlabel('steer command')\n",
+    "    # plt.ylabel('lataccel')\n",
+    "    # # plt.xlim(-2, 2)\n",
+    "    # # plt.ylim(-3, 3)\n",
+    "    # plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "alpha = np.array(fits)[:, 0]\n",
+    "alpha = alpha[0 < alpha]\n",
+    "alpha = alpha[alpha < 3]\n",
+    "mu_alpha = alpha.mean()\n",
+    "\n",
+    "beta = np.array(fits)[:, 1]\n",
+    "beta = beta[-1 < beta]\n",
+    "beta = beta[beta < 1]\n",
+    "mu_beta = beta.mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2500x500 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 4, figsize=(25, 5))\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "ax[0].hist(lag_vals, bins=10, range=(0, 10), align='left')\n",
+    "ax[0].set_xticks(range(11))\n",
+    "ax[0].set_title('lag')\n",
+    "\n",
+    "_, bins, _ = ax[1].hist(alpha, bins=20)\n",
+    "ax[1].axvline(mu_alpha, color='orange')\n",
+    "ax[1].set_xticks(bins)\n",
+    "ax[1].tick_params(axis='x', labelrotation=90)\n",
+    "ax[1].set_title('alpha')\n",
+    "\n",
+    "_, bins, _ = ax[2].hist(beta, bins=20)\n",
+    "ax[2].axvline(mu_beta, color='orange')\n",
+    "ax[2].set_xticks(bins)\n",
+    "ax[2].tick_params(axis='x', labelrotation=90)\n",
+    "ax[2].set_title('beta')\n",
+    "\n",
+    "ax[3].hist(r2s, bins=40)\n",
+    "ax[3].set_title('R^2')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "alpha: 1.6942529739501502, beta: 0.0028692845935240664\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f'alpha: {mu_alpha}, beta: {mu_beta}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1.        , 0.9       , 0.81      , 0.729     , 0.6561    ,\n",
+       "       0.59049   , 0.531441  , 0.4782969 , 0.43046721])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.power(0.9, np.arange(10))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def lateral_objective(u, alpha, beta, w_x, w_u, plan):\n",
+    "    x = alpha * u + beta\n",
+    "    cost = np.sum(w_x * (plan - x) ** 2) + np.sum(w_u * np.diff(u) ** 2)\n",
+    "    return cost\n",
+    "\n",
+    "def gradient(u, alpha, beta, w_x, w_u, plan):\n",
+    "    d = 2 * alpha * w_x\n",
+    "    d[:-1] += 2 * w_u\n",
+    "    d[1:] += 2 * w_u\n",
+    "\n",
+    "    A = np.diag(d) + np.diag(-2 * w_u, k=1) + np.diag(-2 * w_u, k=-1)\n",
+    "    b = -2 * alpha * (plan - beta) * w_x\n",
+    "\n",
+    "    return A@u + b\n",
+    "\n",
+    "def minimize(u, alpha, beta, w_x, w_u, plan):\n",
+    "    d = 2 * alpha * w_x\n",
+    "    d[:-1] += 2 * w_u\n",
+    "    d[1:] += 2 * w_u\n",
+    "\n",
+    "    A = np.diag(d) + np.diag(-2 * w_u, k=1) + np.diag(-2 * w_u, k=-1)\n",
+    "    b = 2 * alpha * (plan - beta) * w_x\n",
+    "\n",
+    "    return np.linalg.solve(A, b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "lag: 0\n",
+      "lag: 0\n",
+      "alpha: 1.9321521997895652\n",
+      "beta: -0.08450483285783916\n",
+      "R^2: 0.9983963016399404\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df = pd.read_csv('data/08975.csv')\n",
+    "t = df[\"t\"].to_numpy()[:100]\n",
+    "vEgo = df[\"vEgo\"].to_numpy()[:100]\n",
+    "aEgo = df[\"aEgo\"].to_numpy()[:100]\n",
+    "roll_la = np.sin(df[\"roll\"].to_numpy()[:100]) * ACC_G\n",
+    "target_la = df[\"targetLateralAcceleration\"].to_numpy()[:100]\n",
+    "steerCommands = -df[\"steerCommand\"].to_numpy()[:100]\n",
+    "steer_la = target_la - roll_la\n",
+    "\n",
+    "length = 100\n",
+    "corr = signal.correlate(steer_la - steer_la.mean(), steerCommands - steerCommands.mean())\n",
+    "lags = signal.correlation_lags(length, length)\n",
+    "lag = lags[np.argmax(corr)]\n",
+    "print(f'lag: {lag}')\n",
+    "\n",
+    "test_fit = np.array([linear_lsq(steerCommands, steer_la, x)[2] for x in range(lag, lag + 10)])\n",
+    "lag += np.argmax(test_fit)\n",
+    "\n",
+    "print(f'lag: {lag}')\n",
+    "\n",
+    "# lag=0\n",
+    "alpha = np.sum((steer_la[lag:] - steer_la[lag:].mean()) * (steerCommands[:100-lag] - steerCommands[:100-lag].mean())) / np.sum((steerCommands[:100-lag] - steerCommands[:100-lag].mean()) ** 2)\n",
+    "beta = steer_la[lag:].mean() - alpha * steerCommands[:100-lag].mean()\n",
+    "ssr = np.sum((alpha * steerCommands[:100-lag] + beta - steer_la[lag:])**2)\n",
+    "sst = np.sum((steer_la[lag:] - steer_la[lag:].mean())**2)\n",
+    "r2 = 1 - ssr / sst\n",
+    "print(f'alpha: {alpha}\\nbeta: {beta}\\nR^2: {r2}')\n",
+    "\n",
+    "plt.plot(steerCommands[:100-lag], steer_la[lag:], '.')\n",
+    "x = np.linspace(-0.5, 0.5, 2)\n",
+    "plt.plot(x, alpha * x + beta)\n",
+    "\n",
+    "plt.xlabel('steer command')\n",
+    "plt.ylabel('lataccel')\n",
+    "# plt.xlim(-2, 2)\n",
+    "# plt.ylim(-3, 3)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 616,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datafile = \"data/GENESIS_G80_2017/00000.csv\"\n",
+    "length = 600\n",
+    "df = pd.read_csv(datafile)\n",
+    "df = df[(df['latActive'])&(~df['steeringPressed'])]\n",
+    "t = df[\"t\"].to_numpy()[:length]\n",
+    "vEgo = df[\"vEgo\"].to_numpy()[:length]\n",
+    "aEgo = df[\"aEgo\"].to_numpy()[:length]\n",
+    "roll_la = np.sin(df[\"roll\"].to_numpy()[:length]) * ACC_G\n",
+    "la_steerAngle = df[\"latAccelSteeringAngle\"].to_numpy()[:length]\n",
+    "la_localizer = df[\"latAccelLocalizer\"].to_numpy()[:length]\n",
+    "steerCommands = df[\"steeringAngleDeg\"].to_numpy()[:length] * np.pi / 180\n",
+    "target_la = la_steerAngle"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dynamic model\n",
+    "$\\delta_{dyn} = L\\frac{a_{lat}}{V_{lon}^2} + \\beta_1(a_{lat} - a_{roll}) + \\beta_0$\n",
+    "\n",
+    "$L$: Vehicle length\n",
+    "\n",
+    "$\\beta_1$: Mass times understeer gradient\n",
+    "\n",
+    "$\\beta_0$: Unaccounted stuff\n",
+    "\n",
+    "Fit with linear least square"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0034472668619882894\n",
+      "[ -0.42951075 -35.80329336]\n",
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "length=100\n",
+    "corr = signal.correlate(steer_la - steer_la.mean(), steerCommands - steerCommands.mean())\n",
+    "lags = signal.correlation_lags(length, length)\n",
+    "lag = lags[np.argmax(corr)]\n",
+    "lag = 1\n",
+    "\n",
+    "B = -steerCommands[:length-lag]\n",
+    "# A = np.vstack([target_la[lag:]-roll_la[lag:], vEgo[lag:]]).T\n",
+    "A = np.vstack([target_la[lag:] - roll_la[lag:], target_la[lag:] / vEgo[lag:] ** 2]).T\n",
+    "x = np.linalg.lstsq(A, B, rcond=None)[0]\n",
+    "\n",
+    "steer_angle = A @ -x\n",
+    "\n",
+    "fig, ax = plt.subplots(1)\n",
+    "ax.plot(t[lag:], steerCommands[:length-lag])\n",
+    "ax.plot(t[lag:], steer_angle, color='orange')\n",
+    "plt.show()\n",
+    "print(np.sum((steer_angle - steerCommands[:length-lag])**2))\n",
+    "print(x)\n",
+    "print(lag)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Kinematic model\n",
+    "$a_{lat} = \\beta_0 + \\beta_1 * \\frac{v^2 * sin(\\gamma)}{L}$\n",
+    "\n",
+    "steer_command $ = f_{steer}^{-1}(\\delta) = arcsin(\\frac{\\frac{a_{lat} - \\beta_0}{\\beta_1}\\cdot L}{v^2})$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.07577371326221764\n",
+      "beta0: 0.026123193367495356, beta1: 0.00175765270787338\n"
+     ]
+    }
+   ],
+   "source": [
+    "L = 1\n",
+    "steerAngle = lambda x: x\n",
+    "\n",
+    "corr = signal.correlate(steer_la - steer_la.mean(), steerCommands - steerCommands.mean())\n",
+    "lags = signal.correlation_lags(100, 100)\n",
+    "lag = lags[np.argmax(corr)]\n",
+    "lag = 1\n",
+    "\n",
+    "\n",
+    "pred_la = vEgo[lag:] ** 2 * np.sin(steerAngle(steerCommands[:100-lag])) / L\n",
+    "\n",
+    "beta1 = np.sum((pred_la - pred_la.mean()) * (steer_la[lag:] - steer_la[lag:].mean())) / np.sum((pred_la - pred_la.mean()) ** 2)\n",
+    "beta0 = steer_la.mean() - beta1 * pred_la.mean()\n",
+    "\n",
+    "# beta1 = 0.002257592851869056\n",
+    "# beta0 = -0.04918295333364523\n",
+    "\n",
+    "pred_la = beta0 + beta1 * pred_la\n",
+    "pred_steer = (steer_la[lag:] - beta0) / beta1 / vEgo[lag:] ** 2\n",
+    "fig, ax = plt.subplots(2)\n",
+    "ax[0].plot(t[lag:], steer_la[lag:])\n",
+    "ax[0].plot(t[lag:], pred_la, color='orange')\n",
+    "ax[1].plot(t[:100-lag], steerCommands[:100-lag])\n",
+    "ax[1].plot(t[:100-lag], pred_steer, color='orange')\n",
+    "plt.show()\n",
+    "\n",
+    "print(np.sum((pred_steer - steerCommands[:100-lag])**2))\n",
+    "print(f'beta0: {beta0}, beta1: {beta1}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAGhCAYAAAByPf5TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABx+0lEQVR4nO3deXgb5bk28Hu0WLZlS17iJbGz2E7i7HtI0ixAKEuAlpal5LSUQHtoaAM9QHuu0pbyQaEtTVcIh7KXlHMKpaUtWwhbgJAEAgGy77YTx3G825IsL1pmvj+kke14k+UZaWZ8/66rV4ms5R2PNXr0vM/7vIIkSRKIiIiIDMCU6AEQERERKYWBDRERERkGAxsiIiIyDAY2REREZBgMbIiIiMgwGNgQERGRYTCwISIiIsNgYENERESGYUn0AOJNkiSIonI9CU0mQdHn0yIeozHwGI2Bx2gMPMahP5cgCFHdd8QFNqIooanJq8hzWSwmZGba4Xa3IRAQFXlOreExGgOP0Rh4jMbAYxy6rCw7zOboAhtORREREZFhMLAhIiIiw2BgQ0RERIbBwIaIiIgMg4ENERERGQYDGyIiIjIMBjZERERkGAxsiIiIyDAY2BAREZFhMLAhIiIiw2BgQ0RERIbBwIaIiIgMg4ENERERGQYDGyIyBEmSIElSoodBRAnGwIaIDOF3z+/GLb99F/6AmOihEFECWRI9ACKi4fJ2+LG3rBEAcLq+FYU5aQkeERElCjM2RKR7NY1tkf+u7vbfRDTyMLAhIt070y2YqWn0JnAkRJRoDGyISPdqmroCmzPM2BCNaAxsiEj3znTL0pxhxoZoRGNgQ0S61z1jU9PUBpHLvolGLAY2RKRrQVFEXXN75N8+v4hmd2cCR0REicTAhoh0raGlA0FRQpLFhIIcO4CeGRwiGlkY2BCRrsnFwvnZqSjMTQfAwIZoJGNgQ0S6Jgcxo7PtKAg35qvhyiiiEYuBDRHpmrwKanR2Kgpyw4FNE1dGEY1UDGyISNe6Z2wKI4ENMzZEIxUDGyLSNbnGZvSo1MhUVKO7E52+YCKHRUQJwsCGiHSrtd2P1nY/AGB0lh3ONBvsKVYAQG0zszZEIxEDGyLSLXnKKcthgy3JDCBUa9P9Z0Q0ssQlsCkrK8ONN96IOXPmYOnSpVi/fj18Pt+gj2tubsbdd9+N8847D3PmzMHll1+O5557Lg4jJiI9aPGEGvFlOZIjt+U4UwAATWzSRzQiWdR+AZfLhTVr1mDChAnYsGEDamtr8cADD6CjowN33333gI/9r//6L5SXl+OOO+7A6NGjsXXrVtxzzz0wm8342te+pvbQiUjjWlpDwUuGPSlymzMt9N9u7+BfnojIeFQPbJ5//nl4vV48/PDDyMjIAAAEg0Hce++9WLt2LfLy8vp8XH19PXbu3Ilf/epXuPLKKwEAS5Yswb59+/Daa68xsCEiuMLBizPNFrlNDmxavMzYEI1Eqk9Fbd26FUuWLIkENQCwatUqiKKI7du39/u4QCAAAEhPT+9xe1paGiRucEdEAFyt4cCmW8YmIxzkyD8jopFF9YxNeXk5rrrqqh63ORwO5OTkoLy8vN/HjR49GsuWLcOjjz6KoqIi5OfnY+vWrdi+fTt++9vfDmtMFosy8ZzZbOrx/0bEYzQGox6juy0UvGQ5kiPHJtfbuNt8ir3XtcKo57E7HqMxJPIYVQ9s3G43HA5Hr9udTidcLteAj92wYQNuv/12XHbZZQAAs9mMu+66CxdffHHM4zGZBGRm2mN+fF8cjhRFn0+LeIzGYLRjbG0PZXYL8h2RYyvIC11v3F6/4u91rTDaeewLj9EYEnGMqgc2sZIkCT/+8Y9x4sQJ/O53v0NOTg527NiBX/7yl3A6nZFgZ6hEUYLbrcwyULPZBIcjBW53O4JBUZHn1BoeozEY9RgbXe0AAAskuN3tcDhSYBFCU9WeNh/qGzywGOhbsVHPY3c8RmNQ+hgdjpSosz+qBzYOhwMej6fX7S6XC06ns9/Hvffee9i8eTNefvlllJaWAgAWLVqExsZGPPDAAzEHNgAQCCj7hxQMioo/p9bwGI3BSMcoilJkKiot2RK5eCYnmWE2CQiKEppcHT2WghuFkc5jf3iMxpCIY1T9q0xxcXGvWhqPx4P6+noUFxf3+7jjx4/DbDZj8uTJPW6fOnUq6urq0N7ersp4iUgf3G0+SBIgCEB6alfxsEkQ4AgXE7u45JtoxFE9sFmxYgV27NgBt9sduW3z5s0wmUxYunRpv48rKChAMBjEkSNHetx+4MABZGdnIyXF+HOTRNQ/edWTw54Ek0no8TN5lRRXRhGNPKoHNqtXr4bdbse6deuwbds2vPjii1i/fj1Wr17do4fNmjVrcOGFF0b+vWLFCowZMwbf//738dJLL+HDDz/Eb37zG/zrX//Cddddp/awiUjjXOE+Nd2XessigQ172RCNOKrX2DidTmzcuBH33Xcf1q1bB7vdjquvvhq33357j/uJoohgsGs33rS0NDzzzDP4wx/+gN/+9rfweDwoLCzEnXfeycCGiNASzsZkdGvOJ3Oylw3RiBWXVVElJSV45plnBrzPs88+2+u28ePH449//KM6gyIiXZPrZxwDZmwY2BCNNMZZB0lEI4pL3icqrY/AJo2BDdFIxcCGiHQpsk+UvY+pqPBtrLEhGnkY2BCRLvW1T5QskrFhjQ3RiMPAhoh0KbIqqq+pqG41Ntw0l2hkYWBDRLojSVJXxqavVVHhwMYfENHeGez1cyIyLgY2RKQ77Z1B+MJt2vuaikqympFiCy36ZJ0N0cjCwIaIdEcOVlJsZtis5j7vw+7DRCMTAxsi0p2uwuHe01Ay9rIhGpkY2BCR7nQt9e49DSVjLxuikYmBDRHpjtycr68VUTL2siEamRjYEJHuuNr6305Bxl42RCMTAxsi0p3WNj8AwJHaf2CTnmoFAHjC9yWikYGBDRHpTmt7KFhJS7H2ex/5Z/J9iWhkYGBDRLrjGUJg42VgQzSiMLAhIt3xDiGw8TCwIRpRGNgQke7IdTNpqYMHNu2dAQSCYlzGRUSJx8CGiHRFlCR4O0KBTfoAGRt7shVC+L+9HYE4jIyItICBDRHpSltHAPKG3fYBAhuTSUBqcmi/KBYQE40cDGyISFfkICXFZobFPPAljAXERCMPAxsi0hW5h81AhcOySAExe9kQjRgMbIhIV6LpYSOLZGw6GNgQjRQMbIhIVzztoS0S0lL67zosY5M+opGHgQ0R6Yq3PbTCKS3FMuh95eLiVk5FEY0YDGyISFeGkrGR94tixoZo5GBgQ0S60hpFcz6ZnVNRRCMOAxsi0pWhFA+nM7AhGnEY2BCRrshBykBdh2UsHiYaeRjYEJGuDCVjw6koopGHgQ0R6UosU1HeDj9EeR8GIjI0BjZEpBuiJHUFNkMoHpak0B5TRGR8DGyISDe6b4AZTcbGYjYhOckMgNNRRCMFAxsi0g15M8vkpME3wJSxgJhoZGFgQ0S64RlCfY2MgQ3RyMLAhoh0YyiFw7I0bqtANKIwsCEi3RhK12FZGrdVIBpRGNgQkW7ElLFJ7lryTUTGF5fApqysDDfeeCPmzJmDpUuXYv369fD5fFE9tra2Fj/60Y+wePFizJo1C6tWrcLLL7+s8oiJSIuGMxXl4VQU0YhgUfsFXC4X1qxZgwkTJmDDhg2ora3FAw88gI6ODtx9990DPraurg7XXnstioqKcN999yEtLQ3Hjh2LOigiImNpDe/sHc12CjJ5KsrLqSiiEUH1wOb555+H1+vFww8/jIyMDABAMBjEvffei7Vr1yIvL6/fx/7mN79Bfn4+nnzySZjNoV4US5YsUXvIRKRRctaFq6KIqD+qT0Vt3boVS5YsiQQ1ALBq1SqIoojt27f3+7jW1la8/vrr+PrXvx4JaohoZPNGug4nRf0Y7hdFNLKonrEpLy/HVVdd1eM2h8OBnJwclJeX9/u4AwcOwO/3w2Kx4LrrrsPnn3+OjIwMfOUrX8Ftt90GqzX6b2xns1iUiefM4QZh5igbhekRj9EYjHKM3vC2CA57Uq/3cX/HmJFmAxAKbJR67yeKUc7jQHiMxpDIY1Q9sHG73XA4HL1udzqdcLlc/T6uoaEBAHDXXXfha1/7Gm655Rbs3bsXDz30EEwmE37wgx/ENB6TSUBmpj2mx/bH4UhR9Pm0iMdoDHo/xnZfKLAZnZve7/v47GP0QwAQWhWVkZEKQRDUHWQc6P08RoPHaAyJOEbVA5tYiaIIAPjCF76AO++8EwCwePFieL1ePP3001i3bh2Sk5NjeF4JbnebImM0m01wOFLgdrcjGBQVeU6t4TEag1GO0eMNTScF/QE0N3t7/Ky/Ywx0hoKhQFBCbb0HNqt+p7aNch4HwmM0BqWP0eFIiTr7o3pg43A44PF4et3ucrngdDoHfBwQCma6W7JkCR599FGcPHkSpaWlMY0pEFD2DykYFBV/Tq3hMRqDno/R5w/CH75AJlvN/R7H2cdoMQkwCQJESYK71YfMdFtcxqsmPZ/HaPEYjSERx6j65FdxcXGvWhqPx4P6+noUFxf3+7iJEycO+LydnZ2KjI+I9EGurzEJQmTH7mgIgoDUZEv4OVhATGR0qgc2K1aswI4dO+B2uyO3bd68GSaTCUuXLu33cQUFBZg8eTJ27NjR4/YdO3YgOTl50MCHiIylLRyUpCZbhlwnYw8HNm3h4IiIjEv1wGb16tWw2+1Yt24dtm3bhhdffBHr16/H6tWre/SwWbNmDS688MIej7399tuxZcsW/OIXv8D27dvx6KOP4umnn8YNN9yA1NRUtYdORBoiZ2zk7MtQpHJbBaIRQ/UaG6fTiY0bN+K+++7DunXrYLfbcfXVV+P222/vcT9RFBEMBnvctnLlSvz+97/HI488gueeew65ubm49dZb8Z3vfEftYRORxshBiT156K0emLEhGjnisiqqpKQEzzzzzID3efbZZ/u8/dJLL8Wll16qwqiISE/koMQeU8ZGrrFhYENkdMbtDkREhjKcqSg5y9PGqSgiw2NgQ0S6IG+nEMtUFDM2RCMHAxsi0oXIVFQKMzZE1D8GNkSkC97O8HJvGzM2RNQ/BjZEpAvDKR7mqiiikYOBDRHpglxjkxpTjQ372BCNFAxsiEgX5GmktJhqbJixIRopGNgQkS50banAGhsi6h8DGyLSPEmSIkFJbDU2oWAoEBTh8wcHuTcR6RkDGyLSvE5/EEFRAhBbHxtbkhnyvpnM2hAZGwMbItI8uTbGbBKQZB36ZcskCEi1yXU2LCAmMjIGNkSked2noQQ59TJE9sjKKGZsiIyMgQ0Rad5wCodlqVwZRTQiMLAhIs1rbY99OwWZPbIyilNRREbGwIaINE/O2MRSOCxLjewXxYwNkZExsCEizZPrYlJjWOotY8aGaGRgYENEmtcW3gDTHsMGmDJmbIhGBgY2RKR5XkVrbBjYEBkZAxsi0jyvgqui2jsZ2BAZGQMbItK8tmFspyCzc4dvohGBgQ0RaV5Xxib2wIZ9bIhGBgY2RKR5XZ2HY5+KYsaGaGRgYENEmqfEVBQzNkQjAwMbItI0UZIUKR6WgyJfQIQ/ICoyNiLSHgY2RKRpHZ1BSFLov4eTsUm2WSBvn8kdvomMi4ENEWma3JzPYjYhyWqO+XlMghCZjmIvGyLjYmBDRJrW3hkEAKTaYg9qZKyzITI+BjZEpGnytFHKMOprZKnhLRna2KSPyLAY2BCRpqmSselkjQ2RUTGwISJNk4OQVFvshcMy+TnaORVFZFgMbIhI0+SMTYoCgY38HJyKIjIuBjZEpGltCmynIOuaimJgQ2RUDGyISNOUzNhwKorI+BjYEJGmKVljk8KMDZHhMbAhIk1rUyFjwz42RMbFwIaINK09nF1RpMZGnopixobIsOIS2JSVleHGG2/EnDlzsHTpUqxfvx4+n29Iz/HMM8+gtLQUa9euVWmURKRFcnZFkYwNp6KIDG/4V4pBuFwurFmzBhMmTMCGDRtQW1uLBx54AB0dHbj77rujeo76+nr8z//8D7Kzs1UeLRFpTSRjo+Ryb05FERmW6oHN888/D6/Xi4cffhgZGRkAgGAwiHvvvRdr165FXl7eoM/xm9/8BitXrkR1dbXKoyUirZGzK4rW2DBjQ2RYqk9Fbd26FUuWLIkENQCwatUqiKKI7du3D/r4Xbt24e2338YPfvADFUdJRFqlaI1N+Dn8ARH+gDjs5yMi7VE9sCkvL0dxcXGP2xwOB3JyclBeXj7gY4PBIO677z7cfPPNyM3NVXOYRKRB3QMQJaaikm0WCOH/ZgExkTGpPhXldrvhcDh63e50OuFyuQZ87F//+le0t7fjhhtuUHRMFosy8ZzZbOrx/0bEYzQGvR6jPGUkAEizJ8EkCP3eN9pjTLFZ0NYZQGcgqNi1IF70eh6HgsdoDIk8RtUDm1g1NjbioYcewq9//WskJSUp9rwmk4DMTLtizwcADkeKos+nRTxGY9DbMbYFJAChxnrZWWlRPWawY7SnWtHWGYAlyar4tSBe9HYeY8FjNIZEHKPqgY3D4YDH4+l1u8vlgtPp7PdxDz74IEpLS7FgwQK43W4AQCAQQCAQgNvtRmpqKiyWoQ9fFCW43W1DflxfzGYTHI4UuN3tCAaNOV/PYzQGvR5jTV3ovZ+SZEFzs3fA+0Z7jMlWMwCgtt6DnHTlvjTFg17P41DwGI1B6WN0OFKizv6oHtgUFxf3qqXxeDyor6/vVXvTXUVFBT755BMsXLiw188WLlyIJ554AitWrIhpTAGFiwaDQVHx59QaHqMx6O0YPd7QdgopNnPU4x7sGOXVVZ42v65+F93p7TzGgsdoDIk4RtUDmxUrVuDRRx/tUWuzefNmmEwmLF26tN/H/eQnP4lkamS//OUvkZycjDvuuAOlpaWqjpuIEk/JHjayrm0V/Io9JxFph+qBzerVq/Hss89i3bp1WLt2LWpra7F+/XqsXr26Rw+bNWvWoLq6Gm+99RYAYOrUqb2ey+FwIDU1FYsWLVJ72ESkAUr2sJGlsJcNkaGpXq7sdDqxceNGmM1mrFu3Dr/73e9w9dVX48477+xxP1EUEQwG1R4OEemI3CFYiR42Mvm5uNybyJjisiqqpKQEzzzzzID3efbZZwd9nmjuQ0TGoUbGhjt8ExmbcRfRE5HuKdl1WMaNMImMjYENEWmWkjt7y7gRJpGxMbAhIs1Sc1UUa2yIjImBDRFplio1NpyKIjI0BjZEpFmq1thwKorIkBjYEJFmqVpjw4wNkSExsCEizVKzxqbTF0RQNHY7e6KRiIENEWmSKEmqBDbdsz/tnWwKSmQ0DGyISJM6fUFI4f9WssbGYjbBFt7hm9NRRMbDwIaINEmur7GYBVgtZkWfO8UWer52FhATGQ4DGyLSJDWmoWSpyVYAzNgQGREDGyLSJDV62Mi4XxSRcTGwISJNalOhh42sq0mfX/HnJqLEYmBDRJrUrkIPG1lKZFsFrooiMhoGNkSkSW1q1thEpqKYsSEyGgY2RKRJatbYsPswkXExsCEiTVJjnyhZZLk3Axsiw2FgQ0SapMY+UbJU1tgQGRYDGyLSJDX72HQVDzNjQ2Q0DGyISJNYY0NEsWBgQ0SapG6NDTM2REbFwIaINEmusVFzuTcDGyLjYWBDRJrUHoepKAY2RMbDwIaINEnNBn1yYBMISvAHuDKKyEgY2BCR5vgDIvwBEYA6NTbJNjOE8H+3cck3kaEwsCEizek+RZScpHxgYxIEJLNJH5EhMbAhIs3pqq8xw2QSBrl3bFhnQ2RMDGyISHPU7GEjYy8bImNiYENEmqNm4bAskrHpYGBDZCQMbIhIc9pV3CdKxl42RMbEwIaINCeuGRsGNkSGwsCGiDQnsrO3Cku9ZayxITImBjZEpDlq7uwtS4ks92YfGyIjYWBDCSGKEto6/AgExUQPhTQoHquiWGNDZEzqXTWI+nD0VAuefu0Q6lraAQD2ZAsuOmccvji/UNUPMdIXNXf2lrHGhgbi8wfh7QjAmZYEk6BOLyVSBz9JKG4+PFCDP286hEBQitzm7QjgX1vL8dYnp3DHtbMxId+RwBGSVrTFYVUUa2yoL/Ut7Xh7VxW27atGe2cQFrOAMaPsuO7CUkwsdCZ6eBQFBjYUFx/srcafNx0GAMwvzcE3LpyMFJsFnx+rx8vbTqCmqQ2P/Gs/7rnxHFW/pZM+xKfGhhkb6unoqRb87m+7I/uUAaGNUitrW/Hbv32OW6+ahekTshI4QopGXGpsysrKcOONN2LOnDlYunQp1q9fD5/PN+Bj6urqsH79elxxxRWYO3cuVqxYgR/84Ac4ffp0PIZMCmpyd+C5t48BAC5cMBbf/coMZKTZYLOasXhaPu66fj5GOZPR4OrAM68fgiRJgzwjGV08lnuzxoa6a/Z04pF/74c/IGJigRO3f202Hv/v8/Drm5dgRlEWfH4RD/59D/aVNyZ6qDQI1QMbl8uFNWvWwO/3Y8OGDbj99tvxwgsv4IEHHhjwcQcOHMBbb72FVatW4ZFHHsGdd96Jo0eP4pprrkFTU5PawyaFSJKEZ984gg5fECUFDly7cmKv+erUZCtuvmIGzCYBu47U4/091QkaLWlFZK8oFbN3DGxI5g+IeORf++D2+lCYY8cPrp2DmcXZsJhNyMlIwa1XzcK8yTkIBCU89dqhyFQpaZPqOf/nn38eXq8XDz/8MDIyMgAAwWAQ9957L9auXYu8vLw+Hzd//ny8/vrrsFi6hjhv3jycd955+Pe//41vfetbag+dFPDJ4TrsKWuE2STghkum9LuhYfEYB646twQvvHsc/3y/HIum5rGYeASTPzjiMRXVZuDl3qIk4d3PTuONjyuRkWbDgim5WDQtD057UqKHpimv7jiBsmo3Um0W3HLlTNiSzD1+brWYsPbL03H30x+jtqkN//qgHN+4cHKCRkuDUT1js3XrVixZsiQS1ADAqlWrIIoitm/f3u/jHA5Hj6AGAPLz85GVlYW6ujq1hksKCgRFvPDucQDA5V+YgIKctAHvf+HCQuRlpaK13Y83Pq6MxxB1w9Pmw3u7T+N//rkP9/75E7z3+WnDTtmJkoR2X/wCm0BQhD9gvOCm2dOJ3z2/G//31lE0uDpw/LQLz79zDD99/CMcqGDWW9bk7sDm8PXmhlVTkJuZ2uf9rBYTrrsoFMxs+awKJ2s8cRsjDY3qX4nLy8tx1VVX9bjN4XAgJycH5eXlQ3quiooKNDY2oqSkZFhjsliUiefMZlOP/zei4RzjriN1aHJ3Ij3Vii8tmzDo790CE645rwQP/3Mf3vzkFC46ZxwccfhmqfXzeKCiCX/69364vV11aX954wj2VzTh25dPRXrq4L8jrR9jd+2dAcgxW7o9Ker361CPMc1uhQBAAuALiEhJtsYw2viK9hiDooiH/7kPFWfcSLKacPV5E2EyAe9/Xo1Tda34wwt78PWLJuGihePiMewhifff6j+3lsMfEDFlXAYWTc+DMMDS7tkTR2HRtDzsPFiL/3v7KH62ZsGA9++Pnt6PsUrkMaoe2LjdbjgcvZfwOp1OuFyuqJ9HkiTcf//9yM3NxWWXXRbzeEwmAZmZ9pgf3xeHI0XR59OioR6jJEl4+9MqAMDly4qRlxPdMu6LvlCEzR9X4niVC2/sqsJ3vjJzyGONlRbP4z+2HMOzmw5ClIDC3DScO68QggA8/+YRfHa0Hp6/+/GbW5dHffHQ4jGeLdAc6nFkMQvIzUkf8gfHUI4xJdmCto4ArMlJil8X1DTYMf7trSOoOOOGPcWK335/OQpz0wEAV66cjIf/vgdbdp3C/75xFMWFmVg4LT8eQx6yePytHq1sxo79NRAEYO1Vs5GVNXBWGQC+e/VsfP7Lt3G8yoValw9Ti2JfJaWH9+NwJeIYdVPEsGHDBnz00Ud48sknkZrad6owGqIowe1uU2RMZrMJDkcK3O52BA3aQTfWYzx2qgVHK1tgMQv4wrRcNDd7o37slSuKsf6vn2Pzhydw6TljYU9R95u0Vs/jvrJGbHztIABgxewxuP6SUiRZQ3P/k8c48MD/fYZjp1rw/BuHcemS8QM+l1aPsS9n6loBhKaKWlqif6/GcozJSWa0dQRQU+dGqkX7TdiiOcbKWg+ee/MIAOC6iybDbjX1eP+tuXgyTJDw9q4qPP3yfhTnpfVb+5YI8fxbffrl/QCAL8wYjWy7NarrlAnA4un52LqnGv989yi+lzH0L196ej/GSuljdDhSov4Cp3pg43A44PH0not0uVxwOqNrdvTCCy/gf/7nf/CLX/wCS5YsGfaYAgFl/5CCQVHx59SaoR7j6x+dBBC6ANiTrUN6bOnYDBTm2FFV78W2vWdwwfzCIY83Flo6j6Io4a9vHwUArJxXgOsuKgXQ9bdbmJOGa8+fiD+/fhgvvl+G2ROzkddPbUB3WjrG/njCU24pNktMYx3KMYbqbDrhafNr/vfSXX/HKEoSnnj5IIKihLmTRuGcKbl93u+KZUX4cH8Nquq9+GBPNZbOHB2PYQ+J2n+rZxq9OFDRBEEArlg2YUivdf7cAmzdU41PDtWh4fx2ZKTZYhqDHt6Pw5WIY1R98qu4uLhXLY3H40F9fT2Ki4sHffxbb72Fe+65B9///vdx9dVXqzVMUlCzpxOfHq0HAFy0YOyQHy8IAlbMHgMAeH+3cYtkB/LB3mqcrvfCnmzBV5b3/T5ZNms0po7PhD8gYuPrhw3ze4pHDxtZpEmfQZbv7jpch5O1HqTYzLj+4tJ+p/HsyVZctmQCAOBfH5Qbsnh6MO9+HuqJNrtkFEY5hzZdMj4/HRMLnAiKErbuZnsKrVE9sFmxYgV27NgBt9sduW3z5s0wmUxYunTpgI/duXMn7rjjDlxzzTVYt26d2kMlhew8WAtJAiYWOlGYO/icdV+WzMiH1WJCVb0X5Wfcgz/AQNo7Q9tMAMCXlhYhrZ+pOEEQsGbVFCRZTDhc2YJ95cZY6dIehw0wZUbqZSOKEl7aVgEg1AjTOUgW4YL5Bchy2NDk7sR7n4+sD+dOXxDb99UAAM6fVxDTc6ycH3rcu7tPczNfjVE9sFm9ejXsdjvWrVuHbdu24cUXX8T69euxevXqHj1s1qxZgwsvvDDy77KyMqxbtw4TJkzAFVdcgd27d0f+V1nJpcBatvNgLQBgybS+exRFw55sxYLSHAAYcd+I3vv8NNxtfuRmpmDlIBfd3IyUyIX55e0VhsjaRHrYxGFrDSNtq7DzYC3ONLaFNpaNYrWT1WLG5eGszZbPqgzxtxOtnYdq0d4ZQE5GMqbHWPy7oDQXDnsSXK0+7CtjN2ItUT2wcTqd2LhxI8xmM9atW4ff/e53uPrqq3HnnXf2uJ8oiggGu9Khe/bsgcfjwdGjR/Ef//EfuPbaayP/e+SRR9QeNsXoTKMXJ2s9MJsELJiSO6znOndO6AP740N1hvjgiYYoSpEU+WWLx8MSRbHcJYvGI8liQnm12xD9SeKZsTHKRphBUcRL20PZmksWjYs6KFw8PQ/JSWbUNrfj8MlmNYeoKfJ77Ly5BTHv3G0xm7A4/OXt48PsraYlcVkVVVJSgmeeeWbA+zz77LM9/n3llVfiyiuvVHFUpIaPDoSyNdOLsqLqrzKQSYVO5GWlorapDZ8drddkgaPS9pU3osHVAXuyBedEmfFy2pNw3twCvPnJKby0vQLTi7Ji6q2hFfGtsQmtMmvXeffh3ccaUNfcjrQU65CK7ZOTLFg8PR/vfX4a7+2uxtQRsMFjZa0HJ2s8sJgFLBvmNWXh1Fy8+ckp7D7WgE5/EDarefAHkeqM2x2I4k6SJHx0MDRvvXh67NNQMkEQsCT8PB+Fp7eMbstnoW+SS2eOHtJF8pJF42C1mFB22o3DlS0qjS4+4rGzt8woNTYf7D0DINQWIDlpaL+38+aECvU/O1rfowmkUX14IHSNmj1x1LC/fBWPdmCUMxmd/iD2cjpKMxjYkGLKz7hR39IBm9WMuRNzFHnOReGsxcETTXAZ/KJb19yG/eGdg4da0JiRZotktLbqfBNRucZGzQ0wZUaosWn2dEZ2nF4+a+gZiHF56Sga7UBQlLBt3xmlh6cpoihFviR9YfrwGxMKgoCFU0NT7h8fGhlfvvSAgQ0pRi6gm1WS3WsTuVjlZaaieIwDkmT8C8d7u6shAZhRlBVVT5qzyR9qnx6ph7fDr/Do4ieeGRsj1Nhs23cGkgRMHpuBvKzYmpfKWZvtBg9sDp5sgqvVh7QUK2aWZCvynOdMCX352lvWqOsA2UgY2JBijp5qAQBMHZ+p6PPKWZudBp6OkiQJu8IFiHIPn6GakJ+Owhw7AkERH+v4d5WQPjY6/UASJQnb9oYydLFka2TzS3NgEgScaWxDXUu7UsPTnA/3h6ahFk7NjaowPxrj8tKQl5UKf0DE7uMNijwnDQ8DG1KEPyCirDrUb6Z0XIaiz33O1DwIAlBe7UZdszLbYWhNdWMbGlwdsJgFzCiOrYBTELqKIeWaCz1iH5voHalsQX1LB1Js5mGtQkxNtmJiYagTvFGXLnf4ApHGoUpMQ8kEQYi0pthvkF5SesfAhhRxosYNf0BEeqoV+TGmw/vjtCdhWni1xo7wNy6j2Rv+pjdlXOaQiz+7WzwjH2aTgBM1HlSF91zSm0jGhjU2g/ognK1ZNDVv2CtyZoenZuR6HaP55HAdfH4RuZkpKB4T3aa80ZoyLpSllrPWlFgMbEgR8ht68tgMVZYay2n2rXuqDdnlc084sJk9cdSwnseRmhR5Dr0WgsrbG8Snj00oGGjT4XJvb4cfuw6HMhDLY5y+7E6uOTl0shmdfv39PgYiSRLe+bQKAHDu7DGKX6MmFjhhNglodHegwWXcqTy9YGBDijjSLbBRw7zJOXCkWtHS6osEAUbR2u7HsdMuAF3fmodjWTgI/PBAje6CwEBQhC+8YV48MjbyVFQgKMKvs80IPzpQi0BQRGGOHRPy04f9fAWj7Mhy2OAPiDhSaaxmfWXVblTWtsJqMSkSBJ7NlmTG+PA5OHbKpfjz09AwsKFhC4oijlWF3sylKgU2FnPXBUnuGmoU+8obIUlAQY4dozKGthlfX2YWZ8FpT4KnzY89x/U1rdB9dVLKMKbkotV92k9v01HyNNRyhTIQgiBgVkko22e0nixbwtmaRVPz+t17bbjkL3VHThkrKNQjBjY0bJW1rej0BZFqs6AwJ7ZNL6Nx7uwxEAAcPNGM2ibjFBFHpqFKhjcNJTObTPjCjFBxpLxiRi/k4CI5yQyTSf3uySaTgOQkufuwfgKbEzWhDITFLGCJgoWws4pDGcO9ZY2G2TvK1dqJT8IrDofSlXmougIbZmwSjYENDZtcXzOp0Knqh9GojJRIHYBRsjaiJEX2d5o9UZm+GkDXdNS+8ia0tHYq9rxqa4tjfY1Mj71s5I1h503OUTQDMXV8JixmAQ2uDtQbZNn31r1nEBQllBQ4ItNFaphc6IQAoLapDS4dveeMiIENDVukcFjhZd59OTc8HfXpkXpDfKOsaWyDtyOAJItJ0ZUao7PtmFjghChJkd4detAexxVRMr0t+e7e80jp/dNsSWaMzwt9+JeH2zfo3e5j4QLrWcrX1nSXmmzF2NxQxvpoFbM2icTAhoZFlKRIYFM6VtnGfH2ZNiELFnNo9UFts/6/UcofHuPz02E2Kft2lLM223UU2CQyY6OXwKb8tAstrT7YrObIMmMlFYUD7DIDBDbuNh9OnPEACHVEV1tkOspgxdd6w8CGhqW63gtvRwA2qxnj8tSrr5HZksyYVJgBAJF9lfSs4kzow6NotLJ9NQBgQWkuzCYB1Q1e3dQkxXM7BZnepqJ2hbcWmTYhE1aL8pfwkjGhRn3l1frPOhysaIIEYGxuGjLSbKq/nhzYHGWdTUIxsKFhkZd5TyxwKNaifDAzikLN+uTaFD2TMzZKNwwDQtM5k8LdZPWyyiWe2ynI5F427TrpZfNJOLBRKwNREv5brKxthU/n/Wz2hTsBx9rNe6jk7s2nG1p1kwE0IgY2NCxHVe5f05fp4cDmcGWL7vq0dOfzB1FVH+oOrEZgA3Q1XdNL75/IdgrxrLFJtvZ4bS3ztPlwNDzNMUuhVXRny3Ymw2FPQlCUUFmrz+7VgFyYHwroZxSpPw0FABlpNmQ7kiFJXdlYij8GNhQzSZIiGZtSFeb6+1OYmwaHPQmd/mCkf44enaz1IChKcNiTkO1IVuU15OW7h042o8On/Q9uucYmMRkb7f9+QsuwQxsvZqarM7UiCEIka6Pn6ahTta1wt/lhs5ojmct4KCkwTo2SXjGwoZjVNrfD7fXBYjahaLR6yyjPZhIETJ8QCqT0PB0VmYYa7VBlGwoAGDPKjuxwN9l9OsjaJKLGRn4tOajSsj3HlNl6YzDFBigg3h/O1oSWsMfvo66kIBRElZ3Wb1CodwxsKGbyNFTxGAesluFtwDdUcmpZvnjpkZyqVmsaCujZTVYuOtWytjju7C3Ty6qooChGNqico3pgo/8CYrm+Zmac6mtkXcXXbkO0pNAjBjYUsyOVLQDiW18jmxaus6msbUVruz/ur68ENQuHu5PrbHYdrtP8hTYRfWz0siqq7LQb3o4A0lOtkayAWibkp0MQgEZ3J5o9+ms21+kPRjIm8rUiXsblpcFqMaG13W+IlhR6xMCGYnY0vCdKaRwa853NaU/CmFH28Dha4v76w+X2+tDg6oAAYEK+uoHN1HGZsJpNqGtqQ3WDV9XXGi72semfvLJtXmme6ttNpNgsKBgVat+gx0Z9ZaddCIoSMtNtyFVg/7WhsJhNkQ7HnI5KDAY2FJMGVzsa3Z0wmwRMHBO/wrzuunpGtCTk9YdD/rDIz05VPTthSzJjyvhQTZLWN8VMxHJvvXQelgObBdPy4vJ6xWNCH84navQX2HQ1Dc1QrX5tIPI1kYFNYjCwoZjIF47x+emwJcW3vkY2eWzo4nFEj4HNmdAFT+1pKJm8D5XWl323s8amT03uDlTVt0IQgHmluXF5TblppB6XLUemyROQTQaMUXytZwxsKCaJ6F9ztsnhDsSVtR5Nfyj1pSJSXxOfbJe8iuboqRbN/q4kSerK2MS1xiYUmLdpuEGfnK2ZWOCEw54Ul9fsCmw8EDVem9WdPxCMBBSlCbo+yTVQVfVs1JcIDGwoJvI3okRdOAAgy5GMnIxQM6zjOkr5ipKE8vD+NcUqbKXQl7ysVBTk2BEUJc0uke/wBSF/fsYzYyNPRQWCIvwBbTZ8lAMbtZd5dzdmlB1WiwntnQHU6agItrzajUBQhMOehPys1ISMITPdhlHO0LVJj9NRzZ5O/OjRHfje79/HXU/uxBOvHNDVbu8MbGjIWlo7UdvcDgGIa+Orvsgbb+qpzqa2qQ3tnaEdvQtz7XF73flTQ7UZezW6x5b8zdZsEpCkwh5I/UlO6gqitPjt2h8I4uDJUDA6Z1L8AhuL2RTZ/01P01FHElxfI5MXVehtqlySJPz59UOob+lAhy+I6gYvPjxQi589uROvfXgCQVGbwX93DGziTJIkHDjRhHc+rcI7n1Zh58FaXaV5ga4gYmxuWqQdfaJEdtPV0cVDzR29B7JgSiiw2VfWqMll39172MTzA8lkEpCcpN3uw0erXPD5RWSm2zA2V/2NZrsrytdfnU0i21B017XTd0tCxzFUH+w9g/3lTbCYTfjB6jm4/WuzMWVcBnwBES++X46/bD6iyetHd/HL945wkiThk8N1eHXHycj+QLImTwdWLRqfoJENnRbqa2RycWBFtRud/iBs1sQUMg+FHNiosaP3QGaUZMNmNcPl9aGytjWyJFUrEtHDRpZis6DDF9RkLxu5HmtyAjIQ8t/oifDUqdYFgmJk6icRbSi6k7eZqTijn2tTo6sDz79zDABw5YpiTJ8Q6gE0oygLH+w9g42bD+ODvWeQn5WKVYu1+5nFjE0cSJKEv205jkdfOoCq+lbYksyYNzknsuPsv7ZW4LTG+4t017U/VEZCxwEAOc5kZKbbEBQl3fTbKI9Dx+G+WC1mTCsKb0VxQnt1NonoYSPT8pLvytpQUDE+L/6B6ITwVimVtR5dTEFU1rbCFxBhT7ZE+lwlSo9rk07qbDbtPIkOXxATC5y4aOHYyO2CIGDF7DFYfcEkAMDf3yvDrsN1iRrmoBjYqEySJLzw7nG8+ckpAMBlS8bjt9/7Am65ciZuv2Y2ZhZnIxAU8fRrB3Vx4Wht9+N0fSgIm6SBjI0gCJEVCHpo/+7zB1FVp+6O3gOZWJABADhZo71v4InYJ0qm5SXfJyOBTXynoYBQ0XmKzQxfQIy877VMvgaUFDhhSmB9DRC6NpXqaKq8vTOAHftrAABfXV7UZxPICxeMxQXzCgEAT7x6ULNfJhnYqEiSJPz93TK88XEoqPnmxaW46twS2MN1KYIg4IZVU5Bis6DijAfv7KpK5HCjciz8Bh2dnQpHanyWnQ5GXlmk1TdZd5W1rarv6D2QCfld38C1JhHN+WRa3VahrcOP+pYOAMDYBGRsTIIQ6Yx9QoPB8Nki2dA4T/P2R54q10OdzUcHatDpCyI/KzXS0LMvq784EbNKsuEPiHjoxb1ocGlvtRQDG5VIkoS/v1eGzR9XAgC+edFknD+3oNf9MtNtuOb8EgDAG5+c0nzWpvuKA62QMx/lZ7S/6Zz8jVLNHb0HItfV1Da3ay47EWnOl5AaG7l4WFu9bCprQ9m9Uc5kpKUkplBfno7SQwFxvPZfi5Z8nSyrdmu2lQAQ+rza8vlpAMD58woGvDaZTSas/fJ0jM1Ng9vrw4P/2Ku5awkDGxVIkoR/vF+GzTtDQc11F03G+eH0XV+WzhgNR6oVzZ5OfHZU251h5cAmUR09+zI+Px0mQYCr1af5DfsSVV8jc9iTkJluA6C9rI1cY5OIjI1Wa2zkaahxCcjWyPSyMqq13R/ptzNBIxmb/KxUOOxJCARFTf/+jlW5cLreiySrCUtn5A96/xSbBf919Sw405Jwut6Lx14+AFHUzpdKBjYKkyQJL75fjtc/CgU137hwMlYOENQAgNViwrlzQtmct3edUn2MsWrvDEQ+DOWuv1pgs5pRmBMqFNT6dJQWvlHKRahyNkArWGPTWyLra2TyyqiqOi98fm1ltLqTA4e8zJSEZbfOJghCt2XfzYkdzAC2fBYqg1g8LT/qFh5ZjmR8/6pZSLKYsLesEX/bclzNIQ4JAxsFSZKEf24tx6aPTgIIBTUXzB84qJGdN7cAZpOAY1UuTRZ2AqHuvpIE5GQkIysB9SED6T4dpVXutvjt6D0QeTrqpNYyNgnYJ0qm1Rob+VqQyKX5WQ4bHPYkiJKEyjptBcPdaeFLQ1+0XkDsau3Ep0fqAQAr5/UulxhI0WgH/vPyaQCAt3adwnvh6axEY2CjEEmS8K8PyvHah6Gg5utfnBR1UAOEam0WTgltbvf2p9rM2mipf83ZisIXswoNZ2ziuaP3QLoyNtoMbBLVxwbQVsam0xdETVMbgMRORQmCgKJ87dfZlMd5/7VoyW0xjp92IRDUXp3N1r1nEBQllBQ4Yvo7WzAlF19dUQwA+N83j2qilURcApuysjLceOONmDNnDpYuXYr169fD5/MN+jhJkvD444/jvPPOw6xZs3Dttddi9+7d6g94iEJBTQVe3REKav7jgkn44oKxgzyqtwsWhAKhnQdr4fYO/vuJt679ofqvmE8UeRXEiRqPpuZ6u9PKN0q5TX51Q5umphba2cemh1P1rZAkwGlPQkaaLaFj6WrUp83ARpKkSNCV6PfX2caMssOebIHPL2ouGy+KEt7fHS4a7mNxS7QuXzIeS6bnQZQkPPKv/ahtblNqiDFRPbBxuVxYs2YN/H4/NmzYgNtvvx0vvPACHnjggUEf+8QTT+Chhx7CDTfcgMceeww5OTn41re+hVOntJXROFDRhFd3nAAArL5gEi5cOPSgBgBKxjhRNNqBQFDC+3uqFRzh8HX6g5ELh5YKh2Wjs+1ITjKj0x/UbLPDCnlFVIK/UWam25CeaoUoSZr6XWlhubeWAhv5QzCR2RrZhG47fWtRXUs7Wtv9sJgFFOYkrh6pL6budTYam47aU9aAJncn0lKskRmDWIRal0zFxAIn2jsD+Cw8tZUoqgc2zz//PLxeLx5++GEsX74cV199Nf77v/8bzz//PGpra/t9XGdnJx577DF861vfwg033IAlS5bg97//PTIyMvDUU0+pPewhyXYmo2h0Or55cWmPbo2x+GI4a/PuZ1WaSluWnXYhKErITLchx6mt+hogtN9P0Wjtrt4QJSnyoZDoHhuCIESmo7T0DTKxNTbm8Bi0k8GSt14Zl8DCYVlReMl3TVNbZPWalshT0OPy0mGN4waq0ZK3V9DaZr3vfhbK1iyfNRpWy/C2fLBaTLjtmtm4YdUULJ89RonhxUz1v4CtW7diyZIlyMjIiNy2atUqiKKI7du39/u4zz77DK2trVi1alXktqSkJFx44YXYunWrmkMestHZdvxszcJhpfJkC6fkwmlPQkurL1LQpQWHT4Yq+hOxX020iiKN+rTXgbi2qQ1tCdjRuz9yFkBLBcTyB6adNTYAEFm6nJ+VmuCRAOmpSRgV/kJzskZ7Xxwi07waWeZ9NrmA+FhVi2amyps9ndhfEaqHOVeBzy4gVB+3YvaYhK9KU/0KUl5ejquuuqrHbQ6HAzk5OSgvLx/wcQBQXFzc4/aSkhJs3LgRHR0dSE6OLXNgUSiiN5tNPf5fCRaLCSvnF+JfW8vxzmdVWDprtGLPHQv52PaVh94AM4qzFPv9KW3SWCfwUShdPpQxqnEezyYHEBNGO2BLiv8H99nHKDddq27wauJ8+vzBSAMzZ7otpjEN5zym20NdtNs7A5r4fQBAfUs4sMm2R8YUj7/V/hSPcaDB1YGTda2YOXGUaq8TyzFWhIOtiWMzNHP+uisa40CqzYK2zgBON3oxMdwuIxHnUba3vBFAaPsJNfbVSuTfqupXWLfbDYejdxTtdDrhcvX/zdrtdiMpKQk2W8+iOYfDAUmS4HK5YgpsTCYBmZnKnkSHI0XR5/vq+ZPwyvYKHK9ywdURTHizKbfXF8mCLJ83FplOZY9XKfOmjQawF6frW5GcahvylIbS57G7qoZQMd204mzF//6GQj7GSeOzAQD1ro6EjkfWGG7LbjIJGJ03vK7MsZxHqy30DdMfEJGWnjzstPxw+QMimtyhrRQmF2Uj86z2Cmr+rfZneskofHyoDlUN3rj8zUR7jP5AECdrQtN2c6fmaeLvuS/TirOx61AtKuu94WtVYs6jbM/xUGCzYm6Bqr+zRBxj4tacJogoSnC7lanYNptNcDhS4Ha3I6hwPcysklH47Gg93vroBK4+r0TR5x4Ks9mE3WWNkCRgbG4aTKKI5mbtFJx2JwDISrehydOJ3YdqBtzvpDs1z6PsQPjbUUF2akJ+f2cfozzb0+LpxJlaF5ITkEXq7nS4P4o92YKWltjen8M5j6IkQQAgATh9xgVnglch1TS1QZSAJIsJCAQifzPx+FvtT35GKLg6XNGEpqZW1aakh3qM5dWhZdRpKVYkm6DZ61PJmHTsOlSLXQdrsXJuQcLOIxDq0ryvLNTlftq4DFV+Z0r/rTocKVFnf1S/mjkcDng8vefxXS4XnM7+V4c4HA74fD50dnb2yNq43W4IgjDgYwcTUHjPjmBQVPw555fm4LOj9fj4YC2uWDohoXUtn4a3p59elKX4cSqtaIwDTUfqcexUCyYWDO1vRI3zCACeNh8qw0W6EwucCf0dysdos5hhT7bA2xHAmYY2jM1NbIGquzW0FYY92Trs30+s5zElPFXg9voiG9UmypnwarWcjBQEgxJCIVcXtf5WBzIuNx1mk4AmTyfONHiRm6lu7U+0x3jsVCibXDTa0efvSiumhguID51sQkdnAA4k5jwCoWt6UJRQmGNHtiNZ1TEk4hhVn/wqLi7uVUvj8XhQX1/fq37m7McBQEVFRY/by8vLMWbMmJjra/RizsRRsJhNqGlqQ1V94r6BSJKEz4+EApsZRVkJG0e0Ih2INdSo73BlCyQAhTl2OO3a2BEdAHIzQyliuUg1kbxy4XBK4jJH8mt72xNfQCzX1+RkaGfa15ZkRkn4y8LBE9rZHiCysazG+tecbWxuGpz2JPj8Io4leHXUZ0dDC1PmTc5J6DjUonpgs2LFCuzYsQNud9cHzebNm2EymbB06dJ+Hzdv3jykpaXh9ddfj9zm9/vx5ptvYsWKFaqOWQtSbBbMLA4FEp+EMyaJcKquFc2eTiRZTZikof2h+iOvitDS1goHw504p47XVmAof2jKH6KJ5G33A0BCMyXya3s7/Akbg0wONuXgUyumTQhlHQ5qoLusTCuNLwcjCAKmh78c7gtPTSdCpy8YWQ3FwCZGq1evht1ux7p167Bt2za8+OKLWL9+PVavXo28vLzI/dasWYMLL7ww8m+bzYa1a9fi6aefxsaNG/Hhhx/iBz/4AVpaWvDtb39b7WFrwoJww6Rdh+sgSYlJr+4tC70Bp03I0mR/iLONz0+HIISWMmplp+9D4W+38oeCVkQyNloIbBK41Fsmv7YWAhstZmyA0HUAAA6dbIaYoGtSd63tftSGg8AijS717m6GBgKbfeWN8AdE5GQkJ3wKWi2qX0WcTic2btyI++67D+vWrYPdbsfVV1+N22+/vcf9RFFEMNizOdZNN90ESZLw9NNPo6mpCVOnTsVTTz2FsWOH1wRPL86ejkrEH+H+8BtwZnF23F87FslJFhSMSkNVfSvKq92YX5rYbyT1Le2oa2mH2SRobo+tSMYmwe3Pga5gIqEZm3DvDU5F9a9odDqSk8zwdgRwqrY1oZtzAl1bPORqaEfvgUwryoIAoLK2FU3u0Ia48fbZsa5pKK32JBuuuHw9KikpwTPPPDPgfZ599tletwmCgLVr12Lt2rUqjUzb5Omoz4814JPDdXEPbPwBEceqQvPX03RQXyMrHpOOqvpWVJxJfGBzKNzYsHiMIyEddQeSm6GhjI08FZXAD6dUjUxFSZKE+pbQUm+tTUWZTSZMGZeJ3ccbcPBkU8IDG71MQ8kcqUkYl5+OkzUefH6kDvMmxvcLYyAoRpZ5z58c+xYKWqf9uYURLpHTURVn3PAHRGSk2TAmO/HdT6Ml78WkhQ7EXfU12pqGAhBZ1dLo6kz49h2tmpqKSmzGxu31odMfhAAg26G9RRLy37IWCojlWjo9TEPJ5NrJz47Ev3by8MlmtHcG4LQnobhAP7+zoWJgo3GJXB0lb9g2vThbVylLuYC4IsE7fYuSFMnYyLUJWuJMS4LVYoIoSZFmcImihYyNPA3WluCMjZytyXLYNFnXJteKHTvVEukWnQiSJKHsdOjLy1BbOyTSjKJQlmb30fq4f1n9NLwaau7kHJh0dE0fKu29a6iHRK6OOloZ+lCeUaKP+hrZmFF22KxmdPqCONOYuKXyVXWt8LT5YUsyazJVbhKESA1HoqejNFFjo5GMTV24QaHW6mtkY0aF2hb4AmIksEiEuuZ2eDsCsJhNuiqCLR7jQJLFBLfXh+qG+F2fRFHC5+HAZr5BV0PJGNjoQCKmowJBEcdPh9K8M0rU2xdGDSaTgAnhuf9E9rORU/WlYzNgSeCeMAPJjRQQJziwaddCHxtt1NjIS721GtgIgoCp8rLvk4lb9l0WnmqekJ+u2fdXXyxmEyYWhjJMhytb4va6x0+74G7zI9VmQem4jLi9biLo569hBEvEdNTJGg86/UHYU6yRnaD1JNKoL4H9bOSL/jQN1tfItLLku60zFEykaSFjk+BVUVotHO5uWrgn06EE1tmU6axwuLsp4S7Eh0/G7/f3eXg11Ozw54mRGfvoDCIR01Fyfc2UcRkwmfQ3FysXE1YkKGMTCIo4Gv4darG+RhaZikpgxiYQFNHeGWr1kJrQ4mFtZGy0utS7O7nOpvyMG20JmrrTY32NTN7H7nBlc9yy8PvLQ1+0Zsd5JVYiMLDRCXk6anc46lbbkXCKtHScdrMNA5G/xVXVe9HpDw5yb+WVnXbB5xfhSLWiIEebuw0D2sjYtHV2fTAmMrCRX7utI5CwhphA17nQcmCT5UhGXlYqJAk4Uhn/rE2nL4iqulD2Wo8Zm+IxDljMJrhafXH5UtHk7sDpBi8EQdtftJTCwEYnZhZnQxBCH9SNLnVXsIiihGNVLQBCGRs9ynIkIyMtCaIk4WRN701Y1SbX10ydkKXpFWW53bZVSNSHubwiKsVmgdmUuEuSXGMTFCV0+OIfDAOhD2y31wdA21NRQLftFeI4nSI7UeOGKEnITLchS4NL4geTZDWjNJy1ORKHfaMOhLdQKBrt0EUjw+FiYKMTaSnWyAZ0e1Vux32ixoMOXxCpNosu62tk8nRUIgqI9VBfAwDZzmQIAuDzi3CFP1DjTQvbKQBAksUEizkUhCZqekWehrInWxK+w/hgpkX62cS/gFhvjfn6MiPczT0eGa994cBGDxsZK4GBjY7MCr8R9pWpG9gcCn8ol+q0vkaWqALi9s4AKqpDWaKpGtsf6mwWsynSBC5RdTZa6GEDhFb7JLrORp6GGqXhaSjZlPGZEACcaWyL+75sx8P1NSVj9FdfI5PbaBw51aJqtlQUJRwKB58zdLI1znAxsNGRWeE3wsGTTfAH1EuVy5X6WuyWOxRyB+KKOHcgPhzeIDA3MwWjnNr/gEr0Lt9yEJGW4IwN0H2/qMQENvI5yNVBYGNPtka2VIhn1kaSpEjGpkTH3XOnjM+C2SSgyd2JBhXLCyrOuOHtCCDVZkHRaP1m4IeCgY2OjM1NQ2a6DT6/GCnuVVr3/aH0HthMyE+HAKDR3YmW1vh9o5Q3mdPLxqGRAuKEZWzkHjaJn3pJTXCTPjljo/X6GtmM8GrN3ccb4vaadS3tcHl9sJgFjNfxVHmyzRLJKh9SsU5pf3gaatqEzITWsMXTyDhKgxAEIfJhuUel6ajyahd8AREOexLGjNLuap5opNgsKAx3JJWDNbUFRRG7j4Uu8nrp7pmrkYyNFmpK0hI8FVWv8eZ8Z5M3UtxX1ojOOBVcy1/qikY7kGQ1x+U11SKvUFI1sAnXZI6UaSiAgY3uzA5PR+053qDKvOyhbtNQWl7NE63JYzMAAEfj1OHzaGULvB0BpKVYMWmsPub/E72tgha6Dsu6L/lOBD30sOluXF4aRjmT4QuI2KfyogZZVyuKjLi8nprklWWHTqrTz6bJ3YGyajcE6CeDrAQGNjozbUIWkiwmNLg6cEKFZcwHDVJfIysNBzZHTsVnSWpkk7lJo3ST9k34VFS463CqLfEZGzlr1JqAjI0oSpFaCz3U2AChLHJky5c47VYtN74sHav/a9TEwozIvlGnVdg3ale4oeukQicy022KP79W6ePKSxG2JDPmTArt3fTRgVpFn7vDF4h06jVKYCNnbKrqvWhVuSBUlCR8Jm8yV6qPaSigKzvQ2u5He2f8MxVaytgkcluFJncHgqIEs0nQ1YfQgtJQYLOnrBE+lZthNrja0ejugNkk6LLj8NmsFhMmhfeNUmM6Su5Uv3BqnuLPrWUMbHRo8fR8AMDOQ7UIiqJiz3uksgVBUcIoZ7JuUuGDcdiTMDo7FQBwTOVGWBXVbrS0+pCcZMbU8frpF5FisyA9NZSpSETWpmtVlAYyNuEC5rYEZGzquy311lObhaLR6chy2NDpC0YawalFnoYan58OW5K+62tkUyeos+9Wg6s9Mg2lpy9aSmBgo0MzirKQlmKF2+tTNMqX05bysnKj6JqOalH1deRpqFkl2bBa9PXWSmQBsVb62ACJXRVVp6Ol3t0JghApIv5E5emoI5FpqAxVXyeepkY6EDcr+kV11+HQ9Wjy2AxkpOknA6gEfV19CUCoqdrC8Ly2UtNR/oAYWaZ8jsHSlpPDRYZqBjaiKOGjAzUAEDk3epKTwD2jtNJ5ODSGxK2K6tojSn9bBJwzNfQ3/9nRelWnM48aqHBYNj4vHak2C9o7g4rWTXZNQ+nvejRcDGx0avH0UPDx6dF6RTZ53F/eiPbOIDLTbZhYqP+56+4mF2YAACprPapddA+ebEJLqw/2ZAtmlYxS5TXUlJugXb5FSepa7q2BjI1c55OIGpv6Fn0VDndXPMaB0dmp8PnFyAeq0po9nahraYcgABMLMlR5jUQwmYTIbt9KdZWvbWpDxRk3BAGYX8rAhnRiYoETo5zJ6PQF8fHB4WdtPpaj+ym5MBlgmXd3WY5k5GQkQ5LU62ezY18oW7NoWp7upqGAxHUf7ugMQF7lqqWMTVtnAmps5B42OmnO150gCFg2czQA4IO91aq8xuHwnkrjctMTugu8GuZNDi8IOViryLLv93afBhBa4u20Jw37+fRGf1dgAhC6kJw/twAA8NauU8N6M3T6gvjcoNNQstJx4XlsFTaca+8MRFZDLQ1f3PUmUUu+W8PTUElWE6yWxBeDysFVe2cQgaBy9Q6DkSSp21SU/gIbAFgyIx8mQUDZaTeqVVi6LBfXan3/tVjMnZSDJIsJdc3tqDgzvOkonz+IbXvPAADOC39GjDQMbHRsxZwxSLKaUFXvjfSficWesgb4/CJGOZMNu5eIXKA3nN9Tfz45XAdfQMTo7FRMyNfn70+e/mjydMT1Az1SOKyBFVEAemQC2uK49N3bEYhMk+o1sMlIs0UWHmzbd0bR55YkKbI5r1FaUXSXYrNgbrhTuVyrF6tPDtfB2xFAtiM5snHySMPARsfsyVYsnzkGAPDWJ6difp73Pg+lLc+ZmmeIbsN9mRLO2FTWeBQvDN0RvogvnTlat78/hz0JNqsZkgRVN+Q7m8vri7y+FphNJqTYQpmjeHYflqcAnWmh86BXy2aFMpY79tcoGiDXt7Sj0d0Js0mI1MwZzeJpoWz5x8Ns4/Fu+Hp+7pwxumoboCQGNjr3xYWFEADsLWvEmcahp38Pn2zG4coWWMwCVs4zbtoyM92G0dmpkABFNxA93eDF0SoXBAFYEu4vpEeCIERW48RzOsodDmy0VAcgd0CO5w7fdTrbI6o/s0pCNR1urw+fHqlX7HnlTGvJGIdh+tecbbrcxqPNH3NPm5M1HpRXu2E2CVg+e4zCI9QPBjY6l5eZitkTQ4Vnr2w/MeTHv7y9AgCwfPYYZDn0t8x0KOQUtpKNsORs15yJo3TVLbYviSggdoV3XddSYBNZGZWAjI0eV0R1ZzGbcO6c0AfqO59WKfa8h8OBzRQDTkPJLGZTZGl2rFN5r+44AQBYMCVXU++peGNgYwBfXjYBAkIV9WWno1/1c6QylK0xmwRctni8egPUiEhgo1ABcacviB37Qxeg8w2Q7UpEAbE8FeVM085FOC287NzT5ovba+q1OV9fzptbALNJwPHTLpxUoC+LKEmRRqTybthGtWJWKCj85HAdqupbh/TYEzVufHq0HgKAy78wQfnB6QgDGwOYkO+IrMb569vHIEaxQkqSJPzrg1C2ZsUIyNYAoZVRAoDqBi9awpmC4dh5qBbtnUHkZqQY4oKbiO7D8lSUI1U7gY1c7+OOY2BTb5CpKCBURCxvjPn2p7HX/slO13vhafMjyWpC8RjHsJ9Py8bnp2N+aQ4kCfjn++VDeuy/w9fzxdPzUDDKrsbwdIOBjUFceW4xbElmVJxxR1VV/8nhOhw91QKrxYTLlhg/WwOEvomPywutWjo8zNVRkiRhy2ehVPt5cwsM0fsnEd2HuzI22pnGk1P4ctAVD/Uu/faw6csF8wsBADsP1g0783XoRGg11OTCDFjMxv/IunJFMUyCgN3HGyI7mQ/meJULe8saYRIEfHlZkboD1AHj/5WMEBlpNlweDlCee/sY6prb+r1vhy+Av205DgC4bPH4EZGtkUWWfQ+zzqbstBuVta2wmE2RlSB61z1jE03WTwkuDRYPyxkbV5wCG39ARLM7lEE0wlQUECryHZ+fjkBQxJbPTg/ruXYfbwBg/Gko2ehsO1bMDl1T/v7e8UHfi4GgiL++fRQAsGxWPvIyU1Ufo9YxsDGQixaOQ/EYB7wdATz04r5+tw94ZfsJNHs6kZORjFWLx8V5lIk1vTh0cdxT1gBRjP3De/PHlQBCad80DWwFoIQsRzJMggB/QISrNT4f6loMbOKdsWlwtUMCYLOaI7us650gCFi1KHRteXvXKXT6Ytv2xd3mi+zxNpJ2qP7ysiLYrGaUnXbj/d0Dd3J+efsJnKjxINVmwRXLiuM0Qm1jYGMgVosJ6746E860JFQ3ePHoSwfQ1q1niyRJeOfTKrwZ7nnzH1+crIlur/FUOjYD9mQLPG1+HKtqiek5apva8Hm40/DF5xgnMLSYTch2hqaEBsr4KaXTF4x84Gmljw0Q/4xNfbeOw3rtg9SXBaW5yM1IgbcjgPf3xLbNwudH6yFJwLi8NEPUH0UrI82Gq84NBSkvvHscDa6+p4ePV7nw2ocnAADXX1Kq+5WZSmFgYzCZ6TbceuUsWMwm7CtvxE+f3IkP9lTjowM1ePSlA/i/t44iKEpYOjMfcybqb7PG4bKYTZgzKXTcsfbZePOTU5AQ6tlhtCK93HAaOx4ro1zh2oskiwnJGupN4rSHPhzilbGRf9e5BqmvkZlMAi4JZ4Tf+LgypoZ9n4a/QIzEjRxXzi/EpEInOn1BbNx8pNeUVGWtB4/8ex8kCVgyPc+w2+HEgoGNARWPceCHq+cgLysVrlYf/vz6YTz+ykF8crgOJkHAtSsn4luXTk30MBNm/uTQRfLTo/VD3mPL3eaL9Ji4xEDZGllkl+84FBC7W7u6DmspUyFnbFrb/MPqAButrj2ijFfrtnRGPpz2JDR7OrFj/9C2CvB2dDWqWzCCpqFkJkHAjZdOhdViwoGKJvziL7tQdtqFBlc7duw/g1/+76doafVhdHYqvnFhaaKHqynG2iKVIiaPzcDPv7UQr+44iT3HG5CabEFmejLOn1eAiQXORA8voaYXZcJmNaPZ04kTNR5MGpsR9WNf3XEC/oCI8fnpKB0X/eP0Ip5N+lzecHM+DfWwAYD0FCsEAZAkwNPmR4bKK7YaWkJbWBilcLg7q8WMi88ZhxfePY6/v3scs0uyo14Bt/toA4KihDGj7BidbazMaLTys1LxrUunYuPmw6g448Evnv20x8+nT8jEd78yw3C7nQ8XfxsGZrWY8dUVxfjqChaUdWe1mDGrJBufHK7DriN1UQc2ZdUuvLMrtMT7yhXFmsoyKCWeTfq6tlPQVl2AySQgPTW0LYDb61M9sIlkbAw2FSX74oJCfHSgBpV1rdi4+QhuvWpmVO+dnYdqAQDzJ4+8bE13i6blYcq4DLzwbhk+OlADk0lAZroN50zNw1dXFMFs4sTL2eIS2GzZsgV//OMfUVFRgTFjxuA73/kOrrrqqgEfs3fvXjz33HPYtWsX6urqkJeXh4svvhjf/e53kZrK5Ww0PPNLc0KBzeE6XLty0qD3DwRFbHz9MCSE5rNnGnTX3Hg26dPaBpjdOcKBjdoFxKIk9SgeNiKL2YT/vHwa7n3mE+w+3oDt+2oGbZFw+EQTdh9rgADgnGmsHXGm2XDTl6bhhlWlMJtNhuibpSbVQ71du3bhlltuwZw5c/DEE09g1apV+OlPf4rNmzcP+LjXX38dJ0+exH/+53/i8ccfx5o1a/DCCy/g5ptvVnvINALMKsmGPdmC+paOyH5PA3lpWwWq6r1IS7Fi9QWDB0J6JX+4ejsCiu+CfjYtLvWWydNjahcQu1p98AdEmAQB2QbuJ1WYm4Yrwo3jNm4+jI/D2Zi+iJKEx/+9DwCwdNZowxXoD4fVYmZQEwXVMzZ/+tOfMGvWLPz85z8HACxevBinTp3CQw89hEsuuaTfx910003IyupqyLRo0SI4HA788Ic/xP79+zFjxgy1h04GlpxkwRXLivDXt4/hxffLcMnSvqfrJEnCy9tP4LUPTwIA/uOLk5Cuofb/SrMlmeG0J8Hl9aGuuR1Fo9XrqyL3ytFiYCNv8aB2xkbO1mQ5bIbvqrtq8ThU1rVi1+E6PPbSAbi8PnxxfmGvaakd+87g2KkWJCeZcRWn0SkGqr6TfD4fdu7c2SuAufTSS1FWVoaqqv53f+0e1MimTZsGAKirq1N2oDQinTe3AKOzU+Fp8+P5t470+nlQFPH398rw0rbQHixXnVuMJdPz4z3MuJNrPdSejpL3YtJiYBOvjE2dgfaIGozZZMLNX56O8+cVQEKoQ/rvX9jTo2fS0VMteP6dUFf0K5YVaWqrDdIPVTM2lZWV8Pv9KC7uGXWXlJQAAMrLy1FYWBj18336aagi/OznGyqLRZl4zhz+hmU28DctIx+jxWLCNy6ajN8+txuvbitHjjMZy2bmQxAEVDd48fjLB1Be7QYAfP3CSbhkkX731BrKeczLTMXxKhcaXB2KvVf6IgcNWc5kRV5Hyb9VudGZu82n6u+g0R1aEZWflRrV6xjh/XjDqinIz0rFP94tw4GKJtz15E6UFDiRkWbDxwdrIQEYl5+OVUsmwGTQWRcjnMfBJPIYVQ1sXC4XAMDh6Lkjq/xv+efRaGpqwoYNG3DBBRdgwoQJMY/JZBKQmansnK3DYfxvW0Y9xnMX2PHhwTps31ONJ14+gB37a9DpD6K8qgWiBNhTrPjulbNw7rzoA3Ati+Y8jh/jxPZ9Z+Bq8yv+XpFJkhSZ5hk7JgOZCu5vo8Tf6pjc0GapbZ1B1X4HANDiDdUxjR/jHNLr6P39+PVV03DewnF45B97sOdYA45UtkR+duE54/DtL8+A3SBblQxE7+cxGok4xiEHNh6PJ6qpoLFjx8Y0oL74/X7ccccdAIB77rlnWM8lihLcbmXaxZvNJjgcKXC72xGMoaumHoyEY7z5y9MxeWwGnn39EA6UN0Zunz0xGzdeOhVZjmQ0N3sTOMLhG8p5dCSHugCfqnGrdtzeDj/8gfA4AgFFXkfJv1UzQo0bG1vaVT33VXWhjGBasjmq1zHS+zHFLOCOr81GTVMbjla24HSDF7NKsjF7Ug7sKVZDHGN/jHQe+6P0MTocKVFnf4Yc2GzevBl33XXXoPfbtGkTnM5QIziPx9PjZ2536M0s/3wgkiThJz/5Cfbu3Yu//vWvyM0dfmvtQEDZP6RgUFT8ObXGyMdosZhw5fmTMKnAgZ0HapGbmYIp4zIj0xFGOu5ozqO8Oqe2uV21Y29yhaZgUmwWmARB0ddR4m81LTmULXB5faqef7nGJjs9eUivY6T3Y44zBTkzu77Vyx+CRjrG/vAY1THkwOaaa67BNddcE9V9fT4frFYrysvLsXz58sjt5eXlAKKrlfn1r3+N119/HU888QSmTJky1OESRa0wJw35y9gjSS4ebvF0wh8IqrJRqlvDS70BwBEuHm5t9yMQFFVZsdTeGYCnLTQVNRKKh4niRdWqnqSkJCxatAhvvPFGj9s3bdqEkpKSQQuHH3/8cTzzzDN44IEHsGTJEjWHSkRh6SlWJCeFJmPqw+3+lablHjYAkJZijfQLkYMPpcmrztJSrGyJT6Qg1cuVv/vd72L37t245557sHPnTjz00EN49dVXceutt/a437Rp0/CTn/wk8u9XXnkFv/vd7/ClL30JhYWF2L17d+R/TU1Nag+baMQSBEH1zTBdrdrtOgyENiBMt4emo9Ra8m30jsNEiaL614QFCxZgw4YN+OMf/4h//OMfGDNmDO6//36sWrWqx/2CwSDEbjvpbt++HQDw8ssv4+WXX+5x31/96le48sor1R460YiVk5mCyrpW1Ku0Z1RLqzY3wOzOmZoEV6svvFlnuuLPLweNuQbdI4ooUeKS/7zgggtwwQUXDHifI0d6Nkh74IEH8MADD6g5LCLqh9oZmyZPKLDJStfuNgKOtCSgTr3uw/I0HzM2RMoybncgIoqZ2t2Hm8ON6bIc2u0s60xVt/twfbjjbk6GdoM7Ij1iYENEvUQyNipNRekmY4OueiClRaaimLEhUhQDGyLqRf6wbXC1QxQlRZ9blCQ0hwMbuVeQFmXYQ2NrUSFjExRFNLpCv4NcBbsuExEDGyLqQ5YjGWaTgECwKwhRiqfNj6AoQRC0XTwsB13NHuWXvDe6OyFKEixmk6Z/B0R6xMCGiHoxmQSMcoamiZQuIJYDBac9SZXGd0rJdMiBjbKBHYDIarOcjORIvxwiUoZ2rypElFBqFRA3ueVpKO3W1wBd9T8tHp/i03H1rK8hUg0DGyLqk1oFxM2RwmHt1tcAoYySSRAgdtuJXCl1bM5HpBoGNkTUJ7V62TSFp6IyNbzUGwhNx8n1L0pPR0Wmoticj0hxDGyIqE/yh25duN+KUpp1sNRblqVSATGnoojUw8CGiPokL0Oua26HJClXY9JVY6PtjA3QNcYmBTM2kiRxKopIRQxsiKhPuRnJEAB0+IKK7nAtZz+03HVYJhc4KzkV5Wn3o8MXhAB2HSZSAwMbIuqT1WJGliP0wVur0HSUpJPmfLKuXjbKBTbyNFRGug1Wi1mx5yWiEAY2RNSv3ExlV0Z52vwIBCUIADLStB/YyFkleW8rJXT1sOE0FJEaGNgQUb/yskJ1NkplbOTMh0PjzflkatTYcI8oInVp/8pCRAmTF87Y1DYpk7Fp0lF9DdCtSV9raAsEJchTUVzqTaQOBjZE1C+lp6L00nVY5kxLggAgEJTQqlABdfftFIhIeQxsiKhfeZldU1FKLPnWU+EwAFjMJjgUbtLXNRXFXb2J1MDAhoj6laPwkm89LfWWZUXqbIZfQOzzB9HSGtqeIZdTUUSqYGBDRP1Sesl3o46a88mU7GVT7woFRyk2M+zJlmE/HxH1xsCGiAaUl6VcAbEcHOlpGkbJXjbdl3oLgjDs5yOi3hjYENGAIlsrtAwvY9PhC8AVnoaRgyU9iExFuRUIbLjUm0h1DGyIaEBKLfmWV1alpVhhT7YOe1zxkqngRpjcI4pIfQxsiGhA3VdGDUdtOLDRU7YGULZJH3vYEKmPgQ0RDah7L5vhLPmuaQoFRnKgpBdydqXR1YGgKA7ruTgVRaQ+BjZENKCcjJTIkm/3MJZ810UCG319qIc2qzQhKEpocMU+HSVKEupbQo/nVBSRehjYENGArBZTZMl33TCmo7qmovSVsTEJgiJ1Ri2eTgSCIswmQVd9fIj0hoENEQ1KiSXfco2O3qaigG6bgTbFHtjJ01DZzmSYTbz0EqmF7y4iGtRwC4jbOvyRzsV67LgrH3/NMDJWdc1cEUUUDwxsiGhQw90MU56GctqTkGLTX8ddOWNVN4yMTR0Lh4nigoENEQ1quBkbeQpHb/U1skjGZhhTcfXsYUMUFwxsiGhQkRqbGJd8RwqHdTgNBQD54YCsyd0BfyAY03MwsCGKDwY2RDSoUc4UCALQGeOS70jhsE4zNumpVqTYzJAQ+3Sc/Dg91hgR6QkDGyIalNViQra8y3cMdSa1Ou1hIxMEodt03NADm7YOP7wdAQBATkayomMjop4Y2BBRVGItIJYkKbJMXK8ZG2B4S77lxnyOVCuSk/RXPE2kJwxsiCgqsRYQu7w+tHUGIAj6XhEUadIXQwF1HfeIIoobBjZEFJWuD/ahZWxO1bUCCBXgJlnNio8rXuSMTSwro7hHFFH8MLAhoqjkhjM2Q91WobLWAwAYm5um+JjiKX8YU1FszkcUP3EJbLZs2YIvf/nLmDlzJi6++GK8+OKLQ36O733veygtLcVTTz2lwgiJaDCxLvmWMzbj8tJVGVe8yBkrl9eH9s7AkB7Lpd5E8aN6YLNr1y7ccsstmDNnDp544gmsWrUKP/3pT7F58+aon+P999/Hnj17VBwlEQ0m1iXfcmCj94xNarIVjlQrAOBM49CyNpGpKNbYEKlO9cDmT3/6E2bNmoWf//znWLx4MW677TZcdtlleOihh6J6vM/nwy9+8QvccccdKo+UiAYSy5LvTn8QNeH76j2wAbqOobLOE/VjAkERje7QqihmbIjUp2pg4/P5sHPnTlxyySU9br/00ktRVlaGqqqqQZ/jqaeegsPhwJVXXqnWMIkoSpEC4igDm9P1XkhSaJmz056k5tDiQp5OO1XbGvVjGl0dkCQgyWoyxO+ASOtUbahQWVkJv9+P4uLiHreXlJQAAMrLy1FYWNjv46urq/H444/jz3/+MwRBUGxcFosy8ZzZbOrx/0bEYzQGpY6xMDcNB040o7qpLar30ekGL4BQQGBVeUVUPM5j0RgHAKCyrjXq60hDOFuTm5Ey7N8B/1aNgceoLlUDG5fLBQBwOBw9bpf/Lf+8P7/61a9w4YUXYs6cOYqNyWQSkJlpV+z5AMDhMH56mcdoDMM9xilF2Xjj41M409gW1fuozhX6UJ88Pkvx911/1DyPMyblAgCq6lvhcKbCbBr8C1dTazUAoKggQ7HfAf9WjYHHqI4hBzYejwd1dXWD3m/s2LExDUi2bds2bNu2bUhFxtEQRQlud2w7FJ/NbDbB4UiB292OYFBU5Dm1hsdoDEodY1ZaaCql/LQLTU2tg2ZSj55sAgDkOm1obvbG/LrRiMd5TLUISLKa0OkL4nBZPcaMGjxQOXqyGQCQo8DvgH+rxsBjHDqHIyXq7M+QA5vNmzfjrrvuGvR+mzZtgtPpBBAKhrpzu90AEPl5X+6//35cf/31SElJidwfADo7O+F2u3tlgYYiEFD2DykYFBV/Tq3hMRrDcI8xLyO0Mqq13Y9GVwcy0mz93leUpMiKqIJR9rj9btU+j2Nz01B22o3yaldUDfeq6kO/g9FZyv0O+LdqDDxGdQw5sLnmmmtwzTXXRHVfn88Hq9WK8vJyLF++PHJ7eXk5APSqvemuoqICjz76KB599NEetz/44IN48MEHsXfvXths/V9UiUh5SVYz8rNScaaxDVV1rQMGNg0t7ejwBWExm5Cfrd89os42LjcdZafdqKxtxeJpA99XFCWcCdcZFebEZyqOaKRTtcYmKSkJixYtwhtvvIE1a9ZEbt+0aRNKSkoGLBz+y1/+0uu266+/HqtXr8all14Kq9WqypiJaGBjc9NwprENp+paMaM4u9/7VZwJZWoLcuwwm4xTJDkuL7Tk+1Tt4Eu+613t8AVEWC0mLvUmihPVt5n97ne/i+uvvx733HMPVq1ahZ07d+LVV1/FH/7whx73mzZtGr7yla/gl7/8JQBg0aJFfT7fuHHj+v0ZEamvMCcNHx+qw6n6gZc8HzgRqq+ZMi4jDqOKH3nJ98naVkiSNGCd0en6ULZmdHYqTFEUGhPR8Kn+NWrBggXYsGEDPv30U3z729/Gq6++ivvvvx+rVq3qcb9gMAhRNPZcI5ERFIab1FXV9R/YSJKEAxWhwGZ6UVZcxhUvhTl2mAQBre1+NHs6B7yvvNy9YJT+mxMS6YXqGRsAuOCCC3DBBRcMeJ8jR44M+jzR3IeI1DU2J/QhfaaxDYGgCEsfKxVqmtrQ7OmExWzC5MKMOI9QXVaLGaNHpeJ0vReVda3ICndj7svpcFargPU1RHFjnIlvIoqLLIcNKTYLgqLU755J+8PZmsljnUhSuTFfIkwIT0cdq2oZ8H5dGRsGNkTxwsCGiIZEEASMDWcgTvWzZ5JRp6Fk08LHta+sqd/7BIIiasKBHzM2RPHDwIaIhqyrzqZ3w7lAUMSRyhYAwPQJxgxsZhRlQUCoR01/dTa1ze0IihJsSebI5qFEpD4GNkQ0ZOPzQ1Mx8sqn7spOu9DpD8KRao0EQEaTnpqE4vC+UfvKG/u8T6S+ZpRd0b3uiGhgDGyIaMjmTsqBxSzgVF0rKs/q5/L5sQYAwLQJWTAZ+AN9Zkmoh8/esr4Dm8rwDuDRbLtARMphYENEQ5aWYsXsiaMAADv210Rud3l9eG/3aQDAOVPzEjK2eJkVDmwOnGhC4Ky9cCRJwufH6gEYr48PkdYxsCGimCydMRoA8NHBWgTDPahe23ECPr+IotEOzJ7Yf1diIxiXlw5HqhWdviCOnWrp8bPTDV6caWyDxSxgzsScxAyQaIRiYENEMZlRnIX0VCvcXh8OVDShwdUeydZcdW6x4etKTIKAmeEtJfacNR2163AdgFDxdGpyXNqFEVEYAxsiionFbMKiaaHppufeOY7f/20PAkEJU8dnYppBV0Odbc6kUDbm/T3VPVZH7ToSmoZaMCU3IeMiGskY2BBRzOTpqNqmNtQ0tUEQgCvPLU7wqOJn7uRRKClwoNMXxN+2HAMQmoaqbvDCbBIwd9KoBI+QaORhjpSIYjY+Px03XzEdja4OZDmSUZibNqK67JoEAdddWIqfb/wEHx+qw5yJNTgarreZXpSF1GRrYgdINAIxsCGiYTH66qfBjM9Px8q5hXjnsyo8/srByO0LOQ1FlBAMbIiIhumrK4qw/0QTmtwdGJ2dipIxzhEf8BElCgMbIqJhSk224pc3LYIEGLopIZEeMLAhIlKAIAhgSEOUeFwVRURERIbBwIaIiIgMg4ENERERGQYDGyIiIjIMBjZERERkGAxsiIiIyDAY2BAREZFhMLAhIiIiw2BgQ0RERIbBwIaIiIgMg4ENERERGQYDGyIiIjIMBjZERERkGIIkSVKiBxFPkiRBFJU7ZLPZhGBQVOz5tIjHaAw8RmPgMRoDj3FoTCYBgiBEdd8RF9gQERGRcXEqioiIiAyDgQ0REREZBgMbIiIiMgwGNkRERGQYDGyIiIjIMBjYEBERkWEwsCEiIiLDYGBDREREhsHAhoiIiAyDgQ0REREZBgMbIiIiMgwGNkRERGQYDGyIiIjIMCyJHoAebN++Hf/85z+xZ88enDp1Ct/4xjdw991397qfz+fDH/7wB7z88svwer2YO3cufvazn6G4uLjH/crKynD//ffj888/h91uxxVXXIHbbrsNSUlJ8TqkqJSWlvb7sw8++AC5ubn93m/UqFHYvn27amNTyp133ol//etfvW5/4oknsGLFisi/oz23WhMMBvH000/jvffew/HjxyFJEkpLS/Ff//VfWLBgQY/76vU86uX9FK3XX38dL7/8Mg4cOAC3243x48fjm9/8Jq666ioIggAA+OY3v4mPP/6412M3bdqEkpKSeA95SP75z3/ixz/+ca/bb7rpJvzwhz+M/Pvvf/87nnzySVRXV6OoqAi33347zj///HgONWb9nR8A+P3vf4/LLrtMd+fw5MmTeOqpp7Bnzx4cO3YMxcXFePXVV3vdL5rz5vF48Ktf/Qpvv/02/H4/li9fjrvuuivymTJcDGyi8MEHH+Dw4cNYuHAhXC5Xv/e7//77sWnTJtx5553Iy8vDo48+ihtuuAGvvfYa0tPTAQAulwtr1qzBhAkTsGHDBtTW1uKBBx5AR0dHn8FSIv3tb3/rdduPfvQjpKSk9PoD/OY3v4nLL7888m+r1ar6+JQyduxY/Pa3v+1x29kXlmjOrRZ1dHTg8ccfx1e/+lXcdNNNMJlMeOGFF3D99dfjqaeewpIlS3rcX2/nUU/vp2g988wzKCgowJ133onMzEzs2LEDP/vZz1BTU4Nbbrklcr958+bhRz/6UY/HFhYWxnu4MXvyySd7vHfy8vIi//3aa6/hZz/7GW6++WYsXrwYmzZtwi233IL/+7//w5w5cxIw2qH5f//v/6G1tbXHbRs3bsSbb77Z4z2np3N47NgxvP/++5g9ezZEUYQkSb3uE+15u+2223D8+HHcc889sNls+OMf/4ibbroJL774IiwWBcISiQYVDAYj/33++edL9957b6/7nDlzRpo6dar0/PPPR25rbm6W5syZIz3++OOR2x599FFpzpw5UnNzc+S2559/Xpo6dapUU1OjzgEo5NSpU9LkyZOlJ554osftkydPlp588skEjWp4fvSjH0mXXXbZgPeJ9txqUSAQkFpaWnrddskll0hr167tcbsez6Oe30/9aWxs7HXbXXfdJc2bNy9yLbruuuuk73znO/EemiJefPFFafLkyX0ep+yiiy6S7rjjjh63XXvttdJ//ud/qj081axcuVK66aabIv/W2zns/jnY33UzmvP22WefSZMnT5Y++OCDyG1lZWVSaWmp9NprrykyVtbYRMFkGvzXtG3bNoiiiEsuuSRyW0ZGBpYuXYqtW7dGbtu6dSuWLFmCjIyMyG2rVq2CKIqaT/m/+uqrEAShxzf6kSDac6tFZrMZTqez122lpaWoq6tL0KiUo+f3U3+ysrJ63TZ16lS0traira0tASOKr1OnTuHEiRNYtWpVj9svvfRSfPjhh/D5fAkaWew+++wzVFVV4Utf+lKihxKzwT4Hoz1vW7duhcPhwNKlSyP3KS4uxtSpUxW7njKwUUh5eTmys7N7fYiUlJSgvLy8x/3OrstwOBzIycnpcT8teu2117Bw4ULk5+f3+tnjjz+O6dOnY8GCBbjttttQXV2dgBHG5uTJk5g/fz5mzJiBK6+8Em+//XaPn0d7bvUiEAhgz549fdYH6e086vn9NBSffvop8vLykJaWFrnt448/xpw5czBz5kxcd911+OSTTxI4wqG7/PLLMXXqVFxwwQV47LHHEAwGASBy3oqKinrcv6SkBH6/H6dOnYr7WIfr1VdfRWpqKi644IIet+v9HHYX7XkrLy9HUVFRpF5MVlxcrNh7ljU2CnG73X3WWjgcjh51OW63Gw6Ho9f9nE7ngPU7iXb48GEcPXoUP//5z3v97Ctf+QrOO+88jBo1CkePHsWf/vQnfP3rX8dLL73UKxjQmqlTp2LmzJmYOHEiPB4PnnvuOaxbtw4PPvhgJEMT7bnViyeffBK1tbW44YYbetyux/Oo1/fTUOzatQubNm3qUYuxcOFCXHHFFZgwYQLq6urw1FNP4cYbb8Szzz6LuXPnJnC0g8vJycGtt96K2bNnQxAEbNmyBX/84x9RW1uLu+++O3Lezj6v8r/1dl4DgQBef/11rFy5EqmpqZHb9XwO+xLteevveup0OrF//35FxjIiAxuPxxNVGn7s2LG6XVnRl+Ec9yuvvAKr1YqLL7641/1//etfR/574cKFmD9/Pq688kq88MILuOmmm4Y/8CEY6jGuWbOmx+0rV67E6tWr8dBDD/WYetKS4ZzH7du3Y8OGDfje976HGTNm9PiZls4jhdTU1OD222/HokWLcP3110du//73v9/jfueddx4uv/xyPPLII3jiiSfiPcwhWb58OZYvXx7597Jly2Cz2bBx40bcfPPNCRyZOrZv346mpqZeU/h6PodaNyIDm82bN+Ouu+4a9H5DWXbncDh6VcEDoei0+7ddh8MBj8fT634ul0v1b8WxHrckSdi0aROWL1/eo5ahP1OmTEFRUREOHDgwnOHGZLjn1mQy4aKLLsJvfvMbdHR0IDk5OepzGy+xHuOBAwdw66234vLLL++xuqY/iTyP0Urk+0ltbrcbN910EzIyMrBhw4YBaxxSU1Nx7rnn4o033ojjCJWzatUqPP300zh06FDkvHk8HuTk5ETu43a7AUB35/XVV19FRkYGli1bNuD99H4Ooz1vDocDNTU1vR6v5Ht2RAY211xzDa655hpFn7O4uBgNDQ29Ts7ZNQB9zSN6PB7U19er3hMl1uP+9NNPUV1djf/+7/9WYVTKSuS5jZdYjvHkyZO46aabMHfuXNx///0qjSz+Evl+UlNHRwfWrl0Lj8eDv/3tb5puKaA0+byd/f4qLy+H1WrF2LFjEzW0Ievo6MDbb7+NL3/5y5pvnTBc0Z634uJifPjhh5AkqUedTUVFBSZPnqzIWFg8rJBly5bBZDLhzTffjNzmcrmwbdu2Ho3eVqxYgR07dkSiWCD0DdxkMvWoEteSV155BampqVi5cmVU9z906BAqKiowc+ZMlUemPFEUsXnzZkyaNAnJyckAoj+3WlVXV4dvfetbGD16NB566KGoL7B6OI96fD8NJhAI4LbbbkN5eTmefPLJHv1d+tPW1ob33ntP0+dqIJs2bYLZbMa0adMwduxYTJgwAZs3b+51nyVLluiqPGDLli1oa2uLajWU3s9htOdtxYoVcLlc+PDDDyP3qaiowMGDBxW7no7IjM1QnT59Gvv27QMAtLe3o7KyMnLy5DqM/Px8XH311Vi/fj1MJhPy8vLw2GOPIT09HatXr4481+rVq/Hss89i3bp1WLt2LWpra7F+/XqsXr06qgtYvAUCAbzxxhv44he/GPmg7+6pp55CZWUlFi1ahKysLBw7dgyPPvoo8vPzFc+cKO306dO48847cdlll2H8+PFwuVx47rnnsH//fmzYsCFyv2jPrRZ1dHTgpptuQnNzM37605/i2LFjkZ8lJSVh2rRpAPR7HvX2forGvffei3fffRd33nknWltbsXv37sjPpk2bhr179+LJJ5/EhRdeiIKCAtTV1eHPf/4z6uvr8eCDDyZu4FH69re/jUWLFkU6Xb/zzjuRppHyFMatt96KH/7whxg3bhwWLVqETZs2Ye/evfjf//3fRA59yF555RWMGTMG8+fP73H7rl27dHcO29vb8f777wMIXTtbW1sjn4PnnHMOsrKyojpvc+fOxbJly/CTn/wEP/rRj2Cz2fCHP/wBpaWluOiiixQZqyBJfbQPpB76awEOAEeOHIn8t9x2/6WXXoLX68W8efNw11139arlKCsrw3333dejBfztt9+uyW8i7733HtauXYvHH38c5557bq+fb9myBY899hgqKirg9XqRmZmJFStW4LbbblOsPbZaWlpa8OMf/xgHDx5EY2MjrFYrZsyYge985zs9ihuB6M+t1lRVVfVaYiorKCjAli1bAOj7POrp/RSNlStX4vTp033+7J133kEwGMTPf/5zHDlyBC0tLUhJScHcuXNxyy23YNasWXEe7dDdf//9+OCDD1BTUwNRFDFhwgRcc801+OY3v9ljauLvf/87nnjiiUhr/jvuuEM3WyoAoazu0qVLsWbNml7T+CdPntTdORzoWvKXv/wFixYtAhDdeZO3VHjrrbcQCASwbNky3HXXXYp9GWFgQ0RERIbBGhsiIiIyDAY2REREZBgMbIiIiMgwGNgQERGRYTCwISIiIsNgYENERESGwcCGiIiIDIOBDRERERkGAxsiIiIyDAY2REREZBgMbIiIiMgw/j+77gk+/r5+wgAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "corr = signal.correlate(steer_la - steer_la.mean(), steerCommands - steerCommands.mean())\n",
+    "lags = signal.correlation_lags(100, 100)\n",
+    "print(lags[np.argmax(corr)])\n",
+    "\n",
+    "plt.plot(lags, corr)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.29559281990781294"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "corr[102]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Check data statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "\n",
+    "beta0s = []\n",
+    "beta1s = []\n",
+    "ssq_residuals = []\n",
+    "\n",
+    "numbers = random.sample(range(0, 20000), 200)\n",
+    "for number in numbers:\n",
+    "    # Load data\n",
+    "    datafile = f\"data/{str(number).zfill(5)}.csv\"\n",
+    "    df = pd.read_csv(datafile)\n",
+    "    t = df[\"t\"].to_numpy()[:100]\n",
+    "    vEgo = df[\"vEgo\"].to_numpy()[:100]\n",
+    "    roll_la = np.sin(df[\"roll\"].to_numpy()[:100]) * ACC_G\n",
+    "    target_la = df[\"targetLateralAcceleration\"].to_numpy()[:100]\n",
+    "    steerCommands = -df[\"steerCommand\"].to_numpy()[:100]\n",
+    "    steer_la = target_la - roll_la\n",
+    "\n",
+    "    # Fit model\n",
+    "    pred_la = vEgo ** 2 * np.sin(steerCommands)\n",
+    "\n",
+    "    beta1 = np.sum((pred_la - pred_la.mean()) * (steer_la - steer_la.mean())) / (np.sum((pred_la - pred_la.mean()) ** 2) + 1e-8)\n",
+    "    beta0 = steer_la.mean() - beta1 * pred_la.mean()\n",
+    "\n",
+    "    pred_la = pred_la * beta1 + beta0\n",
+    "    \n",
+    "    beta0s.append(beta0)\n",
+    "    beta1s.append(beta1)\n",
+    "    ssq_residuals.append(np.sum((pred_la - steer_la)**2))\n",
+    "\n",
+    "beta0s = np.array(beta0s)\n",
+    "beta1s = np.array(beta1s)\n",
+    "ssq_residuals = np.array(ssq_residuals)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(t, target_la)\n",
+    "plt.plot(t, steerCommands)\n",
+    "plt.plot(t, roll_la)\n",
+    "\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/ideas.md b/ideas.md
new file mode 100644
index 00000000..be5a84ff
--- /dev/null
+++ b/ideas.md
@@ -0,0 +1,8 @@
+### Gradualy introduce noises
+- Train model by gradually introducing noises.
+- Randomly use different types of noises to avoid model being trained to a specific type of noise.
+
+### Use smoother reward function (more robust to noise)
+- Reward can be noisy with control noise
+- Use smoother reward
+- Trace moving trajectory rather than directly using lat accel?
\ No newline at end of file
diff --git a/models/pytorch/VehicleStateModel.py b/models/pytorch/VehicleStateModel.py
new file mode 100644
index 00000000..1350641d
--- /dev/null
+++ b/models/pytorch/VehicleStateModel.py
@@ -0,0 +1,24 @@
+import torch.nn as nn
+
+class VehicleStateModel(nn.Module):
+    def __init__(self, input_size=5, hidden_size=5):
+        super(VehicleStateModel, self).__init__()
+        
+        self.model = nn.ModuleDict({
+            'lstm1': nn.LSTMCell(input_size=input_size, hidden_size=hidden_size),
+            'layer_norm1': nn.LayerNorm(hidden_size),
+            'lstm2': nn.LSTMCell(input_size=input_size, hidden_size=hidden_size),
+            'layer_norm2': nn.LayerNorm(hidden_size),
+            'linear': nn.Linear(hidden_size, hidden_size),
+            'relu': nn.ReLU()
+        })
+        
+    def forward(self, x):
+        lstm_out, _ = self.model.lstm1(x)
+        lstm_out = self.model.layer_norm1(lstm_out)
+        lstm_out, _ = self.model.lstm2(lstm_out)
+        lstm_out = self.model.layer_norm2(lstm_out)
+        x += self.model.relu(self.model.linear(lstm_out))
+        last_output = x[:, -1, :]
+        output = self.output_layer(last_output)
+        return output.squeeze(-1)
\ No newline at end of file
diff --git a/performance_exp.ipynb b/performance_exp.ipynb
new file mode 100644
index 00000000..38e0ad66
--- /dev/null
+++ b/performance_exp.ipynb
@@ -0,0 +1,287 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from pathlib import Path\n",
+    "from multiprocessing import Pool\n",
+    "from collections import namedtuple\n",
+    "from functools import partial\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ACC_G = 9.81\n",
+    "def load_data(data_path):\n",
+    "    df = pd.read_csv(data_path)\n",
+    "    data = {\n",
+    "      'roll_lataccel': np.sin(df['roll'].to_numpy()) * ACC_G,\n",
+    "      'v_ego': df['vEgo'].to_numpy(),\n",
+    "      'a_ego': df['aEgo'].to_numpy(),\n",
+    "      'target_lataccel': df['targetLateralAcceleration'].to_numpy(),\n",
+    "      'steer_command': -df['steerCommand'].to_numpy()  # steer commands are logged with left-positive convention but this simulator uses right-positive\n",
+    "    }\n",
+    "    return data\n",
+    "\n",
+    "def load_test(file_path, num_segs=5000, processes=1):\n",
+    "    data_path = Path(file_path)\n",
+    "    if data_path.is_file():\n",
+    "        data = load_data(str(data_path))\n",
+    "    elif data_path.is_dir():\n",
+    "        files = sorted(data_path.iterdir())[:num_segs]\n",
+    "        if processes <= 1:\n",
+    "            data = list(map(load_data, [str(file) for file in files]))\n",
+    "        else:\n",
+    "            with Pool(processes) as p:\n",
+    "                data = p.map(load_data, [str(file) for file in files])\n",
+    "\n",
+    "    return data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "State = namedtuple('State', ['roll_lataccel', 'v_ego', 'a_ego'])\n",
+    "FuturePlan = namedtuple('FuturePlan', ['lataccel', 'roll_lataccel', 'v_ego', 'a_ego'])\n",
+    "FUTURE_PLAN_STEPS = 50\n",
+    "\n",
+    "def get_state_target_futureplan(d):\n",
+    "\n",
+    "    return [(\n",
+    "        State(roll_lataccel=d['roll_lataccel'][step_idx], v_ego=d['v_ego'][step_idx], a_ego=d['a_ego'][step_idx]),\n",
+    "        d['target_lataccel'][step_idx],\n",
+    "        FuturePlan(\n",
+    "        lataccel=d['target_lataccel'][step_idx + 1:step_idx + FUTURE_PLAN_STEPS],\n",
+    "        roll_lataccel=d['roll_lataccel'][step_idx + 1:step_idx + FUTURE_PLAN_STEPS],\n",
+    "        v_ego=d['v_ego'][step_idx + 1:step_idx + FUTURE_PLAN_STEPS],\n",
+    "        a_ego=d['a_ego'][step_idx + 1:step_idx + FUTURE_PLAN_STEPS]\n",
+    "        )\n",
+    "    ) for step_idx in range(100)]\n",
+    "\n",
+    "def get_state_test(data, processes=1):\n",
+    "    if processes <= 1:\n",
+    "        data = list(map(get_state_target_futureplan, data))\n",
+    "    else:\n",
+    "        with Pool(processes) as p:\n",
+    "            data = p.map(get_state_target_futureplan, data)\n",
+    "    return data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "file_path_single = './data/00000.csv'\n",
+    "file_path_multi = './data'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = load_test(file_path_multi, num_segs=5000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rng = np.random.default_rng()\n",
+    "probs = np.random.rand(512, 1024)\n",
+    "probs /= probs.sum(axis=1, keepdims=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9.03 ms ± 161 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%timeit [rng.choice(1024, p = probs[i]) for i in range(512)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.98 ms ± 105 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%timeit (probs.cumsum(axis=1) > np.random.rand(probs.shape[0])[:,None]).argmax(axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([-1.0235, -1.0810])"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from torch.distributions import Normal\n",
+    "import torch\n",
+    "\n",
+    "dist = Normal(torch.tensor([0, 0.]), 1)\n",
+    "sample = dist.sample()\n",
+    "dist.log_prob(sample)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 1.,  1., -1.],\n",
+       "       [ 1., -1.,  1.]])"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = np.ones((2, 3))\n",
+    "a[0, 2] = -0.1\n",
+    "a[1, 1] = -0.1\n",
+    "a[a < 0] = -1\n",
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(4, 2)"
+      ]
+     },
+     "execution_count": 82,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = np.ones((4, 3, 2))\n",
+    "b = np.zeros((4, 2))\n",
+    "a[:, -1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[[0., 0., 0., 1., 0.]],\n",
+       "\n",
+       "       [[0., 0., 0., 1., 1.]],\n",
+       "\n",
+       "       [[0., 0., 0., 1., 2.]],\n",
+       "\n",
+       "       [[0., 0., 0., 1., 3.]]])"
+      ]
+     },
+     "execution_count": 78,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "d[:, None][:, :, -1] = np.array([0,1,2,3])[:, np.newaxis]\n",
+    "d[:, None]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[0] * 10"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/profile256.out b/profile256.out
new file mode 100644
index 00000000..f68b179e
Binary files /dev/null and b/profile256.out differ
diff --git a/requirements.txt b/requirements.txt
index ff7e4bf4..58606f4c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,3 +4,4 @@ pandas==2.1.2
 matplotlib==3.8.1
 seaborn==0.13.2
 tqdm
+scipy
diff --git a/sympy_exp.ipynb b/sympy_exp.ipynb
new file mode 100644
index 00000000..3853b338
--- /dev/null
+++ b/sympy_exp.ipynb
@@ -0,0 +1,292 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sympy as sp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "alpha = 1.2\n",
+    "x_0 = 0.1\n",
+    "r = [0.3, 0.35, 0.36]\n",
+    "W = [1, 0.7, 0.7]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define symbolic variables\n",
+    "m = 3  # Number of variables (you can change this)\n",
+    "u = sp.Matrix(sp.symbols(f'u1:{m+1}'))  # Creates a column vector [u1, u2, u3]\n",
+    "x = sp.symbols(f'x1:{m+1}')  # Creates symbols x1, x2, x3\n",
+    "lower_alpha = (alpha * sp.ones(3)).lower_triangular()\n",
+    "x_0 = sp.Matrix([x_0] * m)\n",
+    "r = sp.Matrix(r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_u = x_0 + lower_alpha * u\n",
+    "Ld = sum(W[i] * (r[i] - x_u[i]) ** 2 for i in range(m))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle \\left[\\begin{matrix}6.912 u_{1} + 4.032 u_{2} + 2.016 u_{3} - 1.3368\\\\4.032 u_{1} + 4.032 u_{2} + 2.016 u_{3} - 0.8568\\\\2.016 u_{1} + 2.016 u_{2} + 2.016 u_{3} - 0.4368\\end{matrix}\\right]$"
+      ],
+      "text/plain": [
+       "Matrix([\n",
+       "[6.912*u1 + 4.032*u2 + 2.016*u3 - 1.3368],\n",
+       "[4.032*u1 + 4.032*u2 + 2.016*u3 - 0.8568],\n",
+       "[2.016*u1 + 2.016*u2 + 2.016*u3 - 0.4368]])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Ld.diff(u)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle \\left[\\begin{matrix}6.912 u_{1} + 4.032 u_{2} + 2.016 u_{3} - 1.3368\\\\4.032 u_{1} + 4.032 u_{2} + 2.016 u_{3} - 0.8568\\\\2.016 u_{1} + 2.016 u_{2} + 2.016 u_{3} - 0.4368\\end{matrix}\\right]$"
+      ],
+      "text/plain": [
+       "Matrix([\n",
+       "[6.912*u1 + 4.032*u2 + 2.016*u3 - 1.3368],\n",
+       "[4.032*u1 + 4.032*u2 + 2.016*u3 - 0.8568],\n",
+       "[2.016*u1 + 2.016*u2 + 2.016*u3 - 0.4368]])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "upper_alpha = (alpha * sp.ones(3)).upper_triangular()\n",
+    "W_diag = sp.diag(W, unpack=True)\n",
+    "DuLd = 2 * upper_alpha * W_diag * (lower_alpha * u - r + x_0)\n",
+    "DuLd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Lj = sum(W[i] * (u[i] - u[i-1]) ** 2 for i in range(1, m))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle \\left[\\begin{matrix}1.4 u_{1} - 1.4 u_{2}\\\\- 1.4 u_{1} + 2.8 u_{2} - 1.4 u_{3}\\\\- 1.4 u_{2} + 1.4 u_{3}\\end{matrix}\\right]$"
+      ],
+      "text/plain": [
+       "Matrix([\n",
+       "[          1.4*u1 - 1.4*u2],\n",
+       "[-1.4*u1 + 2.8*u2 - 1.4*u3],\n",
+       "[         -1.4*u2 + 1.4*u3]])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Lj.diff(u)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def DuLjMat(i, j):\n",
+    "    if i == j:\n",
+    "        if i == 0:\n",
+    "            return 2 * W[i + 1]\n",
+    "        elif i == m - 1:\n",
+    "            return 2 * W[i]\n",
+    "        else:\n",
+    "            return 2 * (W[i] + W[i + 1])\n",
+    "    elif i - 1 == j:\n",
+    "        return -2 * W[i]\n",
+    "    elif i + 1 == j:\n",
+    "        return -2 * W[i + 1] \n",
+    "    else:\n",
+    "        return 0\n",
+    "    \n",
+    "Wj = sp.Matrix(3, 3, DuLjMat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle \\left[\\begin{matrix}0.128436014068963\\\\0.0724128683561799\\\\0.0390124908458912\\end{matrix}\\right]$"
+      ],
+      "text/plain": [
+       "Matrix([\n",
+       "[ 0.128436014068963],\n",
+       "[0.0724128683561799],\n",
+       "[0.0390124908458912]])"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sol = (2 * upper_alpha * W_diag * lower_alpha + Wj).solve(2 * upper_alpha * W_diag * (r - x_0))\n",
+    "sol"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle \\left[\\begin{matrix}1.94289029309402 \\cdot 10^{-16}\\\\2.22044604925031 \\cdot 10^{-16}\\\\5.55111512312578 \\cdot 10^{-17}\\end{matrix}\\right]$"
+      ],
+      "text/plain": [
+       "Matrix([\n",
+       "[1.94289029309402e-16],\n",
+       "[2.22044604925031e-16],\n",
+       "[5.55111512312578e-17]])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "subs_dict = {u[i]: value for i, value in enumerate(sol)}\n",
+    "(Ld + Lj).diff(u).subs(subs_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List, Tuple\n",
+    "import numpy as np\n",
+    "\n",
+    "def optimize_mpc(alpha: float, x_0: float, u_0: float, n: int, plan: List[float], W_d: List[float], W_j: List[float]) -> Tuple[List[float], float]:\n",
+    "    '''\n",
+    "    Model:\n",
+    "        dx = alpha * du\n",
+    "        x: state (lataccel)\n",
+    "        u: input (steer command)\n",
+    "\n",
+    "    Params:\n",
+    "        alpha: steer to lataccel coefficient\n",
+    "        x_0: initial lataccel\n",
+    "        u_0: last control\n",
+    "        n: size of prediction horizon, same as control horizon\n",
+    "        plan: lataccel targets for the length of prediction horizon\n",
+    "        W_d: Weights for deviation error\n",
+    "        W_j: Weights for jerk error (len n-1)\n",
+    "    \n",
+    "    Return:\n",
+    "        control: optimal control for the control horizon\n",
+    "        prediction: predicted future states following the optimal control\n",
+    "        obj: objective value for the optimal control\n",
+    "    '''\n",
+    "\n",
+    "    # Solve for minima of objective function using closed form solution to gradient\n",
+    "    upper_alpha = np.triu(alpha * np.ones((n, n)))\n",
+    "    lower_alpha = np.tril(alpha * np.ones((n, n)))\n",
+    "    W_j = np.array(W_j)\n",
+    "    d1 = -2 * W_j # Off diagonal of DuJ\n",
+    "    d0 = np.zeros(n)\n",
+    "    d0[: -1] += 2 * W_j\n",
+    "    d0[1: ] += 2 * W_j\n",
+    "    DuJ = np.diag(d0) + np.diag(d1, 1) + np.diag(d1, -1)\n",
+    "    plan = np.array(plan)\n",
+    "    W_d = np.array(W_d)\n",
+    "    A = 2 * upper_alpha @ np.diag(W_d) @ lower_alpha + DuJ\n",
+    "    b = 2 * upper_alpha @ np.diag(W_d) @ (plan - x_0)\n",
+    "    control = np.linalg.solve(A, b)\n",
+    "    prediction = x_0 + lower_alpha @ control\n",
+    "\n",
+    "    L_d = (W_d * (prediction - plan) ** 2).sum()\n",
+    "    L_j = (W_j * np.diff(control, n=1) **2).sum()\n",
+    "\n",
+    "    return control, prediction, L_d, L_j\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tinyphysics.py b/tinyphysics.py
index edb141bb..f02c3560 100644
--- a/tinyphysics.py
+++ b/tinyphysics.py
@@ -142,9 +142,11 @@ def sim_step(self, step_idx: int) -> None:
     self.current_lataccel_history.append(self.current_lataccel)
 
   def control_step(self, step_idx: int) -> None:
-    action = self.controller.update(self.target_lataccel_history[step_idx], self.current_lataccel, self.state_history[step_idx], future_plan=self.futureplan)
     if step_idx < CONTROL_START_IDX:
       action = self.data['steer_command'].values[step_idx]
+    else:
+      action = self.controller.update(self.target_lataccel_history[step_idx], self.current_lataccel, self.state_history[step_idx], future_plan=self.futureplan)
+
     action = np.clip(action, STEER_RANGE[0], STEER_RANGE[1])
     self.action_history.append(action)
 
diff --git a/viz.ipynb b/viz.ipynb
new file mode 100644
index 00000000..88690702
--- /dev/null
+++ b/viz.ipynb
@@ -0,0 +1,115 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib import pyplot as plt\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from scipy import signal\n",
+    "\n",
+    "ACC_G = 9.81"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datafile = \"data/00041.csv\"\n",
+    "\n",
+    "df = pd.read_csv(datafile)\n",
+    "t = df[\"t\"].to_numpy()[:100]\n",
+    "vEgo = df[\"vEgo\"].to_numpy()[:100]\n",
+    "aEgo = df[\"aEgo\"].to_numpy()[:100]\n",
+    "roll_la = np.sin(df[\"roll\"].to_numpy()[:100]) * ACC_G\n",
+    "target_la = df[\"targetLateralAcceleration\"].to_numpy()[:100]\n",
+    "steerCommands = -df[\"steerCommand\"].to_numpy()[:100]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGhCAYAAACphlRxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAACBZUlEQVR4nO3dd1iT1xcH8G8SCHsjIIiiOFDEAQjuiXuvqrXV2lo71KpY29pWrfpTO9Rqq63Vto7WbeseVVFRq6KC4AYVWbL3JpDc3x+vCVLZJnkzzud53qcS3rw5pJCc3HvuuQLGGAMhhBBCiJYQ8h0AIYQQQkhdUPJCCCGEEK1CyQshhBBCtAolL4QQQgjRKpS8EEIIIUSrUPJCCCGEEK1CyQshhBBCtAolL4QQQgjRKpS8EEIIIUSrUPJCCCGEEK2iluRl48aNcHNzg7GxMfz9/XH9+vUqz922bRsEAkGFw9jYWB1hEkIIIUQLqDx52bt3LwIDA7FkyRKEhYWhffv2GDhwIFJTU6u8j6WlJZKSkhRHbGysqsMkhBBCiJYQqHpjRn9/f3Tq1AkbNmwAAMhkMri6umL27Nn47LPPXjp/27ZtmDt3LrKzs+v1eDKZDImJibCwsIBAIHiV0AkhhBCiJowx5OXlwdnZGUJh9WMrBqoMRCKRIDQ0FAsXLlTcJhQKERAQgKtXr1Z5v/z8fDRp0gQymQze3t5YuXIlPD09Kz23pKQEJSUliq+fPXuGNm3aKO+HIIQQQojaxMfHo1GjRtWeo9LkJT09HVKpFI6OjhVud3R0xMOHDyu9T6tWrfD777+jXbt2yMnJwerVq9G1a1fcu3ev0h9m1apVWLp06Uu3x8fHw9LSUjk/CCGEEEJUKjc3F66urrCwsKjxXJUmL/XRpUsXdOnSRfF1165d0bp1a/zyyy9Yvnz5S+cvXLgQgYGBiq/lP7ylpSUlL4QQQoiWqU3Jh0qTF3t7e4hEIqSkpFS4PSUlBU5OTrW6hqGhITp27IjHjx9X+n0jIyMYGRm9cqyEEEII0Q4qXW0kFovh4+ODoKAgxW0ymQxBQUEVRleqI5VKcefOHTRs2FBVYRJCCCFEi6h82igwMBBTp06Fr68v/Pz8sG7dOhQUFGDatGkAgClTpsDFxQWrVq0CACxbtgydO3dG8+bNkZ2dje+++w6xsbGYPn26qkMlhBBCiBZQefIyYcIEpKWlYfHixUhOTkaHDh1w6tQpRRFvXFxchSVRWVlZePfdd5GcnAwbGxv4+PjgypUrtIKIEEIIIQDU0OdF3XJzc2FlZYWcnBwq2CWEEEK0RF3ev2lvI0IIIYRoFUpeCCGEEKJVKHkhhBBCiFah5IUQQgghWoWSF0IIIYRoFUpeCCGEEKJVKHkhhBBCiFah5KW2ZDJg1izg55/5joQQQgjRaxq3q7TG+usvYONGQCAA7OyA117jOyJCCCFEL9HIS22NGwd8+CHAGPDGG8DZs3xHRAghhOglSl5qSyAAfviBG3EpLQVGjQJu3OA7KkIIIUTvUPJSFyIRsGMHEBAAFBQAgwcDDx/yHRUhhBCiVyh5qSsjI+Dvv4FOnYCMDGDAACAhge+oCCGEEL1ByUt9WFgAJ04ArVoB8fFcApORwXdUhBBCiF6g5KW+7O2B06eBRo2ABw+AoUO5qSRCCCGEqBQlL6+icWPgn38AW1sgJAQYOxaQSPiOihBCCNFplLy8qjZtgOPHAVNTLpF56y2uoR0hhBBCVIKSF2Xo3JlrYmdgAOzeDcydy/WDIYQQQojSUfKiLIMGccuoAeDHH4EVK/iNhxBCCNFRlLwo06RJXCM7AFi0CNi0id94CCGEEB1EyYuyzZ7NJS4At53A/v38xkMIIYToGEpeVGHpUuC997i6l8mTaR8kQgghRIkoeVEFgYDbgXrcOG4fpNGjaR8kQgghREkoeVEVkQj480+gXz8gPx8YMgSIjOQ7KkIIIUTrUfKiSkZGwMGDgI8PkJ5O+yARQgghSkDJi6pZWAAnTwItWwJxccDAgbQPEiGEEPIKKHlRhwYNuH2QnJ2B+/eBYcNoHyRCCCGknih5UZcmTbgExsYGuHaNK+YtKeE7KkIIIUTrUPKiTp6e3D5IJibAqVPAqFFAURHfURFCCCFahZIXdevSBTh2jNvI8dQpmkIihBBC6oiSFz707cslLubmwLlz3L5Iubl8R0UIIYRoBUpe+NKjB3DmDGBlBVy+zC2jzs7mOypCCCFE41HywqfOnbmRF1tbICQE6NYNePqU76gIIYQQjUbJC9+8vYELF8qXUfv5cSMxhBBCCKkUJS+awMsLuH69vBNv377Atm18R0UIIYRoJEpeNIWLC3DxYvlmjtOmAZ9+CkilfEdGCCGEaBRKXjSJqSmwdy/w5Zfc199+C4wdy23sSAghhBAAlLxoHqEQWL4c2LmT29jx8GGge3cgPp7vyAghhBCNQMmLpnr9deD8ecDBAYiI4Ap5r1/nOypCCCGEd5S8aLIuXbiExcsLSE4GevUC9u/nOypCCCGEV5S8aLomTYB//+W2ESguBiZOBLZv5zsqQgghhDeUvGgDCwvg0CFgxgxAJgPeegvYvJnvqAghhBBeqCV52bhxI9zc3GBsbAx/f39cr2Xtxp49eyAQCDBq1CjVBqgNRCJg0ybgo4+4r997D/jhB35jIoQQQnig8uRl7969CAwMxJIlSxAWFob27dtj4MCBSE1NrfZ+MTEx+Pjjj9GjRw9Vh6g9BAJg3TpgwQLu6zlzgO++4zUkQgghRN1UnrysXbsW7777LqZNm4Y2bdpg06ZNMDU1xe+//17lfaRSKSZPnoylS5eiWbNmqg5RuwgEwDffAIsWcV9/8gm3tJoQQgjREypNXiQSCUJDQxEQEFD+gEIhAgICcPXq1Srvt2zZMjg4OOCdd96p8TFKSkqQm5tb4dB5AgGwbBmwYgX39eLFXGM7xviNixBCCFEDlSYv6enpkEqlcHR0rHC7o6MjkpOTK73P5cuX8dtvv2HLli21eoxVq1bByspKcbi6ur5y3Frj88+B1au5f69YwU0nUQJDCCFEx2nUaqO8vDy8+eab2LJlC+zt7Wt1n4ULFyInJ0dxxOtbJ9r584ENG7h/r1kDzJ7NrUgihBBCdJSBKi9ub28PkUiElJSUCrenpKTAycnppfOfPHmCmJgYDB8+XHGb7PkbsYGBASIjI+Hu7l7hPkZGRjAyMlJB9Fpk5kxALOZWIG3cCBQWAr/8Ahga8h0ZIYQQonQqHXkRi8Xw8fFBUFCQ4jaZTIagoCB06dLlpfM9PDxw584dhIeHK44RI0agT58+CA8P168pobp6911g61Zub6StW4HBg4GsLL6jIoQQQpROpSMvABAYGIipU6fC19cXfn5+WLduHQoKCjBt2jQAwJQpU+Di4oJVq1bB2NgYbdu2rXB/a2trAHjpdlKJqVMBW1tg0iQgKIjbXuD4ceA/o1WEEEKINlN58jJhwgSkpaVh8eLFSE5ORocOHXDq1ClFEW9cXByEQo0qvdFuw4cDly9z/42MBPz9gYMHAeqXQwghREcIGNOt5Sm5ubmwsrJCTk4OLC0t+Q6HP0lJwIgRwM2bXO3LunXABx9wy6wJIYQQDVOX928a8tBVDRsCwcHAuHFAaSlX1Dt2LNXBEEII0XqUvOgyU1Ng3z5g7Vpu9OXgQaBDB26XakIIIURLUfKi6wQCYN484OpVoHlzIC4O6NWLa2onlfIdHSGEEFJnlLzoCx8fICwMmDyZS1q+/BLo3x9ITOQ7MkIIIaROKHnRJxYWwB9/ANu2AWZmwPnzQPv23HJqQgghREvQaqNaksoYZuy4Ce8mNujRwh5tna0gFNZ95U6pVIbT91Jw51kOikulKCmTorhUBqmM4Y3OTeDX1FZpMVcrMpLrB3PrFvf13LnAypWAiYl6Hp8QQsjLUlO5D5p6+Fpcl/dvSl5qKSI+GyM3lhe62pqJ0b25Pbo1t4OztQlsTMWwNeMOY0PRS/fPKSzF7htx2H4lBkk5xZU+hqutCc7P7w0DkZoGxEpKgE8/Bdav5752cADmzOGWVNvYqCcGQgjRV4xxHyQvXeKOixeB2FjA2Bjo2xcYOpQ7mjThO1K1oORFBclLRn4JTtxNxqWoNFx5koH8krIqzzUTi+BoZYyGVsZwtDSGAAKcuJOEolKuQNbeXIzBbRvCwtgAxoYiGBsK8UtwNDIKJFg3oQNGdXRRWty1cuwYt5Q6Lo772twcmDGDK/Rt1Kj+15VKuT4zqanAgAGAvu9BRQghcs+eAW++yU3f18TTExg2jGs+2rkzIHr5A7IuoORFxU3qSqUy3IrLxqVHaQiLy0JGvgRZhRJkFkhQKq366fRwssA73ZtiRAdnGBlU/OXbeP4xvvsnEq0cLXByTo96TUm9ktJSYO9e4NtvgTt3uNsMDLgC3wULuD+e2sjIAP75Bzhxgvtvejp3e/Pm3JLtYcOoUR4hRL8dP85t55KRwW2q26UL1wW9Z08uOYmJ4c45fhy4cgV4vkExAMDODhgyhBshr2SPQG1GyQtPHXYZY8gvKUNaXgmSc4uRnFOM5Nxi5BSVoleLBujibgdBFW/cOUWl6Pb1OeSXlGHLFF/0b+Oo1tgVGANOnQK++YZrcic3bBjwySdAt27c5o8viooCDh8Gjhx5+Q/N0pIbcUlL474eOJDr9uvhofIfhRBCNIpEAnz2GfD999zX3t7Anj1AixZV3yczk3tNPnYMOHkSyM7mbjcyAm7cALy8VB62ulDyoqXbA3xz6iF+vvAEHVytcfDDrlUmOmoTEsKNxBw8yCU1AJe42NgA9vbckZbGJS8vateO+2QweDD3yaC4mOsr8/333B+vgQEwaxawZAnwfONNQgjRaY8fc4skbt7kvp4zh/uQWJfp9LIy7gPikiXAhQvciPiNGzpT3EvJi5YmL2l5Jej+zTmUlMmw611/dHW35zskTlQUsHo1sGMHV+T7X4aGQJ8+3F5Kw4cDjRtXfp3Hj4H587kRGgBo0IBLat5+W2fncAkhBLt3A++9B+TlAba2wNat3OtlfaWmch8SU1K4esUNG5QXK48oedHS5AUAFh++ix1XY9G9uT3+nO7PdzgVSSTcHG1GBlfLkpHBjaL06cNND9XWP/9wS7MfPuS+7tgR+OEHoHt3lYRNCCG8KCjgRlh++437unt3YNcuwNX11a/9zz/AoEHcv48e5ab2tRxtzKjF3u3RDCKhAJcfpyMiPpvvcCoSi7kNH9u2BXr35jZ6HDmybokLwNW93L7NTSNZWXG9Znr04EZgMjNVEjohhKjVvXtAp05c4iIQAIsWcSuLlJG4ANzraGAg9+9p04CkJOVcV0tQ8qJhXG1NMbKDMwDgpwuPeY5GhQwNudGXR4+Ad9/l/ri3bgVat+Y2k9StAUFCiD7JzAT69QMePOA+8AUFAcuWcSPVyrRyJbfZbno68NZbFRdL6DhKXjTQh73dIRAA/9xLwePUPL7DUa0GDYDNm4HLl7nEJTUVmDCBmw+Oj+c7OkIIqbvAQK4excMDCA/nptZVwciIm4YyMQFOny5fxaQHKHnRQM0dLBDQmlsqve1KDL/BqEvXrtz00VdfcaMyx45x01N//EGjMIQQ7XH6NLB9Ozea/PvvXOdyVWrdmms/AQALF5Zv+aLjKHnRUNO6ugEA/g57htziUn6DURcjI24JYHg4t8Q6NxeYMoUbiaFaGEKIpsvP51YVAVw7CHU1kXv3XWD0aK7Z6Ouvc4XCOo6SFw3Vxd0OLR3NUSiRYv/NBL7DUa82bbg9Pv73P26OeP9+rhHTmTN8R0YIIVVbtIjrjtu4MVePoi4CAbBlC+DszK3ilBfy6jBKXjSUQCDAlC5uAIA/rsZAJtOzqRMDA+CLL4CrV4FWrYDERG5/pLlzgaIivqMjhJCKQkLKN7n95Rdujzh1srPjptkFAq6O8O+/1fv4akbJiwYb3dEFFsYGiMkoRHBUGt/h8MPXFwgLAz78kPt6/Xpu+WFEBL9xEUKInEQCTJ/O1ee98UZ5/xV169uX28YF4OJJ0N1Re0peNJiZkQFe8+V6AuhN4W5lTE2BjRu5TcocHcv7J3z3HbdzNSGE8Ombb4C7d7ktU/he8bNsGeDjA2RlcbtW6+hrJCUvGm5KlyYQCIDgqDREp+XzHQ6/hgzhdrweOZIrTPvkE6B/f25JIiGE8OHhQ64+D+BGhu153tZFLOaWT5uZcfsfrVnDbzwqQsmLhmtiZ4a+rbildjuuxvIcjQZo0IDbKHLLFu6P8/x5bmopNJTvyAgh+kYmA2bM4KaNBg/mNl7UBC1bltfffPmlTi6fpuRFC0x9vmz6QGgC8kvK+A1GEwgE3HzuzZtcMW9CArdnyM6dfEdWs5s3gcWLuU9GerCckRCd9uuvwKVL3NT2Tz9xr02a4u23gVGjuFHqyZOBwkK+I1IqSl60QPfm9mjWwAz5JWX4K1R3C7DqzMODq/AfOhQoLuYK5ebP57aN1yTFxVzTKn9/rlZn+XLuxcTBgfvviRPcCwwhRHskJZUXx/7vf4CbG6/hvES+fNrJidum4NNP+Y5IqSh50QJCoQBTny+bXnsmSvM2bOSTlRVw+DC3rBoA1q7lhm8zMviNC+C2N/jsM6BRI27fkevXufno0aMBd3fuk9CuXVzy5ezMbW1/5Qp1FCZEG8yeDeTkcNPWH33EdzSVs7cHtm3j/r1hA3DyJK/hKJOAMd16pazLltrapLhUite3XENYXDbMjQzw+1ud4NfUlu+wNMuBA1ySUFAANG3KJTVeXuqNgTGuN8369cBff5VX+jduDLz/PvDOO9yIC2NcMrNzJ7B3L7enk5ybG9clc9o0oHlz9cZfHZmMm9uv6SgtrXiUlZUfUin3X5ms/JBKuVVknTtzm9gRoukOH+amZEQirt6ufXu+I6renDnADz9wf2d37nC1gxqoLu/flLxokYKSMryz/QauRWfC2FCIX6d0QvcWPFe2axr5aqSnT7mC3m3bgHHjVP+4jHGfar76Crhxo/z23r25F45hw6reUbasjNt1dudOrhg5//mqMoGA26AyMBDo0YOf+XSJhOtwvH59xZ9LVRo35qbXOnfmjo4duU3nCNEUT55wNXbJydxUzNdf8x1RzYqKuCnre/e418eDBzWrPuc5Sl50NHkBuBGY9/8MxYXINIgNhPjpdW8EtHHkOyzNkpEBTJwInD3Lfb1woWq2o5eLiOBqbYKCuK+NjLhaljlzgHbt6natwkLg6FGuRubFIV4fHy6JmTCB+7SnaunpXJfQjRu5uf3KiETczyoWlx+GhpUfIhH3/BsYcP8WiQChkDsEAiA6muuTIZNVfAwDA6BDBy6h6dmTWy6v7s6lhMjFxnK/h3FxgKcnl9BrS3IdEcElMKWl3IaR06bxHdFL6vT+zXRMTk4OA8BycnL4DkVlikvL2Hs7brImnx5j7guPs4NhCXyHpHlKSxmbP58xbkyEMR8fxiIilPsYz54xNm0aYwIB9xhiMWMff8xYaqpyrv/gAWMzZjBmbFz+c7Rty9iJE4zJZMp5jMoe8733Kj6mkxNjy5czFhvLWE4OY0VFjEmlyn/s3FzGzp1jbNUqxkaMYMzRsTwG+WFiwti4cYzt28dYfr7yYyCkKvHxjDVrxv0etmzJWFIS3xHV3ddfc/GbmzMWHc13NC+py/s3JS9aqrRMyubuucWafHqMNfn0GPv5wmMmU9UbmjbbvZsxa2vuD9bQkLGvvmKspOTVrimTMbZpE/cCIH9TnTBBdS8GqamMLV1a/nMAjPXty1hoqHKuL5MxFhTE2NChFRMFb2/G/vjj1Z+vV4krJoaxPXsYmzuXMXf3ivGZmnLJXVQUP/ER/ZGYyCUsAJfAJGjpB8ayMsa6d+d+ju7dua81CCUvepC8MMaYVCpj/zt2T5HALDl8l5VJKYF5SWIiYyNHlr/ptWvH2JUr9btWbCxj/fuXX8vfn7GrV5UabpUyMrjRJLG4/PFff52xJ0/qfq2SEi5hCQwsf1EGuFGkkSMZCw5W3ehOfclkXML26aeMNW1aMeZx4xi7cYPvCIkueviQsTZtuN+1xo25hFqbRUeXf/D65hu+o6mAkhc9SV7ktlx8okhgPvjzJiuSaFY2rRFkMm4Uxs6u/E1vwADGLl+u/f03b2bMwoK7r7ExY2vX8vPJ5elTxiZPLv85DA0ZmzWLsZSUl8+Vybjk7dIlxrZvZ2zJEsbGjmXM0vLlUYyZM7VnFEMm4xKs/44W9e3L2MmTmpd4EfUoKmLs7FnGFi7kPli4uTH2/vvcdGRd/lYLChjbsYOxnj3Lf7dcXOr3QUET/fZb+WtHeDjf0ShQ8qJnyQtjjB0Jf8ZafH6CNfn0GBv/8xWWVcDTUL+mS0lh7O23GROJyl+U+vXj3girEhfH2MCB5ed37cpYZKT6Yq5KaCiXgMnjMjNjbN48xubMYWzYMO7ToonJy3Uj8qNBA8beeoux/fu5WhZtdecOY2++yZiBQfnP5uXFJWt8TXkR9Xr6lLEhQxgzMqr6993RkbEPP2Ts/PmqE5nQUMY++IAxK6vy+wmF3N/To0dq/IFUTCYrH41u25ZL+jRAXd6/abWRDrnyJB3v7QhFXkkZmjuYY9u0TmhkY8p3WJrp6VNg1Spg69byjrzdunFN5YYM4VbBMMZV5QcGArm5gLExsGIFt4pIHSt+auvcOW7J5s2blX9fKOSWIDdrxjXHc3cH+vThmmsJdahPZVwcsG4d11VUvtzcxYX7/2ppyTU0tLQs/7f8aysr7v/ti6ujDAy4/jPyvjQv/ld+CIVA69bas9pEV925AwwcWL4qztkZ6NcP6Nu3fC+0v//mdlmWc3TkWiiMH8/1gtqzh2v1/+IeQE2bcn2Z3nqL+z3SNamp3M+emsq9xmnABo60VFpPkxcAeJici2lbbyAppxgNLIyw9a1OaOtixXdYmis2tjyJkUi42zw9gblzuSZzp05xt3Xpwp3TqhVvoVaLMa5J37Fj3Atzs2blyYqrK7eMWV9kZwObNnG9aZKTVftYhoZcEti9O3d06wbY2an2MUm5y5eB4cO5/+dt23Idq9u2fbmHSWkp18pg3z7g0KGKicyLxGJgzBguaenbV7eS+8ocO8Y9fwDXWqJfP17DoeRFj5MXAEjKKcK0rTfwMDkPpmIRNk72Rp/nO1OTKiQlcZ/af/4ZyMsrv93IiNu3ZN48zRptITUrKQGOH+c27szN5Vq5v/hf+b9zcrj9p/7bFfi/vWnk/xUKuf8WFVW+DUWbNuXJTPfuXMdkDWwIpvWOHOH6HhUXc8/zkSOAjU3N95NIuERm/35uVEae+Lz7LtefSd+Szw8+4JJ9Fxfg9m3Alr/O7ZS86HnyAgC5xaX48M8wXH6cDqEA8GliA58mtvBtYgOfJjawMdOjT+J1kZ3NJTAbNnAjF1u2cBtAEvJfjHHTj5cvc8elS8DDhy+fZ2HBjdh5eHBHs2bcG6Stbflhaan7n/KVaetWLtmQSrmRg7176zd9J5EAKSnc/mP6mmAWFADe3kBUFDeNtncvb88FJS+UvAAAJGUyfHHwDvZXshP1UK+G+GFSR4iEevoHS4gqpKcD//5bntDcvFm7Xc6FQm7UwMamPKGxs+M21rOzKz9e/LpBA65WR1sUFgJnzgDPnpWX0QLc1FufPkDLljVfgzHg22+52jSAq0fZskV13bP1xY0bQNeu3O/qjh3Am2/yEgYlL5S8VPA0vQA3YjIRGpOFm7GZeJJWAADY9IY3BrWljfAIUZmSEm4vnIcPuSMykquzysoCMjO5o7CwftcWCLhRHC8vbtrDywvw8+OmqTRFbi43dffXX9x2F9X9rO3acZ/8x4+vvLZMJgM+/hj4/nvu608+4fYV0tcRE2X73/+ARYu4kcLbt3n5PdK45GXjxo347rvvkJycjPbt2+PHH3+En59fpef+/fffWLlyJR4/fozS0lK0aNEC8+fPx5u1zAQpeanZmtOR+PHcY7RvZIVDM7tBQH/8hPCnuJhLZl5MaDIyyo/09Mr/XdWITosWwKBB3Aqc3r25DUrVKSuLqz/56y/g9GkugZNzc+OmKASC8iMjA7h4seLP4+XFFc6OHcslZmVlwNtvA3/+yX1/zRpuhQxRnrIyoFcv4MoVbnXi9u3c748aaVTysnfvXkyZMgWbNm2Cv78/1q1bh/379yMyMhIODi8XkV64cAFZWVnw8PCAWCzGsWPHMH/+fBw/fhwDBw6s8fEoealZRn4Jun1zDsWlMuya7o+uzWlnakK0CmNAWhq3meXdu9xy4YgIICyMqwORE4u5YtaBA4EBA7jRDWXW1shkQHw88OgRN7J07BhXDPtiItKyJbcseexYbpfwyj4sZWQAhw9zRbRnz1a8v7s7N012/To3PfT777xNa+i8mBhuxVF0NPf1vHnAypVqm57UqOTF398fnTp1woYNGwAAMpkMrq6umD17Nj6Tz1vWwNvbG0OHDsXy5ctrPJeSl9pZfPgudlyNRY8W9vjjHX++wyGEKENODtf3559/uGX+sbEVv+/oyE0tNWjA1c/ID3k9jfwwNeVGTORHYSHXR+fxY24a7PFjLmF58qTiyIpc27blCYunZ92mdjIzuSTo77+5n6O4mLvdxIQbzRk8uP7PD6lZXh43Pbd5M/d1mzZcHYyPj8ofWmOSF4lEAlNTUxw4cACjRo1S3D516lRkZ2fj8OHD1d6fMYZz585hxIgROHToEPr371/jY1LyUjvxmYXovfoCpDKGY7O7Uy8YQnQNY9wKktOnueP8eW5libIZGnK1N82bc0Wf48bVrvi2NvLzuSQsOBiYOpXrqUPU48QJrt9NcjI34rVoEfD55yotjq7L+7dKS7TT09MhlUrh6OhY4XZHR0c8rGxJ4XM5OTlwcXFBSUkJRCIRfvrppyoTl5KSEpS8kPnn5uYqJ3gd52priuHtGuJQeCJ+Dn6Cja978x0SIUSZBAKu8LVVK2D2bG6E5OpVrmg4Pb28fiYtrWI9zX9fQ8VibtrAxYVLUOSHuztXX9O4sere0MzNuWRo3DjVXJ9UbcgQbkrygw+46bwlS7ji6x07NKJZp0auL7OwsEB4eDjy8/MRFBSEwMBANGvWDL0rKR5atWoVli5dqv4gdcD7vd1xKDwRJ+8kISa9AG72ai7sI4Soj5ERV4BZUxGmRMI14DMy4hIX6j+jv+zsuL4vo0YBM2dydUcdOnDL1WfO5PV3Q6WPbG9vD5FIhJSUlAq3p6SkwMnJqeqghEI0b94cHTp0wPz58zFu3DisWrWq0nMXLlyInJwcxREfH6/Un0GXeThZok+rBpAxYPOlaL7DIYRoArG4fL8nSlyIQAC8/jo3CjNgAFeD9NFH3L+zs3kLS6W/mWKxGD4+PggKClLcJpPJEBQUhC5dutT6OjKZrMLU0IuMjIxgaWlZ4SC190Hv5gCAAzcTkJpbzHM0hBBCNJKLC1d/tHEjVzwtlXKdoXmi8mmjwMBATJ06Fb6+vvDz88O6detQUFCAadOmAQCmTJkCFxcXxcjKqlWr4OvrC3d3d5SUlODEiRP4448/8PPPP6s6VL3UyY3bLiA0Ngtfn3qINePbU98XQgghLxMIgA8/BPr356YVeRyZU3nyMmHCBKSlpWHx4sVITk5Ghw4dcOrUKUURb1xcHIQvPAEFBQX48MMPkZCQABMTE3h4eODPP//EhAkTVB2qXhIIBPh4QCtM/vUa/g57hjYNLTG9RzO+wyKEEKKpWrTgOwLaHoBwfr/8FMuO3YdAAPw6xRf9WjvWfCdCCCFESery/k3VWAQAMK2bGyb5NQZjwEe7b+FhMi05J4QQopkoeSEAuOmjZSM90bmZLQokUryz7SbS8ysvkiaEEEL4RMkLUTAUCfHzZB+42ZniWXYR3v8jFDKZTs0qEkII0QGUvJAKbMzE+HVqJxgbCnEzNgsPk/P4DokQQgipgJIX8pLmDuZo3ZArlorJUMFeKIQQQsgroOSFVKqpHbdVwNN0Sl4IIYRoFkpeSKXk+xxR8kIIIUTTUPJCKtWUkhdCCCEaipIXUil58hJDyQshhBANQ8kLqZR82iijQIKcolKeoyGEEELKUfJCKmVuZIAGFkYAaPSFEEKIZqHkhVRJvuKIlksTQgjRJJS8kCrJ616i0yh5IYQQojkoeSFVkte90MgLIYQQTULJC6kSrTgihBCiiSh5IVVSTBulF4Ax2qCREEKIZqDkhVSpiZ0pACCvuAyZBRKeoyGEEEI4lLyQKhkbiuBibQKAOu0SQgjRHJS8kGq52XOjL5S8EEII0RSUvJBqNaUVR4QQQjQMJS+kWm52tEEjIYQQzULJC6lW+e7ShTxHQgghhHAoeSHVerHXCy2XJoQQogkoeSHVcrU1hUgoQFGpFCm5JXyHQwghhFDyQqpnKBKikQ0tlyaEEKI5KHkhNSqve6HkhRBCCP8oeSE1kq84ouXShBBCNAElL6RGzRrQyAshhBDNQckLqRH1eiGEEKJJKHkhNZLXvMRlFEIqo+XShBBC+EXJC6mRs7UJxCIhJFIZErOL+A6HEEKInqPkhdRIJBSgsR1t0EgIIUQzUPJCaoU2aCSEEKIpKHkhtSJPXqLTKHkhhBDCL0peSK3IVxzF0sgLIYQQnlHyQmrF2doYAJCUU8xzJIQQQvQdJS+kVpytuf2NKHkhhBDCN0peSK00tOJGXnKKSlEoKeM5GkIIIfqMkhdSKxbGhjA3MgAAJGbT6AshhBD+UPJCak0++pKUQ43qCCGE8IeSF1JrDanuhRBCiAag5IXUmrN85IWmjQghhPBILcnLxo0b4ebmBmNjY/j7++P69etVnrtlyxb06NEDNjY2sLGxQUBAQLXnE/VxomkjQgghGkDlycvevXsRGBiIJUuWICwsDO3bt8fAgQORmppa6fkXLlzApEmTcP78eVy9ehWurq4YMGAAnj17pupQSQ2crbhpo0SaNiKEEMIjAWOMqfIB/P390alTJ2zYsAEAIJPJ4OrqitmzZ+Ozzz6r8f5SqRQ2NjbYsGEDpkyZUuP5ubm5sLKyQk5ODiwtLV85flLu0qM0vPnbdbR0NMfpeb34DocQQogOqcv7t0pHXiQSCUJDQxEQEFD+gEIhAgICcPXq1Vpdo7CwEKWlpbC1ta30+yUlJcjNza1wENVo+HzkhWpeCCGE8EmlyUt6ejqkUikcHR0r3O7o6Ijk5ORaXePTTz+Fs7NzhQToRatWrYKVlZXicHV1feW4SeXkS6XzSsqQV1zKczSEEEL0lUavNvr666+xZ88eHDx4EMbGxpWes3DhQuTk5CiO+Ph4NUepP8yMDGBpzDWqo+XShBBC+GKgyovb29tDJBIhJSWlwu0pKSlwcnKq9r6rV6/G119/jbNnz6Jdu3ZVnmdkZAQjIyOlxEtq5mxtgtzkPCTlFKOlowXf4RBCCNFDKh15EYvF8PHxQVBQkOI2mUyGoKAgdOnSpcr7ffvtt1i+fDlOnToFX19fVYZI6kjRZTeblksTQgjhh0pHXgAgMDAQU6dOha+vL/z8/LBu3ToUFBRg2rRpAIApU6bAxcUFq1atAgB88803WLx4MXbt2gU3NzdFbYy5uTnMzc1VHS6pgRMtlyaEEMIzlScvEyZMQFpaGhYvXozk5GR06NABp06dUhTxxsXFQSgsHwD6+eefIZFIMG7cuArXWbJkCb766itVh0tqIO+ym0yN6gghhPBE5ckLAMyaNQuzZs2q9HsXLlyo8HVMTIzqAyL1RvsbEUII4ZtGrzYimkc+8pJINS+EEEJ4QskLqZPy/Y2KoeLmzIQQQkilKHkhdSLvslsokSK3uIznaAghhOgjSl5InZiIRbAxNQRAu0sTQgjhByUvpM5ojyNCCCF8ouSF1Jmz9fOiXRp5IYQQwgNKXkidOSl6vdDICyGEEPWj5IXUmXzaKJGmjQghhPCAkhdSZ/JpIyrYJYQQwgdKXkidKQp2adqIEEIIDyh5IXWm2Fk6p4ga1RFCCFE7Sl5InckLdotLZcguLOU5GkIIIfqGkhdSZ0YGItibiwHQcmlCCCHqR8kLqRdqVEcIIYQvlLyQelFs0JhLyQshhBD1ouSF1IuzPHnJpmkjQggh6kXJC6mXhta0XJoQQgg/KHkh9fLicmlCCCFEnSh5IfVCjeoIIYTwhZIXUi/lIy/F1KiOEEKIWlHyQurFycoYAgEgKZMho0DCdziEEEL0CCUvpF4MRUI0MDcCQL1eCCGEqBclL6TemtiZAgAep+XxHAkhhBB9QskLqTdPZysAwN1nuTxHQgghRJ9Q8kLqra2LPHnJ4TkSQggh+oSSF1JvbV0sAQD3EnMhk9GKI0IIIepByQupt+YNzGFkIER+SRliMwv5DocQQoieoOSF1JuBSIjWDbnRF5o6IoQQoi6UvJBXIp86uptIyQshhBD1oOSFvJK2zlS0SwghRL0oeSGvpHzFUS5tE0AIIUQtKHkhr6SlowUMRQLkFJUiIYt2mCb6ITQ2EyM2XMalR2l8h0KIXqLkhbwSsYEQrZwsAAD3qO6F6IlfgqNxOyEHs3ffQkoubY9BiLpR8kJembzu5Q7VvRA9UFwqxeXH6QCA7MJSfLw/gvocEaJmlLyQV/Zi3Qshui7kaSYKJVLYmBrC2FCIS4/S8fu/T/kOixC9QskLeWUvbhNARbtE1517kAIAGNS2Ib4c2gYA8O2pSNxPpOSdEHWh5IW8Mg8nC4iEAmQUSJCSW8J3OISoDGMMQQ9TAQD9PBww2b8xAlo7QCKVYe7eWygulfIcISH6gZIX8sqMDUVo4WAOgOpeiG57lJqPhKwiGBkI0a25PQQCAb4Z2w725kaISsnHqhMP+A6REL1AyQtRCk9qVkf0QNADbtSlq7sdTMQiAICduRFWj28HANh+NRYn7yTxFh8h+oKSF6IUXoodpil5Ibrr3EOu3qVva8cKt/du5YAZPZsBAD7eH4HHqXlqj40QfULJC1EKedEuTRsRXZVVIEFobBYAoK+Hw0vf/2RgK3RuZosCiRTv/RGK/JIydYdIiN6g5IUoReuGlhAIgJTcEqTmlTftuvwoHd+fiUJOYSmP0RHy6oKj0iBjXIG6i7XJS983EAnx4yRvOFka40laARbsj6DVd4SoiFqSl40bN8LNzQ3Gxsbw9/fH9evXqzz33r17GDt2LNzc3CAQCLBu3Tp1hEhekZmRAZrZmwEA7iXmIjW3GLN2heGN30KwPugRJm25hswCCc9RElJ/ilVGrV8edZFrYGGEn97whqFIgJN3k7H5YrS6wiNEr6g8edm7dy8CAwOxZMkShIWFoX379hg4cCBSU1MrPb+wsBDNmjXD119/DScnJ1WHR5TI6/nU0c8XnqDfmmAcu50EoQCwMDbA/aRcTNx8tcKoDCHaolQqQ3Ak95rV18Ox2nO9G9tg8XBPAMA3px7iyvNuvIQQ5VF58rJ27Vq8++67mDZtGtq0aYNNmzbB1NQUv//+e6Xnd+rUCd999x0mTpwIIyMjVYdHlEhe93L9aSbySsrQvpEVjszqjkMzu8HJ0hhRKfmY8Ms1JGbTBo5Eu4TGZiG3uAy2ZmJ0cLWu8fw3/BtjrHcjyBgwZ284MvKp/xEhyqTS5EUikSA0NBQBAQHlDygUIiAgAFevXlXKY5SUlCA3N7fCQfjh39QOAGBhZIDlIz3x94fd0NbFCu4NzLHvvS5wsTbB0/QCvPbLVcRlFPIcLSG1d+75lFHvlg0gEgpqPF8gEOB/o9qihYM50vJK8DHVvxCiVCpNXtLT0yGVSuHoWHGY1dHREcnJyUp5jFWrVsHKykpxuLq6KuW6pO68Glnh2OzuCP6kD97s4lbhRb6xnSn2vd8FbnamSMgqQv/vg7FgfwT1hSFaIeiBfIl01fUu/2UiFuHH1ztCbCDE+cg0bP03RkXREaJ/tH610cKFC5GTk6M44uPj+Q5Jr7V1sYKtmbjS77lYm2Dfe13g3dgaJWUy7A9NwLAfL2Psz1dwJCKRPpkSjZSaV4wnaQUQCoAeLRrU6b4eTpZYNLQ1AODrkw8pWSdESVSavNjb20MkEiElJaXC7SkpKUorxjUyMoKlpWWFg2guB0tj/PVBV/z1QReMaO8MA6EAobFZ+Gj3LWw495jv8Ah5SXwmN8XZ0MoEViaGdb7/G52boH8bR0ikMny0+xYKqP8LIa9MpcmLWCyGj48PgoKCFLfJZDIEBQWhS5cuqnxoosEEAgF8mtjih0kdceWzvni3R1MAwI/nHyMmvYDn6AipKCGLKzBvZPNyb5faEAgE+HZsOzhZGiM6vQBLj95TZniE6CWVTxsFBgZiy5Yt2L59Ox48eIAPPvgABQUFmDZtGgBgypQpWLhwoeJ8iUSC8PBwhIeHQyKR4NmzZwgPD8fjx/SpXBc5WBrj8yGt0b25PSRlMiw+co+mj4hGKU9eTOt9DRszMdZN7ACBANh3MwF7b8QpKzxC9JLKk5cJEyZg9erVWLx4MTp06IDw8HCcOnVKUcQbFxeHpKTyjcwSExPRsWNHdOzYEUlJSVi9ejU6duyI6dOnqzpUwhOBQIBlIz0hFglxMSoNJ+8qp5ibEGVIyOKmjeo78iLXuZkd5gW0BAB8eeguQmMzXzk2QvSVgOnYx9zc3FxYWVkhJyeH6l+0zNrTkfjh3GM4WRrj7PxeMDcy4DskQvDGryG4/Dgdq8e3xzifRq90LZmMYeauMJy8mwx7cyMcnd0NDa1eLSkiRFfU5f1b61cbEd3xYZ/maGxriuTcYqw7E8V3OIQAUN7ICwAIhQKsHt8eHk4WSM8vwXt/hKK4VPrK1yVE31DyQjSGsaEIS0dybdW3XonBgyRqOEj4JZMxPMt+tYLd/zIzMsCWKb6wNjXE7YQcLPz7DtV5EVJHlLwQjdKnlQMGt3WCVMbw5aG79KJOeJWaV4JSKYNIKICTpbHSrutqa4qfXveGSCjAwVvP8Nlfd/AoJU9p1ydE11HyQjTOomFtYGwoRGhsFq4/paJGwh/5lFFDK2MYiJT7ctm1ub2igd3em/Ho//1FjP35CvbdjEehhHrBEFIdSl6IxnG2NsGoDi4AgB1XY3mOhugz+TJp11dYJl2dt7o1xY63/TDQ0xGi5w0bPzlwG53+dxbz90Xg0qM0SGU0+kjIf9FyDqKRpnZ1w54b8Th1LxlJOUW0IoPwQt5dV1n1LpXp2bIBerZsgNS8YvwV+gx7b8QhJqMQf4Ul4K+wBDhYGGF4e2e8070pnK3p74AQgEZeiIZq3dASfk1tIZUx7Aqhhl6EH8poUFdbDhbG+KC3O85/3Bt/fdAFb3RuDGtTQ6TmleC3y0/xxm8hkNEojFL9eS0WnVacxdUnGXyHQuqIkheisaZ2cQMA7L4eh5IyWk5K1C8hW/UjL/8l3z7jf6O8cP3zAGyZ4gtzIwNEpxXgZmyW2uLQBwdCE5CWV4IFByKozkjLUPJCNNYAT0c4WRojPV+C47eTar4DIUr2qvsavSqxgRD92zhiUFtuI9tD4c94iUMXlUlleJjMtWNIyCrC+rOPeI6I1AUlL0RjGYqEeKNzYwDAdircJWomlTEkynu82Kp+2qg6oztyBezHbyfRKKSSRKcXoLhUBqGA+/rXy09xLzGH36BIrVHyQjTaRL/GEIuEiIjPRnh8Nt/hED2SmleMUimDgZJ7vNRH52Z2cLQ0Qk5RKS5EpvEai66QJyrejW0w1KshpDKGhX/fodVdWoKSF6LR7M2NMKxdQwDAjisx/AZD9Ip8ysjZ2gQi+cdznoiEAox83j7g0C2aOlKGe8+4KaO2LlZYMrwNLIwNcDshB9vpdUYrUPJCNN7Urm4AgGO3k5CeX8JvMERvqGOZdF2M7OAMAAh6mIqcolKeo9F+d5+PvLRxtoSDpTEWDuYaBq4+HanYEoJoLkpeiMZr72qN9q7WkEhl2Hsjnu9wiJ7gu1j3v9o0tERLR3NIymQ4dZcK2F8FYwz3E5+PvDhbAQAmdnJFJzcbFEqk+OrIPT7DI7VAyQvRChM7uQIAgh6k8BwJ0Rflu0nzW6wrJxAIMOp54e5Bmjp6JQlZRcgtLoNYJEQLR3MA3I7fS0e0BcC9zlDti2aj5IVohV4tGwAAwuOzkVNIQ+ZE9RRbA9hqxsgLAEXdy7XoTMVKKFJ3d59xU0Ytncxh+MKeVS0dzSEQADIGZBZI+AqP1AIlL0QrOFuboLmDOWQM+PdJOt/hED2gzu66teVibQL/prYAgCMRiTxHo73u/WfKSM5AJIStqRgAqL5Ow1HyQrRGzxbc6MulR7RUlKhWhR4vGlLzIifv+UKrjupPvkza09nype/ZmxsBoORF01HyQrRGj5b2AICLUelgjOajieok5xajTMZgKBLAwYLfHi//NdirIcQiIR4m5ymKTknd3H3+vLX5z8gLANhb0MiLNqDkhWiNzk3tIDYQ4ll2EZ6kFfAdDtFhCc+XSWtCj5f/sjIxRL/WDgCAb049pES+jlJzi5GWVwKhAGjd0OKl7ytGXvKo5kWTUfJCtIaJWAQ/N26+/2IUTR0R1VEU62pQvcuL5g9oBbGBEMFRafgrjKaP6kJe79KsgTlMxQYvfZ+mjbQDJS8aoqyMdjStjZ7yqSOqeyEqpGk9Xv6ruYM55gW0BAAsO3oPqbnFPEekPaqrdwHKk5c0Sl40GiUvPMvOzkZgYCDMzMwwatQopKfTSprq9Hy+ZPpadAaKS2mDOqIa5T1eNDN5AYB3ezRFu0ZWyC0uwxeH7tL0US1VtdJIzt5cXvNC00aajJIXnkilUmzZsgUtW7bE999/D4lEgsOHD6NDhw64ePEi3+FprFaOFnCwMEJxqQw3Y7L4DofoKE1cJv1fBiIhvh3XDoYiAc7cT8HR29R1tzbu1jTyYiGveaGRF01GyQsPQkJC0KlTJ8yYMQNpaWnw8PDAr7/+ipYtW+LZs2fo06cPli1bBqmURhb+SyAQoActmSYqlpCt+SMvAODhZIlZfVoAAL46cg8ZNNVRrZyiUsRncolpmyqSlwZU86IVKHlRsz179qBHjx64desWLC0tsXbtWty+fRvvvPMOQkNDMWXKFMhkMixZsgT9+/enaaRKyOtegqlol6hAmVSGxGyuhsTVVnNHXuQ+6O0ODycLZBZIMHNXGK4+yYCMWttXSr60vJGNCayfN6P7L3nNS0aBhJ5HDUbJi5owxrBmzRpMmjQJpaWlGD16NB49eoR58+bB0NAQAGBubo7t27dj+/btMDMzw/nz59G1a1c8efKE5+g1S48WDSAQAA+T86hQkShkF0rwKCXvla+TnFsMqYxBLBIqPoVrMrGBEKvHt4eBUIBr0ZmYtOUaun59DiuO38fthGzao+cFNRXrAoDd85oXqYwhq5DqXjQVJS9qIJPJMG/ePHz88ccAgDlz5uDAgQNwcHCo9PwpU6bg+vXraNKkCR49eoQuXbogJCREafGkpaUhOztbaddTN1szMbxcuGK7i49oZIoAkjIZxv58Bf2/v4j5+yKQW1z//a/k9S4uNiYQaliPl6q0dbHCwQ+7YWInV1gaGyA5txhbLj3FiA3/os3iUxj24yUE7gvH5otPFPv66KOainUBwFAkhLUp94GSinY1FyUvKlZYWIiJEydi/fr1AIDVq1fj+++/h1BY/VPfpk0bXL16Fd7e3khLS0OfPn1w6NChesUglUpx7do1LF68GL6+vnBwcEDTpk1x+vTpel1PE8i3CqB+LwQA9t6MVzQu/CssAYO+v4grj+uX2Gr6MumqeDWywtdj2+HGlwHY/KYPhrZrCBNDEUrKZLj7LBd/hz3DyhMPMeanK4h/3oRP3yhGXlyqHnkBqO5FG7zcoYcoBWMMu3fvxqeffoqEhAQYGhpi+/btmDRpUq2v0bBhQwQHB2PChAk4ceIExowZg759+0IgEEAmk0Emk6GsrAwFBQUoKChAfn4+CgoKwBiDoaEhDA0NYWBggPz8/JdGWrKzszF48GCsXr0ac+fOhUCgHZ8w5Xq2bIAN5x/j8uN0yGRMaz4hE+UrlJThh6BHAIA3OjfGxah0xGUW4vVfQzCtmxs+HeQBY0NRra+nDcukq2NkIMIATycM8HSCVMYQn1mIh8l5iErJw5GIRDxOzcevl6KxdGRbvkNVqyKJFI9T8wEAntWMvABc3cuj1HxKXjQYJS8qEBISgrlz5+LatWsAgCZNmmDr1q3o06dPna9lbm6Ow4cPY+bMmdi8eTOCgoLqFZOlpSUGDhyIIUOGoE+fPvjqq6+wbds2BAYGIiIiAps2bYKxsWbt4VKdjo2tYSYWIbNAgsiUPLRuWP0nKaK7tv4bg7S8ErjammDxME+USmVYeeIBdobEYeu/MUjIKsKWKb61vp58WkWTl0nXlkgogJu9GdzszTCorRN8mthg8q8h2HszHh/1awE7LajpUZbbCdmQMa6Pi4NF9T+3fLl0Gi2X1liUvChRYmIiPv30U/z5558AADMzM3zxxReYN2/eKyUGBgYG2LRpEyZOnIhnz55BKBQqDpFIBDMzswqHUChEaWkpSktLUVZWBqFQiLZt2yoKgwHg999/R/v27TF//nxs374dDx8+xLZt2+Dh4fHKz4M6GIqEaO9qjStPMhAen03Ji57KKpBg0wWuoH1+f65lvthAiBWjvRDQxhHTt9/EmfspuBWXhY6NbWq8XmhsFs4+SIVAAAS0dlR1+GrX1d0OXi5WuPMsB9uvxiKwf0u+Q1Kbk3eTAXBTzjWNNFOjOs1HyYsSlJSUYN26dVi+fDkKCgogEAgwbdo0/O9//0PDhg2V8hgCgaBeIzfVXW/u3Lnw9PTEhAkTEBISgtatW6N///6YPXs2hgwZApGo9kPtfOggT17isjHJrzHf4RAebAp+grySMng4WWBEe+cK3+vTygFjOrpgf2gC1gc9wrZpftVeizGG/x2/DwB4zccVrZxe3rRP2wkEAnzQ2x0f7gzDjqsxeK9nM5gZ6f7bgEzGcOIO18RvaLuaX5M1aX+jQkkZ8kvKNG53c75Rwe4rOnnyJLy8vPDZZ5+hoKAAXbp0wY0bN/Dbb78pLXFRpf79++P69esYMWIEBAIBzpw5gxEjRqBFixbYvn073+FVq72rNQAgIiGb1zgIP5JyirDtSgwA4NNBHpXWPc3q2xwioQAXItNwK676jszH7yThVlw2TAxFCByguyMSAz2d0NTeDNmFpdhzI57vcNTiZmwWUvNKYGFsoGhyWR2+CnbLpDIEPUjB2tORmLHjJnp9dx6eS/6B34ognI9MVWssmo6Sl3pgjOGff/5B7969MWTIEDx69AiOjo7Yvn07Ll++DB8fH75DrJPmzZvj8OHDePLkCRYsWAAbGxs8ffoUb731Fu7du8d3eFXq+Dx5iUrJQ0EJbWypb9affYSSMhn83GzRu1Xlb0hN7MwwpqMLd/7zot7KlJRJ8c2phwCA93o1g6Ol7n7KFQkFeLdHMwDAb5eiUSqV8RyR6h2/nQiAS9zEBjW/7dlbyKeN1JO8FEmk2HE1Bn3XBOOd7Tfxw7nHOH0/BbEZhZBvWfXbpadqiUVbUPJSB1KpFAcOHICvry8GDRqE4OBgGBoaYv78+YiKisKUKVNqXAKtyZo2bYpvv/0WCQkJ6NmzJwDg1KlTPEdVNQdLYzhbGUPGgNsJ+tu7Qh/dScjBvpvcqMGng1tVW8Pw4uhLeHx2pedsvxKD+MwiOFoaYUbPZqoIWaOM8XaBvbkREnOKcSQ8ke9wVEoqYzjxvN6lNlNGwAvTRnmqrXnJKSrF92ei0PXrICw+fA9xmYWwMTXEa76NsHhYG+ya7o+js7pDIAAuP05HbEaBSuPRJtr7TqtmISEhaNOmDcaPH4+wsDCYmppi7ty5iI6OxurVq2FpqTsFo6amphg1ahQA4MyZM/wGU4MOja0BoMo3JaJ7zj9MxcTNVyFjQP82jvBpYlvt+U3szDBaPvpyNuql72cWSPDjuccAgPkDWsFUrPs1IMaGIrzTvSkArm5Il9vgX3+aibS8EliZGKKbu32t7lO+RUCJyp4bmYxh2tbrWB/0CFmFpXC1NcGykZ648lk/fDuuPd7u3hRdm9vDq5GVoq+Vvkzz1QYlL7Xk4uKCp0+fwtraGosWLUJsbCy+//57NGrUiO/QVKJ///4AgIsXL6K4WHNb8LdvZA0AiKDkRS9s+/cp3tl+AwUSKbo0s8N349rV6n6z+nCjL+crGX35IegR8orL0LqhJcZ66+bfc2Umd24MCyMDPErNx7mHultPcfyOfMrIsVZTRkD5FgGlUoacovp3a67O0duJCIvLhplYhB8ndcT5+b0xpYsbTMQvL5SY5OcKANh/M0Evpvlqg5KXWmrUqBGOHj2KuLg4LFu2DPb2tcvgtZWnpycaNmyIoqIiXLlyhe9wqtThed0LjbzotjKpDIsP38VXR+9DxoAJvq7Y/rZflZvr/ZebvRlGdeBGX1b/E4kDoQn49MBt9F19QVH0++XQ1hDpUbNDS2NDvN6ZW6X3zamHkJTp3ptimVSGU8+njIa1c67h7HJGBiJYGnMjcKqoeykuleKbk1yN1Yd9mmN4e2cYiKp+O+7X2hH25kZIzy9B0IMUpcejjSh5qYOBAwfCwkL3lk9WRiAQICAgAIBmTx15NbKCSChAcm4xknM0d4SI1B9jDLN23cKOq7EQCICFgz3w9VivWn+Klpv9vPbl8uN0fLw/AntvxiM6nashmNqlCbo11+0PJJX5oJc77M3FeJSaj03BurcB7PWnmUjPl8DG1BBd3O3qdF9FozoVJC+/XX6KxJxiOFsZK6bvqmMoEmK8LzcquPs6TR0BlLyQasinjjQ5eTEVG6ClI5dQhsdXvxSWaKeLj9Jx6l4yxAZCbHrDB+/1cq/XdhZu9mZ4p3tTiA2E6NjYGu/1bIZfp/gifHF/vWuVL2dtKsaiYW0AABvOPcaTtHyeI1Kuo7e53i6D2jrBsJqRjcqU93pRbtFuWl4JfjrP1Vh9UoetKyZ24qaOLj5K09u9qV5EyQupknzkJSwsDBkZGTxHU7UOrtw+Jbdo6kjnMMbw/RmuyPbNzk0w0NPpla73+ZDWiFw+CAc/7IaFQ1ojoI1jraeedNWI9s7o1bIBJFIZFv59R2eKd7kpo+eN6bxqP2Uk18BCvuKofiMvpVIZikulL93+/dkoFEikaNfI6qXGitVpYmeGbs3twBiw/yaNvqgledm4cSPc3NxgbGwMf39/XL9+vdrz9+/fDw8PDxgbG8PLywsnTpxQR5jkPxo2bIi2bduCMVbvPZXUQV73QkW7uke+vNnYUIj3e7kr5ZratgmpqgkEAvxvVFuYGIpw/Wkm9ofqxhvj1egMZBWWws5MjM7Nql+RVplXaVRXJpVh0uZr8PrqH8zbG47bzxtpRqXkYc/1OADAl0Pb1HlDWXkn8b0341Gm54W7Kk9e9u7di8DAQCxZsgRhYWFo3749Bg4ciNTUyqvbr1y5gkmTJuGdd97BrVu3MGrUKIwaNQp3795VdaikEvKpo9OnT/McSdU6uHJ71txJyIFURz41Em7UZe3zUZepXdwUn4SJ8rnammL+867CK44/0IkNCY+/MGVUXTFsVcr3N6r7c/H7v09xMzYLpVKGg7eeYcSGfzH25ytYcOA2ZAwY5OkEv6Z1T6j6t3GErZkYKbkluBCZVuf76xKVJy9r167Fu+++i2nTpqFNmzbYtGkTTE1N8fvvv1d6/vr16zFo0CAsWLAArVu3xvLly+Ht7Y0NGzaoOlRSiRfrXhjTzMSguYM5zMQiFEikeJSax3c4REnOPkjFnWc5MBWL9KJxHN/e6uqGti6WyC0uw7Jj9/kO55XIZAxnn6/KGeJVv21a6lvzEp9ZiO/PcN2cP+rbHKM7usBQJEBobBYi4rNhKBLgs8H12wDXyECEcT5c4e7GC4/xMDm3XtfRBSpNXiQSCUJDQxW1EwAgFAoREBCAq1evVnqfq1evVjgf4Fb5VHV+SUkJcnNzKxxEeXr27AmxWIy4uDg8elR1e3U+iYQCtHve7yU8LpvXWIhyvFjrMrWrG+zMadRF1QxEQnw9ph2EAuBoRCKuPtHcOrea3E3MQXq+BOZGBujkVvcRDqB+mzMyxrD48F0UlUrh39QW8/q3xPcTOuDfT/vio77N4d7ADJ8O8oCbvVm9YgK4wl0DoQC34rIxaN0lDP3hEn67/FQnRsvqQqXJS3p6OqRSKRwdK24t7+joiOTk5Ervk5ycXKfzV61aBSsrK8Xh6uqqnOAJAMDMzAxdu3YFoNmrjtpTvxed8s+9FNxPyoWZWIQZPWjURV3auljhdX+urmLtmUiNHW2tibzpXvfm9nVeUi9nX4+C3eN3knA+Mg1ikRArx3gp6qscLI0ROKAVgub3xvRX/H1u1sAcO6f7Y5CnEwxFAtxLzMXyY/fReVUQpv5+HX+HJSBfD/Z60/rVRgsXLkROTo7iiI/XjWIzTaINS6apWZ12yiyQ4LVfriJgbTA+ORCBvTfi8CglD+uet/Gf1q0pbMz0ezWQus3u2wJGBkLciMlCcJR21lWcf14P0tfDod7XKK95kdQqicspKsXSo9x024d93OHewLzej10T/2Z22PSmD65/HoDlIz3RwdUaUhlDcFQaAvdFwGf5GXy4MxQh0do7elYTlW7iYW9vD5FIhJSUih0BU1JS4ORU+ZJHJyenOp1vZGQEIyMaUlal/v3744svvsD58+dRVlYGAwPN2/ul4/M9juQ7TJsZaV6MpKLc4lJM+T0Ed59xU72PU/Ox72aC4vsWRgaY3qPmBl5EuRwtjfFm5yb49fJTrDkdhV4tG2jVCq30/BLF6p5eVew2XhvyaSOJVIbcojJYmRpWe/63px4iLa8EzRqY4YPeylkZVxMbMzHe7OKGN7u44Wl6AY6EJ+JwxDNEpxXgxJ1knLqbjIMfdlOMTOsSlY68iMVi+Pj4VFhmK5PJEBQUhC5dulR6ny5dury0LPfMmTNVnk9Uz9vbG7a2tsjNza1xmTtfHC2N0fD5DtN3ntEO05quUFKGt7fewN1nubA1E+P7Ce3xYW93+DW1hdHzYf4P+zTX+x4sfPmgtztMxSLceZaD0/e1qx19cGQaGAM8nS3haGlc7+sYG4pg8fxDUE1ddm/FZWFnCLcEeuVoLxgZ1K7xnDI1tTfDnIAWCArshWOzu6NXywaQMWDBgQiUlL3cb0bbqXzaKDAwEFu2bMH27dvx4MEDfPDBBygoKMC0adMAAFOmTMHChQsV58+ZMwenTp3CmjVr8PDhQ3z11Ve4efMmZs2apepQSRVEIhH69esHQLOnjuSbNNLUkWYrLpXivT9CcTM2CxbGBtjxth9Gd2yETwZ5YN97XXDnq4G49EkfvN+Lal34YmduhLe7caNea09HaVULgvORXL1Ln1b1nzKSU9S91JC8bP03BgAwpqMLOjer2zYEyiYQCNDWxQrfT+gAOzMxolLysfG87m39oPLkZcKECVi9ejUWL16MDh06IDw8HKdOnVIU5cbFxSEpKUlxfteuXbFr1y5s3rwZ7du3x4EDB3Do0CG0bauf7bs1hXwFWHBwMM+RVK3D86mjsFjaJkBTlUplmL37Fi49SoepWIRt0/zQ1sWqwjliAyFcbU21aqpCF73boxksjA0QmZKHY7cT+Q6nVsqkMlx8XqfT5xXqXeRq0+slt7gU/9zjFpRM7er2yo+pLLZmYix7vu3FT+cf436ibq3EVUvB7qxZsxAbG4uSkhKEhITA399f8b0LFy5g27ZtFc4fP348IiMjUVJSgrt372LIkCHqCJNUo1OnTgCAW7duaewKBHnTp5CnmVr1SVGfrD4diTP3UyA2EGLLFF/4NLHhOyRSBStTQ7z3vL/OurOPtKKja1hcNnKLy2Btaqgo4n8ViuXS1aw4OnE7CSVlMjR3MEe7RlZVnseHIV5OGOTphDIZw4IDESjVgv+HtaX1q42Ienh6ekIsFiM7OxsxMTF8h1Opdi5WsDAyQE5RKe4lUt2LpknNLca258Pra19rr5e7OGubt7o1ha2ZGE/TC/D3rWd8h1Mj+ZRRr5YNIKpj6/3KKPY3qqZR3V9hXJH5WO9GGjdaKBAIsGyUJ6xMDHEvMRebL0bzHZLSUPJCakUsFsPLywsAt1GjJjIQCeH/fL7538e6u0RQW20KjkZJmQzeja0xtJ5dT4l6mRsZKGqP5HvyaLLzz/u7vMoS6RfV1KguJr0AN2KyIBQAozu6KOUxlc3BwhhLhnM7h68/+whXnqRr7Oh5XVDyQmrN29sbgOYmLwDQvbk8eUnnORLyotTcYuwMiQUAzA1oqXGfUEnV+npw9YkPkvI0ejo2MbsID5PzIBAAPVvUf4n0i2pKXv5+PurSvUUDOFnVf2WTqo3u6II+rbidw1/fEoJ+a4LxY9AjxGcW8h1avVHyQmpNG5IX+VTEjZjMSrejJ/z4OfgJSspk8Gligx4taLpImzS1N4OxoRBFpVLEZhTwHU6V5BsVdnS1VlpjQ3nBblol00YyGcNfYdxU2lhvzRx1kRMIBFg9vj3GdHSBsaEQ0ekFWHMmCj2+PY9xP1/BxvOPcfdZDmQanJz+FyUvpNbkyUtoaKjGDjs2dzCHg4URSspktOpIQ6TmFmPX8x4YcwNa0KiLlhEJBWjlZAkAuJ+kuStWlLlEWq66LQJCnmbiWXYRLIwMMNCz8iaqmsTO3AhrJ3TAzS/7Y/X49ujqbgeBALgZm4Xv/onEsB8vw29lEAL3hSM6LZ/vcGtEyQupNS8vL4hEIqSlpeHZM80s3hMIBIrRl3+f0NSRJpCPuvg2sUF3KtLVSm0aWgAAHmho8lJSJlVMFStjibRcgxemjf77gU1eqDusfUMYG6q/KV19mRsZYJxPI+x6tzP+/bQvlo9qi4DWjjAVi5CeX4K/w55h6tbrGj9yTckLqTUTExO0acMVfmny1FFXd67u5TIV7fKu4qgL1bpoqzYNuZGXB0l5PEdSuRN3klAokcLBwgiezpZKu6685qWkTIa8FzY7LJSU4eQdrj/ZWO9GSns8dXO2NuG2gpjqi/DFA7DrXX80tDJGfGYRfgnW7JVJlLyQOtGmupc7CdnIKSrlORr99uKoS7fm/HYeJfXX+nnyoomNzh6n5uHLg3cBABP9Gis1QTYRi2Am5kZVXpw6OnU3GQUSKdzsTHWmV5HYQIiu7vb4YmhrAMBPFx5rdEEvJS+kTrQheXG2NkEzezPIGHBNh3dV1XQpL4y6zOtPoy7azON58pKcW4zMgqp7nqhbXnEpZvwRigKJFF2a2eGjvs2V/hj2/+n1kl9Shj+vcSvnxmhgb5dXNdSrIbq626GkTIblx+7zHU6VKHkhdaINyQtQPvpyhZZM8+bHc49QUiZDJzcbxVQe0U7mRgZoYmcKQHPqXhhj+OTAbUSnFaChlTF+fL0jDETKf0uTTx3FZRZiU/AT9PjmHMLismEgFGhsb5dXIRAIsHSEJwyEApy+n4ILzwuhNY0B3wEQ7dKhQwcIBAI8e/YMKSkpij2qNE235nb441osLlPywou4jELsuR4PAFgw0EPnPp3qo9ZOlojNKMSDpFyVdEfOKSzFybtJOHY7Cen5JWhkYwpXWxO42piisa0pPBpawMXaRPG79MvFaJy8mwyxSIifJnsrkgxlky+X/uRABOQriZs1MMOXQ1vD1dZUJY/JtxaOFnirqxt+vfwUS4/eRxd3O152yq4OJS+kTszNzdGqVSs8fPgQt27dwqBBg/gOqVJdmtlDIACepBUgOadYoxtI6aJ1Z6NQJmPo2bKBYs8pXVJWVoZz586hS5cusLCw4DsctWjd0BKn7iUrdbl0SZkUp++l4HB4IoKjUlEqLV/R8zD55eJgWzMxvFys0NTeDDuuxgAAloxog46NVVd34mDBvXbIGNDY1hRz+rXAyA7OKhnl0SRzAlrgcEQinqYX4LfLT/Fhb+VPyb0KSl5InXl7e+Phw4cICwvT2OTFytQQXi5WuJ2Qg38fp2Osj/auCNA2USl5OBjOLaVfMKAVz9GoRmBgIH788Ue4ublh69at6N27N98hqVwbZ+UV7WYWSLDzWiy2X42t0L3Ww8kCIzo4o7WTJRKyi5CQWYj4rEI8TS/Eo5Q8ZBZIEByVhuDnO0eP92mE1/0av3I81ZnQyRUJWYUY6OmEsT6NYKjjSYuchbEhPh/igXl7I/Bj0GP4NLZRbL+iCSh5IXXm7e2NXbt2aUXdy+2EHPz7hJIXdVp7OgqMAYPbOsFLw3bZVYaYmBhs2rRJ8e8+ffpgzpw5WLlyJUxNdXMaAQBaP+/18iQtH5IyGcQGdX8Tj0kvwJZL0fgrLAHFpdwOx06Wxhjr44IR7V3QyqnqUaziUikik/Nw+1kO7iRkQ2wgxJdD26h8SrKtixW2TvNT6WNoqlEdXLD3RjyuRWdi4pZreL+XO+YFtKzX/3tlo+SF1JnWFO262+PnC0/w72NuIzKqu1C92wnZOHUvGQIBENi/Jd/hqMTSpUtRWlqK3r17o0WLFtiyZQvWr1+PkydPYvv27ejcuTPfIaqEi7UJLI0NkFtchsep+YqRmNqKTM7D6J/+RaGEa37W1sUS7/ZohiFeDWs1mmFsKEJ7V2u0d7UG0KQePwGpK4FAgF+ndsLyo/ex92Y8fr7wBBej0rB+Ygc0d+B3ulTANLXPez3l5ubCysoKOTk5sLRUXrMiUi47Oxs2Ntwcc2ZmpuLfmqa4VIp2S09znxJFQtiaiWFrJoaduRgNrYy5QkA7U7jamsLaxBDJOcVIyCpCQnYRkrKL0MfDAUNo9+M6mfL7dVyMSsMYbxesfa0D3+Eo3cOHD+Hp6QmZTIaQkBD4+fnh5MmTeOedd5CUlASBQID33nsPK1asgK2t7tX6TPjlKkKeZmL1+PYYV4fRzCKJFCM2XMaj1Hy0d7XGwsEe8G9qSx8otMipu8lY+PdtZBWWwshAiM+HtMaULk2U+v+wLu/fNPJC6sza2hrNmjVDdHQ0bt26hb59+/IdUqWMDUWY4OuKP67FQiKVITm3GMm5xbW+/4k7SRjQxlHnC/OU5Vp0Bi5GpcFQJMC8AN0cdfnqq68gk8kwYsQI+PlxUwmDBw/G3bt3MXfuXPzxxx/YtGkT9u/fj2+++QbTpk2DUKg7vz+tG1oi5GlmnZdLLzt2D49S8+FgYYTfpvqqbGUQUZ1BbZ3g3dgaHx+4jYtRadhw/jFGdXCBlakhL/FQ8kLqxdvbG9HR0QgLC9PY5AUAlo9qi8+HtEZGQQmyCkqRUVCCjHwJErOLEJdZiLjMQsRnFiK7qBQNrYzRyMYULjYmOBKeiPySMjxIytPJug1lu/IkHXP2hAPgChx1cQlpREQE9u7dCwBYvnx5he/Z2tpix44deOeddzBz5kzcu3cP06dPx5YtW7B582a0a9eOj5CVrk09Ou0ejUjE7uvxEAiAdRM6UOKixRwsjbF9WifsuBoLN3sz3hIXgJIXUk/e3t44cOCAxte9AFyL70ZiUzSqw+xWUnYRzkem4UZMJiUv1ZDKGDaef4x1Z6MgY0ALB3PM1dFRl0WLFgEAJkyYUGUy0qtXL9y6dQs//vgjlixZgpCQEHTq1AmrVq3C3LlztX4URl7n8iA5t1Z1ZHEZhVj49x0AwKw+zdGVNubUegKBAFO7uvEdBnXYJfUjL9oNDQ3lORLV8HXj6hVuxmbyHIlmKJJIcfdZDmIzCpBTWAqZjCEtrwRTf7+OtWe4xGW8TyMcntVNJz9Zh4SE4OjRoxAKhVi6dGm15xoaGiIwMBCRkZEYPnw4JBIJ5s+fjwEDBmjsbuy11dzBHCKhANmFpTVOwUrKZJi9Owz5JWXo5GaDOf1aqClKog9o5IXUS8eOHQEAUVFRyM3N1bni6E7Pk5cbMVm0UgnAtG3XcS26PJETCAADoQClUgYTQxGWj2pbpwJObfPll18CAKZOnYpWrWrXu8bZ2RmHDx/G5s2bMW/ePAQFBcHLywubN2/GuHHjVBmuyhgbiuDewAxRKfm4n5iLhlYmlZ4nlTF8eegOIhJyYGViiPUTVdO6n+gv+m0i9eLg4IBGjbg3qxs3bvAcjfK1a2QFsUiItLwSxGnwzqrqkJ5fokhcTJ/vsMsYUCplaOlojiOzuul04hITE4OzZ89CJBJh8eLFdbqvfPXRrVu34OPjg6ysLIwfPx6TJ09GZqZ2jurJ616qKtotlcowb2849t1MgFAArB7fHs7WlSc5hNQXJS+k3gICAgAAR44c4TkS5TM2FClqXW7EZPEcDb+uPOF25vZwssD9ZYMQ+b9BuP5FP5z/uDdOzumJFo663R7/6tWrALipUjc3t3pdo1WrVrhy5Qo+//xzCIVC7Nq1C56enjh27JgSI1WP1vKi3UqSl+JSKT74MxRHIhJhIBTgh0kd0b+NZu5/RrQbJS+k3saMGQMA+Pvvv6Fj7YIAAL5NuArfUD2ve/n3Ebe5ZffnxZZGBiI4WBijqb0ZRELdn067du0aALxy8zmxWIwVK1bg6tWr8PDwQHJyMoYPH4633noLT5480Zq/odaKkZeKew8VlJTh7W03cPZBKowMhNgyxRfD2jnzESLRA5S8kHrr378/zMzMkJCQgJs3b/IdjtL5vlD3oq8YY4qdubu30M+VIvLkpUuXLkq5np+fH27duoWPP/4YAoEA27dvR/PmzWFtbY1evXph7ty52Lp1K65fv478/HylPKYyyZOXmIwChMdn43D4M3x76iHG/nwFV55kwEwswrZpfujj4cBzpESXUcEuqTdjY2MMHToU+/btw19//YVOnTrxHZJS+TwfeXmcmo/MAglszcQqf8wiiRTBUWm4/DgN/TwceX8DiMkoxLPsIhiKBDq5O3RNiouLcevWLQCvPvLyImNjY3z33XcYPXo0PvnkE9y4cQO5ubm4ePEiLl68WOHcJk2awNPTEzNnzsSQIUOUFkN9NbAwQgMLI6TllWDUxn8rfM/KxBDb3/ZDB1drfoIjeoOSF/JKxowZo0heVq1apVOrcmzNxGjuYI7HqfkIjc1S2dx9oaQMZ+6n4J97yTj/MA1FpdzeL/tuJGDve53RsTF/2y/IR128G9vAVKx/Lxe3bt1CaWkpHBwc6l3vUp2uXbvi8uXLKC0txYMHDxAeHo5bt27h9u3buHfvHlJSUhAbG4vY2FicPXsW4eHhaN26tdLjqKv+bRyxKyQOFsYGaOVogZZOFmjlaIH+bRypOJeohf69GhGlGjJkCMRiMR4/fox79+6hbdu2fIekVJ3cbPA4NR83YzJVkrycvZ+CLw/drdAzw8XaBDZmhrj7LBfv/xmKo7O6w8HSWOmPXRvyepceejplJC/W7dy5s0oTc0NDQ7Rr1w7t2rXDlClTFLdnZGTg3r17WLZsGYKCgjBjxgwEBwfz3uxuxai2WDCgFaxNDbX6A4tUKkVycjJcXFz4DoXUEdW8kFdiYWGBAQMGAOAKd3WNbxN53Uv9inavP83ErpA4PE7Nq1CQmZZXgpm7wjB9x00k5xbDxdoEH/Z2x9FZ3XH50z7YM6MLWjiYIyW3BO//GYqSMqlSfp66kMoYrjzhkpduetoZVVnFuvVlZ2eHnj174vfff4eZmRkuX76MzZs38xLLiwQCAWzMxFqduADAJ598gkaNGmH16tV8h0LqiJIX8speXHWka+TN6u48y0Fxae0TiDKpDKtOPMBrv1zF5wfvIGDtRXT9+hw+3h+BDeceIWBtMI7fToJIKMD7vdwRNL8XPhnkAa9GVhAIBDA3MsDmKb6wMDZAWFw2vjpyX1U/YpXuPMtBbnEZLIwN4OWin1skKLtYt74aN26MFStWAAA+/fRTre/UqwmkUil27NgBAFiwYIFi3yqiHSh5Ia9s+PDhEIlEiIiIwJMnT/gOR6lcbU3gYGGEUilDRHx2re6TkV+CKb9fxy8XowEA7RtZQWwgRFJOMQ6EJmD16SjkFJWirYslDs/shs8Ge8DYUPTSdZram+GHSR0hEAC7r8dhZ0isMn+0Gv37vN6lq7udXnZHffbsGeLj4yEUCuHr68t3OJg1axb8/PyQm5uL2bNn8x2O1rty5QrS09MVX0+ZMgWXLl3iMSJSF/r3ikSUzt7eHr169QIAHDx4kOdolEsgEChGX27G1rxk+nZCNob/eBlXnmTAVCzCxte9cXhWd9xeMgA73vbDjJ7N0L25Pb4Y0hqHPuyGtjWMaPRp5YAFA7l29F8duYfwWiZQynD5P/1d9E1ISAgAwMvLC+bm5jxHA4hEIvz6668wMDDAwYMHde5vTd0OHToEAHj99dcxevRoSCQSjBw5Eg8fPuQ3MFIrlLwQpRg7diwA3Zw68nXjVvvcrKbu5Vl2Ef537D7GbbqKxJxiNLU3w6GZ3TC0XUMAXMfeni0b4PMhrfHndH+827NZrUczPujljiFeTiiVMszfF16n6av6KpJIEfo8WaN6F37qXSrj5eWFTz75BAAwc+ZMZGXpbw+iV8EYw+HDhwFwr11//vknOnfujKysLAwePBgpKSk8R0hqQskLUYpRo0YB4FZnJCYmKm5njKGsrIynqJTjxZEXmaxiF9TbCdmYvfsWen57Hr9efgpJmQwBrR1xeFY3tFRS23yBQICVo73QwMIIT9IK8P2ZKKVctzrXYzIhkcrgYm2CpvZmKn88TaSJyQsALFq0CC1atEBSUhI6d+6Me/fu8R2S1rl37x6ePHkCY2NjDBw4EKampjhy5Ajc3d0RExODCRMm8B0iqQEtlSZK4ezsjC5duuDq1atYtmwZ7O3tERYWhrCwMKSlpcHLywv+/v7o3Lkz/P39YW5ujuTkZKSkpCA5ORkSiQTjx4+Hg4PmdeX0cLKAqViEvOIy/HIxGgUlZXiaUYDHKfmITClvkd7V3Q7v9miG3q0aKH0VhrWpGKtGe2H6jpvYfCkaAzwd4dNEdU3j5PUu3Zrbaf2KkvooLS1VdI3WtOTF2NgY+/fvx/DhwxEVFQU/Pz/89ttvmDhxIt+haQ35lFFAQADMzLjkvEGDBjh+/Dg8PDwQHByMvLw8WFjo9r5d2kzAtGVDjVrKzc2FlZUVcnJyYGlpyXc4emX16tVYsGBBve9vaWmJxYsXY/bs2RCLVd/Nti7e+DVE0bDtRQZCAYa3d8b0Hk3h6az6FTnz90Xgr7AENLU3w4mPesBE/HKhrzIMWX8J95NysX5iB4zsoH89MEJDQ+Hr6wsbGxukp6fz3lelMunp6Zg0aRLOnj0LAJgzZw6+++47GBoa8hyZ5vP19UVoaCh+/fVXvPPOOxW+5+joiNTUVNy8eRM+Pj48Raif6vL+TSMvRGmmTJmCPXv2gDEGb29vxeHk5ISwsDBcu3YN165dw40bN1BWVgYnJyfFERcXh4iICHz88cfYtGkT1qxZg+HDh2vMp/53ujdFal4x7MyM0LSBGZramaGpvRnauVrBwUJ9DeQWD2+Dfx+n42l6Ab77JxKLh7dR+mOk55codgzW93oXf39/jUxcAK5Q/tSpU1i8eDFWrlyJ9evXY/v27bCxsYG5uTnMzc1hbGyMgoIC5ObmKg4fHx8cOHAA9vb6+f82Pj4eoaGhEAgEGD58+Evfb9WqFVJTUxEZGUnJiwaj5IUojYODQ5UbNDZp0gSjR48GAMhkMggEggqJiUwmw/bt2/H555/j8ePHGDlyJIYNG4bdu3drxEqPPh4OvO8zBHB7x3w91gtvbb2BrVeeYqCnI/yb2Snt+vcSc/D1SW61ReuGlrA3N1LatbWJpta7/JdIJMKKFSvg5+eHqVOnIjs7G9nZ2dXeJzg4GOPGjcPp06c1boRTHeSFut26dat0mrply5a4dOkSIiMj1R0aqQNKXojaVfZJVigUYtq0aRg3bhxWrlyJtWvX4tixYxgwYABOnDgBa2tr9QeqoXq3csDETq7YcyMe07ffxNz+LTGlSxMYvkIvlsep+fj+TBSO30kCgOfN85opK2Stoy3Ji9zIkSORkJCAmJgY5OfnK47CwkKYm5vD0tISlpaWyM3NxYgRIxAcHIwPP/wQW7Zs0ZjRTXWR17vIFxn8V6tWXGuCqCjVF8aT+qOaF6KRrl+/jkGDBiErKwsdOnTA6dOn0aBBA77D0hh5xaV487frir4vzR3M8dVwT3Sv4x5ED5NzsTk4GofCn0HGAIEAGN7OGfP6t9TbVUbp6emK37XMzEzY2PC3MaYqnDx5EsOGDYNMJsPatWsxb948vkNSm6ysLDg4OKCsrAyPHj1C8+bNXzrnyJEjGDlyJDp27IiwsDAeotRfdXn/1szJXKL3/Pz8cOHCBTg4OCA8PBy9evWqsARb31kYG+KvD7pi1Rgv2JqJ8Tg1H2/8FoIZO27iQmRqtXshMcbtWTT19+sYtO4S/r7FJS792zji5Jwe+GFSR61MXGQyGfLy8mo+sQby5nStW7fWucQFAAYPHow1a9YAAD7++GMcP36c54jU58SJEygrK4Onp2eliQvATRsB3MiLjn221ykqmzbKzMzE7NmzcfToUQiFQowdOxbr16+vtn5h8+bN2LVrF8LCwpCXl4esrCyaLtBj7dq1w8WLFxEQEIAHDx6gR48eOH/+PBo3bsx3aBpBJBRgkl9jDGnbEN+fjcIf12Jx+n4KTt9PgalYhJ4tGqBfawe42JggKbsYSTlFSMwpRkR8Nu4lcgW5QgEwuG1DvNerGdo1sub3B3oFpaWl6N+/P4KDg2FjY4NmzZrB3d0d7u7ueOuttxRvSLVx/vx5ANozZVQfc+bMwf3797FlyxZMmjQJly9fRrt27fgOS+VqmjICgGbNmkEkEqGgoACJiYm047SGUtm00eDBg5GUlIRffvkFpaWlmDZtGjp16oRdu3ZVeZ9169ahuLgYALBw4cJ6JS80baR7YmJi0K9fP0RHR6NPnz4ICgrSu3n62ohMzsO2KzE49zAFKbkl1Z5rbCjEeB9XTO/RFE3stG+U5b8WLFhQ5c7Atra2uHLliqKWoTq7d+/GG2+8AZlMhp07d+L1119XdqgaQyKRYMCAAQgODoa1tTUOHTqk2OZDFxUXF8Pe3h4FBQW4ceNGtftVtWzZEo8ePUJQUBD69u2rxij1W53ev5kK3L9/nwFgN27cUNx28uRJJhAI2LNnz2q8//nz5xkAlpWVVefHzsnJYQBYTk5One9LNNeTJ0+YsbExA8D27NnDdzgaTSqVsdvx2WzN6Ug2/MdLrM9359nrW66y+fvC2Zp/HrI912NZRn4J32EqzdGjRxkABoDt3r2b3blzhx06dIitXbuWdezYkQFgTZo0YYmJidVe56+//mIikYgBYO+99x6TyWRq+gn4k5GRwTp37swAMLFYzHbu3Ml3SCqzZcsWBoA1atSoxv+3w4YNYwDYTz/9pKboCGN1e/9WSfLy22+/MWtr6wq3lZaWMpFIxP7+++8a71+X5KW4uJjl5OQojvj4eEpedNTSpUsZAObi4sLy8vL4DodogLi4OGZra8sAsI8++uil76emprIWLVowAKxDhw5Vvi4cO3aMGRoaMgDsrbfeYlKpVNWha4zCwkI2duxYRQK4YsUKnUvcioqKWKNGjRgAtnbt2hrPDwwMZADY3Llz1RAdkatL8qKSgt3k5OSX1s8bGBjA1tYWycnJSn2sVatWwcrKSnG4uroq9fpEc3zyySdo1qwZnj17huXLl/MdDuFZaWkpJk6ciMzMTPj6+uLbb7996ZwGDRrg1KlTisLvsWPHQiKRVDjnn3/+wdixYxXX+/XXXzW2MZ0qmJiYYN++fZg/fz4A4IsvvsCMGTMglap+A1B1+emnn5CQkABXV1d88MEHNZ4vn2KkXi+aq05/oZ999pmiuVhVh7q3E1+4cCFycnIUR3x8vFofn6iPsbEx1q9fDwBYu3YtbV2v57788ktcuXIFlpaW2Lt3L4yMKm+o16xZM5w4cQJmZmY4e/YsRo8ejffffx89e/aEvb09Bg0ahJKSEowZMwY7duyASKSaLRc0mVAoxOrVq7FhwwYIhUL8+uuvmDdvnk6stsnNzcXKlSsBAEuWLIGxcc0dsSl50QJ1GdJJTU1lDx48qPYoKSlR67TRf1HNi+6Tz0cHBATo3PA2qVlpaSlbsWKFYprjwIEDtbrfyZMnmYGBgeJ+8kMgELBJkyaxkhLdqQN6Fbt371Y8N6tXr+Y7nFf21VdfMQCsVatWrLS0tFb3SUxMZACYUChkxcXFKo6QyPFe8yIv2L1586bitn/++YcKdolSPHnyhBkZGTEAbP/+/XyHQ9TowYMHzM/PT/HmOm/evDrd/+DBg+y1115jn3/+Ofvzzz9ZWFgYKygoUFG02mv16tWK53jv3r18h1NvaWlpzMLCggFg+/btq/X9ZDKZ4n737t1TYYTkRbwnL4wxNmjQINaxY0cWEhLCLl++zFq0aMEmTZqk+H5CQgJr1aoVCwkJUdyWlJTEbt26pagKv3jxIrt16xbLyMio9eNS8qIfFi9ezAAwV1dXVlhYyHc4RMXKysrYmjVrFCvOrKys2LZt22jkTUVkMhmbPXu2YhXSxYsX+Q6pXuSFt97e3nUuwvb19WUAajVbQJRDI5KXjIwMNmnSJGZubs4sLS3ZtGnTKqwQefr0KQPAzp8/r7htyZIlLw3pAmBbt26t9eNS8qIfCgsLmaurKwPAfvnlF77DISpUUlLCBg4cqHg9GDBgAIuPj+c7LJ1XVlbGRo8ezQAwGxsbdv/+fb5DqpP4+HjFCO3JkyfrfP/XX3+dAWCrVq1SQXSkMhqRvPCFkhf98f333yvmsvVpaau++fDDDxkAZmpqyn755RcabVGjwsJCRR+Y3r178x1Onbz77rsMAOvZs2e9fmfkrRmmTZumguhIZXhfKk2IOrzzzjuwsrJCZGSkXu3Pok9+//13/PTTTxAIBNi7dy9mzJhB3ZXVyMTEBLt37wYAXLx4EampqTxHVDsPHjzAb7/9BoBrp1Gf3xlacaTZKHkhWsvCwgIzZswAAMVGc0R3hISEKHpyLF26FMOGDeM5Iv3k5uYGb29vyGQyHD16lO9wauXTTz+FTCbD6NGj0bVr13pdg5IXzUbJC9FqH330EQwMDBAcHIybN2/yHQ5RkuTkZIwZMwYSiQSjRo3CF198wXdIem306NEAyjc21GTBwcE4evQoRCIRVq1aVe/rtGjRAgCQkZGBjIwMZYVHlISSF6LVGjVqhIkTJwKg0RdtFR0djdOnT+Ps2bMICgrCuXPnMG7cOCQmJqJ169bYsWOHXnW81UTyXZjPnDmD/Px8foOpBmMMCxYsAADMmDGjVptxVsXMzAyNGjUCAERFRSklPk0mk8nw448/okGDBhg5cqTm/8yqL8FRLyrY1T+3bt1iAJhIJGIxMTF8h0NqKTMzk82cOZMJhcJKVxlaWVmxyMhIvsMkjFs67e7uXqemgHzYu3cvA8DMzMxYcnLyK1+vX79+dV7xqo2ioqJYjx49Kvz9GRoasvnz57Ps7Gy1xVGX928DPhImQpSpQ4cO6NevH4KCgrB+/XqsXbuW75BINWQyGX7//XcsXLgQ6enpAABPT0+IRCIwxiCTyWBhYYGVK1eiZcuWPEdLAEAgEGDUqFFYs2YNDh48iLFjx6rssYqKivDo0SMkJCTg2bNnSEhIQE5ODsaPH49u3bpVeT+JRIKFCxcC4PZBc3R0fOVYWrZsiaCgIM0fhagnqVSK9evX44svvkBxcTHMzMywePFiXLx4EcePH8eaNWuwY8cOLFiwAI6OjjAwMIBIJIKBgQEsLS3Rv39//oJXfS6lXjTyop9OnjzJADBzc/N6dWYm6nH//n3WqVMnxae7Nm3asHPnzvEdFqmFy5cvK0bEJBKJUq8tk8lYSEgIe/fdd5m5uXmlI3EA2Pvvv1/la/v69esZAObk5KS0XefXrVvHALAxY8Yo5XqaJDw8nPn7+yue24CAAPb06VPF90+cOMFatWpV5f+LVq1aKT0m6vNCyYvekclkzNPTkwFg33zzDd/hkErExsYyZ2dnBoBZWFiwtWvXKv1NkKhOWVkZc3BwYADYmTNnXvl6MpmMRUdHs/Xr1zMvL68Kb4y2trasQ4cObOjQoWzGjBls4sSJiu+5uLiwI0eOMMYYk0gkLCwsjP3yyy/Mzs5O6U0r5R+KPD09lXZNvuXm5rLAwEAmEokUf4ubN2+utBeORCJhP/zwAxs2bBgbOHAg69evH+vduzfr3r17hY75ykLJCyUvemnr1q2KbqBpaWl8h0NekJmZydq0aaN4I0hMTOQ7JFIP06dPZwDYzJkz63X/xMREtnXrVjZ16lTWuHHjCgmLsbExe+ONN9iFCxcqfSMNCgpS1N3IR+3k20XIj9atW9d688XaiI6OZgCYkZERKysrU9p1ayKVSll4eDj77rvvWP/+/ZmHhwe7du1are8vk8nY8ePH2erVq9mvv/7K/vrrLxYUFMR27tzJGjVqpHi+xo8fzxISElT4k9RNXd6/BYzpwJ7nL8jNzYWVlRVycnJgaWnJdzhEjaRSKXx8fBAREYH33nsPmzZt4jskAqC4uBgDBw7ExYsX4ezsjGvXrsHV1ZXvsEg9HD9+HMOGDYOLiwvi4uJqvQqsoKAAK1euxOrVqyGRSBS3GxgYwM/PD5MmTcLkyZNhY2NT7XUKCwuxdOlSrFmzBlKpFABgZWUFX19fdOrUCR999BEaNmxY/x/wP6RSKczMzFBSUoLo6Gg0bdq00vPy8vKwf/9+ZGdno6ysTHE0btwYb7zxBgwMKi8vlUqliIyMRExMDGJjYxETE4Po6OhKGwI6OzsjLCysxlqeBw8eYPbs2QgKCqrynGbNmmHjxo0YNGhQDc+AetXp/VvlqZSa0ciLfgsODmYAmEAgYGFhYfW+TmlpKbWhVwKpVMpee+01BoBZWlqyiIgIvkMir6CoqEhRk3L9+vUaz5fJZGzPnj0VPu17e3uzzz77jP3zzz8sPz+/XnHcv3+f7d+/n0VGRqp8axD5dHRV+yMdO3ZMsc9aZUenTp3YgwcPXrrf+fPnFdeu7DA1NWVDhgxha9euZR4eHootGqoaWcrNzWUff/wxMzAwUIxkjRs3jg0bNox169aNeXp6Mnd3d/bll19q7Ga2NG1EyYtemzRpEgPAunXrVqcEJD8/n+3Zs4eNGjWKicViNmjQIBVGqR/ku/oaGhqyoKAgvsMhSjB+/HgGgH3++edVnlNWVsbOnj3LevfurXgzdnNzYwcPHtS6DwVjxoxRbAh68OBBRTFwcnJyhVocNzc3NnnyZDZ16lT2zjvvsOnTpzMrKytFIvH9998zqVTKEhISKtzP1NSUtW/fno0YMYJ99NFHbM2aNez8+fOsuLhYEcP9+/cVSeOCBQsqxCeTydjOnTsV9WQA2IgRI1h0dLRanydloOSFkhe9Fh8fz0xNTRkA9ueff1Z5XllZGbtz5w777bff2MSJExX3efG4e/euGiPXLd98843ieazu/wPRLjt37lTUl7xIJpOx69evs7lz5zInJ6cKtSxLly7V2E/7NVm9enWF1wSxWMz69evHbGxsGAAmFArZ/PnzKx1Fio+PZwMGDFDc18fHR5GECAQC9uGHH7KMjIxaxbFv3z7FdeS9dm7dusW6d++uuN3d3Z0dP35cqT+/OlHyQsmL3luxYgUDwBo2bMhyc3MZY+Uvrp999hnr1asXMzMzeylZcXd3Z59//jnr1asXA8AWLlzI80+inbZs2aJ4Tr/99lu+wyFKlJWVpZiacHNzY66urszZ2ZnZ2tpW+FuysbFh7733XoXlt9pIJpOx06dPs9mzZ7NmzZpV+Bk7duzIbt68WeP9f/755wqvN507d2ahoaF1jmX+/PmKFULTpk1TNHg0NTVlK1asYEVFRfX9MTUCJS+UvOi9oqIixQvN22+/zT755BPm5ub2UrJibm7OevfuzT777DN248YNxZC2vFNnkyZNVD6nrmsOHDigeFH95JNP+A6HqMDYsWMrrdMwMTFhEydOZEeOHGElJSV8h6l0MpmMPXjwgK1bt45t27atTiubHj9+zGbMmMG2bdtW79eU0tJSxQcr+TFhwgQWFxdXr+tpGlptRKuNCIAjR45g5MiRFW4zMzPD8OHDMWDAAPj7+6NVq1YQiUQv3beoqAiOjo7Iy8vDpUuX0L17d3WFrdXOnj2LoUOHQiKRYPr06di8eTMEAgHfYRElKy4uxu3bt8EYg0gkgkgkglAohLu7O8zNzfkOT6elpKSgf//+MDIywurVq9GrVy++Q1Kaurx/U/JCdBZjDG+88QaOHDmCIUOG4LXXXsPgwYNhampaq/u/9dZb2L59O95//338/PPPKo5WuzHGcOrUKYwfPx4FBQUYO3Ys9u7dW2liSAghlaHkhZIXogRnzpzBgAEDYGtri6SkJIjFYr5D0jh5eXn4888/sWHDBty/fx8A0K9fPxw/fhxGRkY8R0cI0SZ1ef+mjRkJqULfvn3h5OSE5ORknD59GsOGDeM7JN788MMP2L17N0xNTWFubg5zc3MIBAIcOXIEeXl5ALgpubfeegurVq2ixIUQolKUvBBSBZFIhIkTJ2LdunXYuXOn3iYvUVFRCAwMVHQ0/a+WLVti5syZmDp1KqysrNQcHSFEH1HyQkg1Jk+ejHXr1uHw4cPIy8uDhYUF3yGp3aJFiyCVStG3b19Mnz4d+fn5yM/PR2FhIfz8/NCvX79at4knhBBloJoXQqrBGIOHhweioqKwY8cOvPnmm2p5zKdPn6JBgwa8J0uhoaHw9fWFQCBAREQEvLy8eI2HEKK76vL+TR+XCKmGQCDA5MmTAQA7d+5U6WNlZGRg/fr1aNeuHdzd3eHi4oL58+cjNjZWpY9bnc8//xwA8MYbb1DiQgjRGDTyQkgNHj9+jBYtWkAoFCI+Ph7Ozs5KvX5ISAjWrVuHv//+W7HjrkAggPxPUyQSYezYsZg/fz78/PyU+tjVOXfuHPr16wdDQ0NERkZWuaMuIYQoA428EKJEzZs3h7+/P2QyGZo3b47hw4fjl19+QUJCQpX3SU1NxfHjx7F06VKsWLECT548eemc+Ph4TJ48GZ07d8aePXsgkUjg7e2Nn376CRkZGThx4gQCAgIglUqxb98++Pv7Y+jQoYiIiFDljwuAm7pauHAhAOD999+nxIUQolFo5IWQWjhz5gymT5+OuLi4Crc7OzvDysoKVlZWsLa2hqGhIW7fvl3pVE/v3r3x9ttvY9CgQdiwYQO+++47FBUVQSAQYOrUqZg9eza8vb1ful9ERATWrl2LnTt3Klb8TJo0CcuWLUPz5s1V8vMePHgQY8aMgZmZGZ48eQJHR0eVPA4hhMhRkzpKXogKMMZw9+5dHDt2DMeOHcPVq1dR1Z+PQCBAq1at0KlTJ6SmpuL06dOVntuzZ0+sW7cOHTt2rPHxHz16hMWLF2PPnj0AAAMDA/j4+EAsFisOc3NzdOrUCT169ICPjw8MDQ1r9XOVlJQgLy9PsZJowoQJePDgARYtWoRly5bVeA1CCHlVlLxQ8kLUICMjAzExMcjJyUFOTg5yc3NRWFgIDw8P+Pj4VPj9i4+Px/bt27F161ZER0ejadOm+O677zBmzJg67/1z69YtfPHFFzh58mS155mamqJz586Keh35IZPJkJKSgqSkJMVRVFT00v3t7Ozw5MkT6t1CCFELSl4oeSEaSiaTIS4uDs7Ozq+83UBERARiY2MhkUgUR1paGv79919cvnwZGRkZdb6miYkJLCwsYGVlhWXLlmHixImvFCMhhNQWJS+UvBA9J5PJ8ODBA1y+fBkpKSlgjEEmk0EmkwEAGjRogIYNGyoOe3t7mJub00aKhBDe0N5GhOg5oVAIT09PeHp68h0KIYQoHS2VJoQQQohWoeSFEEIIIVqFkhdCCCGEaBVKXgghhBCiVSh5IYQQQohWoeSFEEIIIVqFkhdCCCGEaBVKXgghhBCiVSh5IYQQQohWoeSFEEIIIVqFkhdCCCGEaBVKXgghhBCiVSh5IYQQQohW0bldpRljALittQkhhBCiHeTv2/L38eroXPKSl5cHAHB1deU5EkIIIYTUVV5eHqysrKo9R8Bqk+JoEZlMhsTERFhYWEAgECj12rm5uXB1dUV8fDwsLS2Vem1SET3X6kPPtfrQc60+9Fyrj7Kea8YY8vLy4OzsDKGw+qoWnRt5EQqFaNSokUofw9LSkv4Y1ISea/Wh51p96LlWH3qu1UcZz3VNIy5yVLBLCCGEEK1CyQshhBBCtAolL3VgZGSEJUuWwMjIiO9QdB491+pDz7X60HOtPvRcqw8fz7XOFewSQgghRLfRyAshhBBCtAolL4QQQgjRKpS8EEIIIUSrUPJCCCGEEK1CyUstbdy4EW5ubjA2Noa/vz+uX7/Od0g6adWqVejUqRMsLCzg4OCAUaNGITIyku+wdN7XX38NgUCAuXPn8h2Kznr27BneeOMN2NnZwcTEBF5eXrh58ybfYekcqVSKRYsWoWnTpjAxMYG7uzuWL19eq/1ySPUuXryI4cOHw9nZGQKBAIcOHarwfcYYFi9ejIYNG8LExAQBAQF49OiRSmKh5KUW9u7di8DAQCxZsgRhYWFo3749Bg4ciNTUVL5D0znBwcGYOXMmrl27hjNnzqC0tBQDBgxAQUEB36HprBs3buCXX35Bu3bt+A5FZ2VlZaFbt24wNDTEyZMncf/+faxZswY2NjZ8h6ZzvvnmG/z888/YsGEDHjx4gG+++QbffvstfvzxR75D03oFBQVo3749Nm7cWOn3v/32W/zwww/YtGkTQkJCYGZmhoEDB6K4uFj5wTBSIz8/PzZz5kzF11KplDk7O7NVq1bxGJV+SE1NZQBYcHAw36HopLy8PNaiRQt25swZ1qtXLzZnzhy+Q9JJn376KevevTvfYeiFoUOHsrfffrvCbWPGjGGTJ0/mKSLdBIAdPHhQ8bVMJmNOTk7su+++U9yWnZ3NjIyM2O7du5X++DTyUgOJRILQ0FAEBAQobhMKhQgICMDVq1d5jEw/5OTkAABsbW15jkQ3zZw5E0OHDq3w+02U78iRI/D19cX48ePh4OCAjh07YsuWLXyHpZO6du2KoKAgREVFAQAiIiJw+fJlDB48mOfIdNvTp0+RnJxc4bXEysoK/v7+Knmv1LmNGZUtPT0dUqkUjo6OFW53dHTEw4cPeYpKP8hkMsydOxfdunVD27Zt+Q5H5+zZswdhYWG4ceMG36HovOjoaPz8888IDAzE559/jhs3buCjjz6CWCzG1KlT+Q5Pp3z22WfIzc2Fh4cHRCIRpFIpVqxYgcmTJ/Mdmk5LTk4GgErfK+XfUyZKXojGmjlzJu7evYvLly/zHYrOiY+Px5w5c3DmzBkYGxvzHY7Ok8lk8PX1xcqVKwEAHTt2xN27d7Fp0yZKXpRs37592LlzJ3bt2gVPT0+Eh4dj7ty5cHZ2pudah9C0UQ3s7e0hEomQkpJS4faUlBQ4OTnxFJXumzVrFo4dO4bz58+jUaNGfIejc0JDQ5Gamgpvb28YGBjAwMAAwcHB+OGHH2BgYACpVMp3iDqlYcOGaNOmTYXbWrdujbi4OJ4i0l0LFizAZ599hokTJ8LLywtvvvkm5s2bh1WrVvEdmk6Tvx+q672SkpcaiMVi+Pj4ICgoSHGbTCZDUFAQunTpwmNkuokxhlmzZuHgwYM4d+4cmjZtyndIOqlfv364c+cOwsPDFYevry8mT56M8PBwiEQivkPUKd26dXtpyX9UVBSaNGnCU0S6q7CwEEJhxbc2kUgEmUzGU0T6oWnTpnBycqrwXpmbm4uQkBCVvFfStFEtBAYGYurUqfD19YWfnx/WrVuHgoICTJs2je/QdM7MmTOxa9cuHD58GBYWFoq5UisrK5iYmPAcne6wsLB4qY7IzMwMdnZ2VF+kAvPmzUPXrl2xcuVKvPbaa7h+/To2b96MzZs38x2azhk+fDhWrFiBxo0bw9PTE7du3cLatWvx9ttv8x2a1svPz8fjx48VXz99+hTh4eGwtbVF48aNMXfuXPzvf/9DixYt0LRpUyxatAjOzs4YNWqU8oNR+volHfXjjz+yxo0bM7FYzPz8/Ni1a9f4DkknAaj02Lp1K9+h6TxaKq1aR48eZW3btmVGRkbMw8ODbd68me+QdFJubi6bM2cOa9y4MTM2NmbNmjVjX3zxBSspKeE7NK13/vz5Sl+fp06dyhjjlksvWrSIOTo6MiMjI9avXz8WGRmpklgEjFHbQUIIIYRoD6p5IYQQQohWoeSFEEIIIVqFkhdCCCGEaBVKXgghhBCiVSh5IYQQQohWoeSFEEIIIVqFkhdCCCGEaBVKXgghhBCiVSh5IYQQQohWoeSFEEIIIVqFkhdCCCGEaBVKXgghhBCiVf4PYN/hxJE4k7UAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(t, target_la)\n",
+    "plt.plot(t, roll_la, color='r')\n",
+    "plt.plot(t, steerCommands, color='black')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABy9ElEQVR4nO3deXiU5bk/8O87a/Z9h0AI+w5GjFHcaipoF2mpRz20Vkr1VKWn/WGt5fRUrV2waq2tpVptxXqq1drFqqVYRHFlUSDsO4GE7AvJZJ3JzDy/P2aeNwkEyDIz7zLfz3XlUpLJm2eYMHPP/dz3/ShCCAEiIiIiE7FovQAiIiKiUGOAQ0RERKbDAIeIiIhMhwEOERERmQ4DHCIiIjIdBjhERERkOgxwiIiIyHQY4BAREZHp2LRegBb8fj+qq6uRmJgIRVG0Xg4RERENghACbW1tyMvLg8Vy7hxNVAY41dXVyM/P13oZRERENAyVlZUYPXr0OW8TlQFOYmIigMBfUFJSksarISIiosFwuVzIz89XX8fPJSoDHLktlZSUxACHiIjIYAZTXsIiYyIiIjIdBjhERERkOgxwiIiIyHQY4BAREZHpMMAhIiIi02GAQ0RERKbDAIeIiIhMhwEOERERmQ4DHCIiIjIdBjhERERkOgxwiIiIyHQY4BAREZHpMMAhIlM63tiBJzceRZfHp/VSiEgDUXmaOBGZ26kOD5b8bguqWroQ77TilpICrZdERBHGDA4RmYrfL3D3KztR1dIFANhb5dJ4RUSkBQY4RGQqz7x/DG8fqFf/fLCuTcPVEJFWIhLgrF69GgUFBYiJiUFxcTG2bt161ts+88wzuOyyy5CamorU1FSUlpaecXshBO677z7k5uYiNjYWpaWlOHz4cLjvBhHpnBACv37nCABg6aUFAIDDdW3w+4WGqyIiLYQ9wHn55ZexYsUK3H///di+fTtmz56NBQsWoL6+fsDbb9y4ETfffDPeeecdbNq0Cfn5+bjmmmtQVVWl3ubhhx/Gr371Kzz11FPYsmUL4uPjsWDBAnR3d4f77hCRjrV09qCt2wsA+M41k+GwWtDh8anbVUQUPcIe4Dz22GO47bbbsHTpUkybNg1PPfUU4uLi8Oyzzw54+xdeeAF33nkn5syZgylTpuB3v/sd/H4/NmzYACDwDu3xxx/H//7v/+L666/HrFmz8Pzzz6O6uhqvvvpquO8OEemYDGQyEpyId9pQmBkPADhYy20qomgT1gDH4/Fg27ZtKC0t7f2BFgtKS0uxadOmQV2js7MTPT09SEtLAwCUl5ejtra23zWTk5NRXFx81mu63W64XK5+H0RkPjLAGZUaCwCYnJMIgHU4RNEorAFOY2MjfD4fsrOz+30+OzsbtbW1g7rGvffei7y8PDWgkd83lGuuWrUKycnJ6kd+fv5Q7woRGUDVqWCAkxIDoDfAOcQAhyjq6LqL6qGHHsJLL72Ev//974iJiRn2dVauXInW1lb1o7KyMoSrJCK9qJYZnJRgBic7mMHhFhVR1AlrgJORkQGr1Yq6urp+n6+rq0NOTs45v/fRRx/FQw89hH//+9+YNWuW+nn5fUO5ptPpRFJSUr8PIjIfuUWVFwxwJgUDnKMN7ejx+TVbFxFFXlgDHIfDgaKiIrVAGIBaMFxSUnLW73v44Yfxox/9COvWrcOFF17Y72vjxo1DTk5Ov2u6XC5s2bLlnNckIvOrPi3AGZ0ai3iHFT0+geONHVoujYgiLOxbVCtWrMAzzzyDP/zhD9i/fz/uuOMOdHR0YOnSpQCAW265BStXrlRv/7Of/Qw/+MEP8Oyzz6KgoAC1tbWora1Fe3s7AEBRFHz729/Gj3/8Y7z22mvYvXs3brnlFuTl5WHRokXhvjtEpGNVLYFREXKLSlEUTArW4RzgNhVRVAn7WVQ33ngjGhoacN9996G2thZz5szBunXr1CLhiooKWCy9cdaTTz4Jj8eDL33pS/2uc//99+OBBx4AAHz3u99FR0cHbr/9drS0tGD+/PlYt27diOp0iMjYunt8aGx3A+gNcIBAHc6OihYWGhNFGUUIEXUjPl0uF5KTk9Ha2sp6HCKTKG/swFWPbkScw4q9P1wARVEAAM9+UI4H39iHBdOz8duvXHieqxCRng3l9VvXXVRERIMlW8TzUmLV4AYAxqbHAQBOnuI0Y6JowgCHiEzh9BZxSRYcV/O4BqKowgCHiEzh5GkdVJKcanyqswedHm/E10VE2mCAQ0SmIDM0o1P7BzhJMXYkOm39bkNE5scAh4hMobcG58xuSpnFYR0OUfRggENEplDdKmtw4s74Wm8dTndE10RE2mGAQ0SG5/cL1ASDlwEzOCw0Joo6DHCIyPAa293w+PywKEBO0pkBjszgVDHAIYoaDHCIyPBk4JKdFAOb9cynNVmDwwCHKHowwCEiw6ttDWxP5SYPfFzLqOC2VRWLjImiBgMcIjK8GjXAiR3w67LwuNbVDZ8/6k6nIYpKDHCIyPBqXYEAJ+csGZzMRCdsFgU+v0Cdi51URNGAAQ4RGd75tqisFgW5wW0qdlIRRQcGOERkeDLAyR6gg0rKS2ahMVE0YYBDRIZX4woELWfL4ADspCKKNgxwiMjQhBCoa3UDOHsNDtA77I+dVETRgQEOERlac4cHHp8figJkJZ4/wGENDlF0YIBDRIYmW8TT451w2M7+lMZpxkTRhQEOERna+TqoJLUG51QXhOAsHCKzY4BDRIZ2vhk4kuyi6vD44Oryhn1dRKQtBjhEZGgygzPQIZt9xTqsSI93AOA2FVE0YIBDRIYma3DOl8EBWIdDFE0Y4BCRodUOYgaOxE4qoujBAIeIDK2WGRwiGgADHCIyLCFE7xbVeWpwACAveB4VAxwi82OAQ0SG1eb2otPjAzC4DM7oVE4zJooWDHCIyLDqgtmb5Fg74hy2894+jzU4RFGDAQ4RGdZQtqeA3iLj+jY33F5f2NZFRNpjgENEhjWUAmMASIt3IMZu6fe9RGRODHCIyLBqBnlMg6QoSm8nFetwiEyNAQ4RGdZgj2noaxRbxYmiAgMcIjKs2tZAkDLYGhyAAQ5RtGCAQ0SGNZRjGiR2UhFFBwY4RGRYdS5ZgxM76O9hBocoOjDAISJD6u7x4VRnD4DhZnDYRUVkZgxwiMiQZJt3rN2KpJjzD/mT1GnGLV3w+0VY1kZE2mOAQ0SGVOvqbRFXFGXQ35edFANFATxeP5o6POFaHhFpjAEOERnSUIf8SQ6bBdmJPHSTyOwY4BCRIQ31mIa+5Kni7KQiMi8GOERkSOoMnCFmcABgVGocAAY4RGbGAIeIDKlvDc5QyQzOSR7XQGRaDHCIyJB6a3AGPwNHGs1hf0SmxwCHiAxpZDU4HPZHZHYMcIjIcHp8fjS0uwEMtwaHGRwis2OAQ0SG09DmhhCA3aogPd4x5O+XGZxTnT3o9HhDvTwi0gEGOERkOHJ7KjspBhbL4If8SUkxdiQGpx8zi0NkThEJcFavXo2CggLExMSguLgYW7duPett9+7di8WLF6OgoACKouDxxx8/4zYPPPAAFEXp9zFlypQw3gMi0pPaEdTfSPLQTXZSEZlT2AOcl19+GStWrMD999+P7du3Y/bs2ViwYAHq6+sHvH1nZycKCwvx0EMPIScn56zXnT59OmpqatSPDz74IFx3gYh0RraID6f+RhrFQzeJTC3sAc5jjz2G2267DUuXLsW0adPw1FNPIS4uDs8+++yAt583bx4eeeQR3HTTTXA6nWe9rs1mQ05OjvqRkZERrrtARDojh/wNZwaO1NtJ1RmSNRGRvoQ1wPF4PNi2bRtKS0t7f6DFgtLSUmzatGlE1z58+DDy8vJQWFiIJUuWoKKi4qy3dbvdcLlc/T6IyLj61uAMVx4zOESmFtYAp7GxET6fD9nZ2f0+n52djdra2mFft7i4GM899xzWrVuHJ598EuXl5bjsssvQ1tY24O1XrVqF5ORk9SM/P3/YP5uItFcXii2qYKt4FWtwiEzJkF1U1157LW644QbMmjULCxYswNq1a9HS0oI///nPA95+5cqVaG1tVT8qKysjvGIiCqU6V3AGzoiKjHmiOJGZ2cJ58YyMDFitVtTV1fX7fF1d3TkLiIcqJSUFkyZNwpEjRwb8utPpPGc9DxEZhxAC9W2BDE5W4kgCnMCBm7Wubnh9ftishny/R0RnEdZ/0Q6HA0VFRdiwYYP6Ob/fjw0bNqCkpCRkP6e9vR1Hjx5Fbm5uyK5JRPrU5vaiu8cPAMhMHP4bl8xEJ2wWBT6/QH2bO1TLIyKdCPtblhUrVuCZZ57BH/7wB+zfvx933HEHOjo6sHTpUgDALbfcgpUrV6q393g8KCsrQ1lZGTweD6qqqlBWVtYvO/Od73wH7777Lo4fP46PPvoIX/jCF2C1WnHzzTeH++4Qkcbqg9tTiU4bYh3WYV/HalGQy20qItMK6xYVANx4441oaGjAfffdh9raWsyZMwfr1q1TC48rKipgsfTGWdXV1Zg7d67650cffRSPPvoorrjiCmzcuBEAcPLkSdx8881oampCZmYm5s+fj82bNyMzMzPcd4eINCa3pzKTRr7tnJcci8rmLk4zJjKhsAc4ALB8+XIsX758wK/JoEUqKCiAEOKc13vppZdCtTQiMpiG4HZS1gi2p6RRqbFAOacZE5kRq+qIyFB6A5zhFxhLcppxTSsDHCKzYYBDRIZSH8IMjpyjU8Nhf0SmwwCHiAylPjjkLytENTgAUN3KAIfIbBjgEJGh1Idwi0p2UXGLish8GOAQkaGEcosqN5jBaensQZfHN+LrEZF+MMAhIkMJ5RZVUowNccFZOsziEJkLAxwiMozuHh9c3V4AQGYItqgURUGuLDRmHQ6RqTDAISLDkC3iTpsFSTGhGeOVF2wV57A/InNhgENEhqEespnkhKIoIbmmzODUMoNDZCoMcIjIMOQ5VKHooJJy2SpOZEoMcIjIMELZQSX11uBwi4rITBjgEJFhqFtUoQxw5HENnGZMZCoMcIjIMNQtqqTQbVHlBTM41czgEJkKAxwiMgy5RZUZhgxOW7cX7W5vyK5LRNpigENEhhGOACfBaUOiM9ByXsssDpFpMMAhIsNoCEORMdB7JlU163CITIMBDhEZgtfnR1NH6NvEgd5WcXZSEZkHAxwiMoSmDg+EAKwWBWnxjpBeOy+FxzUQmQ0DHCIyhDpXb4u41RKaKcZSThJbxYnMhgEOERlCnSs89TdAnxocblERmQYDHCIyBDWDE8IZOFKeWoPDDA6RWTDAISJDkC3i2Unhy+DwwE0i82CAQ0SGUK/W4IQ+gyPPo2p3e+Hq7gn59Yko8hjgEJEhyC2qcGRw4hw2JMfaAbDQmMgsGOAQkSGoJ4mHoQYH6M3isNCYyBwY4BCRIcguquwwbFEBQB5PFScyFQY4RKR7PX2nGIdhiwrozeDwPCoic2CAQ0S619juhhCAzaIgLS60U4yl3i0qZnCIzIABDhHpXn2fIX+WEE8xlngeFZG5MMAhIt2THVSZYSowBnpn4bAGh8gcGOAQke7VySF/YTimQeo7zVgIEbafQ0SRwQCHiHSvQZ2BE74MTk6wBqerx4fWLg77IzI6BjhEpHtqi3iYOqgAIMZuRVp8oIC5mttURIbHAIeIdK+uLXzHNPQlO6lYaExkfAxwiEj3ZAYnXDNwpFyeKk5kGgxwiEj3GtrCX4MDAHkpzOAQmQUDHCLStR6fH43tHgCBOTjhJAuN2SpOZHwMcIhI1xqCLeJ2q4LUME0xlmSrOA/cJDI+BjhEpGvqKeKJMWGbYiz1nkfFDA6R0THAISJdk1OMw11gDPQ5UZzD/ogMjwEOEelavQxwwlx/AwSKmBUFcHv9aOrwhP3nEVH4MMAhIl3rHfIX3g4qAHDYLMhMCARSLDQmMjYGOESka/URahGXcoPbVFUtLDQmMjIGOESkazKDkxmBLSoAGMVZOESmwACHiHStLgIHbfaltoozg0NkaBEJcFavXo2CggLExMSguLgYW7duPett9+7di8WLF6OgoACKouDxxx8f8TWJyLjkHJxwHrTZl+yk4oGbRMYW9gDn5ZdfxooVK3D//fdj+/btmD17NhYsWID6+voBb9/Z2YnCwkI89NBDyMnJCck1iciYPH26mbLDfNCmlMcaHCJTCHuA89hjj+G2227D0qVLMW3aNDz11FOIi4vDs88+O+Dt582bh0ceeQQ33XQTnM6B37EN9ZpEZEwN7YHsjcNqQUqcPSI/c1QKt6iIzCCsAY7H48G2bdtQWlra+wMtFpSWlmLTpk26uSYR6ZOcgZOZ6ISihHeKsSQP3Kxvc8Pt9UXkZxJR6IU1wGlsbITP50N2dna/z2dnZ6O2tjZi13S73XC5XP0+iEj/emfgRKb+BgDS4h1w2gJPjXWt7oj9XCIKrajoolq1ahWSk5PVj/z8fK2XRESDIGfgZEWo/gYAFEVRt6lYh0NkXGENcDIyMmC1WlFXV9fv83V1dWctIA7HNVeuXInW1lb1o7Kyclg/m4giq7dFPHIZHADI5SwcIsMLa4DjcDhQVFSEDRs2qJ/z+/3YsGEDSkpKInZNp9OJpKSkfh9EpH/1wS2qrAjNwJE4C4fI+Gzh/gErVqzAV7/6VVx44YW46KKL8Pjjj6OjowNLly4FANxyyy0YNWoUVq1aBSBQRLxv3z71/6uqqlBWVoaEhARMmDBhUNckInOoa4vcOVR99baKcxYOkVGFPcC58cYb0dDQgPvuuw+1tbWYM2cO1q1bpxYJV1RUwGLpTSRVV1dj7ty56p8fffRRPProo7jiiiuwcePGQV2TiMwhkieJ98VWcSLjU4QQQutFRJrL5UJycjJaW1u5XUWkYxf8aD2aOzx489uXY3JOYsR+7geHG/Hl32/BxKwErF9xRcR+LhGd21Bev6Oii4qIjMft9aFZTjGOcJGxnIVT3dKFKHwPSGQKDHCISJfkGVQOmwXJsZGZYizJGpwOjw+uLm9EfzYRhQYDHCLSJTnkLyuCU4ylGLsV6fEOAJyFQ2RUDHCISJca2uQMnMh2UEl5LDQmMjQGOESkS1oc09BXTnIgsKp1sVWcyIjC3iZORDQcda7IH9PQlwys6qM8wGloc+OdA/Xo6gkcPHrtjJyID14kGg4GOESkS/XBIuPMCM/AkXKSmMFZu7sG//P33Wjp7FE/99ftJ/H3Oy+F1RLZuiiioeIWFZFO1LR2YWdlC9uSg2QXVaSH/EkySyG3yqLNA6/txZ0vbEdLZw8mZiXgMzNzkei0YdfJVjy/6bjWyyM6L2ZwiHSgpdODzz3xIRrb3ZiSk4ivX1aIL84dBUsUv0tu0DiDk60GONGXwdl24hSe++g4FAW488rx+NbVk+CwWfDHzSfwv6/uwaNvHsTCGTnIDZ7ZRaRHzOAQ6cDDbx5EY3vgBf1AbRu+88pO/GzdAY1Xpa2Gdq0DnGANTlv0ZXB+ueEwAOCGotG4Z8EUOGyBl4r/vGgMLhiTgg6PDz98bZ+WSyQ6LwY4RBrbUXEKf9paAQB4+itF+HbpRADAb987hnV7arVcmmZ8foEmrQOcYHFzc4cHbq9PkzVoYduJU3jvUAOsFgXLr5rY72sWi4KffnEmFAVYt7cWlc2dGq2S6PwY4BBpyOcX+P7f90AIYPEFo3HN9Bx8u3QSvj5/HADgnld2oryxQ+NVRl5Thxt+AVgUID1emwAnJc4OhzXwFFkfRXU4Mnuz+IJRGJMed8bXp+QkoaQwHQDwj7KqiK6NaCgY4BBp6L1DDdhX40JSjA0rr5uifv7ea6dgXkEq2txe/ODVPRquUBuy/iY9walZt46iKMhSt6miow5nf40L7x1qgG2A7E1fX5g7CgDwt+1VLIon3WKAQ6Shf+6uAQAsmjsKGQm9mQq71YLH/mMOLArwwZFG7K9xabVETagFxgnaZG+knCjrpHr7QD0A4MrJWQNmb6RrZ+Yixm7BscYO7DzZGqnlEQ0JAxwijXi8fvx7b6DG5rqZuWd8PT8tDtfOCHz+2Q/KI7o2rWndQSVFWyfVu4caAABXTM485+0SnDYsmJ4DAPj79pNhXxfRcDDAIdLIh0cb4er2IiPBiXkFaQPe5mvBWpx/lFWrL/rRQOsOKkluUUVDBqetuwfbT5wCAFwx8dwBDtC7TfXazmp4vP6wro1oOBjgEGlk7a7A9tS1M3LOWmdSNDYVc/JT4PH58cfNJyK5PE3pLYMTDcc1bD7WDK9foCA97pzbU9L8CRnISHDiVGcPPjraGIEVEg0NAxwiDfT4/Pj3vjoAA29P9bUsmMV5YcsJ+PzRUdBZr5MaHDkLJxqOa3gvuD112SCyNwBgs1rw6WnZAIAN++vDti6i4WKAQ6SBj442obWrBxkJTlw0buDtKWnhjBwkxtjQ2O7B7qroKOjUTQYnMXpqcN47HAhwLp80uAAHAEqnZgEIFCezm4r0hgEOkQbeDBYXL5iefd42aLvVos4d+SD4ImR2jXoJcJLlFpW5a3BONHXgRFMnbBYFJePTB/19l4zPgNNmQVVLFw7UtoVxhURDxwCHKML8foEN+wPbU9cEO1HO57KJGQCA9w9HR62DbjI4wRqcNrcXHW6vpmsJJ/l7VTQ2FQnOwR9RGOuwYv6EwO+m/J0m0gsGOEQRtqe6FXUuN+IdVlxceO7tKUnWRWyvOGXqF1oA6PL40Ba8j1qdJC4lOG2Id1gBmPtMqp2VLQCA4sLBZ2+kq6cG63AOsA6H9IUBDlGEvRUsyLx8UiacNuugvmdsehxGp8aixyewtbw5nMvTnDx0NMZuGVI2IVyiYRbOobrA9tLUnMQhf++npgTqcMoqW9THjkgPGOAQRdhbwe4p+c53MBRFiZptqvo+21OKos0xDX31zsIxZ4Dj9wscqmsHAEwaRoCTkxyDGaOSIETvJGQiPWCAQxRBVS1d2FfjgkUBrjrPtNjTzZ8QuP0HR8xdaKyXYxoks2dwKk91oqvHB4fNgoL0+GFd41NTAsH6uwfN/btJxsIAhyiC3g4WYhaNTUX6EF/AL52QDkUBDtW1o7bVnC+2ANAQPNhS6wJjKdvk51HJ7qeJWQnDPtj0ymCw/v7hBnh9nGpM+sAAhyiCZCHmULanpJQ4B6bnJQEAtgVH6puRXjqoJFnobNYMzqFggDM5e+jbU9Ls0SlIibPD1e3FzpMtIVoZ0cgwwCGKkB6fXy0QvmIIw9T6mjkqGQCwt9q8A//Uc6gSYjReSUBWMINj1rPADgYLjCcPo/5GsloUtdOP21SkFwxwiCJk18kWdHp8SI2zD/vd8rS8QICzr8YVyqXpit4yOLIWqMGkHUIHgxmc4RQY9yWD9o2HGOCQPjDAIYqQTUebAAAXF6bDMsxaB7lFtbeaAU6kyHU0mLAGx+31obyxAwAwZYQBzuXBLr9dJ1vZLk66wACHKEI2HQsEOEMZhX+6qTlJsCiBIKC+zZw1IXoLcGSbeJvbiy6PT+PVhNaxhg54/QKJMTbkJI1sSzArKQbTcgMB+AcmH2VAxsAAhygC3F4fPjkeKAwuGca0WCnWYUVhZgIAc2ZxhBBobPcAADISHBqvJiDRaYPTFniqNFsdjhzwNyUnMSQzh64IdlNtPMh5OKQ9BjhEEVBW0QK314+MBCcmZCWM6FryXfI+EwY4rm4vPME24wydzMFRFEXN4jS0mytrJlvEJ42gg6ovOYzS7NO2yRgY4BBFgNyeurgwbcTvlHvrcMzXSSVrNxKdNsTYB3eMRSSohcZmy+DU9mZwQmH26BRYFKC6tdu0bfVkHAxwiCJAFhiPpP5Gmi47qUyYwWkMBhDpOtmekmQ9kNkO3Ax1BifeaVOvtaOiJSTXJBouBjhEYdbd41Of7EdSfyPJDM7xpk60dfeM+Hp60tQh62/0sT0lZSWabxZOW3cPqlq6AIxsBs7p5o5JBRA4fJNISwxwiMJsT1UrPD4/MhIcGJcxvLN++kqNdyAvOfCCu7+mbcTX0xO5RaW3AEfN4JioVVwesJmd5ERKXOgyZnPzUwAAOyrMO22bjIEBDlGYbQ8+0V8wJjVkp2PLgX9mq8ORW1QZifraopLHNZhp2N8hdYJxUkivO3dMCoDAPByeS0VaYoBDFGbbT7QAAC4Ymxqya04LblPtN9lE44Zgi3h6vD4zOGbaojqonkE1sq6+043PTECi04auHp+aJSLSAgMcojASQmBbnwxOqMiuF/kiZRZNcotKJ0P+pN4iY/N0Bh0McYGxZLEomC23qSq5TUXaYYBDFEYnT3Whoc0Nm0XBrNHJIbuuLAo9VNcOv1+E7Lpaa1QP2tTbFlWg5qmx3WOav+/eIX+h3aICerep2ElFWmKAQxRGsv5mel5SSOe6FKTHw2mzoKvHh4rmzpBdV2tyinG6zoqMZdu6zy9wqtOj8WpGrqHNjaYODxQFIx48OZA5wQwOO6lISwxwiMJIvoOdG8LtKQCwWhRMDNZOHDDRNpVeu6jsVgvS4gNBjhlm4cjsTUF6PGIdoR+oKAOcI/XtcJlslAEZBwMcojDadiKQwSkKYYGxNDk7sLVgljqcTo8XncHDLPVyDlVfWSYqNO4d8Bf67A0QyMDJUQYHTDbKgIyDAQ5RmHR5fGqXUyg7qCS10LjOHJ1UTcHtKafNggSnTePVnMlM04zlEQ2hbhHvS3b67TPZKAMyDgY4RGGy62QLvH6B7KTed7OhNCkY4Jhli6qhz/ZUqOYFhZKZWsUPyBk4Ie6g6mtqrhxlYI7fTzKeiAQ4q1evRkFBAWJiYlBcXIytW7ee8/avvPIKpkyZgpiYGMycORNr167t9/Vbb70ViqL0+1i4cGE47wLRkO2uCrxznT06JSwv2DKDc7yxA909vpBfP9LUIX863J4CzBPg+P0Ch9Uhf+ELcOSp9/trzZFhJOMJe4Dz8ssvY8WKFbj//vuxfft2zJ49GwsWLEB9ff2At//oo49w8803Y9myZdixYwcWLVqERYsWYc+ePf1ut3DhQtTU1Kgff/rTn8J9V4iGZF9we0oejhlqWYlOpMTZ4ReBYk6jkx1UeiswluSJ4kafhXPyVBc6PT44bBYUpMeF7efIDM6B2jZONCZNhD3Aeeyxx3Dbbbdh6dKlmDZtGp566inExcXh2WefHfD2v/zlL7Fw4ULcc889mDp1Kn70ox/hggsuwK9//et+t3M6ncjJyVE/UlNDX+NANBLytG9ZixBqiqKoWwxm2KZq0mkHlZSVZI4DNw8GszcTMhNgs4bvJWBMWhziHVZ4vH6UN3aE7ecQnU1YAxyPx4Nt27ahtLS09wdaLCgtLcWmTZsG/J5Nmzb1uz0ALFiw4Izbb9y4EVlZWZg8eTLuuOMONDU1nXUdbrcbLper3wdROLm9PjWrMj1MAQ7Qd6Kx8X+nZYt4ul63qBLMcR7VoQhsTwGBicZTglmcfSY7UoSMIawBTmNjI3w+H7Kzs/t9Pjs7G7W1tQN+T21t7Xlvv3DhQjz//PPYsGEDfvazn+Hdd9/FtddeC59v4DqEVatWITk5Wf3Iz88f4T0jOrfDde3w+gVS4uzIDUOBsSS7YMyQwdH9FpWswTH4ieIHwnREw0Cm5gZ+BgMc0oL+ejEH4aabblL/f+bMmZg1axbGjx+PjRs34uqrrz7j9itXrsSKFSvUP7tcLgY5FFZye2p6XlJYO4Im5wTmmJihBqdBp+dQSVlJgXW1ub3o8vjCMiAvEmSL+JQwZ3AAYFpuoP6MnVSkhbBmcDIyMmC1WlFXV9fv83V1dcjJyRnwe3JycoZ0ewAoLCxERkYGjhw5MuDXnU4nkpKS+n0QhdPe4OwP2UkSLhMyAy9SNa3daDP4xFi1Biden1tUiU4bnLbAU6ZR63A8Xj+ONgSC4UkRCHDUDE41MzgUeWENcBwOB4qKirBhwwb1c36/Hxs2bEBJScmA31NSUtLv9gCwfv36s94eAE6ePImmpibk5uaGZuFEIyRT8uEqMJaS4+zq1snRBmMXcqpbVDrN4CiKomZxGtqN2UlV3tgBr18g0WkLy2ym003JSYJFCdRXGb37jIwn7F1UK1aswDPPPIM//OEP2L9/P+644w50dHRg6dKlAIBbbrkFK1euVG//rW99C+vWrcPPf/5zHDhwAA888AA++eQTLF++HADQ3t6Oe+65B5s3b8bx48exYcMGXH/99ZgwYQIWLFgQ7rtDdF5+v+izRRWeFvG+JmQaf5vK4/WjtSuQgdJrDQ7Qp9DYoBmcA8Fi9Ek5iREZphjrsKIgIx4At6ko8sIe4Nx444149NFHcd9992HOnDkoKyvDunXr1ELiiooK1NTUqLe/5JJL8OKLL+Lpp5/G7Nmz8Ze//AWvvvoqZsyYAQCwWq3YtWsXPv/5z2PSpElYtmwZioqK8P7778Pp1O8TI0WPiuZOdATnjBQGn9zDSZ4GbeQAp6kjEDBYLQpSYu0ar+bsjH5cQ6Q6qPqStT5G/v0kY4pIkfHy5cvVDMzpNm7ceMbnbrjhBtxwww0D3j42NhZvvvlmKJdHFFJye2pKTmJY54xIZghwGtsC21Np8Q5YLPo7pkHKSjT2LBx5MGs4j2g43fhghlHW/hBFCs+iIgoxWWAczvk3fckAx8gvIHIGTpZO628kox/XcFCDDI4a4Bg4ACdjYoBDFGIH1TbcyAY4J5qMeyaVDBgydR7gZBl4i6rd7UVlcxcArTI4xi6CJ+NhgEMUYofqgm24EXoRyUp0IjHGBr8AjjcZ80VEzsDJ1HGBMWDsDI48YDMr0YnUCLbiF2YG6tAa291o7TT2KAMyFgY4RCHU6fGi8lQnAGBSdkJEfqaiKIavwzFKBqe3yNh4Lc+HIxx4S/FOmzrN+2ijMX8/yZgY4BCF0JH6dggBpMc7kB7BbITRW8WNEuDIIuPGdg/8fqHxaoZG1mjJYDiSWIdDWmCAQxRCkd6ekpjBiQx5EKjPL3Cq06PxaoZG1sDILaNIGh/8mazDoUhigEMUQrLOIVLbU5LhAxyD1ODYrRakBetXjFZofCyYwZHZlEgab4JOPzIeBjhEISTbcCdqlME51tgBn8G2TgDjZHCA3k4qIxUa9/j8qGgO1IZpEuBwi4o0wACHKIS0KuQcnRoHp80Cj9ePyuALmVF0erxod3sBGCPAMeI04xNNnfD6BeIdVmQnRf7vWAY4J5o74fH6I/7zKToxwCEKkbbuHlS1BOaMRHqLympRUGjQQmM5xTjGbkGCMyLD1UfEiK3icnuqMDMhImdQnS47yYl4hxU+v0BFM+twKDIY4BCFyOFgYJGV6ERKXOTmjEhqHY7B6hzkydyZiU5NXnyHyogBjpYFxkBglMF4tU6MAQ5FBgMcohDpLTCO7PaUZNRWcbX+RucFxpJcp5Fm4RzVsMBY4plUFGkMcIhCRKsWcUlmcA4bNcAxQP0NAGQlGe/ATS07qKTCjPjgWpjBochggEMUIoc0ahGX1EM369shhHE6qYwW4MgMjmxt1zshhOZbVAAwJj0OAHDylLGK4Mm4GOAQhYjcGop0i7hUkBEHixI4VLHOZYwXX6DvDJwYjVcyOGoNjkH+jps7PGjt6oGiAOMytAtwRqfKAKdLszVQdGGAQxQCXR4faloDNRmFGr2IOG1WFKQHfraR6nCMlsHJCrZZt7m96PLo//R2mb0ZlRKLGLtVs3Xkp8YCAGpau9DjY6s4hR8DHKIQkKd4p8TZI3pS8+l6O1XaNFvDUBktwEl02uC0BZ46jVCHo4cCYwDISHDCYbPAL4DaVuMUaJNxMcAhCoHyxkCAIzMoWjFiq7jRAhxFUdQsjmxx17PeGTja/m5aLApGB7M4lazDoQhggEMUAjLA0bLGAehtFZcTlfVOCNFbg2OQAAfoU2hsiAxO4HdT6wwO0KcOp5l1OBR+DHCIQuC4XgIcgx1q2NrVgx5foOMrI0G7rb2hMtJxDXpoEZdkBoedVBQJDHCIQkDW4BRoHODIGpzGdg9aOj2armUwZAYkOdYOp027Atihyko0xiwct9fX55BNbX83ASCfnVQUQQxwiEJA3aLSuAYnwWlDXnLgxdcInVRGq7+RjHJcw4mmTvhFoDBaD3/HvRkcBjgUfgxwiEaorbsHje2BbElBRpzGq+nbSWWAAKfdWMc0SFkG2aLqW2Csh3O+WGRMkcQAh2iEjjcGnqwzEpxIjLFrvJo+nVRGCHCCAUKGDrILQ2GUDI6eCoyB3iLjWlc3PF7OwqHwYoBDNELlTbLAWPvsDWCsM6lkBifLoAGO3g/cVGfgZOkjwMlIcCDGboEQgYF/ROHEAIdohMob9DEDRzLSqeJGrcGRRcaN7R74/fo990s9g0rj4ndJURQ1i1PJVnEKMwY4NGhCCPxpawUue/htPPj6PrR192i9JF2QHVTjdNClAvRmcKpautDp8Wq8mnNTAxyD1eCkB1vafX6BUzrtVhNC9LaI6ySDA7BVnCKHAQ4NSqfHi7tf2YmVf9uNyuYuPPthOUofexdvH6jTemma00sHlZSe4ERqXKAW6FjwHbxeGTWDY7dakBY8kkOvhcYN7W60dXthUYCx6frYPgXYKg4Afr/A5mNNeOC1vXhxS4XWyzEtm9YLIH3r9Hjx4pYK/Pa9Y2hoc8OiALdeMg4bDtThRFMnbn9+G/7wtYtw6YQMrZeqGb3MwOlrYlYith5vxpH6dswYlaz1cs6qMViDk2GwDA4QqBtq7vCgoc2Nqblar+ZMR+sDv5f5aXG6mjEU7Z1U+2tcuP3/Pum3RacowM0XjdFwVebEDA6dVWO7G9f+8n38+J/70dDmxqiUWLzw9Ytx3+em4c1vX47PzMqF1y/wjT9uw6E64xzuGEqnOjxo6Qxs1emlBgcwRqu41+dHU0dge8doGRxA/51Uxxr1M8G4r9FRnMFxe3347z/tQGVzFxKdNhSPSwMA/O+re/DeoQaNV2c+DHBoQB6vH3f+cTtONHUiNzkGDy+ehXe+cyVKxqcDAGLsVvz8htmYV5CKtm4vlq75GO1ufdd7hIOcEpud5ESsQz/vkns7qfQbeDZ3eCAEYFGgbvcYid6Pa5AZHL0UGEv5adFbg/OL9YdxuL4dGQkObLznSrx0+8X44txR8PkF7nxhOw7UurReoqkwwKEBPfjGXmw93oxEpw3/t6wY/zEvHw5b/1+XGLsVT3/lQoxOjUVVSxde/rhSo9VqR6bZZV2BXhhhFo4MDNITnLBatB9CN1SGyeDoqMAY6M3g1LnccHt9Gq8mcrZXnMLT7x0FAPx40UykJzihKApWLZ6J4nFpaHd78bU1H6POpe/RA0bCAIfO8M7BevxxcwUUBXj8pjnqi+VAUuMduPPKCQCANR+Ww+uLruFdch89P02fAc6Jpk706PQxMeoUY0muW6+zcGRwq7cMTmqcHXHBbGdVFG1TPbLuIPwCWDQnDwtn5Kifd9oCbxQLM+NR3dqNrz33MTqiMBseDgxw6Ayr3z4CAFh6yThcPTX7vLf/4gWjkBbvwMlTXfj3vujqqpJpdlk4qRd5yTGIc1jh9QucaNJnJ5VRO6ikrCT9Hrjp6u5Ra1wmZSdqvJr+FEWJuk6qmtYubC5vAgDcfc3kM76eHGfHc7dehPR4B/ZWu/DAa3sjvURTYoBD/Wwtb8YnJ07BYbXgv64oHNT3xNit+PLFYwEAv3v/WDiXpzuVwSdovW1RKYqi+20qowc4MoMjM1F6sq86UMsxKiUWqTqsb4q2Qzdf31kNIYB5BalnzfaOSY/Dk18ugqIAr2w7yREcIcAAh/r5zcZA9mZx0WhkB9+hDsZXLh4Lh9WC7RUt2HbiVLiWpztqBidNXxkcQP8TjY0e4GQlBQMcl/4CnL3BAGd6XpLGKxlYtLWKv7qjGgBw/ZxR57zdRePSsOzScQCA7/11N1p0OkTSKBjgkGpvdSs2HmyARQG+McjsjZSZ6MQX5gb+8T4ZDJLMzu8X6jtQvWVwgN7iUr2eSdVo9BqcYGDW5vaiy6OvYtm9Va0AgOl5+pyBJLMY0ZDBOVzXhn01LtgsCq6bef6BSd9ZMBnjM+NR3+bGqrUHIrBC82KAQ6rnPjwOALhuZi7GDmOmy39dUQiLAry1vx57q1tDvDr9aWx3w+P1w2pRkJs8+GxXpHCLKrwSnTY4g52FeqvDMUoGJxpaxf9RFsjeXDEpc1DjEGLsVjy0eBYA4G87TqpvBGjoGOAQAKDL48Pa3TUAgFtKCoZ1jcLMBHxmVh4A4DfvHA3V0nRLptdzkmJgs+rvn5IMcI42tOvyQEi1i8qgAY6iKL3bVO366aTq7vHhSPAMqumj9BrgREcGRwiBf+ysAgBcP/fc21N9zStIw+z8FPT4BP78SfSN3wgV/T0rkyb+va8WHR4f8tNiceHY1GFf566rxgMA1u6pwREdD5kLhd4Wcf3V3wDA2LQ42K0Kunv8qGrR3wuJ0TM4QJ9CYx1lcA7WtsHnF0iLdyBnCHV0kSQzOA1tbnT36Gt7L5S2ljejsrkLCU4bPj2IjtS+vlwcOLrhhc0V8OnwDYoRMMAhAMDfdwTeZXxhzihYRjB0bUpOEq6Zlg0hgCc3mrujqrdFXH/1NwBgs1owLjgDRb6j14vuHh/augOzPgwd4OhwmnHf7SlF0ecAxeRYOxKdgaMQzZzF+cu2kwCAz8zMHfKk88/NzkNyrB1VLV3YeLA+HMszPQY4hPq2bvUclC9cMHrE17vjykAW5/Wd1Wgy8f6xmsHRaYAD9Nmm0lkdjsx4OG0W9YXOiLIS9TcLZ0+1vguMgcD23iiT1+F0uL34Z3Db/0sXDv15NcZuxX8Ev++Pm0+EdG3RggEO4bWyavgFMHdMivqOfyTmjknF7NHJ8Pj8eMnExzecbAke06DTLSqgt1X8cJ3OApw+9Td6zTIMhh6Pa9B7gbEkM5+VJs3grNtTi06PD2PT44a97b+kODBfbOOhBtS0mvPvKZwY4JC6PfXFEGRvpK8EC5Vf2HzCtMc3yAyOXreogD6niutsi8oM9TcAkKWzLSqvz48DNcYIcMx+6KbcnvrSBaOHHcQXZMRjXkEqhADe2FkTyuVFBQY4Ue54Ywf2VrtgtSj4zCBmNAzWZ2flIjXOjurWbmw4YL79Y59foLpF30XGQP9WcSH0U6goA5wMg87AkfSWwSlv7IDb60e8w4qCYYx6iCQzd1JVNndi07EmKArwxaKRvXH8/OxAZ+prO6tDsbSowgAnyq3dE3hXcMn49EHNaBisGLsVN84LdAE8v+l4yK6rF7Wubnj9AnarotZh6NH4zAQoCtDa1YPGdv1MRTVLBqe3yFgfbeIH6wKdi5NyEkfULBAJ6iycZvNlcF7fFQhGLh6XjlEpI3sDdN3MXFgtCnZXtaK8UZ/nyulVRAKc1atXo6CgADExMSguLsbWrVvPeftXXnkFU6ZMQUxMDGbOnIm1a9f2+7oQAvfddx9yc3MRGxuL0tJSHD58OJx3wbT+tbsWAHDtjNBlb6QvXzwGigJ8eKQJta36eAEIlcrgk/KolFhYdfxCEmO3qi8kehr4Z/STxCUZ3Da2e3Qxa+hQbTDAydLXAZsDMfOBm3I76XPB7MtIpCc4cemEDACBekkavLAHOC+//DJWrFiB+++/H9u3b8fs2bOxYMEC1NcPvG3x0Ucf4eabb8ayZcuwY8cOLFq0CIsWLcKePXvU2zz88MP41a9+haeeegpbtmxBfHw8FixYgO5uc72IhltFUyd2V7XCalGwYPrQZjQMxujUOMzJTwEAbDDZwXHqEQ1nOThPTyYGX+z0VIdjlgxOekIg6+nzC5zSwblBh4LF5BOzEzReyfnJLqqmDg86PV6NVxM6xxra1aMZFs7ICck1rw8GSv/YWaWrrWa9C3uA89hjj+G2227D0qVLMW3aNDz11FOIi4vDs88+O+Dtf/nLX2LhwoW45557MHXqVPzoRz/CBRdcgF//+tcAAtmbxx9/HP/7v/+L66+/HrNmzcLzzz+P6upqvPrqq+G+O6Yit6cuLkxDepjeSZcGh1ut32euAOdEUyBVbIQAR63DqdPP4MVGg08xluxWi7q1q4dC40PB4ZqTsvWfwUmOtSMpJjAioMJE21Rv7Ao8r146ISNk2/7XTM+G02bBsYYOtUuOzi+sAY7H48G2bdtQWlra+wMtFpSWlmLTpk0Dfs+mTZv63R4AFixYoN6+vLwctbW1/W6TnJyM4uLis17T7XbD5XL1+yDgX8EZDeHYnpKumRYIcD460oR2t3nepcm98HE6L+QE+pwqzgxOWGTppNDY7fXhRFMgUDBCgAP0Bt96G2MwEm8E628+Oyt0z6uJMXZ8akoWgMB8MRqcsAY4jY2N8Pl8yM7uv/2RnZ2N2traAb+ntrb2nLeX/x3KNVetWoXk5GT1Iz8/f1j3x0xqWruw82QrLAqwYHpo0qgDmZCVgIL0OHh8frwfHCZoBseDGZyCEMwNCrfxOjt0UwjRG+AYvAYH0E8n1bGGDvj8AokxNmQnGePvdXJOIBA7pKPs4kgcqmvDobp2OKwWXBPi51XZTfX6zmpd1HsZQVR0Ua1cuRKtra3qR2WleYfPDdYHhxsBALPzU8L6LlpRFNNtUwkhcLwx8E55XIb+t6jGZwaCsDqXGx06yKK1ub1wewOzkcyQwdHLcQ0ySJiUnWiY4Yky02SWAEceWHz5pAwkx9pDeu2rpmQhwWlDdWs3tlWcCum1zSqsAU5GRgasVivq6vq/sNXV1SEnZ+DoNicn55y3l/8dyjWdTieSkpL6fUS7TUebAATaw8Pt08FtqrcP1pti6F9juwftbi8sijFqcFLiHEiNCzzZysyTlmSmIzHGhhj70M7n0SO9ZHDkNs8kAxQYS70Bjj6yiyP1fvCNY+kQD9YcjBi7FdcEm0HYTTU4YQ1wHA4HioqKsGHDBvVzfr8fGzZsQElJyYDfU1JS0u/2ALB+/Xr19uPGjUNOTk6/27hcLmzZsuWs14yUssoWLH9xO17R+fH2Qgh8eDTwD/HS8Rlh/3lFY1ORGmdHS2cPPjlh/HceMkjIS4mF02aMF2h5BIce5miYqf4G6N1m03oWjsyCTDRAi7gkA5zjTR2GP1Xc1d2DssoWAMD8ieF5Xr1+zigAwD9316DHBG8Wwy3sW1QrVqzAM888gz/84Q/Yv38/7rjjDnR0dGDp0qUAgFtuuQUrV65Ub/+tb30L69atw89//nMcOHAADzzwAD755BMsX74cQGDL49vf/jZ+/OMf47XXXsPu3btxyy23IC8vD4sWLQr33TmnreVNeGNXDdZ8eFzXrXzHGjtQ53LDYbPggmGekTIUNqsFV04OFMhtPGj8Ohy1wNgA9TeSrBU6rqcAxwT1NwCQlaSPAzdlgCPrWowgI8GBtHgHhNBPjdhwbTnWDJ9foCA9LmzHt1w6Ph3p8Q40d3jw4ZHGsPwMMwl7gHPjjTfi0UcfxX333Yc5c+agrKwM69atU4uEKyoqUFPTe8bGJZdcghdffBFPP/00Zs+ejb/85S949dVXMWPGDPU23/3ud/HNb34Tt99+O+bNm4f29nasW7cOMTHaTpS9oSgfDpsF+2pc2BGM5PXoo+A/jAvHpkZsi+DKyZkAgI0HjX9sgwwS9D4Kv6/CYIBzTE8BjskyOHJ4oRa6e3w4EWy1NsIMHElRFEwMFsEbvQ5HBhzhyt4AgTeL1wWP1JH1Pnp08lQnXtxSgeYObWdDRaTIePny5Thx4gTcbje2bNmC4uJi9WsbN27Ec8891+/2N9xwAw4ePAi32409e/bguuuu6/d1RVHw4IMPora2Ft3d3XjrrbcwadKkSNyVc0qNd+BzswKV7no+3v7DI4H6GzkdMxIum5gJRQEO1LYZfqqxkTqoJF1lcEwyA0fKCnYsNbi0C3ACZ40BKXF2w2XGZMbpoMEDnPcPB7LT88P8vCq7Xt852KDbbqp/lFXjf/6+G996aYem64iKLqpI+kpJ4Hj7N3bVaB69DsTvF9h0LBDglESgwFhKi3dg9ugUAMC7h4ydxSk3UAeVxBqc8JH3o83tRZdHmzqSw/W9RzQYpYNKUguNa40b4NS0duFoQwcUBSgpDG+AM29cKuIcVjS0ubGvRp8z3eSsnlAe4DwcDHBCbPboZMwclQyP16/LYuN9NS60dvUgwWnDrFHJEf3ZvdtUxq3DEUKoU4yNtEUl13qqswctGh8pYLYanESnDU5b4Km0UaNtKlm/MsFA21NS7ywc49bgyKz4rFHJSI4LbXv46Zw2q5p9f+eA/t4sHqlvx4HatpAeVTFcDHBCTFEUfOXiQBbnj1tO6C6F+FGwe6p4XBps1sg+/LLQ+IPDjYbtAKhvc6PT44PVohiiRVyKd/YOf9M6iyMDnAyTZHAURVG3qbTqpDpaH3hMx2caL8CRB4NWtXShrbtH49UMTyTqb/q6Kvhc+o4OaxrlJOf5EzOQEheaoyqGiwFOGHxudh6SYmyobO7Cu4f1la2Q7zQuiWD9jTRrVDLS4h1oc3ux3aDt4jI4GJ0aC3uEA8SRkttUWs/CaTTJSeJ9qYXGGnVSHWsMZD/kUEcjSY6zq8H3YQN2Uvn9Qq2/iVRdo8yG76hs0VUphBBCPYtL1qNqyVjP0AYR67DiS0WB4yD+uEk/xcYerx9by5sBRGbA3+ksFgWXBd/hbDTosQ1G7KCS1DqcBu0CHJ9foCn4hJxlkgwOoO00Y5+/d7K2ETM4gLHrcPbVuNDY7kG8w4oLx6ZF5GfmpcRiSk4ihOgtbtaDg3VtOFIfOKri09NDP+xwqBjghMmSi8cACEzvrdTJSbk7T7agq8eH9HgHJmt0GJ/R63DKm4w3A0dSA5wm7X4fT3V64PMLKApCdtKyHmQlajcL5+SpTnh8fjhtFuSlxEb854eCkScay9EXl0zIgMMWuZdUueWvpzqcN3YGsjdXTM5EUkx4a5EGgwFOmIzPTMD8CRkQAnhxa4XWywHQu09cMj4dFos2nRaXB9vF99e4UOcyXru4zH4UpBun/kYalxF4d1/eqN2LiAwA0uMdEa8BCyctj2s4GjwlflxGPKwa/bseqckGPpNKvlm7YlJmRH/uVcE3i+8dbtRFrafPL/D3HVUAQnuS+kiY5xlGh74cLDZ++eNKuL3ajyH/SD1/KvL1N1J6glPt3nrXgFmcvgcaGo1saz/e2KnZpG21wNhE9TdA73abFltUxxqMW2AsTTLoLJzWzh5sDx58GekAZ+6YQLt4c4dHF39v7x1qQFVLF5Jj7eqsHq0xwAmj0qlZyE2OQXOHB3/+WNuW8U6PFzuC/xAvnRD5+pu+rgimVt81WB1Oh9urTos10jh8KT8tDhYFaHd7NZu6a7YZOJK2GZxAgFNowAJjSU4zbmhz45SOimbP54MjjfCLQHF3pLsqHTYL5hUEan70cGzDC1sCOxVfKhqtm0N0GeCEkc1qwZ1XjgcA/OrtI+j0eDVby8fHT6HHJzAqJRZjNG5vlnU47x9uMNTp4ofq2iBE4N16ugEzEE6bFaNSAzUaJzSqwzHbFGNJD1tURs7gxDttGB383TTSNpUcWirrYSJNNotsCmbntVLd0oW3D9QBAG6+aIyma+mLAU6Y3ThvDPLTYtHQ5saaD49rtg45/+aS8emaTzqdPToFqXF2uLq9uj6z63QHgh0eU3KTNF7J8OUHDwE8eUqjAMekGRxZZNzY7o54PcQxE2RwAOPV4Qgh1Cx0pLenJNmWvqW8WdM3iy99XAm/AC4uTMOELP0E2gxwwsxhs2DFpwPnZP323aNo7dRmkJWsd4nk+VNnY7UouGyi8Q7fPBAciz7VgNtTknyXfLK5S5Ofb7YpxlJ6QqAjzOsXOBXBSdGtXT3qXKFCA2dwAOPV4RyobUOdy40YuwUXjYtMe/jppuYmITnWjna3F7uqWjVZQ4/Pj5c/DmxPLSkeq8kazoYBTgR8fvYoTM5OhKvbi0f/fTDiP7+yuRMHattgtSjq9pDWjNguvl/N4Bg5wJEZHI0DHJNlcOxWi9r2HslC42PB7ansJCcSnLaI/dxwmBQ8ZuJQrTFaxeVzV0lhumY1J1aLgosLA8GVVttUr+6oQp3LjcxEp26KiyUGOBFgtSj4wWenAQD+b/OJiA9mWr8vsDc6ryBV89HZkszg7K126WoS59kIIdQMzpQc425RyQxOpVZbVCatwQF6O6kiWYdz1AQdVJI6C6e+TbMuv6HQuv5Gkll5LQqNfX6BJzceBQB8ff64iM4BGgx9rcbE5k/MwC3Bk8bveWVXRLeqZIDz6Wn6ia4zE52YEkxJy/ogPatu7Yar2wubRTH0i4leMjhmmmIsaVFoLDM4Rq+/AQJBmkUBWjp7NDvyYrDaunvwyXFt2sNPJwuNPzlxCt09kR1Hsm5PLY41diA51o4lF+trewpggBNR37t2CsZlxKPW1Y3v/GVnRA6cbO3swdbjgeMZSqdq+07jdFq+8xgqmb2ZkJWgu3cpQ5GfFsjgVLd0wRfhYli314fWrkBgb7Y5OIA2xzXIDqrCDOMG3VKM3YqC4LRtvdfhfHS0CV6/QEF6nLpmrYzPTEBWohMer1+dyRMJQgisfucIAODWSwp0uUVq3GdqA4pz2PDYf8yG3apg/b46fPvlsrBXvm88VA+fX2BSdgLG6uz8pPnBAOcDIwQ4sv7GwAXGQKDbx25V4PWLiE+SrncFXvidNguSY7Uf4x5qWmRwZLu/EY8OGYg8Wfygzs+kkvU3Wm9PAYHT7GUW56MjkavDWbenFvtqXIhzWHHrJQUR+7lDwQAnwuaOScWTS4pgtyr4564aLH9xB1rC2HXxb3V7SvuDz0530bg02CwKKpu7UKHh+UiDsV/W3xi4RRwI1IPJ84oifUZafVsgoMpOitF8VEE4yM4weT/DTQihbjXKzJzRyU6qwzo+k0oIgXeD3Z9ab09Jcjp9pLb727p78MPX9wEAls0fh1SdnivHAEcDpdOy8ZtgkLNuby2u/vm7+Ou2k/B4Q5vNaen0YGPwILarp+ovwIl32jB3TAoA/WdxzJLBAfq0ike4DqcumMHJTjLf9hQAZCVF9sDNls4etLsDw0NlbZXRyVk4et6iOlLfjurWbjhsFlxcqO1UeOmS4HT6nSdb1d+JcPr5vw+h1tWNgvQ43HXVhLD/vOFigKORT0/Lxp9uuxgTshLQ1OHB3a/sRNGP1+PbL+3AthOh2Ud95v1j6PD4MCUnEXNGp4TkmqGm1uHouNC4u8enFnNONXgGB+g77C/SAU4gsyGH4pmNzOBE6hgM2QmXlejUzWj8kZKt4ofr9NtJJd+MFY9LQ6xDH3/vo1PjMCYtDj6/wNby8G5T7ag4hT9sOg4A+MkXZur6d48BjoYuLEjD2v++DPcsmIzMRCfaur14tawai5/8CF977mPsGcHgpuYOjzo5ecWnJ2l2evj5yDqcj47o40TcgRypb4dfAKlxdlN0//RmcCK7RSUzOFmmzeAEAxxXZAKciuAWY6TPQAqngox42K0KOjw+VLVo0+l3Ph8HmzaKNRrudzaRqMOpaOrE7f+3DUIAX5w7SheDY8+FAY7GHDYL7rpqArasvBp/vaME/3HhaFgtCt4+UI/PPvEB7nxhG47UDz1d+9v3jqLT48OMUUm6rL+RZuenIN5hxanOHt2mpff3mX9jhtoRuZ0R6Vk49a7eGhwzkkXGbW4vujzhb9etDE6jzk81R/0NEBiYKMcw6PHIBiEEtpYHMuzyoEu9uES+WQzTwL/6tm58+fdb0NDmxpScRNz/+elh+TmhxABHJywWBUVj0/Dwl2bjrRVX4Po5eVAUYO3uWlz7y/fx120nB32telc3nv/oBIBA9kbPL8p2qwVzgnU4n4Roay7UDphggnFfmtXgqEXG5szgJDptcAZHCDRGYJtKBqhmyuAAvQP/DupwovHxpk40trvhsFowOz9F6+X0UxKsB9pXE/rhqYfq2nDTbzejorkTY9Li8PzXLjJEJyQDHB0alxGPX940F//61mW4cnImenwCd7+yE4+tPzSofekHXt+Lrh4fLhiTgqt00MZ4PkVjA++EtgVTv3pzoFaeQWX8+hug9wWxprU7ogf0qUXGJq3BURRF3aaKRCeV7ILLN0mBsaQe2aDDDI7cnpo1Oll3tSeZiU717y6U0/Jf31mNRas/xLHGDuQlx+D/ll2kFtTrHQMcHZuSk4RnvzoPd145HgDwqw2H8eN/7j9nkLN+Xx3W7q6F1aLgx4tm6jp7I104NhWAPjM4QgjsrzFXBiczwQmH1QKfX6A2grNw1CJjgzw5DodaaByBTqreFnGzBTj6PVX84/JAgDNPZ/U3kixHePq9YyOuaezx+fHD1/fim3/agU6PD5dOSMfr35yvu3lq58IAR+csFgXfXTgFP/nCDADA7z8ox1PvHhvwtm3dPfjBq3sAALdfXohpecbIOMwdkwKLEnjCjvTwufNpaHejucMDiwJMzDJHgGOxKBglz6SK0KniXR4f2roD7atm3aICIjfN2OcXqDLZDBxpspyFU98e8Wnb5yMzOPMKUjVeycCWzS9EgtOGvdUu/GtP7bCvU+fqxs1Pb1YbVe68cjye/1ox0g02gZwBjkEsKR6L7183FQDws3UH8Lv3j/XL5PT4/Ph/L5epswm+dfVErZY6ZIkxdkwObv+EqkU+VA4EszcFGfG6aQkNhUh3UsktmziHVZcj3UNFtsCHO4NT5+qGx+eHzaIgN9lcAU5+ahxi7BZ4vH6caOrQejmq+rZuHG/qhKL0bqvrTVq8A8vmjwMAPLb+4LC2oDcfa8JnfvUBPjlxColOG57+ShG+u3AKrDrtxD0XBjgGctvlhfivKwoBAD/+534sfe5jlDd2oMvjw7dfKsNb++vhtFnw8/+Yrbv94fNRt6mO6yzAMVn9jRTpQzd7h/yZc4qxFKnjGmT9TV5KrCFfeM7FYlHUbKmetqk+DnZPTc5O1HWB7dcvG4eUODuONnTgbzuqBv19Qgg8894xLPndFjS2BzqlXvvmfFwzXT+HNA8VAxyD+d7CKbjvs9PgsFmw8WADrnp0I6betw7/3F0Du1XBb79SpNt3F+dyYTDlu+2EvgqNZQbHDBOM+4p0J5Xcesw0wRyhc8mK0BZVpUm3p6TeOhz9dFLJ7amLdFp/IyXG2NW6zUfePAhXd895v6fd7cVdL27HT9buh88vsGhOHv525yWGP+OMAY7BKIqCr80fh9eXz0fR2FTYgu/eYu1WPHHzXF0c/jYcF4wJBDh7q10RmSEyWPvVFnGzZXCCNTgR2qKqM/kMHCnSGRyzdVBJk3MC3UB6mo3VW3+j7wAHAL56SQEKM+LR0ObGz988eM7btnb14EtPfoS1u2thtyp48Prp+MWNcxDnMP5WsvHvQZSanJOIv95xCfx+gdauHjjtFkP/Qo5OjUV2khN1LjfKKltQMl77M156fH51yKL5MjiBF8aqCGVwZEYj2+QZnIgFOCadgSNNlBkcnZwq3tbdow78NEKA47RZ8aNFM7Dkd1vw/OYTWFw0GrMGOK7H7fXh9uc/wYHaNmQmOvHUl4tQNFafBdTDwQyOwVksClLjHYYOboBAZkr+w9peoY86nGMNHejxCSQ4bWrGwyzk1kZNaxd6IjALJ1oyOLLIuLHdHdajR042m7NFXJKHbpY3doT8EOLh2HbiFPwi8O8mJ9kYv8OXTsjAojl5EAK496+70enpfwinzy9w9593Ykt5MxKcNjz/tYtMFdwADHBIR+YEJ4PuOtmi6TokWWA8JSfRdIWxmQlOOG0W+AVQ2xr+1vzeGTjmzuBkJDhgtSjw+oU6uTkc1HOoTBZ4S7nJMUh02uD1C5Q3at9JZaTtqb6+/5lpSImzY3+NC3e9sF19M+Pq7sGyP3yMN3bVwGYJ1G6a4SDh0zHAId2YHUyh7qwc/iGjoWS2AX99KUrfWTjhr8Op79NFZWY2qwV5KYH7GK4ZQ909PjV4MmsGR1EUTMzWTx2O7KC6yGABTmaiE7//6oWIsVvwzsEG3PHH7XjkzQP4wuoPsfFgA2LsFvz6P+fq/tDM4WKAQ7oxc3QyLApQ6+qOSFbhfHozOOZ7ZwNEtlU8WraoAGBMMOgIV+B4rKEDQgDJsXakxzvC8jP0QA7807oOx+31oSyYVdbrBONzKRqbhl/ffAGsFgVv7a/D6neO4mhDB3KSYvDKf12ChTNytV5i2Bi7cINMJc5hw6TsRByobcPOky3ISdZ2/oJsEZ9qwgwO0Lu9Ee5hf+1uLzqCnXFZJi8yBmRnU5O6jRRqh4OF7xOzEky3ddqXeuimxhmc3Sdb4fH6kZHgQKFB26ZLp2Xj2Vvn4fWd1Yh3WJGVFIMbLhyt1oyZFQMc0pU5+SmBAKeyBQs0HDB1qsOjntMkn2jNJlIZHJm9SXTaEG/iKcaS3DYKVwv+0frAbJgJWQlhub5eyELjwxoHOFuD9TcXjk0zdEB5xaRMXDEpU+tlRBS3qEhXZgcLjXdqXGh8IJgWz0+LRWKMfqeWjkSkZuGoQ/5MXmAsqUMUw1SDczhKAhzZKn6iuVPT2VjygM0LdXr+FJ0dAxzSFVlovKuyNaxttudj9vobIHLTjKtbAgFOnsnOTDqbMWHO4ByJkgAnI8GBtHgHhOi9z5Hm9wv1fDy9TzCmMzHAIV2ZlJ2AGLsFbW4vjmnYHqrW35hswF9fciul1tUd1lkjcpjgqJToCHD6/r26vaHNPPT4/Grb9ESTbp1KiqJgksadVOVNHXB1e+G0WUzZRm12DHBIV2xWC2aOSgYA7Kxs0WwdagbHxE9q6fEOxNgtECIw8C9cqloCmYxRJp3Zcrr0eAdi7VYIEfpJ0SeaOuH1C8Q5rMgzyMC5kZikcR2OfA6aMSoZditfLo2GjxjpjjoPR6M6HJ9fqO8YzXZEQ1+KoqiFxuGa2QIAVS3RlcFRFEWdFF0Z4gBHHh0yweQdVJLWnVQywJk9wDEHpH8McEh31EJjjTI4J5o60N3jR4zdgrHpxmwLHazREWgVlzU+0ZLBAcI3C0etv8k0d/2NpPUsnLKTgaGjs/OTNfn5NDIMcEh35JEN+2pcIa9hGAzZQTU5OxFWi7nfJeeHuVXc7xeoCRYZm+08r3PpzYyFNsCRHVTjTV5gLE3KCgQ41a3daOvuiejPdnt92F8d2Kqem88OKiNigEO6Mzo1FmnxDvT4hHpcQiTJU4Mnm3h7Sgp3Bqeh3Q2Pzw+rRUFOFEwxlsI1C0dmcCZGSYCTHGdHdnC8wKEIb1Ptr2mDx+dHapxd3XIkY2GAQ7qjKApmj9au0HhnMC09Y5T509Iy03AiTFN3ZWYoJykGtigq0sxXz/kKXWbM7xc42hAdLeJ9ye6lvcFsSqSo9Tf5KVFR72RGYX3GaW5uxpIlS5CUlISUlBQsW7YM7e3nnmfQ3d2Nu+66C+np6UhISMDixYtRV1fX7zaKopzx8dJLL4XzrlCEaVWHI4RQTzOPhsLCccHR88fD1JIfbQXG0pj00Gdwqlq60N3jh8NqUWt8osGs4BuNXScjewhvWfC5R26Zk/GENcBZsmQJ9u7di/Xr1+ONN97Ae++9h9tvv/2c3/P//t//w+uvv45XXnkF7777Lqqrq/HFL37xjNutWbMGNTU16seiRYvCdC9ICzLAKYtwgFPZ3IWWzh7YrYopTxE/XUFG4IXyVGcPTnV4Qn79qigsMAZ6a5taOnvgClHtyMFgbdi4jPioyobNDL7R2B3hAKdvBoeMKWwHw+zfvx/r1q3Dxx9/jAsvvBAA8MQTT+C6667Do48+iry8vDO+p7W1Fb///e/x4osv4lOf+hSAQCAzdepUbN68GRdffLF625SUFOTkaHsYI4WPzJ4ca+xAa2cPkuMic1yCbE2fmpsEp80akZ+ppTiHDbnJMahp7caxxg4Uhfh0anUGTpRlcOKdNqTFO9Dc4UFlcyem5418u3NXVfRsnfY1K7hdfbi+DZ0eL+Ic4T/PrLWzRx00OicKMrlmFba3AZs2bUJKSooa3ABAaWkpLBYLtmzZMuD3bNu2DT09PSgtLVU/N2XKFIwZMwabNm3qd9u77roLGRkZuOiii/Dss89CiLOP9Xe73XC5XP0+SN/S4h1qGn5XVUvEfq7cnpJPqtGgMDOwTVUehm2qaM3gAL2FxhVNodmm2qlumUTP7yYAZCfFICvRCb8A9kWoDke+0RmbHofUEAf9FDlhC3Bqa2uRlZXV73M2mw1paWmora096/c4HA6kpKT0+3x2dna/73nwwQfx5z//GevXr8fixYtx55134oknnjjrWlatWoXk5GT1Iz8/f/h3jCJGizocWWA8K4retck6nPLG0J/3E601OEDvrJpQnKMkhFBfdKPpd1OSbzgiVYfDAX/mMOQA53vf+96ARb59Pw4cOBCOtap+8IMf4NJLL8XcuXNx77334rvf/S4eeeSRs95+5cqVaG1tVT8qKyvDuj4KDdlJVVYZmSc1n19gT3AbIJqe2MZlBF6IjzWENoMjhIjqDI7sdDocggCnorkTLZ09cFgtUVEbdjoZ1O2K0HRzGUyywNjYhryZeffdd+PWW289520KCwuRk5OD+vr6fp/3er1obm4+a+1MTk4OPB4PWlpa+mVx6urqzllvU1xcjB/96Edwu91wOp1nfN3pdA74edK3uWNSAAQKjYUQYW/VPNrQjk6PD3EOa1S14RZmhGeLqrWrBx2ewKDGaMzgTAxhgCMzi1PzoqM27HQzZQanKvxvdoQQ6psqFhgb25ADnMzMTGRmZp73diUlJWhpacG2bdtQVFQEAHj77bfh9/tRXFw84PcUFRXBbrdjw4YNWLx4MQDg4MGDqKioQElJyVl/VllZGVJTUxnEmMz0vGRYLQoa292oae1GXphfJNWD9YI/N1r0rcHx+wUsIbrvcgZORoIDMfboe1GeGDwJ+2hDO3x+MaLfKbX+Jopqw/qSB/Aea+hAW3cPEmPC13RQ1dKFxnY3bBYF0/PMe9huNAhbDc7UqVOxcOFC3Hbbbdi6dSs+/PBDLF++HDfddJPaQVVVVYUpU6Zg69atAIDk5GQsW7YMK1aswDvvvINt27Zh6dKlKCkpUTuoXn/9dfzud7/Dnj17cOTIETz55JP46U9/im9+85vhuiukkRi7VT3sMhJ1OLvU+pvoehEZlRILu1WB2+tHdQhPFY/m+hsgMETRabPA4/WPeFK0/P2PxvobAMhIcKq/R3uqwltovDOYvZmamxSVgbmZhHWYwgsvvIApU6bg6quvxnXXXYf58+fj6aefVr/e09ODgwcPorOz9x//L37xC3z2s5/F4sWLcfnllyMnJwd/+9vf1K/b7XasXr0aJSUlmDNnDn7729/isccew/333x/Ou0IaUefhRGDvXe2girK0tK3P4LhQblNFc/0NAFgtCsYHC40P1w1/m6rH58eeam6ZyCzO7jB3Vcr6Gx6waXxhHSiQlpaGF1988axfLygoOKO9OyYmBqtXr8bq1asH/J6FCxdi4cKFIV0n6dec0Sl4cUtF2DM4Hq9fPfdqdpRlcACgMDMBRxs6UN7Ygcsmnn8LejDkFN9ozeAAgULjfTUuHK5vR+m07GFd41BdG7p7/Eh02tR6qWg0c3Qy1u2tDXsnVVlFC4DoajQwq+gZh0mGJN+x7j7ZCp//7LOORupArQsenx8pcfaoGoMvyRfOUHZSyWsVZkZPwfbpeguNh39QpLp1mp8csvooI5Jbx7vDWGjs9fnV68smBzIuBjikaxOyEhDnsKLD41MPGgwH2aUyc1RyVB6sJ2fhHAvhFpWc/xJNHWmnk4XGI5mFw5ksAXKL6kRTJ1o7Q3P8xekO17ejq8eHBKcNhRnR+3trFgxwSNesFkV9YgvnuVS7ovxFRGZZQjXsr8vjU4uMx0dxBmdCVqBI/kh9+zmnrZ9LWZQXGEspcb3TzcOVxen9u47ubJlZMMAh3ZsTgYnG0dpBJckMzslTXeju8Y34eseCgVJqnB1pUTzqfmx6HOxWBZ0eH6pbu4f8/Z0eLw7VBba3OHSu7zyclrBcX9bf8O/aHBjgkO6pRzaEqZOq0+NVaySitUslI8GBtHgHhID6gjoScksmmrM3AGC3WlCQHggeDw/j73VvtQt+AWQnOZGTHBPq5RnOLNlJFaZC4+0VpwAAF4xJDcv1KbIY4JDuyaDjQE1bSLILp9tT1fsikp0UnS8iiqJgWm5gqFkoDjQ8Giwwjub6G2kkdTisv+lvZhjPpGrt6lGnTs9hgbEpMMAh3ctLjkFGghNevwjL3vuuKD7EsK9pwamt+2pCEeAwgyNNDNbhDOfvVdaERGtm8XQzghmcqpYuNLW7Q3ptGUyOSYtDRgKn4psBAxzSPUVRMK8gkDLeWt4c8uvLDqponH/TV0gzOHKLKit657ZIsp5jOEXy6tC5KA++paQYuzrSINRvdnYE628uYPbGNBjgkCFcXJgOANh8rCnk197Jd8kAAqPpAeBAbRv8I5g55PMLtd2cGZzeAOdYQwdaOj2D/r7mDg8qmwOdaDOjPPjuS/5dhLoOZ0dloP5mLutvTIMBDhlCcWEaAOCT46fQ4/OH7LqnOjyoaA5M3J01KiVk1zWiwsx4OGwWtLu96hTi4ag61QWP1w+HzYLRqdE3NPF0qfEOtUttKFkcmb0pzIxHcmz4Dpc0Gjk2IpQni/v9Qs3gcMCfeTDAIUOYlJWI1Dg7unp8IS0w/ORE4F3b+Mx4JMdF94uI3WrB5OxgvcgItqmONAS6hQoz4qPqVPZzkVkc+SI6GL0niKeEfD1GJmvlQjk2orypA61dPXDaLGomk4yPAQ4ZgsWi4KJxgSxOKLepPj4eqOmR1452ah3OCAqNj9Zze+p0MiswpAxOn6Fz1GvGqCRYLQrq29yoHcZsoYFsD77RmTU6GXYrXxbNgo8kGYasw9kSwkJjWbQ8r4ABDtCnk2oEGZzeDioWGEtz8wN1HWWVLYOqb/L5BbYFX3TnsCaknziHDZOCmcZQTTffEbwO62/MhQEOGUbxuECA88nx5pDU4XR6vNgT3MdngBMg0/P7R5DBUYf8cQaOakpuIpw2C1q7elDedP7zvnZXtcLV7UVijA0z8rhlcro5+YGsViiGfwoh8MHhRgAc8Gc2DHDIMKbkJCI51o5Oj08NTEairKIFXr9AbnIMRqfGhmCFxjclN/DOuLq1G6c6Bt/xI/n9AgdqAzU48l02Beqb5FbTYOpwPjjcAAC4ZHw6bNwyOYNsmy8bQk3T2eytdqGiuRMxdgsun5Qx4uuRfvBfDhlG3zoc+Y5rJLYe792eisYTxAeSFGNXDzQcTh1OeVMH2t1eOG0WTGQGpx+5/bEjeBzAuXxwJPD7PX9iZljXZFRypMPuqlb4RjDSAADW7q4BAFw1OQtxDttIl0Y6wgCHDKV0ahYA4LWd1cM+nVmSBcbzWGDcz/Tglsje6qFnyeRskml5Scw8nGZu8EX5o6NN56zD6fR41fqb+ROYURjIxKwExNqtaHd7caxh6EdgSEIINcC5dmZuqJZHOsFnIDKUa2fmwmmz4HB9O/aOoBC2x+fH9hMtAKBOSaYAOQ5/d9XQ/37ldFl5KCL1umRCBhKdNpQ3dmDtnpqz3m5reTN6fAKjUmJRkM45QgOxWS3qPJyRFBrvq3HheFMnnDYLPjUlK0SrI71ggEOGkhRjR+m0bADA37ZXDfs6+6pd6OrxITnWjklZrBXpSwY4e4dR5yQzODM5u+UMybF2LLtsHADg8bcOn3VrRW6/XjYxg1un5yAPxBxJofG/dtcCAK6YlIkEJ7enzIYBDhnOF+eOAhDYpvIOs5vqw6OBF5F5BamwcBhdP7Jr51hjB9q6ewb9fT6/ULe1ZjKDM6CvzR+H5Fg7jtS347WdAwfosv7mUm5PndNsdeDf8BoO+m5PfWYWt6fMiAEOGc7lkzKRHu9AY7sb7x8ZXrHxuwcb1GtRf+kJTuQlxwDAkLYByxvb0eHxIdZu5Qycs0iKseP2ywsBBLI4HW5vv6/vq3bhQG0bFIUBzvnMDraK769xocvjG/L3bz7WjGONHYixc3vKrBjgkOHYrRZ8bnYeAODPH1cO+fvbunvUIs4rJ/GJbSBym2oo7fiy/mY6C4zP6dZLCpCR4MSJpk4sfe5jdHoCQY7b68OKP5cBABZOz0FavEPDVerfqJRY5KfFwusX+Mv2k0P+/t9/UA4A+FLRaCTGRPcxLWbFZyEypP+4MB+KAvxrTy3eD84MGawPjzTC6xcozIjHGBZxDmg4AY48I2wGt6fOKd5pw+++eiESnTZsLW/G0jUfY/OxJjz65kEcqG1DerwDP1o0Q+tl6p6iKFh2aaCm6en3jg5pu/p4Ywc2HKgDACwNXoPMhwEOGdK0vCR8taQAALDyb7vVd8GDsTG4PXXFZG5PnY2sodkzhC0qWWDMs5POb05+Cv6w7CIkOG3YUt6Mm57ejGfeD2QUfvKFmchIcGq8QmO4cd4YpMc7UNnchTd2nb0z7XRrPiyHEMCnpmTxzDQTY4BDhvWdBZMxKiUWJ0914bF/HxrU9wghegMc1t+c1fRRgULjow3tZ9SJDCRQYBwIhlhgPDgXjEnFS7dfjM/MzEVWYiCgufmifCyckaPxyowj1mHF0ksLAABPbjw6qHO+Wjt78Mq2wJbWsvnM3pgZAxwyrASnDT/+QiCV/+yH5YM6IPJQXTtqXd1w2izq4Z10pqzEGGQnOSHE4CYa768JtN3HO6wo5DviQZsxKhmrl1yALf9zNbb/4NP4yaKZWi/JcL5SUoAEpw0H69pw7193ofk8R4ys3ngEnR4fpuQk4pLxfA4wMwY4ZGhXTc7CZ2blwi+AB17be97pxm8fqAcAlIxPR4zdGoklGtbMIdThfBjsZisuTIeVbfdDpigK0uIdHFkwDMmxdvy/T08CALyy7SQ+9fONeCf47/x0xxrasebDwFbgvddO4Zwhk2OAQ4b3/eumItZuxdbjzXhtZ/VZb3ekvg2r3zkCACidmh2p5RnWzFEpAHqPtDiXD482AQDfEZMmls0fh1e+UYIpOYlo6ezB8he340h92xm3+/E/96PHJ3DV5ExcNZkdlGbHAIcMLy8lFnddNR4A8NO1+9HadeZwutbOHtz2/Da0u70oHpeGG+flR3qZhiOLsN871Ai39+xzRjxePz4uDwRBnN1CWplXkIbXvzkfFxemocPjwzf+uL1f/di6PTV4+0A97FYFP/jsNA1XSpHCAIdM4euXFWJsehzqXG7c8NRHqGrpUr+2veIUbnl2C8obOzAqJRa/WXIB7JzTcl6zRiUjK9GJdrcXm4+dPYuzo+IUunp8SI93YHI2j70g7ditFjxx8wXITnLiSH07/uv/tuFwXRte3VGF5S/uABBoC2edWHTg4RtkCjF2K576chFuXbMVh+rasWj1h5hXkIp6lxufBIf6xTusePqWIqSzBXdQLBYFV0/Nxp+2VuCtfXVn7TqT21Ml49NZQ0Kay0x04jdLLsBNT2/GB0cacc3j70GW5n12Vi7uvmaStgukiOHbWDKNqblJ+Pudl2JydiIa2txYu7sWn5w4BYsC/MeFo/HvFVdgeh5bmIfi09MCdQpv7a87awH3R8EC4/ncniKdKBqbhteWz8fC6TlqcPO1S8fhVzfNhdPG5oJowQwOmUpeSiz+ckcJ3thVgx6fH/EOGy4Ym4pxGTwbaTguGZ+BWLsVNa3d2FvtOmNKcYfbi7LKFgCsvyF9mZqbhKe+UoTDdW1oaHOjZHw6u6aiDAMcMp3EGDtuvmiM1sswhRi7FZdNzMC/99Vh/b66MwKc9w83wOsXyE+LRX4aj70g/ZmYnYiJrA2LStyiIqJz+vS0QEv967uq0dPnvJ/uHh9W/esAAOC6GbmarI2I6GwY4BDROV0zLQcpcXYca+hQT2AGgF9tOIwTTZ3ISYrB8k9N0HCFRERnYoBDROeUHGfH/1w3FQDw+FuHUNnciY+PN+Pp944BAH54/XQkxti1XCIR0RlYg0NE53VD0Wj8bftJbD7WjOt+9T7augMD1K6Zlo0F03k4JBHpDzM4RHReiqLgp1+YCYfNgrZuL2wWBdfNzMGqL/JwSCLSJ2ZwiGhQCjMT8H9fuwhHGzqwYHo2ByYSka4xwCGiQSsuTEdxIQ/UJCL94xYVERERmQ4DHCIiIjIdBjhERERkOgxwiIiIyHTCFuA0NzdjyZIlSEpKQkpKCpYtW4b29vZzfs/TTz+NK6+8EklJSVAUBS0tLSG5LhEREUWXsAU4S5Yswd69e7F+/Xq88cYbeO+993D77bef83s6OzuxcOFC/M///E9Ir0tERETRRRFCiFBfdP/+/Zg2bRo+/vhjXHjhhQCAdevW4brrrsPJkyeRl5d3zu/fuHEjrrrqKpw6dQopKSkhu67kcrmQnJyM1tZWJCUlDe9OEhERUUQN5fU7LBmcTZs2ISUlRQ1CAKC0tBQWiwVbtmzR3XWJiIjIXMIy6K+2thZZWVn9f5DNhrS0NNTW1kb8um63G263W/2zy+Ua9hqIiIhI/4aUwfne974HRVHO+XHgwIFwrXXYVq1aheTkZPUjPz9f6yURERFRGA0pg3P33Xfj1ltvPedtCgsLkZOTg/r6+n6f93q9aG5uRk7O8E8eHu51V65ciRUrVqh/drlcDHKIiIhMbEgBTmZmJjIzM897u5KSErS0tGDbtm0oKioCALz99tvw+/0oLi4e3kpHcF2n0wmnkwcDEhERRYuwFBlPnToVCxcuxG233YatW7fiww8/xPLly3HTTTepnU5VVVWYMmUKtm7dqn5fbW0tysrKcOTIEQDA7t27UVZWhubm5kFfl4iIiChsp4m/8MILWL58Oa6++mpYLBYsXrwYv/rVr9Sv9/T04ODBg+js7FQ/99RTT+GHP/yh+ufLL78cALBmzRp1a+x81x0M2RnPYmMiIiLjkK/bg5lwE5Y5OHp38uRJ1uAQEREZVGVlJUaPHn3O20RlgOP3+1FdXY3ExEQoijLi68mi5crKStMODuR9NAfeR3PgfTQH3sehE0Kgra0NeXl5sFjOXWUTti0qPbNYLOeN/IYjKSnJtL+kEu+jOfA+mgPvoznwPg5NcnLyoG7H08SJiIjIdBjgEBERkekwwAkBp9OJ+++/39SzdngfzYH30Rx4H82B9zG8orLImIiIiMyNGRwiIiIyHQY4REREZDoMcIiIiMh0GOAQERGR6TDAGaKf/OQnuOSSSxAXF4eUlJQBb1NRUYHPfOYziIuLQ1ZWFu655x54vd5+t9m4cSMuuOACOJ1OTJgwAc8991z4Fz8MGzduhKIoA358/PHHAIDjx48P+PXNmzdrvPrBKygoOGP9Dz30UL/b7Nq1C5dddhliYmKQn5+Phx9+WKPVDt3x48exbNkyjBs3DrGxsRg/fjzuv/9+eDyefrcx+uMIAKtXr0ZBQQFiYmJQXFzc70BfI1m1ahXmzZuHxMREZGVlYdGiRTh48GC/21x55ZVnPF7f+MY3NFrx0D3wwANnrH/KlCnq17u7u3HXXXchPT0dCQkJWLx4Merq6jRc8dAN9NyiKAruuusuAMZ8DN977z187nOfQ15eHhRFwauvvtrv60II3HfffcjNzUVsbCxKS0tx+PDhfrdpbm7GkiVLkJSUhJSUFCxbtgzt7e2hXaigIbnvvvvEY489JlasWCGSk5PP+LrX6xUzZswQpaWlYseOHWLt2rUiIyNDrFy5Ur3NsWPHRFxcnFixYoXYt2+feOKJJ4TVahXr1q2L4D0ZHLfbLWpqavp9fP3rXxfjxo0Tfr9fCCFEeXm5ACDeeuutfrfzeDwar37wxo4dKx588MF+629vb1e/3traKrKzs8WSJUvEnj17xJ/+9CcRGxsrfvvb32q46sH717/+JW699Vbx5ptviqNHj4p//OMfIisrS9x9993qbczwOL700kvC4XCIZ599Vuzdu1fcdtttIiUlRdTV1Wm9tCFbsGCBWLNmjdizZ48oKysT1113nRgzZky/38srrrhC3Hbbbf0er9bWVg1XPTT333+/mD59er/1NzQ0qF//xje+IfLz88WGDRvEJ598Ii6++GJxySWXaLjioauvr+93/9avXy8AiHfeeUcIYczHcO3ateL73/+++Nvf/iYAiL///e/9vv7QQw+J5ORk8eqrr4qdO3eKz3/+82LcuHGiq6tLvc3ChQvF7NmzxebNm8X7778vJkyYIG6++eaQrpMBzjCtWbNmwABn7dq1wmKxiNraWvVzTz75pEhKShJut1sIIcR3v/tdMX369H7fd+ONN4oFCxaEdc2h4PF4RGZmpnjwwQfVz8kXxh07dmi3sBEaO3as+MUvfnHWr//mN78Rqamp6mMohBD33nuvmDx5cgRWFx4PP/ywGDdunPpnMzyOF110kbjrrrvUP/t8PpGXlydWrVql4apCo76+XgAQ7777rvq5K664QnzrW9/SblEjdP/994vZs2cP+LWWlhZht9vFK6+8on5u//79AoDYtGlThFYYet/61rfE+PHj1TeIRn8MTw9w/H6/yMnJEY888oj6uZaWFuF0OsWf/vQnIYQQ+/btEwDExx9/rN7mX//6l1AURVRVVYVsbdyiCrFNmzZh5syZyM7OVj+3YMECuFwu7N27V71NaWlpv+9bsGABNm3aFNG1Dsdrr72GpqYmLF269Iyvff7zn0dWVhbmz5+P1157TYPVjcxDDz2E9PR0zJ07F4888ki/bcVNmzbh8ssvh8PhUD+3YMECHDx4EKdOndJiuSPW2tqKtLS0Mz5v1MfR4/Fg27Zt/f5tWSwWlJaWGuLf1vm0trYCwBmP2QsvvICMjAzMmDEDK1euRGdnpxbLG7bDhw8jLy8PhYWFWLJkCSoqKgAA27ZtQ09PT7/Hc8qUKRgzZoxhH0+Px4M//vGP+NrXvtbvoGejP4Z9lZeXo7a2tt/jlpycjOLiYvVx27RpE1JSUnDhhReqtyktLYXFYsGWLVtCtpaoPGwznGpra/sFNwDUP9fW1p7zNi6XC11dXYiNjY3MYofh97//PRYsWNDvsNKEhAT8/Oc/x6WXXgqLxYK//vWvWLRoEV599VV8/vOf13C1g/ff//3fuOCCC5CWloaPPvoIK1euRE1NDR577DEAgcds3Lhx/b6n7+Oampoa8TWPxJEjR/DEE0/g0UcfVT9n9MexsbERPp9vwH9bBw4c0GhVoeH3+/Htb38bl156KWbMmKF+/j//8z8xduxY5OXlYdeuXbj33ntx8OBB/O1vf9NwtYNXXFyM5557DpMnT0ZNTQ1++MMf4rLLLsOePXtQW1sLh8NxRq1jdna2+lxqNK+++ipaWlpw6623qp8z+mN4OvnYDPTvsO9rYFZWVr+v22w2pKWlhfSxZYAD4Hvf+x5+9rOfnfM2+/fv71f8ZnTDuc8nT57Em2++iT//+c/9bpeRkYEVK1aof543bx6qq6vxyCOPaPrCOJT72Hf9s2bNgsPhwH/9139h1apVuh6jPpzHsaqqCgsXLsQNN9yA2267Tf28Xh9HAu666y7s2bMHH3zwQb/P33777er/z5w5E7m5ubj66qtx9OhRjB8/PtLLHLJrr71W/f9Zs2ahuLgYY8eOxZ///Gddv9Ebrt///ve49tprkZeXp37O6I+hnjHAAXD33Xf3i6gHUlhYOKhr5eTknNG1Iav+c3Jy1P+e3glQV1eHpKSkiP2jHs59XrNmDdLT0wf1YldcXIz169ePZIkjNpLHtbi4GF6vF8ePH8fkyZPP+pgBvY+rFoZ6H6urq3HVVVfhkksuwdNPP33e6+vhcRysjIwMWK3WAR8nLR+jkVq+fDneeOMNvPfee/0ypwMpLi4GEMjQGfHFMSUlBZMmTcKRI0fw6U9/Gh6PBy0tLf2yOEZ9PE+cOIG33nrrvJkZoz+G8rGpq6tDbm6u+vm6ujrMmTNHvU19fX2/7/N6vWhubg7pY8sAB0BmZiYyMzNDcq2SkhL85Cc/QX19vZqCW79+PZKSkjBt2jT1NmvXru33fevXr0dJSUlI1jAYQ73PQgisWbMGt9xyC+x2+3lvX1ZW1u+XWwsjeVzLyspgsVjUx7CkpATf//730dPTo97/9evXY/LkyZpuTw3lPlZVVeGqq65CUVER1qxZA4vl/CV4engcB8vhcKCoqAgbNmzAokWLAAS2djZs2IDly5dru7hhEELgm9/8Jv7+979j48aNZ2yRDqSsrAwADPOYna69vR1Hjx7FV77yFRQVFcFut2PDhg1YvHgxAODgwYOoqKiI6HNlqKxZswZZWVn4zGc+c87bGf0xHDduHHJycrBhwwY1oHG5XNiyZQvuuOMOAIHn05aWFmzbtg1FRUUAgLfffht+v18N8EIiZOXKUeLEiRNix44d4oc//KFISEgQO3bsEDt27BBtbW1CiN428WuuuUaUlZWJdevWiczMzAHbxO+55x6xf/9+sXr1at22iUtvvfWWACD2799/xteee+458eKLL4r9+/eL/fv3i5/85CfCYrGIZ599VoOVDt1HH30kfvGLX4iysjJx9OhR8cc//lFkZmaKW265Rb1NS0uLyM7OFl/5ylfEnj17xEsvvSTi4uIM0yZ+8uRJMWHCBHH11VeLkydP9mtJlYz+OAoRaBN3Op3iueeeE/v27RO33367SElJ6dfVaBR33HGHSE5OFhs3buz3eHV2dgohhDhy5Ih48MEHxSeffCLKy8vFP/7xD1FYWCguv/xyjVc+eHfffbfYuHGjKC8vFx9++KEoLS0VGRkZor6+XggRaBMfM2aMePvtt8Unn3wiSkpKRElJicarHjqfzyfGjBkj7r333n6fN+pj2NbWpr72ARCPPfaY2LFjhzhx4oQQItAmnpKSIv7xj3+IXbt2ieuvv37ANvG5c+eKLVu2iA8++EBMnDiRbeJa++pXvyoAnPEhZxoIIcTx48fFtddeK2JjY0VGRoa4++67RU9PT7/rvPPOO2LOnDnC4XCIwsJCsWbNmsjekSG6+eabzzp/4rnnnhNTp04VcXFxIikpSVx00UX9Wjv1btu2baK4uFgkJyeLmJgYMXXqVPHTn/5UdHd397vdzp07xfz584XT6RSjRo0SDz30kEYrHro1a9YM+Hvb9z2O0R9H6YknnhBjxowRDodDXHTRRWLz5s1aL2lYzvZ4yeeKiooKcfnll4u0tDThdDrFhAkTxD333KP7GSp93XjjjSI3N1c4HA4xatQoceONN4ojR46oX+/q6hJ33nmnSE1NFXFxceILX/hCv6DcKN58800BQBw8eLDf5436GL7zzjsD/m5+9atfFUIEWsV/8IMfiOzsbOF0OsXVV199xn1vamoSN998s0hISBBJSUli6dKlaqIgVBQhhAhdPoiIiIhIe5yDQ0RERKbDAIeIiIhMhwEOERERmQ4DHCIiIjIdBjhERERkOgxwiIiIyHQY4BAREZHpMMAhIiIi02GAQ0RERKbDAIeIiIhMhwEOERERmQ4DHCIiIjKd/w/2HFN/iEpDmAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "plt.plot(signal.correlation_lags(100, 100), signal.correlate(target_la - target_la.mean(), steerCommands - steerCommands.mean()))\n",
+    "plt.show()\n",
+    "print(signal.correlation_lags(100, 100)[np.argmax(signal.correlate(target_la - target_la.mean(), steerCommands - steerCommands.mean()))])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}