barebone_mppi_numba.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Barebone Numba implementation of Model Predictive Path Integral (MPPI) control proposed by Williams et al. [Paper link (see alg. 2).](https://ieeexplore.ieee.org/document/7989202)\n",
    "* Unicycle dynamics\n",
    "* Multiple obstacles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import copy\n",
    "import numba\n",
    "import time\n",
    "from numba import cuda\n",
    "from numba.cuda.random import create_xoroshiro128p_states, xoroshiro128p_normal_float32\n",
    "\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Information about your GPU\n",
    "gpu = cuda.get_current_device()\n",
    "max_threads_per_block = gpu.MAX_THREADS_PER_BLOCK\n",
    "max_square_block_dim = (int(gpu.MAX_BLOCK_DIM_X**0.5), int(gpu.MAX_BLOCK_DIM_X**0.5))\n",
    "max_blocks = gpu.MAX_GRID_DIM_X\n",
    "max_rec_blocks = rec_max_control_rollouts = int(1e6) # Though theoretically limited by max_blocks on GPU\n",
    "rec_min_control_rollouts = 100\n",
    "\n",
    "class Config:\n",
    "  \n",
    "  \"\"\" Configurations that are typically fixed throughout execution. \"\"\"\n",
    "  \n",
    "  def __init__(self, \n",
    "               T=10, # Horizon (s)\n",
    "               dt=0.1, # Length of each step (s)\n",
    "               num_control_rollouts=1024, # Number of control sequences\n",
    "               num_vis_state_rollouts=20, # Number of visualization rollouts\n",
    "               seed=1):\n",
    "    \n",
    "    self.seed = seed\n",
    "    self.T = T\n",
    "    self.dt = dt\n",
    "    self.num_steps = int(T/dt)\n",
    "    self.max_threads_per_block = max_threads_per_block # save just in case\n",
    "\n",
    "    assert T > 0\n",
    "    assert dt > 0\n",
    "    assert T > dt\n",
    "    assert self.num_steps > 0\n",
    "    \n",
    "    # Number of control rollouts are currently limited by the number of blocks\n",
    "    self.num_control_rollouts = num_control_rollouts\n",
    "    if self.num_control_rollouts > rec_max_control_rollouts:\n",
    "      self.num_control_rollouts = rec_max_control_rollouts\n",
    "      print(\"MPPI Config: Clip num_control_rollouts to be recommended max number of {}. (Max={})\".format(\n",
    "        rec_max_control_rollouts, max_blocks))\n",
    "    elif self.num_control_rollouts < rec_min_control_rollouts:\n",
    "      self.num_control_rollouts = rec_min_control_rollouts\n",
    "      print(\"MPPI Config: Clip num_control_rollouts to be recommended min number of {}. (Recommended max={})\".format(\n",
    "        rec_min_control_rollouts, rec_max_control_rollouts))\n",
    "    \n",
    "    # For visualizing state rollouts\n",
    "    self.num_vis_state_rollouts = num_vis_state_rollouts\n",
    "    self.num_vis_state_rollouts = min([self.num_vis_state_rollouts, self.num_control_rollouts])\n",
    "    self.num_vis_state_rollouts = max([1, self.num_vis_state_rollouts])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFAULT_OBS_COST = 1e3\n",
    "DEFAULT_DIST_WEIGHT = 10\n",
    "\n",
    "# Stage costs (device function)\n",
    "@cuda.jit('float32(float32, float32)', device=True, inline=True)\n",
    "def stage_cost(dist2, dist_weight):\n",
    "  return dist_weight*dist2 # squared term makes the robot move faster\n",
    "\n",
    "# Terminal costs (device function)\n",
    "@cuda.jit('float32(float32, boolean)', device=True, inline=True)\n",
    "def term_cost(dist2, goal_reached):\n",
    "  return (1-np.float32(goal_reached))*dist2\n",
    "\n",
    "class MPPI_Numba(object):\n",
    "  \n",
    "  \"\"\" \n",
    "  Implementation of Information theoretic MPPI by Williams et. al. \n",
    "  Alg 2. in https://homes.cs.washington.edu/~bboots/files/InformationTheoreticMPC.pdf\n",
    "\n",
    "\n",
    "  Planner object that initializes GPU memory and runs MPPI on GPU via numba. \n",
    "  \n",
    "  Typical workflow: \n",
    "    1. Initialize object with config that allows pre-initialization of GPU memory\n",
    "    2. reset()\n",
    "    3. setup(mppi_params) based on problem instance\n",
    "    4. solve(), which returns optimized control sequence\n",
    "    5. get_state_rollout() for visualization\n",
    "    6. shift_and_update(next_state, optimal_u_sequence, num_shifts=1)\n",
    "    7. Repeat from 2 if params have changed\n",
    "  \"\"\"\n",
    "\n",
    "  def __init__(self, cfg):\n",
    "\n",
    "    # Fixed configs\n",
    "    self.cfg = cfg\n",
    "    self.T = cfg.T\n",
    "    self.dt = cfg.dt\n",
    "    self.num_steps = cfg.num_steps\n",
    "    self.num_control_rollouts = cfg.num_control_rollouts\n",
    "\n",
    "    self.num_vis_state_rollouts = cfg.num_vis_state_rollouts\n",
    "    self.seed = cfg.seed\n",
    "\n",
    "    # Basic info \n",
    "    self.max_threads_per_block = cfg.max_threads_per_block\n",
    "\n",
    "    # Initialize reuseable device variables\n",
    "    self.noise_samples_d = None\n",
    "    self.u_cur_d = None\n",
    "    self.u_prev_d = None\n",
    "    self.costs_d = None\n",
    "    self.weights_d = None\n",
    "    self.rng_states_d = None\n",
    "    self.state_rollout_batch_d = None # For visualization only. Otherwise, inefficient\n",
    "\n",
    "    # Other task specific params\n",
    "    self.device_var_initialized = False\n",
    "    self.reset()\n",
    "\n",
    "    \n",
    "  def reset(self):\n",
    "    # Other task specific params\n",
    "    self.u_seq0 = np.zeros((self.num_steps, 2), dtype=np.float32)\n",
    "    self.params = None\n",
    "    self.params_set = False\n",
    "\n",
    "    self.u_prev_d = None\n",
    "    \n",
    "    # Initialize all fixed-size device variables ahead of time. (Do not change in the lifetime of MPPI object)\n",
    "    self.init_device_vars_before_solving()\n",
    "\n",
    "\n",
    "  def init_device_vars_before_solving(self):\n",
    "\n",
    "    if not self.device_var_initialized:\n",
    "      t0 = time.time()\n",
    "      \n",
    "      self.noise_samples_d = cuda.device_array((self.num_control_rollouts, self.num_steps, 2), dtype=np.float32) # to be sampled collaboratively via GPU\n",
    "      self.u_cur_d = cuda.to_device(self.u_seq0) \n",
    "      self.u_prev_d = cuda.to_device(self.u_seq0) \n",
    "      self.costs_d = cuda.device_array((self.num_control_rollouts), dtype=np.float32)\n",
    "      self.weights_d = cuda.device_array((self.num_control_rollouts), dtype=np.float32)\n",
    "      self.rng_states_d = create_xoroshiro128p_states(self.num_control_rollouts*self.num_steps, seed=self.seed)\n",
    "      \n",
    "      self.state_rollout_batch_d = cuda.device_array((self.num_vis_state_rollouts, self.num_steps+1, 3), dtype=np.float32)\n",
    "      \n",
    "      self.device_var_initialized = True\n",
    "      print(\"MPPI planner has initialized GPU memory after {} s\".format(time.time()-t0))\n",
    "\n",
    "\n",
    "  def setup(self, params):\n",
    "    # These tend to change (e.g., current robot position, the map) after each step\n",
    "    self.set_params(params)\n",
    "\n",
    "\n",
    "  def set_params(self, params):\n",
    "    self.params = copy.deepcopy(params)\n",
    "    self.params_set = True\n",
    "\n",
    "\n",
    "  def check_solve_conditions(self):\n",
    "    if not self.params_set:\n",
    "      print(\"MPPI parameters are not set. Cannot solve\")\n",
    "      return False\n",
    "    if not self.device_var_initialized:\n",
    "      print(\"Device variables not initialized. Cannot solve.\")\n",
    "      return False\n",
    "    return True\n",
    "\n",
    "  def solve(self):\n",
    "    \"\"\"Entry point for different algoritims\"\"\"\n",
    "    \n",
    "    if not self.check_solve_conditions():\n",
    "      print(\"MPPI solve condition not met. Cannot solve. Return\")\n",
    "      return\n",
    "    \n",
    "    return self.solve_with_nominal_dynamics()\n",
    "\n",
    "\n",
    "  def move_mppi_task_vars_to_device(self):\n",
    "    vrange_d = cuda.to_device(self.params['vrange'].astype(np.float32))\n",
    "    wrange_d = cuda.to_device(self.params['wrange'].astype(np.float32))\n",
    "    xgoal_d = cuda.to_device(self.params['xgoal'].astype(np.float32))\n",
    "    goal_tolerance_d = np.float32(self.params['goal_tolerance'])\n",
    "    lambda_weight_d = np.float32(self.params['lambda_weight'])\n",
    "    u_std_d = cuda.to_device(self.params['u_std'].astype(np.float32))\n",
    "    x0_d = cuda.to_device(self.params['x0'].astype(np.float32))\n",
    "    dt_d = np.float32(self.params['dt'])\n",
    "\n",
    "    if \"obstacle_positions\" in self.params:\n",
    "      obs_pos_d = cuda.to_device(self.params['obstacle_positions'].astype(np.float32))\n",
    "    else:\n",
    "      obs_pos_d = np.array([[1e5,1e5]], dtype=np.float32) # dummy value, else numba panics : (\n",
    "    if \"obstacle_radius\" in self.params:\n",
    "      obs_r_d = cuda.to_device(self.params['obstacle_radius'].astype(np.float32))\n",
    "    else:\n",
    "      obs_r_d = np.array([0], dtype=np.float32) # dummy value, else numba panics : (\n",
    "\n",
    "    obs_cost_d = np.float32(DEFAULT_OBS_COST if 'obs_penalty' not in self.params \n",
    "                                     else self.params['obs_penalty'])\n",
    "    return vrange_d, wrange_d, xgoal_d, \\\n",
    "           goal_tolerance_d, lambda_weight_d, \\\n",
    "           u_std_d, x0_d, dt_d, obs_cost_d, obs_pos_d, obs_r_d\n",
    "\n",
    "\n",
    "  def solve_with_nominal_dynamics(self):\n",
    "    \"\"\"\n",
    "    Launch GPU kernels that use nominal dynamics but adjsuts cost function based on worst-case linear speed.\n",
    "    \"\"\"\n",
    "    \n",
    "    vrange_d, wrange_d, xgoal_d, goal_tolerance_d, lambda_weight_d, \\\n",
    "           u_std_d, x0_d, dt_d, obs_cost_d, obs_pos_d, obs_r_d = self.move_mppi_task_vars_to_device()\n",
    "  \n",
    "    # Weight for distance cost\n",
    "    dist_weight = DEFAULT_DIST_WEIGHT if 'dist_weight' not in self.params else self.params['dist_weight']\n",
    "\n",
    "    # Optimization loop\n",
    "    for k in range(self.params['num_opt']):\n",
    "\n",
    "      # Sample control noise\n",
    "      self.sample_noise_numba[self.num_control_rollouts, self.num_steps](\n",
    "            self.rng_states_d, u_std_d, self.noise_samples_d)\n",
    "      \n",
    "      # Rollout and compute mean or cvar\n",
    "      self.rollout_numba[self.num_control_rollouts, 1](\n",
    "        vrange_d,\n",
    "        wrange_d,\n",
    "        xgoal_d,\n",
    "        obs_cost_d, \n",
    "        obs_pos_d, \n",
    "        obs_r_d,\n",
    "        goal_tolerance_d,\n",
    "        lambda_weight_d,\n",
    "        u_std_d,\n",
    "        x0_d,\n",
    "        dt_d,\n",
    "        dist_weight,\n",
    "        self.noise_samples_d,\n",
    "        self.u_cur_d,\n",
    "\n",
    "        # results\n",
    "        self.costs_d\n",
    "      )\n",
    "      self.u_prev_d = self.u_cur_d\n",
    "\n",
    "      # Compute cost and update the optimal control on device\n",
    "      self.update_useq_numba[1, 32](\n",
    "        lambda_weight_d, \n",
    "        self.costs_d, \n",
    "        self.noise_samples_d, \n",
    "        self.weights_d, \n",
    "        vrange_d,\n",
    "        wrange_d,\n",
    "        self.u_cur_d\n",
    "      )\n",
    "\n",
    "    return self.u_cur_d.copy_to_host()\n",
    "\n",
    "\n",
    "  def shift_and_update(self, new_x0, u_cur, num_shifts=1):\n",
    "    self.params[\"x0\"] = new_x0.copy()\n",
    "    self.shift_optimal_control_sequence(u_cur, num_shifts)\n",
    "\n",
    "\n",
    "  def shift_optimal_control_sequence(self, u_cur, num_shifts=1):\n",
    "    u_cur_shifted = u_cur.copy()\n",
    "    u_cur_shifted[:-num_shifts] = u_cur_shifted[num_shifts:]\n",
    "    self.u_cur_d = cuda.to_device(u_cur_shifted.astype(np.float32))\n",
    "\n",
    "\n",
    "  def get_state_rollout(self):\n",
    "    \"\"\"\n",
    "    Generate state sequences based on the current optimal control sequence.\n",
    "    \"\"\"\n",
    "\n",
    "    assert self.params_set, \"MPPI parameters are not set\"\n",
    "\n",
    "    if not self.device_var_initialized:\n",
    "      print(\"Device variables not initialized. Cannot run mppi.\")\n",
    "      return\n",
    "    \n",
    "    # Move things to GPU\n",
    "    vrange_d = cuda.to_device(self.params['vrange'].astype(np.float32))\n",
    "    wrange_d = cuda.to_device(self.params['wrange'].astype(np.float32))\n",
    "    x0_d = cuda.to_device(self.params['x0'].astype(np.float32))\n",
    "    dt_d = np.float32(self.params['dt'])\n",
    "\n",
    "    self.get_state_rollout_across_control_noise[self.num_vis_state_rollouts, 1](\n",
    "        self.state_rollout_batch_d, # where to store results\n",
    "        x0_d, \n",
    "        dt_d,\n",
    "        self.noise_samples_d,\n",
    "        vrange_d,\n",
    "        wrange_d,\n",
    "        self.u_prev_d,\n",
    "        self.u_cur_d,\n",
    "        )\n",
    "    \n",
    "    return self.state_rollout_batch_d.copy_to_host()\n",
    "\n",
    "\n",
    "  \"\"\"GPU kernels from here on\"\"\"\n",
    "\n",
    "  @staticmethod\n",
    "  @cuda.jit(fastmath=True)\n",
    "  def rollout_numba(\n",
    "          vrange_d, \n",
    "          wrange_d, \n",
    "          xgoal_d, \n",
    "          obs_cost_d, \n",
    "          obs_pos_d, \n",
    "          obs_r_d,\n",
    "          goal_tolerance_d, \n",
    "          lambda_weight_d, \n",
    "          u_std_d, \n",
    "          x0_d, \n",
    "          dt_d,\n",
    "          dist_weight_d,\n",
    "          noise_samples_d,\n",
    "          u_cur_d,\n",
    "          costs_d):\n",
    "    \"\"\"\n",
    "    There should only be one thread running in each block, where each block handles a single sampled control sequence.\n",
    "    \"\"\"\n",
    "\n",
    "\n",
    "    # Get block id and thread id\n",
    "    bid = cuda.blockIdx.x   # index of block\n",
    "    tid = cuda.threadIdx.x  # index of thread within a block\n",
    "    costs_d[bid] = 0.0\n",
    "\n",
    "    # Explicit unicycle update and map lookup\n",
    "    # From here on we assume grid is properly padded so map lookup remains valid\n",
    "    x_curr = cuda.local.array(3, numba.float32)\n",
    "    for i in range(3): \n",
    "      x_curr[i] = x0_d[i]\n",
    "\n",
    "    timesteps = len(u_cur_d)\n",
    "    goal_reached = False\n",
    "    goal_tolerance_d2 = goal_tolerance_d*goal_tolerance_d\n",
    "    dist_to_goal2 = 1e9\n",
    "    v_nom =v_noisy = w_nom = w_noisy = 0.0\n",
    "\n",
    "\n",
    "    # printed=False\n",
    "    for t in range(timesteps):\n",
    "      # Nominal noisy control\n",
    "      v_nom = u_cur_d[t, 0] + noise_samples_d[bid, t, 0]\n",
    "      w_nom = u_cur_d[t, 1] + noise_samples_d[bid, t, 1]\n",
    "      v_noisy = max(vrange_d[0], min(vrange_d[1], v_nom))\n",
    "      w_noisy = max(wrange_d[0], min(wrange_d[1], w_nom))\n",
    "      \n",
    "      # Forward simulate\n",
    "      x_curr[0] += dt_d*v_noisy*math.cos(x_curr[2])\n",
    "      x_curr[1] += dt_d*v_noisy*math.sin(x_curr[2])\n",
    "      x_curr[2] += dt_d*w_noisy\n",
    "\n",
    "      # If else statements will be expensive\n",
    "      dist_to_goal2 = (xgoal_d[0]-x_curr[0])**2 + (xgoal_d[1]-x_curr[1])**2\n",
    "      costs_d[bid]+= stage_cost(dist_to_goal2, dist_weight_d)\n",
    "\n",
    "      # Add obstacle costs\n",
    "      num_obs = len(obs_pos_d)\n",
    "      for obs_i in range(num_obs):\n",
    "        op = obs_pos_d[obs_i]\n",
    "        dist_diff = (x_curr[0]-op[0])**2+(x_curr[1]-op[1])**2-obs_r_d[obs_i]**2\n",
    "        costs_d[bid] += (1-numba.float32(dist_diff>0))*obs_cost_d\n",
    "\n",
    "      if dist_to_goal2<= goal_tolerance_d2:\n",
    "        goal_reached = True\n",
    "        break\n",
    "    \n",
    "    # Accumulate terminal cost \n",
    "    costs_d[bid] += term_cost(dist_to_goal2, goal_reached)\n",
    "\n",
    "    for t in range(timesteps):\n",
    "      costs_d[bid] += lambda_weight_d*(\n",
    "              (u_cur_d[t,0]/(u_std_d[0]**2))*noise_samples_d[bid, t,0] + (u_cur_d[t,1]/(u_std_d[1]**2))*noise_samples_d[bid, t, 1])\n",
    "\n",
    "  @staticmethod\n",
    "  @cuda.jit(fastmath=True)\n",
    "  def update_useq_numba(\n",
    "        lambda_weight_d,\n",
    "        costs_d,\n",
    "        noise_samples_d,\n",
    "        weights_d,\n",
    "        vrange_d,\n",
    "        wrange_d,\n",
    "        u_cur_d):\n",
    "    \"\"\"\n",
    "    GPU kernel that updates the optimal control sequence based on previously evaluated cost values.\n",
    "    Assume that the function is invoked as update_useq_numba[1, NUM_THREADS], with one block and multiple threads.\n",
    "    \"\"\"\n",
    "\n",
    "    tid = cuda.threadIdx.x\n",
    "    num_threads = cuda.blockDim.x\n",
    "    numel = len(noise_samples_d)\n",
    "    gap = int(math.ceil(numel / num_threads))\n",
    "\n",
    "    # Find the minimum value via reduction\n",
    "    starti = min(tid*gap, numel)\n",
    "    endi = min(starti+gap, numel)\n",
    "    if starti<numel:\n",
    "      weights_d[starti] = costs_d[starti]\n",
    "    for i in range(starti, endi):\n",
    "      weights_d[starti] = min(weights_d[starti], costs_d[i])\n",
    "    cuda.syncthreads()\n",
    "\n",
    "    s = gap\n",
    "    while s < numel:\n",
    "      if (starti % (2 * s) == 0) and ((starti + s) < numel):\n",
    "        # Stride by `s` and add\n",
    "        weights_d[starti] = min(weights_d[starti], weights_d[starti + s])\n",
    "      s *= 2\n",
    "      cuda.syncthreads()\n",
    "\n",
    "    beta = weights_d[0]\n",
    "    \n",
    "    # Compute weight\n",
    "    for i in range(starti, endi):\n",
    "      weights_d[i] = math.exp(-1./lambda_weight_d*(costs_d[i]-beta))\n",
    "    cuda.syncthreads()\n",
    "\n",
    "    # Normalize\n",
    "    # Reuse costs_d array\n",
    "    for i in range(starti, endi):\n",
    "      costs_d[i] = weights_d[i]\n",
    "    cuda.syncthreads()\n",
    "    for i in range(starti+1, endi):\n",
    "      costs_d[starti] += costs_d[i]\n",
    "    cuda.syncthreads()\n",
    "    s = gap\n",
    "    while s < numel:\n",
    "      if (starti % (2 * s) == 0) and ((starti + s) < numel):\n",
    "        # Stride by `s` and add\n",
    "        costs_d[starti] += costs_d[starti + s]\n",
    "      s *= 2\n",
    "      cuda.syncthreads()\n",
    "\n",
    "    for i in range(starti, endi):\n",
    "      weights_d[i] /= costs_d[0]\n",
    "    cuda.syncthreads()\n",
    "    \n",
    "    # update the u_cur_d\n",
    "    timesteps = len(u_cur_d)\n",
    "    for t in range(timesteps):\n",
    "      for i in range(starti, endi):\n",
    "        cuda.atomic.add(u_cur_d, (t, 0), weights_d[i]*noise_samples_d[i, t, 0])\n",
    "        cuda.atomic.add(u_cur_d, (t, 1), weights_d[i]*noise_samples_d[i, t, 1])\n",
    "    cuda.syncthreads()\n",
    "\n",
    "    # Blocks crop the control together\n",
    "    tgap = int(math.ceil(timesteps / num_threads))\n",
    "    starti = min(tid*tgap, timesteps)\n",
    "    endi = min(starti+tgap, timesteps)\n",
    "    for ti in range(starti, endi):\n",
    "      u_cur_d[ti, 0] = max(vrange_d[0], min(vrange_d[1], u_cur_d[ti, 0]))\n",
    "      u_cur_d[ti, 1] = max(wrange_d[0], min(wrange_d[1], u_cur_d[ti, 1]))\n",
    "\n",
    "\n",
    "  @staticmethod\n",
    "  @cuda.jit(fastmath=True)\n",
    "  def get_state_rollout_across_control_noise(\n",
    "          state_rollout_batch_d, # where to store results\n",
    "          x0_d, \n",
    "          dt_d,\n",
    "          noise_samples_d,\n",
    "          vrange_d,\n",
    "          wrange_d,\n",
    "          u_prev_d,\n",
    "          u_cur_d):\n",
    "    \"\"\"\n",
    "    Do a fixed number of rollouts for visualization across blocks.\n",
    "    Assume kernel is launched as get_state_rollout_across_control_noise[num_blocks, 1]\n",
    "    The block with id 0 will always visualize the best control sequence. Other blocks will visualize random samples.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Use block id\n",
    "    tid = cuda.threadIdx.x\n",
    "    bid = cuda.blockIdx.x\n",
    "    timesteps = len(u_cur_d)\n",
    "\n",
    "\n",
    "    if bid==0:\n",
    "      # Visualize the current best \n",
    "      # Explicit unicycle update and map lookup\n",
    "      # From here on we assume grid is properly padded so map lookup remains valid\n",
    "      x_curr = cuda.local.array(3, numba.float32)\n",
    "      for i in range(3): \n",
    "        x_curr[i] = x0_d[i]\n",
    "        state_rollout_batch_d[bid,0,i] = x0_d[i]\n",
    "      \n",
    "      for t in range(timesteps):\n",
    "        # Nominal noisy control\n",
    "        v_nom = u_cur_d[t, 0]\n",
    "        w_nom = u_cur_d[t, 1]\n",
    "        \n",
    "        # Forward simulate\n",
    "        x_curr[0] += dt_d*v_nom*math.cos(x_curr[2])\n",
    "        x_curr[1] += dt_d*v_nom*math.sin(x_curr[2])\n",
    "        x_curr[2] += dt_d*w_nom\n",
    "\n",
    "        # Save state\n",
    "        state_rollout_batch_d[bid,t+1,0] = x_curr[0]\n",
    "        state_rollout_batch_d[bid,t+1,1] = x_curr[1]\n",
    "        state_rollout_batch_d[bid,t+1,2] = x_curr[2]\n",
    "    else:\n",
    "      \n",
    "      # Explicit unicycle update and map lookup\n",
    "      # From here on we assume grid is properly padded so map lookup remains valid\n",
    "      x_curr = cuda.local.array(3, numba.float32)\n",
    "      for i in range(3): \n",
    "        x_curr[i] = x0_d[i]\n",
    "        state_rollout_batch_d[bid,0,i] = x0_d[i]\n",
    "\n",
    "      \n",
    "      for t in range(timesteps):\n",
    "        # Nominal noisy control\n",
    "        v_nom = u_prev_d[t, 0] + noise_samples_d[bid, t, 0]\n",
    "        w_nom = u_prev_d[t, 1] + noise_samples_d[bid, t, 1]\n",
    "        v_noisy = max(vrange_d[0], min(vrange_d[1], v_nom))\n",
    "        w_noisy = max(wrange_d[0], min(wrange_d[1], w_nom))\n",
    "\n",
    "        # # Nominal noisy control\n",
    "        v_nom = u_prev_d[t, 0]\n",
    "        w_nom = u_prev_d[t, 1]\n",
    "        \n",
    "        # Forward simulate\n",
    "        x_curr[0] += dt_d*v_noisy*math.cos(x_curr[2])\n",
    "        x_curr[1] += dt_d*v_noisy*math.sin(x_curr[2])\n",
    "        x_curr[2] += dt_d*w_noisy\n",
    "\n",
    "        # Save state\n",
    "        state_rollout_batch_d[bid,t+1,0] = x_curr[0]\n",
    "        state_rollout_batch_d[bid,t+1,1] = x_curr[1]\n",
    "        state_rollout_batch_d[bid,t+1,2] = x_curr[2]\n",
    "\n",
    "\n",
    "  @staticmethod\n",
    "  @cuda.jit(fastmath=True)\n",
    "  def sample_noise_numba(rng_states, u_std_d, noise_samples_d):\n",
    "    \"\"\"\n",
    "    Should be invoked as sample_noise_numba[NUM_U_SAMPLES, NUM_THREADS].\n",
    "    noise_samples_d.shape is assumed to be (num_rollouts, time_steps, 2)\n",
    "    Assume each thread corresponds to one time step\n",
    "    For consistency, each block samples a sequence, and threads (not too many) work together over num_steps.\n",
    "    This will not work if time steps are more than max_threads_per_block (usually 1024)\n",
    "    \"\"\"\n",
    "    block_id = cuda.blockIdx.x\n",
    "    thread_id = cuda.threadIdx.x\n",
    "    abs_thread_id = cuda.grid(1)\n",
    "\n",
    "    noise_samples_d[block_id, thread_id, 0] = u_std_d[0]*xoroshiro128p_normal_float32(rng_states, abs_thread_id)\n",
    "    noise_samples_d[block_id, thread_id, 1] = u_std_d[1]*xoroshiro128p_normal_float32(rng_states, abs_thread_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple navigation task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "cfg = Config(T = 5.0,\n",
    "            dt = 0.1,\n",
    "            num_control_rollouts = int(1e3), # Same as number of blocks, can be more than 1024\n",
    "            num_vis_state_rollouts = 20,\n",
    "            seed = 1)\n",
    "x0 = np.array([0,0,np.pi/4])\n",
    "xgoal = np.array([7,5])\n",
    "\n",
    "obstacle_positions = np.array([[5,4.5], [2,1]])\n",
    "obstacle_radius = np.array([1.5, 1])\n",
    "assert len(obstacle_positions)==len(obstacle_radius)\n",
    "\n",
    "\n",
    "mppi_params = dict(\n",
    "    # Task specification\n",
    "    dt=cfg.dt,\n",
    "    x0=x0, # Start state\n",
    "    xgoal=xgoal, # Goal position\n",
    "\n",
    "    # For risk-aware min time planning\n",
    "    goal_tolerance=0.5,\n",
    "    dist_weight=10, #  Weight for dist-to-goal cost.\n",
    "\n",
    "    lambda_weight=1.0, # Temperature param in MPPI\n",
    "    num_opt=1, # Number of steps in each solve() function call.\n",
    "\n",
    "    # Control and sample specification\n",
    "    u_std=np.array([1.0, 1.0]), # Noise std for sampling linear and angular velocities.\n",
    "    vrange = np.array([0.0, 2.0]), # Linear velocity range.\n",
    "    wrange=np.array([-np.pi, np.pi]), # Angular velocity range.\n",
    "\n",
    "    ## obstacles\n",
    "    obstacle_positions=obstacle_positions,\n",
    "    obstacle_radius=obstacle_radius,\n",
    "    obs_penalty=1e6,\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MPPI planner has initialized GPU memory after 0.014859199523925781 s\n",
      "2.74 ms ± 425 µs per loop (mean ± std. dev. of 5 runs, 5 loops each)\n"
     ]
    }
   ],
   "source": [
    "# How fast does the loop run?\n",
    "mppi_planner = MPPI_Numba(cfg)\n",
    "mppi_planner.setup(mppi_params)\n",
    "\n",
    "%timeit -n 5 -r 5 mppi_planner.solve()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MPPI planner has initialized GPU memory after 0.009333372116088867 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "goal reached at t=4.50s\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsEAAADCCAYAAACouh/zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABjHklEQVR4nO2dd3gc1fX+36tu9S6rWZZkSa6y3A3GBWyMTTPNNi2hBZJfQgiBJJBGSeBLEkiHhJCEEiDGpsUUgws2YGMbXJBcJMuSi2z1ZjWra+/vj7MjreVdacvMzqz2fJ5Hz2hXuzNX0uzMuee+5z1CSgmGYRiGYRiG8SZ89B4AwzAMwzAMw7gbDoIZhmEYhmEYr4ODYIZhGIZhGMbr4CCYYRiGYRiG8To4CGYYhmEYhmG8Dg6CGYZhGIZhGK/DT4+DxsbGyrFjx+pxaIZhGIZhGMaL2LdvX72UMm7w87oEwWPHjsXevXv1ODTDMAzDMAzjRQghyqw9z3IIhmEYhmEYxuvgIJhhGIZhGIbxOjgIZhiGYRiGYbwODoIZhmEYhmEYr4OD4OE49DZw4nO9R8EwDOO5lO0EDr6l9ygYrdn/H+D0Hr1HwTB243IQLIQIEkJ8JYQoEEIcFkI8rsbADIGUwIcPAlse03skDMMwnsvnzwAbfkzXVGZk0tsFfPAAsOFHeo+EYexGjUxwF4BLpJRTAeQBWCaEmKvCfvWn6RTQcQao/BroaNJ7NAzDMJ5JQwnQ0Qi0Vus9EkYragsBUw9QlU/3TIbxAFwOgiXRZn7ob/4aGdP9qgLaShNwcoe+Y2EYhvFEejqAptP0fc1hfcfCaEdlPm2FL7DvFV2HwjD2ooomWAjhK4TIB1ALYLOU8ksrr7lHCLFXCLG3rq5OjcNqT1UBfaD9g4Hjn+o9GoZhGM+j8QT68yI1h3QdCqMhVQVAUASQuwo4+CbQ1ar3iBhmWFQJgqWUfVLKPAApAGYLISZbec0LUsqZUsqZcXHnda4zJlX5QPwEIO1C4MRneo+GYRjG82gooa3w4SB4JFOVDyROBWbcAXS3UVE5wxgcVd0hpJRNALYBWKbmfnVBSlreSZwKpC8E6o8CLZV6j4phGMazaCilbdo8lkOMVHq76X+bmAekzgbiJwL7XtZ7VAwzLGq4Q8QJISLN348CcCmAI67uV3daq4D2egqCMxbRc8c5G8wwDOMQ9aVAWBIFR/VHyUWAGVnUFQF93UBSHiAEMON2Ko5TdMIMY1DUyAQnAtgmhDgAYA9IE/yBCvvVF+XDm5gHJEwGgmNYF8wwDOMoDSVATCaQMAkw9VIgzIwsLO+XAOmC/YI4G8wYHjXcIQ5IKadJKXOllJOllL9SY2C6U1UAQACjJwM+PkD6AtIFs88lwzCM/TSUArFZlEwAgGrWBY84qgqAwAggOoMej4oCJl1nLpBrG/q9DKMj3DHOFlUFQGw2EBBCj9MXkkSCsxgMwzD2cbaBvNZjsoDoTMA3kIvjRiJV+UBiLkkhFGbcbi6Q406BjHHhINgWVfmkb1JgXTDDMIxjKEVxMeMAXz8gfjwXx400+noou5849dznU2cDcRNYEsEYGg6CrdFaQ1lfyw91dDoQOYZ1wQzDMPai2KPFjqNtwhQOgkcadUeAvi4gadq5zwsBzLyDC+QYQ8NBsDWqD9B28Mw2YxF1juvrdfuQGIZhPI76EsDHH4gYQ48TJgFna4G2Wn3HxajH4KI4S7hAjjE4HARboyqftqOnnPt8+kKgq3ng54zxqD0ClG7RexQMwwAkh4jOICkEQEEwwLrgkURVPhAQNlAUZwkXyDEGh4Nga1TmUxFHUMS5z6cvpC1LIozL9meAt+/WexQMwwADzhAKikMESyJGDlUFVBTnYyOc6C+Q4w5yjPHgINgaVQfOl0IAQGgcXcS5hbJxaakCOhqpIp1hGP0w9QGNx8kjWCEkBghL5CB4pNDXay6Ky7P9mv4CuZfcNiyGsRcOggfT3gg0n7IeBAOkCz71JdDT4dZhMXbSWkXbxhP6joNhvJ2mU9RFLCbr3OcTJrEcYqRQXwz0dpzrpDQYLpBjDAwHwYNR9L62PtTpC6kS9tRud42IsRcpgdZq+v4MB8EMoyuW9miWJEwC6orJWovxbIYqirNEKZDb/4rWI2IYh+AgeDBVBbQdnWv952kXAj5+rAs2Il2tQM9Z+p4zwQyjL0oQHDs4EzyZMsT1Je4fE6MuVflAQOj5E53BjIoCJl0LHOACOcZYcBA8mKoC8gMOjrb+88BQIGUW64KNiJIFBjgIZhi9qS8BgiKB4Jhzn+93iGBdsMdTVUAuSraK4iyZcQfQ3coFcoyh4CB4MJX5wy/tpC+k17U3umFAjN20mYNgH3+WQzCM3jSUUobQspUuQO3offxZF+zpmPqA6oPD3y8VuIMcY0A4CLako4mCJ1tFcQoZiwBIapzBGAclE5w0jTPBDKM3g+3RFHz9gThun+zx1B8FetqHLoqzpL9Abv+A7JBhdIaDYEuqD9J2uJlt8gzAP4R1wUZDcYZIuwBorWQHD4bRi+6zQEvFufZolrBDhOdjb1GcJdxBjjEYHARbojhDDJcJ9gsAxs5jXbDRaK2mIo0Ec6e/Myd1HQ7DeC0Nx2g72B5NIWESTVrPNrhvTIy6VOUD/sHWs/224AI5xmC4HAQLIVKFENuEEIVCiMNCiB+oMTBdqCoAwpOpKcZwpC+k5b7mcu3HxdhHaxUQNhqITqfHLIlgGH1oMDs/2AqQlOK4WpZEeCz9RXG+jr2PC+QYA6FGJrgXwINSyokA5gL4nhBiogr7dT9VBcNngRUyFtH2OGeDDUNrNXWjUnrYc3Ecw+hDwzEAYuCzOJjR5tUa1gV7JqY+c2fVPMffywVyjIHwc3UHUsoqAFXm71uFEEUAkgEUurpvt9LVSpY+k2845+l/bT+O6uZOzMuKxZz0aAQHmP9k8ROB4FjSBU+7xf3jdYGWzh68/MVJlNS2ITrYH5HBAYgK9kdUSACigukrMtgf0SEBCA7whRhc3T2Iju4+nGnvRuPZbjS19+BMezea2rvReHbg+46ePs1/r19XluFE0AS8+NYx/NEnBF/t2o01pXM0Py4z8slJCMONs8cgKXKU3kPpp6m9GwfKm1FwuglHalrR22fSe0j93FmzG5l+8fj5G7aD3Kd9I3Hwi0/xn5JZbhyZZ5MQHoQfLM5CTGigpsfZVlyLN/eeRp9JWv356O4yPN5zFi+diMDuV/c6vP+LTZfgxsrn8MS/1uB0oANyisH7yYnH6lmpw96jXKGnz4R/fHYMByuaHX6vgECAnw8C/XwQ6O+DAF9fBPqbH/v59j/f/72fDwL9fTEhMQzxYUEa/DauU9PSib9/egyp0cG4dEICxsQE6z0kl3A5CLZECDEWwDQAX1r52T0A7gGAMWPGqHlYdag+BECekwneUliDJz4sghDAv3acgL+vwPQxUZifFYt542IxNX0hfE58Rp3KNPwQqkVnTx9e2XkSf//sGJrae5AaPQotHb1o7rDduSnA16c/II4M9kdYkD/OdvXiTHsPzpztxpn2bnT12r75hgX6ITLEH8H+ftr+iaREeG89TveEo6yxAxViNELby1HW0K7hQRlvoM8ksamwBs9uK8XiCQn4xtw0XDQuFj4+7vvMd/b0obCqBQWnm+irvBkn6s/2/zwtJhij/B1cltaQqI4ylInEIT9/pWIs4tpLVf+Mzu3ZjRk9X+Ofo+5Et9A2WHQ3247U4cMDVXjy2slYNjlR9f23dvbgiQ+KsHbvaSSEByIqOMDq6zK7qahxd+cYlPU4/v97y3QRrsU/MbV2PXYEf9epsbZ392Hj4RrsKK3HU9dNQViQv1P7GYrq5k58f81+7Dl5BuPiQ+Hn4GfeJCV6+iS6evrQ1Wsyf/Whp8/65EIhLNAPv7k+F1fkqv8/doXS2jbc9uJXqG7pRJ9J4tcfFCI7IRRLJiRgycQE5KVEuvW6qAZCyqH/GXbvSIhQAJ8BeFJK+c5Qr505c6bcu9fx2aOm7H4e+Pgh4IEjQHgiGtq6cNmfPkdcWBDWfnsuCk43YUdJPXaU1uNwZQsA4Pagz/AY/oH35r2D3GlzkRYTrOmM1Fl6+kxYu+c0/rq1BDUtXViUE4cfLc3B5OQIAEBvnwnNHT0U2LZ344xFRrexvRtN5ozumfZutHb2IiTQz5wxpuxxZLA/ooMDzssoRwb7w9/XTbWXHU3Ab9OApU8CF94LvHk7yVvu+9o9x2dGNKcb2/Hfr05h3Z7TaDjbjbSYYNw6Jw03zEhBVIj1QMFZ+kwSx+vakH+6CQXlTSg43Yyiqhb0mrNyo8ODMDU1AlNTI5GXEonJKREI1yAAcBopgd+MAabeCFz+tO3Xbfw5sOdfwE8rAF8V8zH/vASo2EeStRvXAAGenamypLi6FQ+sy8fhyhZck5eEx6+ejIhgdf73O0vr8eO3DqCquQPfXpiJ+5dkIdDPxsTq458Ce18Cflru/P/u3e8ARR8ADx6hJlQOYjJJPP/5Mfx+01GMiQ7GczdPx8SkcOfGYoXPj9bh/rX56Ozpw1PXTcGKvGTV9t1nkug2B8RdvSZ09Qx839rZi99+fAT5p5vwjblp+PkVExBkgAnu3pON+NZ/9sLPR+Cl22cjfJQfthTVYkthDb462Yg+k0RsaCAWj4/HkokJuGhcLEYF6D9uBSHEPinlzPOeVyMIFkL4A/gAwEYp5R+Ge70hg+B3/x9QugX40VFIAN95bR+2HanD+9+/CDmjw855aUNbF3Yea8Dhwwfx8NFVeKznm3i5bxmSI0f1Z4nnjYtFtMo3R0fpM0m8X1CJP2w+ilON7ZiZFoWfLBuP2ek2uuF5MrVHgL/NAa7/NzDlBmDL48DOvwA/r1H3Bst4NV29ffj4UDVe212GPSfPIMDPB1flJuHWuWOQlxrp8CTYZJIoa2zHwYpmHCxvwsGKZhyqaEFbVy8AygjlpkZgakokpqZGYmpKJEZHGHOZtJ/WGuD32cDyp4E599h+Xf4a4H/fAb63B4jLVufYZ+uBp8cBqXOA018CYy8Cbl4LBISos38D0NNnwnPbSvHs1lLEhAbgN9fn4uKceKf3197di99+dASv7CpDRmwInlk1FdPHRA39pheXA6Ze4FubnT4uTu0GXrwMuPqvwPRvOr2bL4834PtrvkZzRw8ev3qSy/KIPpPEn7YcxbPbSpEdH4bnbpmOcfGOB+mu0N1rwtMbj+Cf209gYmI4nrtlOtJj9TuHNx6uxn1rvkZS5Ci8csfs8yQQze09+PRoLTYX1uCz4jq0dvUi0M8H87NisWRCAi6ZEK+7vMNWEOxydCDobPs3gCJ7AmDDUpVPpt9C4O195dh4uAY/u3z8eQEwAMSEBuKqqUm4amoS5J/H4seR1cjMnoQdpfX48GAV3thzGj4CuDAzFivykrBs8mhNlmpsIaXElqJaPLOxGMU1rZiYGI6Xbp+FRTlxhsxUq4LiERxmXj6KTqeLdPPpAbcIhnGRQD9frMhLxoq8ZBypbsFru8vw7v4KvL2/HJOTw3HrnDRcnZc0UDtggZQSZQ3mgLeiGQfLm3GoshmtnRTwBvj5YEJiOK6dloy8VAp6M2JDPG55EQ2ltLXlEazQ3z75kHpBcOknACSw7Ckax7vfBl67AbhlHRB4/rXcE/H39cH9S7KxZEICHliXjzte2oMbZ6Xi51dMcPg+s6+sEQ+uK8DJhnbcOS8dP74sZ/jsnckEVB8Apt7kwm8BmqgoBXIuBMFzMmKw4Qfz8cO1+Xj4nYP46kQjnrh2stXP4HDUtnbiB2vyset4A1bOSMGvVkzWJZsZ4OeDn18xEXMzYvDgmwW48i/b8X8qZ6Pt5dXdZXh0/SHkpkTi37fNtKpHjwj2778udvea8NWJRmwpqsHmwhpsKaoFAOSlRuLSiQn4fwszDXVNczkTLIS4CMB2AAcBKOLQn0kpN9h6j+Eywd3twFPJwPwHUT7tASz703ZMTArHmrvnwne4f9b7PwAOvQP85ATg64fePhMOVDRj25FarM+vxKnGdgT4+WDJhHisyEvGopw420tMKrDzWD2e3liMr081IT02BA9cmo0rpiQa6qTThII36Ib3/f108z25A3j5CuAb7wKZl+g9OmYE09bVi3e/rsBru8pQXNOKsCA/XD89BVfnJaGqqRMHKpoo4K1oRosS8Pr6YEJiGKakRGBKcgSmJEciKyHUffIhLdn3Ml0X7z8IRA5R/9HbBTyZCFx0P7D4EXWO/dZd5N/+4FHAx4dsuN6+G0iZCdzyFhCk3nK5Eejq7cMfN5fghc+PITFiFJ5emYsLM2OHfV9nTx/+uPkoXth+HMmRo/D0DVNxQWaMfQetLwGenQmseA6Ydqtrv4AiQ/z2diAx16Vd9ZkknttWij9uOYrMuFD8/ZbpyEqwf+Kz81g97luTj7auHjxxzRTcMCPFpfGoRWVTB+5b8zX2lp3BTbNT8ehVk9wij5BS4plNxXhu2zEsmRCPv9403eEJgZQSR6pbsaWwBluKatAnJT74/nyNRjw0msohHMVwQXD5XuBfi2Fa9Spu3hGHg+XN+Pj+BUiNtkNLdugd4K07gLu2AKnnVjlLKfH16Sa8l1+J9wsq0XC2G+FBfrh8SiJW5CVjTnq0asFpwekmPL2xGDtK65EYEYT7l2Th+ukp8BsJN1V72PFHYMtjwM8qaemzuQL440Tgit8Ds76l9+gYL0BKib1lZ/DqrjJ8dKiqv/jF31dg/Ohwi4A3AtkJYQjwG6GfTUXr+7MqCkSH4rm5QFQaSRZcxdQHPJ0JZC8Drn1+4PnC9cBbd5Kd161vA6MiXT+WwdhXdgY/erMAJ+rP4vYLx+KhZeNtBiwHypvw4LoClNS24eY5Y/CzyycgNNCBrOmBN4F3vgV85wtg9GTXBt5xBvj9eCDvFuBKdRaSvyitxw/e+Bpnu/rwxDWTcf0wwazJJPHstlL8actRpMeG4G+3zLC6AqwnPX0m/GHzUfz902MYPzoMz96srUSjp8+Eh94+gHf2V+Cm2an49YrJqsQSnT19uumbNZNDjAgqqXhqbUUMdh9vxO+uz7UvAAaA9AW0Pf7peUGwEOQmMX1MFH5xxQTsKK3vD4jf2HMao8ODcHVeElbkJWFiYviwUoXePhMaz3ajtrULta2dqG3pQm1rFw6UN2FLUS2iQwLwyysn4pY5YwwhpO9n65NASyVwzXPaHaO1GggMH9D+hSUCvoHcMINxG0IIzBobjVljo1HfNhG7jjVgbEwIskeHarr6YzgajgHRmcMHwABJIk6fZybkHBX7KKjKuvTc5yeuAFb9B1h3G/DqNcCt7wDBI6suYkZaFDbcNx+/23gEL31xEp8drcMzK3MxIy2asq1pF6A7bgqe3VaK57aVIi40EK/cORsLs+1oDDWYqnxqfRw33vWB93eQWwcsehgIdV7brDBvXCw23Dcf973xNR58swBfnWjE4yusZ08b2rpw/9p8bC+pxzV5SXjy2ikIcWRC4Cb8fX3w0LLxmJMejQfWFeDqZ3fgiWsm47rp6mer27p68d3X9+Pzo3V44NJsfP+ScarJKA0Vl5gx3n9bD6oK0BcUhUc/a8aSCQlYOdOBEysklozfT3wGLPyxzZf5+fpgUU48FuXEo6O7D5uLarD+6wq8uOMEXvj8OLLiQ7EiLwmZcaGobe1CnRLotnb1B7uNZ7tgzbYxNjQQD1yajTsvSndsRu8O+nqAr14AfDQel9ItTsHHh7TA3DqZ0YFYc92AV9JQMqD3HY7Rk4FDb5G7i6sZ2pJNgPCxLn8afwWw+jVg3TeA/6wAvrl+xAXCowJ88ehVk7B04mj8+K0CrHx+F+6dNxoP7H0IZ5MuxMqOn6GwqgXXTU/Go1dNQsQoJ+tUKvOBhMnqFRxf+H3g8P+A/64Cbv9QlSLG+PAgvHbXHPz5kxL8dWspCsqb8Nwt05EZN5A9/epEI76/Zj/OtPfgqeum4EaN/YbVYFFOfH+A/8C6Auw61qCqbrm2tRN3vrwHRVWt+N31uVg1K1WV/RoZg0VM+mCqKkBB71iEBfrjN9dPcfyDkL6QAr3udrvseEYF+OLqqUm4emoSzpztxocHq7A+vwLPbDra/xpfH4HY0ADEhwUhMYIskeJCAxEXHoT4sED6Cg9CbGiAsbNMJ7cDnU30fU8H4K9Rs4HW6nODYACISgcaj2tzPIZhzqevhyaeE1fY9/oE83J6zWFg7DzXjl2yGUiZTdlFa+QsI8u0N24GXrmKAuGQ4fWznsYFmTH4+P4FePLDImz/4hM8EAiEVO5EoO8JvPCNpVg6afTwO7GFUhQ3ZaV6A06YBKx8if4vb94B3PhfVQJsP18fPLg0BzPSovDDtfm4+q878NT1ubhySiL+8flxPLOpGKlRo/Did2dhUlKECr+IexgdEYT/fosC/Ge3lSL/NAX42Q7on61xvK4Nt730Fepbu/Gvb87ExeNdz8p7AhwE93ZB1hRid8/leOqmKYh1phNPxsXArmeBU7uAcYsdemtUSABunZuGW+emobKpA2fauxEfFoTokIDhi/I8gcL3Br5vrgBix2lznNZqYMzcc5+LTqcMvYc0M2EYj+dMGbmyxNjZBazfIcLFILi1hpbpL/nl0K/LWgLc/Aaw5ibg5SuB295TZQneaIQG+uGp66agOPBTYA89998ZRzFqkvMuDACoFX1XCzkpqUnOcqrf+OCHwIcPAFf9WbVr9qKceGz4wXx8/79f4741X+Mvn5SgtLYNV+Qm4jcaNdnQGiXAn50eTQH+szvw2FWTsHxyIsJH+TmcyNt/6gzuenkPfITAG/fMxdTUSG0GbkC8PgguKvgSE2QvwsbOcH6GnHYB4ONPumAHg2BLkiJHua8t67an6GK27CntjmHqA458AIQnAy0VZFemRRAspfVMcHQG0NMOtNWc/zOGYdSnoYS2MXZ+zsMSKXNbc8i14x77hLaD9cDWyLwEuHkdsOZGcpC57f0Re33I8SkH/EOAjIUYdfgNYOkjgJ8L/vXm+hkk5qkyvnOYeSfQdBrY8QcgMhVYYFte6CiJEaOw5p65eGZTMV7bVYZfr5iEW+emGV7+MBzzs+Kw4b75+MEbZA/38DsHERzgi8SIICRFjkJiRBASI0YhKfLcraXueUthDe5dsx8J4UF45Y7ZGKujH7EeeHUQ3N7diw82foQJAK694nLndxQQAqTOpqyjp3BgLQWl838EhNhpjeMop3YDZ+uAS38FbH6EjqcFHWeAvq4Bj2CFKLM/cOOJEXuTYxhDoXgE2zvZFYIkETWHXTtuySYgdDQw2k6brYyFZJn2+sqBQDh8BGq4aw4D8eMpwCzeQF+TrnF+f1X5VHAcP0GtEZ7L4kcoYbL1CSA8Bchz0YvYAn9fH/x0+QQ8dNl4x12ZtjwG9HYDS38N+BhLfhgfHoTXvjUHW4/UoqzhLCqbOlHV3IHK5k4UV9ehrq0Lg03AwoP8kBQ5CnFhgfiitB6TkyPw4u2znFsJ93C8Ogh+8sMiTOwoRm9QGEJH27l8Z4v0hcCnTwHtjcYvuOg+ay4Yk8Dhd4DZd2tznML1VEU8/Ta6iDSXa3Oc1mrahiac+7zSJKPxOGXrGYbRlvoSIDjWti7XGgmTgf2vkN7UHkeJwfT1Ase2AuOvcmwJfew84BvvUDONly4Hbv8AiDCGN6xq1BaR1CDzEiAilf7OrgTBlfkkYfHVSEIgBHD1s3RNf+9eICxBdZ93hwPgrjZg13NAXzdwtha45nnDdSH19RG4dGKC1Z9195pQ09KJqmZzcNx07nZFXjKeuGayIV0x3IF3/tYAthXX4vUvT2FnTBX84vJc1x9lLAI+/T/gxOeuXWTcQe0RABIQvmRNo0UQbDIBRe8DmYup6jssUcMgeFC3OIWIVPodz7BNGsO4hYZj9kshFBImkWzpzInhu8xZo3wP0NlsnxRiMGPmUkOd166jQPjOjUB44vDv8wTaaoH2eiB+ImUvp91KiZozJ4GosY7vT0qg6gAw+Tq1R3oufgHA6lepNfPabwJ3fkQOTHpx4jMKgCdcBRx8kzTv1/1Tu4mAMzSdAl66AojLAbIvoy9zo5oAPx+kRgfbb/vqZYxQt/ahOXO2Gz956wAmxo9CYucxIHGq6ztNng4EhJIu2OjUmpcep38DKP9KGweFin1AayUw8Wp6HJGinRxCyQQPljz4BdBx2SuYYdxDQ4njun/L9snOULqZJrsZi5x7f+os4Jv/o0Bi/3+c24cRUSQmCRNpO+1WspDb/6pz+ztzAuhqVr8ozhpBEcAtb1Kr69dXapdAsYeSTUBAGHD9i8ClvwYOv0sNsnq79RvTYI5tA5pPAXVHgA0/Av40hRrRbH4EKNtJqyWMVbwuCJZS4hf/O4Sm9m785dJgiL4uIGma6zv29QfGXuQZuuCaQsA/mPTAENQBSG2K1lOxYPYyehyRQkUPWtBmIwgGSBLBNmkMoz2dLVSE6mgmOH4CBWfO6oJLNlFG1xWf4eQZQGw2ULnf+X0Yjdoi2sabg+CIFGDcpcDXrzkXFFXm01aLojhrRCQDt75F8r3XbiAvaXcjJVnvZS6ipMq8+4DLnqJVzjdvo9bfRqBiL00c7j8I3LsPWPokEBpHMo6XllMnxbfuBArWAmcb9B6tofC6IHh9fiU+PFiF+5dkY1yvuYhDjUwwQLrgxuOUUTAytYep209kKpA+n4rk1GyfLSVZo2UsHLgxRaRQwYPJpN5xFFqrgaBI6x7E0Rksh2AYd6AUxdlrj6bgP4oCZ2eC4JYqoPogMG6J4+8dTPJ0cj9Q81qoJ7WHSZ9taQE343ZKGpRsdHx/VfmAb8BAUO0OEiZRk5OGUmDtre4POmsO0X0r67KB5y74LnD5M1RkuPZWoKfTvWOyRsV+msgJQSsxF95LxZ4/OUHdEsdfSVLNd+8BnhkH/Hsp8Pkz9NkZKee7k3hVEFzZ1IFfrj+EGWlR+M7CTKCqgCQM0U7o0KyhLMcdN3g2uLZoYIksdzXQeIw+RGpRfQBoKgMmXD3wXESqubCgTr3jKAzuFmdJVDq5R3ScUf+4DMMM0B8EO2GDmDCJbsiOUrqFtllLHX/vYJKmUya7pdL1fRkBy+u8QtZSqp3Y94rj+6vMpwDYFYs1Z8hYCFzzN2q89L/vapNIscVR82RhsN589t3AlX+iVYg3bqJGUHrR1QbUFgLJM8//WVA4Na655jngwaPA3VuBBT+he/HWXwPPXwS8+233j9lAeE0QbDJJ/PitAvSZJP6waio1oqgqIEsdZyqSrRE/AQiJN7YuuK2OAtF4sw5vwlXk4HBgrXrHKHyPljfHXzHwXIS5/aIW2i5rHsEK0RY2aQzDaEdDKX3ulc+cIyRMoolzZ4tj7yvdDIQl2d+meSgUWdxIkESYTFQAPThr6+sH5N1CfzdHrsVS0v1SrVVTR8ldBSx+lFpsf/K4+45bspl+Z2v3l5l3ACueIz3uf1eRbEMPqvIBaQJSrATBlvj4ULb44p8C93wKPFgMTLqOWlYbSd/sZrwmCH5jz2l8UdqAX1wxEWkxIdTIofqguh9qIWjWeuJz4y4x1A4qlgiKIAudQ29Ty1M1KHoPSJt3bktSxXpIi+K41urznSEUFK9glkQwjLbUlwCRaYCfE16jSvtkRcdqD309FIBkLVGnu9joKYCP30BDCE+m6STQc9a6dGH6N+j+9PVrDuyvDOhsck9RnC0u+iEw8y7giz8BX/1T++O1N1LhuKUUYjDTbgWufR44uYMK+LratB/XYCr20TZ5hmPvCxsNTLqWPParD6g/Lg9BlSBYCPGiEKJWCOFi2x/tuCI3Eb+4YgJumm3OSNaXkC2P2jPb9IXkJejIxdyd1BTSNt4ic5K7mqx0jm11ff+1R4D6o7QEY4lWQbCtbnEKnAlmGPfQUOKcFAIYCIIdcYg4/SV1vVRDCgEA/kEUNKopDdOLwUVxlkSNBTIvJpcIU599+3N3UZw1hACW/w7IXg589BPgyIfaHq/0E8qwDnd+Tb2RLNNO7QZeu97x1QxXKd9Lk0/LpJO9pM6m7ekv1R2TB6FWJvhlAMtU2pcmRIzyx7fmZwy0SawqoK3aQXDGQtoaVRJRexgIiaPKUYXMxcCoaHUkEUXvARAks7AkKIJsZtSWQ7Q3AqYe25nggBBqosFBMMNoh5TkERzrZNOhiBQgMMKx4riSzZS5TV/o3DGtkTRtZBTH9Sc7xlv/+fTbgJZyCvTsoSqf3H7UkJ24gq8fcMO/6f/01l0UAGpFySYgOIYKJodjyg00roq95Dnd2azduAZTsX94KYQtwkaTn/Dpr9QdkwehShAspfwcQKMa+3IbVfmA3yiyxVGTyDHkSGBUq7SawvOzA34BZIB+5EPXZ7GF7wGpc87PzApBbhRqB8FKo4zB3eIsiUpnOQTDaElLJa2sOdPsAjC3T57kWCa4ZDMw5gIq/lGL5Om07O/p14vaQsoOBoZZ/3nO5ZQM2W9ngVxlPtW8OCN1UZuAEOCmtRSgbvy5Nscw9VHR5bhL7W+TPOlaYOXL9Lf6zwr3FGO3VtNkxlEphCWpczgI9kqqCoDRk7Vpf5i+kDRCamls1cJkIjNta0tkuauB3k7gyAfO77/xOFBzcKBBxmC0aJjR3yhjiC5P0RmcCWYYLXHWHs2ShEk0Sben+r+5gla1nOkSNxRJ5qyfp0siaq0kOyzxCwDybgaKPxq4htpCSkoa6VUUZ43QOHJoOL2bViDUpnwv0NEIZDsotZlwFXW7qzkMvHI1rVRqiZIJt+YMYS8ps6mxlZ4NSXTEbUGwEOIeIcReIcTeujoNbLIcwWSi9o9afajT5wPdbc53QNKKMycoWzPYNgcAUmaRVswVSUThe7QdLIVQ0KJhRn/LZBuaYIB0wa2V+trYMNapKgDWfoP/N55OQwltnZVDABQEd7dS56vhKN1MW7X0wArxE8gtx5OL43q7qObF2nXekum3AbJv+AK5plOU1dSzKM4auavJjST/dfX3XbKJuhBmXuL4e3OWAzeuAeqKgVeu0rZYrmIfSYISc53fh5frgt0WBEspX5BSzpRSzoyLixv+DVrSeJwutlqJ/OMm0FaLGaor1FopilMQgi4qxz8jA3pnKFxPWi1zz/LziEih2bWaVjJDdYtT6HeIOKnecRl12PMv0pGf+FzvkTCuUF8K+IcMvSIzHKOn0NYeXXDJZiA8hZr+qImvP43Dk4Pg+hIKbodrahGTCYydT62ih8q+99fPqNBZVU3CE6lJSsEb9hf42UvJRpIJjIpy7v1ZS4AbXqRE2NGP1R2bJRV7afJorVGUvSRMpg6yp/eoNy4PwjvlEFX5tNUqE6w4EhgtCK4pBCBsF0tMWQVAkhejozSdJn/NCTakEAAQYQ6Omysc378tWqupqG8orVp0Bm1ZEmEsTKYBM3ply3gmDaUUVLliVRY3HoAAqodZQevtpsLjrEvVsUYbTNI00nWqHVi5i/5khx2d3WbcTvZnQ9WwVOVTtlHvojhr5N1MHd3ULERvqST7VEelEIPJWU7FnlrVB5lMQMXXrkkhAJKEJs/gTLArCCHWANgFIEcIUS6EuEuN/WpGVQG1f1Q7i6DgP4qyFI0GC4JrD5PkISDE+s9jx9GHwRlJRNH7tB1sjWaJFjZpQ9mjKSiTEk8vdhlpVH5NHboCQmn50dMr8r0ZV+zRFAJD6bM6nIzs9G6Sm6mtB1ZImk4eu/Ul2uxfa2oLycnBnv/H+CspibDvZduvqcyn1U3/ILVGqB7Zy4GgSCD/v+rts2QTbV2V2vj4AmMv0m6Vq/4orWi7UhSnkDKLvIK9UJamljvETVLKRCmlv5QyRUr5bzX2qxlV+TSr1bL9Y0yGMTPBw83mc1fTLFix2LGXovdIZjFUdXh/EKyiAH+olskKo6JoRt54XL3jMq5TvIF0dwt+RBOjuiN6j4hxht4u0o26ogdWSJg0vByiZBMFeWpao1miWGJ5aue4mkL6X9hzf/MPAqbeRM5AbVZqdYxYFGeJfxAwZSUVdHc0qbNPRWpjTyZ9ODIWkgzvTJnr+xpMhbkozll7NEtS5wCmXs+WATmJ98kh3NX+MTrTWJngng4az3Af7EnXUWBycJ39+26tIaPwobLAAOkFhY8GmeBhdIhCUIaJ5RDG4ujHZHE1ZZX5MUsiPJLGE9RUwBVnCIWEyeaajSHqBkq2AGkXUuZYC2LG0eqEpzpEDOcMMZgZt5HXeoGVbGpzOdDeYLyiOEvybiZno8PvuL6v3i7qQpi9VB2pTfoC2mqRDa7YBwSGq/O5S5lFWy+URHhfENxURkbWWgfBMZlUUau1RYq91BXTjWq4iuHQOGDcYuDAm/ZZFQHAkfcBSNvWaAq+fkBYknqZYJOJltOHywQDFASzHMI+pFQvq2KLplO07J2zDIhIBhKmDCxDMp6F4gzhrEewJQmTAUjqPGmNptNAXZH6rhCW+PhS0bQnZsU6WyjJED/B/vfE5dBkdP9/zpck9RfF5ak2RNVJmkZBvxqSiLIvSAqj1vkVNx4IiddGF1y+l353HxXCuJAYmvx5YXGc9wXB7vpQR5tvCEZZgh/KGWIwuavJgPvUTvv2XfgezUbt0Vir2TCjvYGWcOypSI9Kp8Crr1edY49kPv0N8MdJwNkG7Y5RbK6YzrmcttlLaTXBHQbzjLr0ewS7qAkGBuRaNQet/7zfGk0jPbBC8jSShfV2a3sctVHaJTtaxDb9Nvo/ln1x7vNV+bQyOHqyKsPTBCEoG1y+h5I9rlCyGfANHMjgqjG29AWUCVaz5qGng2RDakghFFLnUCbYy2ozvC8IrsynSlc19D5DoWRFjKILrjlMH27FKWEoci6n5UB7CuTaG6kxyMSr7Vs+UrNhhj0ewQrRGRQwq92sY6TRcAzY8QcqPFJjedEWxRuoW6PyOclaSrZOx7Zpd0xGG+pLqWOjGp3bItPo2mNLF1yymSwY1e70OZikaUBf10DywFNwxBnCkokrqG5icIFcZT4lN1yx4HIHU1ZRsO5qNvjoRvL5t1U87gwZC2nF0tUA3ZKqArpeqlEUp5AyC2ivN07izk14XxBcVeCeSteosaR/NYouuLaQlr3s6ZAXEEwNLw6vB3o6h37tkQ/pwziUNZolESlkkWav1GIolE5HoXbKIQCWRAzHxp+Rc0rUWODgm9oco7OFJk7ZywaeS5lFBYwsiXCcxhPAy1eqaz3oCA2l6ugSAVrajZ9oPQju7SIf83EaWaNZonSO8zRJRG0hTSIiUh17X0AwMHU1reopEj6jF8VZEpZAE+kDa523tms4RvfrrMvUHZsWumA1OsUNJnWOed/eJYnwriBYKYpLcsOH2i+QAj7DZILtcIawJHcV0NVMpuFDUfQeZWbsvVBGpFARRluN/WOxhSOZYKVhhpfNch3i6EYqVlv4EDD9m7Q0pkWDkWOf0DmgSCEA0mGOW0KZPjUmSN7ElseAk9v1azjSUEL2imoxejLpxQcvy5btVFevORRRY2lS5mkOETWFpAd2Ric6/TbKfisrgC2VwNk6YxfFWZJ3M90Tjm117v391mgqS22ixtIKh5q64Ip9NNEJS1Bvn3HjqdDOy4rjvCsIbqmgdL+7RP5GcYhob6TOao4skaUvpCXOA0O4RHQ20/L1BDulEIBFwwwVdMH9mWA7LgRhidQOlR0irNPbBXz8MGX05nyHbIcAbbLBxR+RN6nSrlMh6zL6fHpa4KEn5fuAwv/R9/VH3X/89kbS5quhB1ZImETXlsHXiH695nz1jmULIUgSUeFBmWApHXeGsGT0ZFpe3/fyQBYYMHZRnCXZy+i64mwb5aMbSWajrBqqSfoCmqiq1YClYu+AlZ9a+PiQxtjLiuO8KwjuL4pz0/JOTCbQcFx/obmytDicM4QlPr4UCB3daNvh4uhGyugNZ41miZoNM9qqgeBY+/wwfXxoRs6tk62z61nKki//Lf09I8dQxfiBdeqev329lHHJvozOMUvGLSYJEVul2YeUwOZHgJA4+n/pEQQrK11qySEAs0MEzpdElG4Gxs5TV685FEnTKaj0lAYCbTXUlt6VepcZt5Nf9+mv6H4pfAbaWRsdvwBawTzyoeMFtl1tVBSo1SpDxiKa2CkxiCu01VGRt5pSCIWU2dRUq6tV/X0bFO8LgoXPwEVWa6IzSVLQrmGVvT044gxhSe4qCnKVTNNgCtdThtWRD6OaDTPs8Qi2JIq9gq3SXAF8/gx1jxq3eOD5KSspsFLjwq1w+ku6QVnqgRWCo0kbzLpg+yjZDJTtIPnK6FydgmDFHk3FTLBi72XZOe7MSfr93CGFUEieTvUO1TacKoyGcp13JNkxmEnXkaZ438tUFBebQ3phTyHvZqCvGzj4lmPvO/4pvU+r82usefVCDUlExT7aqlkUp5A6m6xUlWN4Ad4VBLv7Q20Uh4iaw6Rvs0c7a8noXNIJWZNEdLUBpVuogM4R/VlQOFUhq5EJbq1yTBOleAXrnZk3Gpt/SRe+y/7v3OcnXUududSURBRvoMI7y2DbkqyltAyrSF0Y65j6gC2PkuvJjNtpGbfxONDX495x1JeQ205Umnr7DIqgzLZlJrjEbI02TmNrNEuSptHWU5pmKF0+XckEB4bS5Pfwu1Qg5QlFcZYkTiXPcUddIko2AQFhtPqlBWEJVJCvhm6/Yi85YWih1U6ZCUDQSoCX4F1BsDs6xVnS7xWscxBcW0hZYEcrqoWgbPCpXefLCEo3U5ceR6QQChEpKmaCHQjsozOAnnZ1ivJGCie2A4feBubdf34gExxNRSIH31JPy3b0Y8qKBIZZ/3m2uTJbCXoY6xxYS5/rxY8Avv7k/GLqdf9KR0MprbD4+qu734Qp5wfBUenqNOSwl/Akcp7xFIeI2kJqzBAS69p+ZtwG9HaQtMJTiuIsybuZ6goUz+ThkJLOr8yL7ZPWOUv6AqBsF9VfuELFPproaCELCoqglRgvKo7zniC4tZo0pO4MgiPH0IxNz0ywyUQXA2eXyJQCqQODsoGF75EW0ZmZc2Sq65lgU5+5W5yDcgiAJREKfb3ARw9RseJF91t/zZSV9Lk5ud3149WXUNCUs9z2axImU1fB4VxJvJmeTmDrk7QcOvEaei7WrMmtV9GL1B4aStWVQigkTCKpRU8H/b4nPqcJmdbWaINJmuY5hZq1ha5JIRSSptEqIOA5RXGW5K6i1Ql7C+SqDwKtldpLbTIW0uRCsTdzBpNZqqB2UZwlqbNpFUBtl56iD4A9/1IvoaIS3hMEK7pGd85s/QIo4NMzE9x8ihofOLtEFjkGSJtHmSdFRtDTSctH4684v7jJHtTIBJ+tpyV8hzLBbJN2Dnv/TUUQlz1p2ww/ZzktEw6eBDlD8Ue0taYHVhCCgp1jn3pety538dU/qKPjkscHgkKleYQ7dcEmE03w1bRHU0iYRJ/vuiOke+7tcK8eWCF5Ok3eOlvcf2xHMPVRq2m1mkDN+wFZcCXmqrM/dxISS9eYgrX2dQjtt0bT+PxKm0c1Sa7oghuPUYGdmp3iBpMym46h9rVkxx+BPS/S38BAGGs0WuLrD6Rd5L6iOIXoTH0zwYpOzNE2mpbkrqKsjLIseGwrBdb2NsgYTEQKFUd1tTk/pn6PYAcywRGplJnnhhk0idj2JJBxMem6beE/iroBFq53vUq++CNa5o4cxsg/+zKgu5VkOMy5dJwBtv+ebtiWVmGBYZRBr3NjENx8mnxlNckEWzhElGwhe8OxF6l/nOFImg5AqlscqgVnTtJEQa0geMoNwA8Puc+JQ23ybgbO1lLdynCUbKKMt5qeu9YYFUnHcUUX3F8Up2EQ3N80Q0VdcH0JaZmn3uj+1Zxh8J4gOPMS4I4P1Wnt6QgxmZR51KsYq9asq1Mqrp1h4goqZlIK5IreA4Iine+vrnQzciUb7Ei3OAW/AArAWQ4BfPI40H0WWP674S9KU1ZSUHr0Y+eP194InN49tBRCIX0hnW/sEnE+2/9AWcnFj57/s7hs92aC+50hVLRHU4hOB/yDzUHwJtKR69G6VymOM7okwtl2ySOVrKVknzmcJKK9kZb+lVoErUlfQMdzNgFUvpfcO+Jy1B2XJTGZ5Lespi64YA1lgHNXqbdPlVAlCBZCLBNCFAshSoUQD6uxzxFDdCZlTdtq9Tl+TSFJGmwVItnDqCi6SBx6i7KBxRuo25ezxTBq2KQ50i3Okuh0lkNU7AP2v0pNMeKyh399+gKabLgiiSjZRMvb9gTBgaGU9WO/4HNpOg18+Q9g6k3U2GAwsdmUcXHXhFtZ4YrVIAj28aWJ+5EPza1s3egKYUlIDF0/je4QUVMIQADx4/UeiTHw9QdyV9Pq09khLEpLP6HrkrukNhkLqYD11G7n3l+xjyZmzsgQ7UUI0gWr1TTDZCJpSuYljt+v3YDLQbAQwhfAcwCWA5gI4CYhBE9HFWJ0dohQnCFcJXc1tdD85FekF5ropBQCsMgEu1Ac11oNQACh8Y69LzrDu+UQJhOw4cf0d1v4kH3v8fEFJl9PgaytxinDUbyBAml7C22yllKm0dsnLJZ8+hRtL/6Z9Z/HZlPGXpkgak19CbVZDYnTZv8Jk4CmMvp+3BJtjmEPSdON7xBRW0jNgDxVvqAFeTeTz/2hITyDSzZSxjhJw0IzS1Ln0irXiU8df29PJxXxaVkUp5A6m4psnb3eW3JyO9UwTL3J9X1pgBqZ4NkASqWUx6WU3QDeAOCEb9YIJTqDtnrognu76EalRsVw1lKyT9n9N1qOybjY+X2FjSZtrktBcBXdfB3NRkelk67S0Y5CI4WC/1I24dJfOSYNyl1pbpyy3vFj9nYBpVuBnGX2e0ormRm2SiNqDpP36Zx7bGuqleK4Ojc5RCjOEFpp/BRdcHSme63RBpM0jYLxoTKKeuNKu+SRyujJ5AZlSxJh6iPNcNaljnndu0JAMBWeOaMLrj5I12At9cAKKeaW9q44WSgUvEGT5fFXuL4vDVDjP58MwDKaKTc/dw5CiHuEEHuFEHvr6upUOKyHEJlGdi16ZILrj1LHIzUujn6B1DwBIGmEf5Dz+/LxBcKTXZNDtNU4t7TS7xDhhdngzmZgy2NU+JC72rH3JuZRkGWtccpwnNxBGcpsO6QQCjGZFGCxJILY8jhNWi56wPZrFJ1gfYl7xqSVPZqCUsyrhyuEJUrmrcqg2eCeTkqyqJHsGGnk3UJFjdWHzv9Z+R5KhrhbapO+AKg64HiWVSmK09IZQiF5OiWqXC2O62qjxMmka/TR9NuB2wrjpJQvSClnSilnxsVptHxmRHz9KBDWIxOshjOEJXm30FbxDnYFV23SWqucDILNmXlvlER8+htyhbCnGG4wQgBTVgGndlLfekc4+jHgN4r0cI6QdZk5gD7r2PtGGid30LLtRQ9QAxNbhCZQxsUdXsHd7bSSo4UeWCFpOrXynnGbdsewB0XCU2HQILg/2eFC8fNIZcpK6npprYNcySYK9DJtdK/UioyFACR9rh2hYi+5IYUnaTKscwgIoUy6q8VxRz4Aes4aVgoBqBMEVwCwXJ9LMT/HKCgOEe6m9jBdANTK1qTOBu4/ZF9x03C42jDD0W5xClFjaetpmeCiD4D376cmJd3tjr+/ppCKqmbc7rxX9pQbaHtwCI3dYKSk4pTMSxzPBGRdShZcx13w1fR0pAQ2P0IrJ3O+PfRrhTAXx7nBIUK5nmmZCQ4IBm58Xf/gLiicHDCM6hDR7wyhUrJjJBEcTferA2vPbyl+dBMwZi5Zl7mTpOmAf4jjfsEV+6hBjrtInUMFofZ4Ldsi/7+UBEydq964VEaNIHgPgCwhRLoQIgDAjQDeU2G/I4donWzSagppiVTNlqbDebzaS0QK0FLpXPeYvl5y23DEI1ghIIQyZp6SCe7tpq5ua28Bvn4NWPcN4OlMYN1twKF37LPakRL46CfkELL4EefHEp1OWrGDDrhE1ByiyU7OEA0ybJE2j/Tn3myVVriebn4X/9y+SURstnu8gvvt0TQMgo1EsoGL42oLqdhKT920kZl2K9Bef+51pLkCqDmoj+uIXwCQdqFjuuD2Rooh3CGFUEiZTc5WyiTLUZrL6XecepP7NNdO4PLIpJS9AO4FsBFAEYB1UsrDQ7/Ly4jJBHraB7xt3YWRiyUiUsgqxpm/ydlaANJ5u5XoDM/IBDedAl5aBnz5PDD3u8DDp4BvrifD8bIvgLfuAJ4eB6y9lbKztrpaFf6PKnQX/3Lo5XR7yF1F55U1jZ01ij8GIIbuEmcLvwAgY5HZXk0nn22ACs1c7XDoDH095MYSP5H+5/YQl01trjubtR1bQyltvSXwSppGEqwWNzlvOEJNIU1+1Ex2jCQyFwMh8edKIkrNBbdZbvIHHkz6Alqxaam07/X9TTLcmQlWiuOc1AUfWAtAAlMdrD9xM6qE51LKDVLKbCllppTySTX2OaJQdKjuLI7rOAO0VBi3WMKVhhlK4OxMJhgghwijB8HFHwPPz6cip1WvAsueouXhjEXAlX8EHiwGbv8QmP4N8nN8+y4KiNfcRNW4HU20n+6zwMZfAKOnADPucH1ck66jQs8Da+38PTbQhdtRKzuF7MvoPK7RaV7dcAz452Lg3e+4/9j7X6FrxpLH7PcF7W+frHFxXH0pSTS8xZJLsdAyoiSitsi4yQ4j4OtHgdjRj4E2c1H+0U10D9JLaqPUR5zYbt/rK/YBEAPNW9xB5BhaNT3tRBAsJd2HxlwwEP8YFOPmqEcSSrbEncVxtUdoa1SdWH/DDCd0wf3d4pxscxmdDrRWut4GWAv6ekkDumY1XYS+/Zl1T2YfX2oocfnTwANFwJ0bgZl3UiX0u9+mgPj1lcD//h95NC5/Wh2D9ZAYyqwceps8h4eitZqCBlc05OPMy5UlOrhE9HQCb95GzhZlO91rq9fVBnz6W5KEOOKOEKs4RGgsiWgo8R4pBECTSOFrPElERxN9vvXWTRudvFto5fHgm2TZePxTkkLo1cI3YQo1obJXF1y+F4gb71rTK0fpb5rhRHFc5X66Btm7gqUjHAS7g4hU0my5MxOstEs2bCbYha5x/d3inMwE9ztEnHTu/VrRUgm8chXwxZ8poL1rs32zaB8fKvBY/hsqXLxrCxVR1R4hTWnuaiDtAvXGmbuKsrNlXwz9OqXNcs7lzh8rPBEYnauPX/DGn5I354KfUPV9yRb3HXvXsyT7ufRXjt2oo9KoGFbLIFhKkkNo6QxhNAKCKdA0Wue42iLaquUANFKJn0DZ/PzXyZWh56x+UgiArtlj51PR73BSLykpE5ziRimEQuocuk862vE2fw3ga2GramA4CHYHPr7kSuDOTHBNIRAYQUuWRiQwDAiKdD4TLHyc71QVZUCv4GNbSf5QVQBc9y+SPDjjxezjA6TOAi57Erj/APDd3cBVf1F3rDnLqbr54DCewcUfUTbb1SxV9mWUjVCje5G9HHwL2PsiMO8HwKKfkqaweIN7jt1WC+z8KzBxheOFML7+NHHSsjjubD1pjr0pEwzQUnTlfn316YPpd4YwaLLDSEy7hQp1t/8B8AsiXa6eZCykLP5wzlFnTgAdje5pkjEYpWmGI5KI3m7q0jf+CmqwZXA4CHYXikOEu6gtpCywXss99hCR6nwmOCSetF7OoDTMMIJDhKkP2PZ/wKvXUVB/z6fUnU0NhKAA1JXGJtYICAEmXAUcXk+SAWt0t9OSY87lrp+DWZcB0kQTBXdQXwq8/wPKglzyS5pY5Cyj7lK93dof/7PfkVTnEiedPOI0tknrL4rzokwwQA4RHWcGWjkbgdpC8oZWVtYY20y+nrKTZTsoCxsQrO940hVd8DCSiHIdiuIUEqfSKrYjxXElG+lzknezduNSEQ6C3YXiFTycjlINpKRMsNGzA842zHC2W5zCqCjKkuvh3WxJWy3w6rXAZ78lG5m7t1IA4wnkrgS6mm3blx3/FOjtdM4VYjDJ04HgGPd0j+vpAN68nS78N7w4UHGfvRzoahleAuIqDceAfS+Rn3Osk5nW2Gw6t7UK2Pvt0bzEGUJBKUoykiSitogmukZOdhiFUVEDrXv17kII0EpKWNLwVmkV+6jZkB73c/8gCoQdyQQXvEFJqoyLtRuXinAQ7C6iMygoaLXTEsUVWiooQDGqHlghIsVJOUSV83pggG4Y0To7RJz8guQPp78EVjwHXPt3/TMTjpC+iDLXtiQRRz+iDFXaPNeP5eMLjFtCmVhnfKUd4eOHyT/02n+cm13LWERLqIrOWSs+fYqyVQsfcn4fsTmkYdZqpaO+hMYYOUab/RuV+Ek0OXLVIUJKktu4arcmJbmmcFGc/cz5NhAxZiAY1hMhSJJx4vOhk2MVe6nBkbMrn66iNM2wZ1J9toGSFbmr9Buvg3AQ7C7c6RChtEs2qjOEQmQqaQtt+dvaorUaCHPSGUIhOl0/OcTOvwKvXAkEhgLf+oTM3D0NXz9aXjy6ccCOTcFkIou3cUvI61cNspaSLk7xy9SCA28C+14G5t0PZA/KFAUEU2ajeIN2mtCOJipknP4N185vpWCtTqP2yQ3HaFKvhtuIJ+EXQC4Rlfmu7efQ22RpuP67ru2ntQrobDL+dd5IjJkL/PAgEGGQWpmMhUB7g+2GFL3dQNUBfaQQCimzqHNn9cHhX3vobcDUY+g2yYPhINhdRJuDYHc4RCjOEPHjtT+WKzjjENHXA5ytcy0TDFBxXNMp11pCOkPjcWDTL0gre8+n1J/dU8ldBfR1A0WDGkRW7idnAzXaayuMW0wWVVpJIupLgA/up/ael/zS+mtyltM542wHpeEoeo/+nrmrXNtPv1ewRrrghhLvk0IoJE2jINhZWdvZBure6B9CGndHuoYNRjkPjb7ix9hGKc6zpQuuOUQBqDs7xQ0mdQ5t7bFKK1hD9m8edF/jINhdhCfTcqq7MsHhyaSBMjLONMxoq6GtK5pggDJZpl7n5BiuUPQ+bS/7P/d6PmpB0nSa3B0YJIko/ogC1nFL1DvWqCi6GGvhF9zTQW2o+3XANpbxss2WSlq5RBxYR39PpTGDswSG0udfiyC4r5dkRN5kj2ZJ0nTyjVZ00Y7y8UO08nX7B/Q/2vK48ysL/St+HAR7LBEp9Jm3NRnSo1PcYMITSUIyXHFcXTElQPI8JwsMcBDsPnx8zJ3K3FCMZeR2yZY40zDD1W5xCno5RBR9QIUGUWnuPa4WCEFZy5M7gOaKgeeLP6JOQa62aB5M1qW0JGdvq1F7+egntHpy3QtDL5OGjaabUbEGuuCWSvo75q5Sp8gpViOHiKYyWu70Nns0hWSlc5wTTTOKP6ZmDQt+RPtZ+BDpPY986NxYaouA0NHqf84Y95K+gGpErK1KVuyjIjMlYaQXqbOGL44rWEPJjykquRu5CQ6C3UlMpvaZ4L4empF5whJZ6Ggy9nckE9wfBLuYCdbDK7ilimbTE65y3zG1ZspKAJJ8IQHgTBkFlGpKIRSUTKyajTMK1gL7/wNc9AAF2cORs5wCl9Ya9cYAUKEUpHo3kNhskniorV8u30PbxKnq7tdTiM0mKYOjDhGdzcAHP6TkxEUP0HN5t9BkYuuvnSv4rOWiuBFBxkJaXbA2sSrfS1IIvd0/UudQwb2te7Wpj1ayxi0BQuPdOzYX4SDYnURnUOZRywr3hlLK1HhCsYSPDxCe5GAm2FxRHepiEByWSPIUd9qkHfmAthOstEH2VGIyKTt64E163N8lToMgOH4iEJ5i25bNUeqOUmAy5gLg4p/b955s8++ltkvEwXX0d1RLaxuXDXS3qZ81L9tJBviesNKkBT6+NAFw1CFi8yNAWzVw9bMDxaK+fqQ/rzsCHFjr2P5MfeZkhwdc55mhGTuftic+Pff5jiaS3SS7KI9Sg5RZtLWVDT7xOQXJHtAmeTAcBLuTmEwqfHHGG9deagzeLnkwjjbMaK2mJZeQWNeO6+NDXfzc2Tq56H1qMBCX475juoPc1WQrVltEetnYbG0Kp4Qg14Zj24DeLtf21d0OvHkb+WAOpQMeTMIk0sepGQTXHiGZxxQXC+Is6S+OU9kh4tQuKh70NmcIS5Km0f+rr8e+15/4nFxH5n73/Na3E1cAiXnAtqccO6cbT5DlprdORkYSIbFUTDZYF6xMtPToFDeY0VPIq9hWEFzwBnnv51zu3nGpAAfB7sQdDhG1hRQkKjdBo+Now4zWaiA0QZ2bcJQbvYLbG0nzOZKkEAqTrqNzbs+/SdumRRZYIWsp0HPW9aYVH/2EPivXvUCrEfYiBP1+x7ZRIK0GB9fR32/ydersDyCvYIAkEWpxtp50xmkXqLdPTyR5OgWgtUXDv7a7HXjvPrrWWFttEAJY8ijQfArY+5L9Y+h3AGI5xIggfQFw6ksq0lVQOsUpTVr0xNefzntrxXFdreRsM/la9buTugGXgmAhxEohxGEhhEkIYYDpisFxh1dwTSFVbvsFancMNYlIoSVbe63KWqtc1wMrKPIUrXxfLTn6MTUwGIlBcGgckHkxsOdfJMXJ1jAITl9AjRpc0QUXvAF8/Sow/0HnHCxylgO9HcO3O7UHKalYKmORulq60HjKzKjpFXxqF23HXKjePj0RJSixpzhu25N0jbn6r7ab4WRcTEvinz9NAYU91BYBEECcwW0wGfvIWEhWaJaZ1op9lMwaFanbsM4hdTZQVXBuoA7QCmdPu0d5A1viaib4EIDrALhgduhFhCUC/sHa6lBrD3vWEllkKgWHbdX2vb6txnVnCIXodPrwtqlc5GSNovdJz2qEWb0WTFkFQAKjouliqRUBIUD6fOf9guuKSQecNg9Y9DPn9pE2j7rhqWGVdvpL8h521Rt4MEKQLlhNh4iynaSjH6nnsL1EZ5AuejhdcPk+YPffgBl30DlrCyGAJY8B7fXA7r/bN4aaw3T98qQuk4xtxlxAq0HKxFpKKsA1ghRCIWU22YoObhZTsIZWOhQ/YQ/DpSBYSlkkpdSoLdEIRAi6gGqVCe5qpRuqp+iBgQGbtCY7i+Naq1zvFqfgLoeIrjag9BNgwpX6V/lqxfgrgIBQ0oRprRfNuowkRUN9jqSkv3tzBa2OlO0k67Z1t9FE9Pp/O9/W0y+Amncc3eh80wSFA+tIa6dFG1e1bdLKdtJNWa0ugJ6KEDQRGMohorcbWP89KuC99PHh95kyExh/JXWTPNsw/Os9xQaTsY+gcCqMPW4OgptPU1MoIxTFKSjJDcumGU2ngRPbKQvsofc2z2juPJKIztCu45SiUfMEZwgFRxpm9HZRi0k1M8EAZea11DmWbqGlrpEohVAIDAXu3kbSCK3JuhT4CMDHD1PDgc4msqDqMG+VxyYrEhsfP+DmdWQA7wo5lwOH36Ul8cHFTvbS10P7GH+5No1TYrOB/Nfp7+LqkmpXK1B9AJj/IzVG5vkkTQd2/gXo6bSug9z+e6CuiM61oAj79nnJL4C/Xwjs+ANw2ZO2X9fTQdesydc7N3bGmKQvoP99ZzNZowH6doobTEgs1TUpNomA2dVEAlNX6zYsVxk2CBZCbAFgTYT5cynlensPJIS4B8A9ADBmzBi7BzjiiMmkZdS+XuczUbbwNGcIwLGGGWp1i1OIHENLUFo3zCh6HwiOpSWvkUycm4oxo9NJl3psGwV3QZEUaIyKop8FRQw8FxRhfo35ufBkdVYSxi2hc6d4g/NBcOknQEejuq4QlvQ7RJSQ2b0rnP4KkCYuilNImkaTrJpD5wcqNYcpCJ6ycsDb2h7iJ1BG7at/kpOErcYtdcX0v+CiuJFFxkJg+zO04lKxj2ofEgzWfjh1NiV1lDqagjUkD4saq+uwXGHYKExKqUrvUynlCwBeAICZM2e6oRLJoERnmtv1nqKssJrUFtKSdIQHTTICQkhHak8mWK1ucQq+/hSEaymH6O2iZfPJ13q3rZTa3GHW4+q1BBccTZOa4o+Axb90bh8H19G5P26xumNTUKz46o+6HgSf2kVBf4qGem9PQlmmrth/bhDc1wusv5eWt5f91vH9LnqYCiU/+w0V01nDE1f8mOFJmU2a+xOf0wpT4lS6RxmJ1NkU+J45QY5HDaXAvPv1HpVLsEWau+l3iNCgOK6mkLIDPh72b41IsS8TrFa3OEuiM7QtVDz+GXUDGj+CpRB6IIT+GrSc5VSIeqbM8fd2tQJHNgCTrtXuRheZBvgGqOMVXLYLSMwl2QtDKwoh8ec7RHz5dyqYW/47ICTG8f1GjgFm3gV8/bpte7vaw5QlVDuJwuiLfxAVl5V+QsVnRpJCKCiT4NN7gPz/UtA+cYW+Y3IRVy3SrhVClAO4AMCHQggnS7a9CK28gqX0PGcIBXsbZihBsKvd4iyJTtdWDnHkfSAgjJa6mJGF4ofsTOOMIx+SzZrarhCW+PrR9cZVr+DeLtIBers1miVKcZylQ0TDMWDrE6QXd0WvO/9BCi62PmH95zWFJD1SW07H6E/6Apq09nZQoZzRiJ9A97OTnwOH3qZizqBwvUflEq66Q7wrpUyRUgZKKROklA4IoLyU0HiSLKjtENFaDXSc8cw2mvY2zGitosKmYCcyLLaISqe/W0eTevtUMPVRsJN9mef4NjP2E5NJTSmcsUo7sI6yflrbCsVmue4VXPk1FXamcRB8DsnT6W/b1UouIe/dR5n3K37v2ipFaBxw4b1A4f+sexHXFrEUYqSSsWjgeyMGwT6+VANRsJYKkPM80xvYEg9bNx8BCEHZR7WX4Ps7CHliJjgF6GqhqtihaK2mLLCacg/FIUKLbPCpXeRmMZJdIbydnGXUCXC4c9eStlrg+DYqnNJa0hGXQ63BXWkzXbaTtiO9sNNRkqYBkEDVAWD/y0DZDmDpE451ILTFBfeSXvyTX537fMcZoLWSi+JGKol55EEeHGPcYrPUOdQUKXQ0NXrxcDgI1oPoTPXlEDVm2zVPzARH2mmTpma3OAVFV6eFLrjofdLuOdOVjPEMci6nQtfST+x/z6F3qLpfK1cIS2KzqRmNK+f3qV2U8XZG4zqSSTIXxx35ANj0CC1lT/+mOvsOCidZxLGtVCiloBTFeeJ1nhkeXz86h3Jv1L/mwRaKX3DuqhFR7M1BsB7EZFIxTV+PevusLaSZWXC0evt0F4pX8HANM1qr1Q+Cldm22g4RUgJFH1DlPxcTjVxSZlHWpvgj+99zcB0wegoQ74aWt/02aU42zTD1Aae+ZGs0a4TG0bVr999oInTVX9QNXGZ9iwrwtjw+YEml2GByJnjkctmTwLL/03sUthk7nyz85n5X75GoAgfBehCdSdmZplPq7bPmsGf5A1tir1dwmwZBcEAIEJqgvhyi8mugpZylECMdH18gexlQstG+SW3DMfIAdUcWGCBNMADUORkE1xwGupq5KM4WSXm0XfzLAWmVWvgHkWVaxV6qLQAo2REYQcExw+iBXyCw7CnXGw4ZBA6C9aDfJk0lSURfLxVoeKIeGCCrIR//oeUQPZ2kh1M7CAbMNmkqB8FF75OvavYydffLGI/sZaQJPrV7+NcefBOAAKbcoPmwANAkLyLV+UzwqV205UywdabfDsy4HZjzHW32P/VmICYL2PprysrXFlGyw6hL5QzjYXAQrAdq26Q1HqfqbU/Vifn4UHekoYLgNpUbZVgSla5NEDz2Is+UpzCOkXkJuQIMZ5UmJblCjL1IneIpe4nNct4ruGwnBdGRHtSAx51kLQGu+rN22khfP2qnXHeEWtQqXvAMw6gCB8F6EBJLFaBqZYI92RlCISJ1aDmEFo0yFKLTqeK6p0Od/dUVAw0lLIXwFgJDgfSFtGQth2iGWbmfJr5aegNbIzaHvIJNJsfeJyVlgtkVQl8mriDXgE2/IGmKJ1/nGcZgcBCsB0KYl+BVCoJrCgHhM9Am1RMZrmFGaxVttcgEKw4RZ06qs7+i92g7/kp19scYn5xlpCsfSnZw4E3KGE+42n3jAigT3NNOEz1HaDwOtNWwFEJvhACWPEp2iwAHwQyjIhwE60VMpoqZ4EKSWPiPUmd/ehCRQoGureKi1hraaiWHANSTRBS9T+0lR0jhAGMH2ebucbYaZ/T1Uoel7MuAUZFuGxaAgcmxo00z+v2BuShOdzIuJgs2gOUQDKMiHATrRXQmLf/3dru+L092hlCISCHvVCXjO5jWKsqijYpS/9ixWYDfKLI66ut1bV9nyoCqAmACZ4G9iohkIHEqUGxDF3ziM+BsrftcISzpt0lzsH3yqV3UsMGTV5hGCkIAK54Drv0H1xkwjIpwEKwXMZkU9Lm6BN99lvbh6W00I4fxCla6xWlRFR0UDlz5R+DkdmDrr4Z//VAoVkYshfA+ci4HTn8JnK0//2cH3yRrq6yl7h9XSBwQFOl4cVzZTmqVzE4ExiByDDD1Rr1HwTAjCg6C9UIth4jqQwDkCMgED9M1TotucZbk3QTMvBP44s9A4Xrn91P0PpAwecAGj/EespcBkMDRjec+391O58XEq8n71d0IQdlgRzLBrdWkceaiOIZhRjAcBOuFWl7B+18B/IPJdsmTUczfbTlEaNEtbjDLfgMkzwD+9z3Hl44BoK2WlpDZFcI7SZwKhCWdrws++hHQ3eZ+VwhL4rId0wQremAuimMYZgTDQbBeBEfTEqUrmeDWavIdnXarNlpZdxIQTO1nbWWC26q1KYqzxC8QWPUfwC8AWHsr0NXm2PuLNwCQLIXwVoQAcpYDx7ZRcxeFA29ScJym40Q1Nps0yR1n7Hv9qV2Afwgweqq242IYhtERDoL1xFWHiK/+ST3rtepW5G4iUqwHwd3t1JErLME9Y7jhRbK6eu/7Q/u+DqbofXKa8NSmJYzr5FwO9JwlfTkAtDcCpZuBKddTUxi9cLQ4rmwnkDqLmjUwDMOMUFy6wgkhngZwFYBuAMcA3CGlbHJmXz09PSgvL0dnZ+fwL9aZoKAgpKSkwN/f37UdRWcOtCV1lO52YO+/gfFXjBz9aUQq0FB6/vNadouzRsYi6tL0ya+A1NnA3P83/Hs6moDjn9FruZDIexl7EWVQizcAWZcCh9+liaoerhCW9AfBR+mcHoqOJnKcWfRTzYfFMAyjJ65O8zcD+KmUslcI8VsAPwXwkDM7Ki8vR1hYGMaOHQth4CBCSomGhgaUl5cjPT3dtZ3FZFLVeE+n4wUzBWtoafOCe10bg5GISAWOf0rZV8tzQMtucbaY90OgfB91aUrMG14bWbIJMPW4vxECYyz8g4Bxl5BV2hV/oM933Hhg9BR9xxWZRhaD9uiCT38JQJIzBMMwzAjGpfU5KeUmKaVirLobQIqz++rs7ERMTIyhA2AAEEIgJiZGnYx1dCYASVXYjmAykadt0nRgzFzXx2EUIlKogKiz6dzntewWZwsfH+Dav5Mt0Zu3DQTitih6nyzckme4Z3yMccm5nLqzHfmAVnqmrNR/dcDXD4gZZ58comwn4OMPpMzUflwMwzA6oqZI7U4AH9n6oRDiHiHEXiHE3rq6OluvUXE42qHaOGPM7Xod1QWXbCTZwAXf0//mqiYR5jnUYF2wHplgAAiKAFa/BnS2AG/eYbubXXc7ULqFGmToqftkjEHWUmpj/uGD9HjKSn3HoxCbZZ9X8KldQNI0z+5AyTAMYwfD3rGFEFuEEIesfK2weM3PAfQCeN3WfqSUL0gpZ0opZ8bFxakzek/HWa/gXc+RdGDiNaoPSVcibDTMaK0GfAPJTcPdJEwCrv4LcGonsOUx6685thXoaWdrNIYIiaW22W01QOpcICpN7xERsTnUWKe3y/ZrejqAiv1sjcYwjFcwrCZYSrlkqJ8LIW4HcCWAxVI6UkrPYFQk2YI5kgmuzKfK86VPjLzK7UgbDTMUj2C9st65q4DyPcCuZ0nuMPm6c39e9D5Z1KXN02d8jPHIWQ6c3g3kGiQLDFBxnDTR9cZWc53yvaRtH8N6YIZhRj4urd0KIZYB+AmAq6WU7eoMSR8efvhhPPfcc/2PH3vsMTzzzDPaHzg6E2g8bv/rdz0HBIQC07+p3Zj0IjiWMr6DG2a0VrlXD2yNpU9Sdm/9vecWF/X1UDOE7OWAr4tuIczIIe8WYOZd+rtCWBJn4RBhi1O7AAhgzBy3DIlhGEZPXE0lPgsgEMBms052t5TSZdPax98/jMLKFld3cw4Tk8Lx6FW2/VtXr16N+++/H9/73vcAAOvWrcPGjRttvl41YjLJWssemiuAw+8As+8hvepIw8cHiEi2ngnW23vXLwBY+TLwwkJqpHH3ViAwjLLync0shWDOJTQOuPIPeo/iXGLG0XaoILhsJ33WPL35DsMwjB246g4xTkqZKqXMM395bNeGadOmoba2FpWVlSgoKEBUVBRSU1O1P3B0JlWSd9uRSP/qBVrOHCnNMaxhrWFGqxu6xdlDRDI10mgoBdZ/j6zcit4nX9jMi/UeHcMMTUAIEDHGdhDc10uynzGsB2YYxjswpKh0qIytlqxcuRJvvfUWqqursXr1avccVHGIaDwOjJ5s+3VdbcC+l8iH1iiFNloQMQY49snA4642oLvVPd3i7CF9AbDkMWDzI8DOvwBHPqSmCFxJz3gCsVm2vYKrD5BFIRfFMQzjJRgyCNaL1atX4+6770Z9fT0++8xOiYKrWDpEDBUE579Oy+4jqTmGNSJSKPPb200ShLYaet4ImWCFC++jjNnmR+gxSyEYTyEuh3S/JtP5dn5lO2nLRXEMw3gJbGpqwaRJk9Da2ork5GQkJrop6FJaHg9VHGfqo+YYqXOA1FnuGZdeRKQAkCQRASwaZbjZI3gohABW/I00lr4BlAlmGE8gNovs/FrKz//ZqV1A1Fgg3EATToZhGA3hTPAgDh486N4DBoYBIfFD26QVbyB/z0t/5bZh6YZlw4yosRaNMgx2Yw4KB775HnX7G4lFiszIJDaHtvVHqRuigpQUBGcv02dcDMMwOsCZYCMQM4xN2s5ngcg0YPyV7huTXgxumGHETLBCRDIw9iK9R8Ew9hNrtkmrG1QcV38UaG/gojiGYbwKDoKNQHSm7Uxw+V4y3Z/7/wAfX/eOSw8ikmmrOES0VgN+o4DAcP3GxDAjhZBYsj8b7BCh6IHTWA/MMIz3wEGwEYjJANqqyQlhMLueAwIjgGm3un9ceuA/CgiJG2iYoXe3OIYZSQhB2WBrQXBIPBCdoc+4GIZhdICDYCMQbaM4rukUULgemHEbaYe9BUuvYKN4BDPMSMFaEHxqF1mj8WSTYRgvgoNgIxBjYZNmyZf/oJvSnG+7f0x6ck4QXGVMPTDDeCqx2cDZOqC9kR43naaVF7ZGYxjGy+Ag2AgoS5CWuuDOFmDfK8CkawccE7yFiDF0U5aSM8EMozZxikNECW1P7aIt64EZhvEyOAg2AgEhQOjoc+UQX79KndLmfle/celFRAp5mTaVAT1nORPMMGoSm0XbenPnuLKdVHiaoE+nToZhGL3gINgoxFg4RPT1ArufB9LmAcnT9R2XHiiZ7/K9tOUgmGHUIzIN8A0c0AWf2kWNeLzBfYZhGMYCDoLNPP300/jLX/4CAPjhD3+ISy65BACwdetW3HLLLdoPIDpjQBNc9B7QfAq44HvaH9eIcBDMMNrh40vdDutLgLMNQN0RKopjGIbxMozZMe6jh4FqlTu3jZ4CLP+NzR/Pnz8fv//973Hfffdh79696OrqQk9PD7Zv344FCxaoOxZrxGRSsUpnC7DrWQqKs5drf1wjojTMKP+KtqwJZhh1icsGKvMH9MBcFMcwjBfCmWAzM2bMwL59+9DS0oLAwEBccMEF2Lt3L7Zv34758+drPwDFJq1gDVCxj7TAPl767wmJBfyCgKoD9JgzwQyjLrHZpLk//ilJI7xRdsUwjNfjUiZYCPFrACsAmADUArhdSlnp8qiGyNhqhb+/P9LT0/Hyyy/jwgsvRG5uLrZt24bS0lJMmDBB+wEoNmnbngSCIoG8m7U/plERgiQRDaVAQKh3eSQzjDuIzQakCTj4JpAyE/AL1HtEDMMwbsfVVOPTUspcKWUegA8APOL6kPRj/vz5eOaZZ7BgwQLMnz8fzz//PKZNmwbhDgP5qHTadjYDs+4ixwhvRtEFhyboOw6GGYnEZtO2swkYw3pghmG8E5eCYClli8XDEADSteHoy/z581FVVYULLrgACQkJCAoKco8UAgACgoHwZMDHH5h1t3uOaWSUIJj1wAyjPjHjAJgn91wUxzCMl+JyYZwQ4kkA3wTQDODiIV53D4B7AGDMmDGuHlYTFi9ejJ6env7HR48eHeLVGjBlJeDrD4Rz4NdfHMd6YIZRn4BgIDKVOjOmzNZ7NAzDMLowbCZYCLFFCHHIytcKAJBS/lxKmQrgdQD32tqPlPIFKeVMKeXMuLg49X6DkcSljwOX/ELvURgDDoIZRluSZwCpc4GgcL1HwjAMowvDZoKllEvs3NfrADYAeNSlETEMwHIIhtGaFc9RcRzDMIyX4pImWAiRZfFwBYAjrg2HYczE5ZB1E7dyZRhtCAhh5xWGYbwaVzXBvxFC5IAs0soAfMeVnUkp3ePE4CJSenT9n2cQNhp46CRpFxmGYRiGYVTGpSBYSnm9WgMJCgpCQ0MDYmJiDB0ISynR0NCAoKAgvYcy8uEAmGEYhmEYjTBM2+SUlBSUl5ejrq5O76EMS1BQEFJSUvQeBsMwDMMwDOMkhgmClY5tDMMwDMMwDKM1rnaMYxiGYRiGYRiPg4NghmEYhmEYxuvgIJhhGIZhGIbxOoQedl9CiDqQpZq7iQVQr8NxGc+Azw/GFnxuMLbgc4OxBZ8bxiFNSnleu2JdgmC9EELslVLO1HscjDHh84OxBZ8bjC343GBsweeG8WE5BMMwDMMwDON1cBDMMAzDMAzDeB3eFgS/oPcAGEPD5wdjCz43GFvwucHYgs8Ng+NVmmCGYRiGYRiGAbwvE8wwDMMwDMMw3hMECyGWCSGKhRClQoiH9R4Pox9CiBeFELVCiEMWz0ULITYLIUrM2yg9x8jogxAiVQixTQhRKIQ4LIT4gfl5Pj8YCCGChBBfCSEKzOfH4+bn04UQX5rvL2uFEAF6j5XRByGErxDiayHEB+bHfG4YGK8IgoUQvgCeA7AcwEQANwkhJuo7KkZHXgawbNBzDwP4REqZBeAT82PG++gF8KCUciKAuQC+Z75W8PnBAEAXgEuklFMB5AFYJoSYC+C3AP4opRwH4AyAu/QbIqMzPwBQZPGYzw0D4xVBMIDZAEqllMellN0A3gCwQucxMTohpfwcQOOgp1cAeMX8/SsArnHnmBhjIKWsklLuN3/fCrqZJYPPDwaAJNrMD/3NXxLAJQDeMj/P54eXIoRIAXAFgH+ZHwvwuWFovCUITgZw2uJxufk5hlFIkFJWmb+vBpCg52AY/RFCjAUwDcCX4PODMWNe7s4HUAtgM4BjAJqklL3ml/D9xXv5E4CfADCZH8eAzw1D4y1BMMPYjSTLFLZN8WKEEKEA3gZwv5SyxfJnfH54N1LKPillHoAU0CrjeH1HxBgBIcSVAGqllPv0HgtjP356D8BNVABItXicYn6OYRRqhBCJUsoqIUQiKMvDeCFCCH9QAPy6lPId89N8fjDnIKVsEkJsA3ABgEghhJ8548f3F+9kHoCrhRCXAwgCEA7gz+Bzw9B4SyZ4D4Asc5VmAIAbAbyn85gYY/EegNvM398GYL2OY2F0wqzh+zeAIinlHyx+xOcHAyFEnBAi0vz9KACXgnTj2wDcYH4Znx9eiJTyp1LKFCnlWFCMsVVKeQv43DA0XtMswzw7+xMAXwAvSimf1HdEjF4IIdYAWAQgFkANgEcB/A/AOgBjAJQBWCWlHFw8x4xwhBAXAdgO4CAGdH0/A+mC+fzwcoQQuaDiJl9QEmmdlPJXQogMUMF1NICvAdwqpezSb6SMngghFgH4kZTySj43jI3XBMEMwzAMwzAMo+AtcgiGYRiGYRiG6YeDYIZhGIZhGMbr4CCYYRiGYRiG8To4CGYYhmEYhmG8Dg6CGYZhGIZhGK+Dg2CGYRiGYRjG6+AgmGEYhmEYhvE6OAhmGIZhGIZhvI7/D0sS6Qx4cieoAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 864x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mppi_planner = MPPI_Numba(cfg)\n",
    "mppi_planner.setup(mppi_params)\n",
    "\n",
    "# Loop\n",
    "max_steps = 151\n",
    "xhist = np.zeros((max_steps+1, 3))*np.nan\n",
    "uhist = np.zeros((max_steps, 2))*np.nan\n",
    "xhist[0] = x0\n",
    "\n",
    "vis_xlim = [-1, 8]\n",
    "vis_ylim = [-1, 6]\n",
    "\n",
    "plot_every_n = 15\n",
    "for t in range(max_steps):\n",
    "  # Solve\n",
    "  useq = mppi_planner.solve()\n",
    "  u_curr = useq[0]\n",
    "  uhist[t] = u_curr\n",
    "\n",
    "  # Simulate state forward using the sampled map\n",
    "  xhist[t+1, 0] = xhist[t, 0] + cfg.dt*np.cos(xhist[t, 2])*u_curr[0]\n",
    "  xhist[t+1, 1] = xhist[t, 1] + cfg.dt*np.sin(xhist[t, 2])*u_curr[0]\n",
    "  xhist[t+1, 2] = xhist[t, 2] + cfg.dt*u_curr[1]\n",
    "\n",
    "  if t%plot_every_n==0:\n",
    "    # Visualize the basic set up\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.plot([x0[0]], [x0[1]], 'ro', markersize=10, markerfacecolor='none', label=\"Start\")\n",
    "    ax.plot([xhist[t+1, 0]], [xhist[t+1, 1]], 'ro', markersize=10, label=\"Curr. State\", zorder=5)\n",
    "    c1 = plt.Circle(xgoal, mppi_params['goal_tolerance'], color='b', linewidth=3, fill=False, label=\"Goal\", zorder=7)\n",
    "    ax.add_patch(c1)\n",
    "\n",
    "    # Show obstacles\n",
    "    for obs_pos, obs_r in zip(obstacle_positions, obstacle_radius):\n",
    "      obs = plt.Circle(obs_pos, obs_r, color='k', fill=True, zorder=6)\n",
    "      ax.add_patch(obs)\n",
    "\n",
    "\n",
    "    # Get rollout states from subset of maps for visualization? (e.g., 50)\n",
    "    rollout_states_vis = mppi_planner.get_state_rollout()\n",
    "    \n",
    "    ax.plot(xhist[:,0], xhist[:,1], 'r', label=\"Past State\")\n",
    "    # ax.plot(rollout_states_vis[:,-1,0].T, rollout_states_vis[:,-1,1].T, 'r.', zorder=4)\n",
    "    ax.plot(rollout_states_vis[:,:,0].T, rollout_states_vis[:,:,1].T, 'k', alpha=0.5, zorder=3)\n",
    "    ax.plot(rollout_states_vis[0,:,0], rollout_states_vis[0,:,1], 'k', alpha=0.5, label=\"Rollouts\")\n",
    "    ax.set_xlim(vis_xlim)\n",
    "    ax.set_ylim(vis_ylim)\n",
    "\n",
    "    ax.legend(loc=\"upper left\")\n",
    "    ax.set_aspect(\"equal\")\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "  \n",
    "  # Update MPPI state (x0, useq)\n",
    "  mppi_planner.shift_and_update(xhist[t+1], useq, num_shifts=1)\n",
    "\n",
    "  # Goal check\n",
    "  if np.linalg.norm(xhist[t+1, :2] - mppi_params['xgoal']) <=mppi_params['goal_tolerance']:\n",
    "    print(\"goal reached at t={:.2f}s\".format(t*cfg.dt))\n",
    "    break\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12,3))\n",
    "ax.plot(uhist[:,0], label='v')\n",
    "ax.plot(uhist[:,1], label='w')\n",
    "ax.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.10 ('venv': 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.8.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "1f74b981ce186e523e14680e623d64ffc3734a44ecf348aec364ee341f346f80"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}