linear_pixels_to_torques_hardware_run.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "import datetime\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "from cartpole_lib_python import *\n",
    "import odrive\n",
    "import os.path\n",
    "from enum import Enum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;39;49maxis0\n",
      "  active_errors: \u001b[0;92;49;1mno error\u001b[0;39;49m\n",
      "  disarm_reason: \u001b[0;92;49;1mno error\u001b[0;39;49m\n",
      "  procedure_result: \u001b[0;92;49;1mProcedureResult.SUCCESS\u001b[0;39;49m\n",
      "  last_drv_fault: \u001b[0;92;49;1mnone\u001b[0;39;49m\n",
      "internal issues: \u001b[0;92;49;1mnone\u001b[0m\n",
      "\u001b[0;39;49maxis0\n",
      "  active_errors: \u001b[0;92;49;1mno error\u001b[0;39;49m\n",
      "  disarm_reason: \u001b[0;92;49;1mno error\u001b[0;39;49m\n",
      "  procedure_result: \u001b[0;92;49;1mProcedureResult.SUCCESS\u001b[0;39;49m\n",
      "  last_drv_fault: \u001b[0;92;49;1mnone\u001b[0;39;49m\n",
      "internal issues: \u001b[0;92;49;1mnone\u001b[0m\n",
      "odrive initialized\n"
     ]
    }
   ],
   "source": [
    "init_odrive()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;39;49maxis0\n",
      "  active_errors: \u001b[0;92;49;1mno error\u001b[0;39;49m\n",
      "  disarm_reason: \u001b[0;92;49;1mno error\u001b[0;39;49m\n",
      "  procedure_result: \u001b[0;92;49;1mProcedureResult.SUCCESS\u001b[0;39;49m\n",
      "  last_drv_fault: \u001b[0;92;49;1mnone\u001b[0;39;49m\n",
      "internal issues: \u001b[0;92;49;1mnone\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "odrv = get_odrive()\n",
    "odrive.utils.dump_errors(odrv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up camera stream\n",
    "gst_string = 'v4l2src ! video/x-raw, format=GRAY8, width=640, height=400, framerate=60/1 ! videoconvert ! videoflip method=2 ! appsink sync=true'\n",
    "cap = cv2.VideoCapture(gst_string, cv2.CAP_GSTREAMER)\n",
    "if not cap.isOpened():\n",
    "    print(\"Cannot open camera\")\n",
    "    exit()\n",
    "\n",
    "# Load calibration data\n",
    "calib_data = np.load(\"calibration_data.npz\")\n",
    "mtx = calib_data[\"matrix\"]\n",
    "dist = calib_data[\"coefficients\"]\n",
    "\n",
    "# Initialize image undistortion matrix map\n",
    "ret, frame = cap.read()\n",
    "h, w = frame.shape\n",
    "newcameramtx, roi = cv2.getOptimalNewCameraMatrix(mtx, dist, (w,h), 1, (w,h))\n",
    "mapx, mapy = cv2.initUndistortRectifyMap(mtx, dist, None, newcameramtx, (w,h), 5)\n",
    "x_roi, y_roi, w_roi, h_roi = roi\n",
    "\n",
    "# Define image cropping parameters\n",
    "top_off = 10\n",
    "left_side_off = 30\n",
    "right_side_off = 30\n",
    "\n",
    "# Define image size params\n",
    "w_small = 200\n",
    "h_small = 125"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1423,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N:  1800\n"
     ]
    }
   ],
   "source": [
    "### Temporal params\n",
    "\n",
    "# Runtime\n",
    "T_min = 0.5 # minutes\n",
    "\n",
    "# Frequency\n",
    "control_frequency = 60 # Hz\n",
    "control_period = 1/control_frequency\n",
    "\n",
    "# don't edit:\n",
    "T = T_min*60 # seconds\n",
    "N = int(T*control_frequency)\n",
    "print(\"N: \", N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1424,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Discrete Dynamics\n",
    "div = 1.5\n",
    "A = np.array([[1.0000000000, -0.0003967107, 0.0166666667, -0.0000022013/div],\n",
    "              [0.0000000000, 1.0071773311, 0.0000000000, 0.0167064931/div],\n",
    "              [0.0000000000, -0.0476620907, 1.0000000000, -0.0003967107/div],\n",
    "              [0.0000000000, 0.8623075615, 0.0000000000, 1.0071773311/div]])\n",
    "B = np.array([[0.00071],\n",
    "              [-0.0028918346],\n",
    "              [0.0850797930],\n",
    "              [-0.3474342796]])\n",
    "\n",
    "H = np.array([[1, 0, 0, 0],\n",
    "              [0, 1, 0, 0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1425,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Controller params\n",
    "div = 1.5\n",
    "control_clamp = 0.6\n",
    "\n",
    "k_matrix = np.array([-3.29489, -19.36664, -4.46195, -2.79850/div]) * .2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1426,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Encoder KF params\n",
    "\n",
    "# Encoder KF gains\n",
    "meas_noise_cov = np.diag([.01, .01]) # most recent\n",
    "process_noise_cov = np.diag([1, 1, 50, 50]) # position, angle, linear velocity, angular velocity\n",
    "nx = process_noise_cov.shape[0]\n",
    "\n",
    "def kf_update(x_meas, x_pred_prev, control_prev, est_cov_prev):\n",
    "\n",
    "    x_pred = A@x_pred_prev + B@control_prev\n",
    "    est_cov_pred = A@est_cov_prev@A.T + process_noise_cov\n",
    "\n",
    "    Kn = est_cov_pred@H.T @ np.linalg.inv(H@est_cov_pred@H.T + meas_noise_cov)\n",
    "    x = x_pred + Kn @ (x_meas - H@x_pred_prev)\n",
    "    est_cov = (np.eye(nx) - Kn@H) @ est_cov_pred @ (np.eye(nx) - Kn@H).T + Kn@meas_noise_cov@Kn.T\n",
    "    return x, est_cov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "### Pixel LO \n",
    "\n",
    "# Image size\n",
    "frame_w = 200\n",
    "frame_h = int(frame_w*h_small/w_small)\n",
    "\n",
    "# assume linear feedback (no u in estimator, only x)\n",
    "assume_linear_feedback = True\n",
    "\n",
    "# data file\n",
    "pixel_lo_data_file = \"./learned_luenberger_observer/learned_hardware_lo_matrices_2e-2_reg_assume_feedback_20_traj.npy\"\n",
    "\n",
    "print(os.path.isfile(pixel_lo_data_file))\n",
    "\n",
    "# switch time\n",
    "switch_time = 10 # seconds\n",
    "\n",
    "if assume_linear_feedback:\n",
    "    if os.path.isfile(pixel_lo_data_file):\n",
    "        learned_KF_matrices = np.load(pixel_lo_data_file)\n",
    "        learned_ABK_hat = learned_KF_matrices[\"ABK_hat\"]\n",
    "        learned_L = learned_KF_matrices[\"L\"]\n",
    "        learned_d2 = learned_KF_matrices[\"d2\"]\n",
    "    else:\n",
    "        learned_ABK_hat = np.zeros(A.shape)\n",
    "        learned_L = np.zeros((A.shape[0], (frame_h-top_off)*(frame_w-left_side_off-right_side_off)))\n",
    "        learned_d2 = np.zeros(A.shape[0])\n",
    "else:\n",
    "    if os.path.isfile(pixel_lo_data_file):\n",
    "        learned_KF_matrices = np.load(pixel_lo_data_file)\n",
    "        learned_A_hat = learned_KF_matrices[\"A_hat\"]\n",
    "        learned_B_hat = learned_KF_matrices[\"B_hat\"]\n",
    "        learned_L = learned_KF_matrices[\"L\"]\n",
    "        learned_d2 = learned_KF_matrices[\"d2\"]\n",
    "    else:\n",
    "        learned_A_hat = np.zeros(A.shape)\n",
    "        learned_B_hat = np.zeros(B.shape)\n",
    "        learned_L = np.zeros((A.shape[0], (frame_h-top_off)*(frame_w-left_side_off-right_side_off)))\n",
    "        learned_d2 = np.zeros(A.shape[0])\n",
    "\n",
    "def kf_pixel_update(y_meas, x_prev, u_prev):\n",
    "    # Update\n",
    "    # xkp1_corrected = xkp1_pred + learned_L@ykp1\n",
    "    xkp1_corrected = learned_A_hat @ x_prev + learned_B_hat @ u_prev + learned_L @ y_meas + learned_d2 \n",
    "\n",
    "    return xkp1_corrected\n",
    "\n",
    "def kf_pixel_update_feedback(y_meas, x_prev):\n",
    "    # Update\n",
    "    # xkp1_corrected = xkp1_pred + learned_L@ykp1\n",
    "    xkp1_corrected = learned_ABK_hat @ x_prev + learned_L @ y_meas + learned_d2 \n",
    "\n",
    "    return xkp1_corrected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1488,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1488-f95b78cfc7ac>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     47\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mx_ref\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mx_ref\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     48\u001b[0m         \u001b[0mtraj_snippet_start_indices\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mx_ref\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mx_ref\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     50\u001b[0m         \u001b[0mtraj_snippet_end_indices\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     51\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "### Generate training reference traj\n",
    "\n",
    "# Training reference params\n",
    "min_goal = 0.001 # m\n",
    "max_goal = 0.07 # m\n",
    "\n",
    "peak_length = 0.5 # seconds\n",
    "ramp_length = 1 # seconds\n",
    "stabilize_length = 2.5 # seconds\n",
    "one_traj_length = peak_length + ramp_length + stabilize_length\n",
    "\n",
    "ramp_N = int(ramp_length * control_frequency)\n",
    "peak_N = int(peak_length * control_frequency)\n",
    "stabilize_N = int(stabilize_length * control_frequency)\n",
    "one_traj_N = int(ramp_N + peak_N + stabilize_N)\n",
    "\n",
    "num_peaks = int(T // (peak_length + ramp_length + stabilize_length)) - 1\n",
    "\n",
    "# generate random peaks\n",
    "goal_points = []\n",
    "\n",
    "for i in range(num_peaks):\n",
    "    if i % 2 == 0:\n",
    "        gp = np.random.uniform(low=min_goal, high=max_goal, size=1)\n",
    "    else:\n",
    "        gp = np.random.uniform(low=-max_goal, high=-min_goal, size=1)\n",
    "    \n",
    "    goal_points.append(gp[0])\n",
    "    \n",
    "x_ref = [0]*(one_traj_N//2)\n",
    "for xg_i in goal_points:\n",
    "    peak_i_ramp = list(map(lambda x: x*(xg_i / ramp_N), list(range(1, ramp_N+1))))\n",
    "    peak_i_peak = [xg_i]*peak_N\n",
    "    peak_i_stabilize = [0]*stabilize_N\n",
    "\n",
    "    x_ref.extend(peak_i_ramp)\n",
    "    x_ref.extend(peak_i_peak)\n",
    "    x_ref.extend(peak_i_stabilize)\n",
    "\n",
    "x_ref.extend([0]*(one_traj_N//2))\n",
    "\n",
    "print(len(x_ref) == N)\n",
    "\n",
    "traj_snippet_start_indices = []\n",
    "traj_snippet_end_indices = []\n",
    "for i in range(1, N):\n",
    "    if x_ref[i-1] != 0 and x_ref[i] == 0:\n",
    "        traj_snippet_start_indices.append(i)\n",
    "    if x_ref[i-1] == 0 and x_ref[i] != 0:\n",
    "        traj_snippet_end_indices.append(i)\n",
    "\n",
    "traj_snippet_end_indices.append(N)\n",
    "\n",
    "# Remove first end index since it doesn't have a start\n",
    "traj_snippet_end_indices = traj_snippet_end_indices[1:]\n",
    "# Remove last start index since it doesn't have an end\n",
    "# traj_snippet_start_indices = traj_snippet_start_indices[:-1]\n",
    "\n",
    "plt.plot(x_ref)\n",
    "plt.scatter(traj_snippet_start_indices, [.05]*len(traj_snippet_start_indices), s=5, c='g')\n",
    "plt.scatter(traj_snippet_end_indices, [.05]*len(traj_snippet_end_indices), s=5, c='r')\n",
    "# plt.xlim([N-(N//4), N])\n",
    "plt.show()\n",
    "\n",
    "print(len(traj_snippet_start_indices))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1489,
   "metadata": {},
   "outputs": [],
   "source": [
    "Sensor = Enum('Sensor', ['ENCODER', 'PIXEL'])\n",
    "\n",
    "# CHANGE THIS TO SWITCH BETWEEN ESTIMATORS\n",
    "estimator_sensor = Sensor.PIXEL\n",
    "\n",
    "# Track goal trajectory (cell above)\n",
    "reference_x = False\n",
    "\n",
    "# Perturb control with noise\n",
    "perturb = False\n",
    "perturb_std = 0.05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1628,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.0037944  0.0974903]\n"
     ]
    }
   ],
   "source": [
    "### Calibrate cartpole position\n",
    "cart_midpoint = -0.05985056\n",
    "encoder_offset = np.array([cart_midpoint, -2.792311053164165, 0, 0])\n",
    "measurement = get_measurement() - encoder_offset[:2]\n",
    "print(measurement)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize python arrays to keep track of timing\n",
    "read_times = []\n",
    "frame_times = []\n",
    "control_times = []\n",
    "loop_times = []\n",
    "    \n",
    "# Initialize numpy array to store image frames\n",
    "frames = np.zeros((frame_h-top_off, frame_w-left_side_off-right_side_off, N))\n",
    "\n",
    "# Initialize numpy arrays to keep track of data\n",
    "x_encoder = np.zeros(A.shape[0])\n",
    "xs_pixel = np.zeros(np.append(x_encoder.shape, N))\n",
    "xs_encoder = np.zeros(np.append(x_encoder.shape, N))\n",
    "measurements = np.zeros((2,N))\n",
    "controls_encoder = np.zeros(N-1)\n",
    "controls_pixel = np.zeros(N-1)\n",
    "\n",
    "# Initialize Kalman filter variables\n",
    "# First state estimate\n",
    "meas = get_measurement() - encoder_offset[:2]\n",
    "x_encoder = np.array([meas[0], meas[1], 0, 0])\n",
    "x_pred_prev = x_encoder\n",
    "x_pixel = x_encoder\n",
    "\n",
    "measurements[:,0] = meas\n",
    "xs_encoder[:,0] = x_encoder\n",
    "xs_pixel[:, 0] = x_encoder\n",
    "\n",
    "# Estimation covariance\n",
    "est_cov = np.eye(4)*20\n",
    "est_cov_prev = est_cov\n",
    "\n",
    "# calculate switch point if using Pixel LO\n",
    "switch_point = switch_time * control_frequency\n",
    "\n",
    "try:\n",
    "    for i in range(N-1):\n",
    "        time_start = time.perf_counter()\n",
    "        \n",
    "        # if tracking, change goal state by reference\n",
    "        if reference_x:\n",
    "            encoder_offset[0] = cart_midpoint + x_ref[i] # track cart reference trajectory generated above\n",
    "\n",
    "        # calculate control\n",
    "        control_encoder = -k_matrix @ x_encoder\n",
    "        control_pixel = -k_matrix @ x_pixel\n",
    "\n",
    "        if perturb:\n",
    "            w_perturb = np.random.normal(scale=perturb_std, size=1)[0]\n",
    "            control_encoder = control_encoder + w_perturb\n",
    "            control_pixel = control_pixel + w_perturb\n",
    "\n",
    "        control_encoder = min(control_clamp, max(-control_clamp, control_encoder))\n",
    "        control_pixel = min(control_clamp, max(-control_clamp, control_pixel))\n",
    "\n",
    "        controls_encoder[i] = control_encoder\n",
    "        controls_pixel[i] = control_pixel            \n",
    "\n",
    "        # send control to motor\n",
    "        if estimator_sensor == Sensor.ENCODER:\n",
    "            command_linear_torque(-control_encoder)\n",
    "        elif estimator_sensor == Sensor.PIXEL:\n",
    "            if i < switch_point:\n",
    "                command_linear_torque(-control_encoder)\n",
    "            else:\n",
    "                print(\"switching!\")\n",
    "                command_linear_torque(-control_pixel)\n",
    "            \n",
    "        # how long it takes to do control\n",
    "        control_times.append(time.perf_counter() - time_start) \n",
    "\n",
    "        ### capture encoder measurements\n",
    "        measurement = get_measurement() - encoder_offset[:2]\n",
    "        measurements[:,i+1] = measurement\n",
    "\n",
    "        ### Capture IMAGE frame\n",
    "        ret, frame = cap.read()\n",
    "        read_times.append(time.perf_counter() - time_start) # how long it takes to read the frame from camera\n",
    "        \n",
    "        # if frame is read correctly ret is True\n",
    "        if not ret:\n",
    "            print(\"Can't receive frame. Exiting...\")\n",
    "            command_linear_torque(0)\n",
    "            break\n",
    "\n",
    "        # 1. remap warped image\n",
    "        frame_undistort = cv2.remap(frame, mapx, mapy, cv2.INTER_CUBIC)\n",
    "        # 2. crop to usable area\n",
    "        frame_undistort = frame_undistort[y_roi:y_roi+h_roi, x_roi:x_roi+w_roi]\n",
    "        # 4. threshold\n",
    "        ret, frame_undistort = cv2.threshold(frame_undistort, 30, 255, cv2.THRESH_TOZERO | cv2.THRESH_OTSU)\n",
    "        # 3. blur\n",
    "        frame_undistort = cv2.GaussianBlur(frame_undistort, (9, 9), 0)\n",
    "        # 5. normalize\n",
    "        frame_undistort = cv2.normalize(frame_undistort, None, 0, 1, cv2.NORM_MINMAX, dtype=cv2.CV_64F)\n",
    "        # 6. resize to correct aspect ratio (makes image proportions correct)\n",
    "        frame_undistort = cv2.resize(frame_undistort, (frame_w, frame_h), interpolation=cv2.INTER_CUBIC)\n",
    "        # 7. crop again (can flip steps 5 and 6 to increase speed a tiny bit but probably doesn't matter and might introduce artifacts when blurring the edges of the image)\n",
    "        frame_undistort = frame_undistort[top_off:, left_side_off:-right_side_off]\n",
    "\n",
    "        frames[:,:,i+1] = frame_undistort\n",
    "        \n",
    "        # image data stored as floats from 0-1\n",
    "        frame_undistort = frame_undistort.astype(float)\n",
    "        frame_times.append(time.perf_counter() - time_start) # how long it takes to process the image\n",
    "\n",
    "        # now do state estimation\n",
    "        if assume_linear_feedback:\n",
    "            x_pixel = kf_pixel_update_feedback(frame_undistort.T.reshape(-1), x_encoder)\n",
    "        else:\n",
    "            x_pixel = kf_pixel_update(frame_undistort.T.reshape(-1), x_encoder, [control_encoder])\n",
    "        x_encoder, est_cov = kf_update(measurement, x_encoder, [control_encoder], est_cov)\n",
    "        \n",
    "        xs_encoder[:,i+1] = x_encoder\n",
    "        xs_pixel[:,i+1] = x_pixel\n",
    "        \n",
    "        busy_sleep(control_period, time_start, get_now=time.perf_counter)\n",
    "        loop_times.append(time.perf_counter() - time_start)\n",
    "        \n",
    "        if measurement[1] > .35 or measurement[1] < -.35: # arbitrary max and min angles in radians\n",
    "            print(\"POLE FELL OVER :(\")\n",
    "            break\n",
    "        if measurement[0] > .43 or measurement[0] < -.43: # measured fom center\n",
    "            print(\"POLE EXCEEDED MAX CART POSITION :(\")\n",
    "            break\n",
    "        \n",
    "    command_linear_torque(0) # Set motor torque to 0 when done\n",
    "    print(\"done\")\n",
    "\n",
    "except Exception as e:\n",
    "    print(\"error: {}\".format(e))\n",
    "    command_linear_torque(0) # Set motor torque to 0 on exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# THIS SAVES ALL DATA - CELL BELOW SAVES ONLY STABILIZING TRAJECTORY SNIPPETS\n",
    "# Save data to npz to transfer to laptop\n",
    "\n",
    "if reference_x:\n",
    "    file_name = \"data/hardware_cartpole_stabilizing_training_data.npz\"\n",
    "    np.savez(file_name, frames=frames, controls_encoder=controls_encoder, measurements=measurements, est_states_encoder=xs_encoder, traj_snippet_start_indices=traj_snippet_start_indices, traj_snippet_end_indices=traj_snippet_end_indices, x_ref=x_ref)\n",
    "else:\n",
    "    file_name = \"data/hardware_cartpole_testing.npz\"\n",
    "    np.savez(file_name, frames=frames, controls_encoder=controls_encoder, controls_pixel=controls_pixel, measurements=measurements, est_states_encoder=xs_encoder, est_states_pixel=xs_pixel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1631,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8c0c9240>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(range(len(loop_times)), np.array(loop_times), s=2, label=\"total loop time\")\n",
    "plt.scatter(range(len(loop_times)), np.array(control_times), s=2, label=\"kf/control time\")\n",
    "plt.scatter(range(len(loop_times)), np.array(frame_times), s=2, label=\"threshold time\")\n",
    "plt.scatter(range(len(loop_times)), np.array(read_times), s=2, label=\"frame retrieval time\")\n",
    "\n",
    "plt.ylim([0,0.05])\n",
    "plt.legend()\n",
    "plt.ylabel(\"time (s)\")\n",
    "plt.xlabel(\"iteration\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1632,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAD8CAYAAACPWyg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzsnXl4VdW5/z9r7zPmnExkIoxhHhIwjA44IFXRVtEWrAO2WqzUWvXa/urVXq1apa3Ve1vrtVRtr+JtpcXiraJWcQBEmYRAhDCTECAkZB7OfPawfn+ckIGE+YRA3J/n4eHsYa317pNkfff7rrXeJaSUWFhYWFhYnAxKdxtgYWFhYXHuYYmHhYWFhcVJY4mHhYWFhcVJY4mHhYWFhcVJY4mHhYWFhcVJY4mHhYWFhcVJY4mHhYWFhcVJY4mHhYWFhcVJY4mHhYWFhcVJY+tuA06FlJQUOXTo0O42ox2BQACPx9PdZrTDsunEORvtsmw6Mc5Gm+DstKugoKBGSpkRl8qklOfcv+HDh8uzjeXLl3e3CR2wbDpxzka7LJtOjLPRJinPTruADTJO/bAVtrKwsLCwOGks8bCwsLCwOGks8bCwsLCwOGnOyQHzztA0jbKyMsLhcLe0n5yczPbt27ul7aPRVTa5XC769euH3W6Pe90WFhbnBj1GPMrKykhMTCQnJwchxBlv3+fzkZiYeMbbPRZdYZOUktraWsrKyhg0aFBc67awsDh36DFhq3A4TFpaWrcIx1cJIQRpaWnd5uFZWFicHfQY8QAs4ThDWN+zhYVFjxIPCwuL7kevDyOt7a17PJZ4WFhYxJVDv1mPVubvbjMsuhhLPCwsLOKG1MzY/4bZzZZYdDWWeMSJgoICxo4dSzgcJhAIkJubS1FRUXebZWFxRjF8UQDMkN7Nllh0NT1mqm53M2HCBGbMmMGjjz5KKBTitttuIy8vr7vNsrA4oxj+ZvEIWuLR0+mx4pHz8Htxr7P06W8c8/pjjz3GpEmTcLlcPP/883Fv38LibMf0a7H/Lc+jx9NjxeN4HX1XUFdXh9/vR9M0wuHwWZeO2cKiq2nxPCzx6PFYYx5xZO7cuTz11FPMnj2bhx56qLvNsbA445h+DQRI3Row7+n0WM/jTLNw4UJsNhu33norhmFw0UUXsWzZMqZNm9bdpllYnDFMv4aa4gTNEo+ejiUeceLWW2/lBz/4AQCqqrJu3bputsjC4sxj+KOoKU5rqu5XgLiErYQQVwshdgoh9gghHu7k+u+EEIXN/3YJIRraXDPaXFsSD3ssLCy6B8OnYUtxtaz3sOi5nLbnIYRQgT8AVwJlwHohxBIp5bbD90gpf9zm/vuAcW2qCEkp80/XDgsLi+7H9EdRc5LQ66zEmT2deHgek4E9UsoSKWUU+Dtw/THuvwX4WxzatbCwOMsw/BpqqtPyPL4CxEM8+gIH2hyXNZ/rgBBiIDAIWNbmtEsIsUEIsVYIcUMc7LGwsOgGpG4iowZqogOsMY8ejzjd7JdCiBuB6VLK7zcffweYLKW8r5N7HwL6tb0mhOgjpSwXQgwmJipfk1IWd1J2LjAXICMjY8Ibb7zR7npycjJDhw49rWc5HQzDQFXVbmu/M7rSpj179tDY2HjS5fx+P16vtwssOj3ORrvONZtsIei3VqFyrElqsUL55DMjIGfj9wRnp12XX355gZRyYlwqk1Ke1j/gQmBpm+OfAT87yr2bgIuOUdcCYNbx2hw+fLg8km3btnU4dyZpamrq1vY7oyttOtXve/ny5fE1JE6cjXadazZFDjTJQ78vkOG9DbJyfuFZYVN3cjbaBWyQp9nnH/4Xj7DVemCYEGKQEMIB3Ax0mDUlhBgBpAJr2pxLFUI4mz+nA1OAbUeWPRdoaGhg/vz5AKxYsYJrr732pMovWLCA8vLyrjDNwqLLMaXJ4k1v0GgLIGyKtUjwK8Bpi4eUUgfuBZYC24E3pJRbhRBPCiFmtLn1FuDvzep3mFHABiHEl8By4GnZZpbWuURjY2OLeJwKlnhYnMts/nQN3kKDreEdlnh8RYjLIkEp5b+Afx1x7rEjjp/opNxqYEw8bOhuHn/8cYqLi8nPz8dut+PxeJg1axZFRUVMmDCBv/71rwghKCgo4Cc/+Ql+v5/09HQWLFjAqlWr2LBhA7Nnz8btdrNmzRqeffZZ3nnnHUKhEBdddBEvvfSStf2rxVlL+gcm6YzinYSV1BuNlnh8BbByW8WJX/ziFwwZMoTCwkKeffZZNm3axHPPPce2bdsoKSlh1apVaJrGfffdx+LFiykoKGDOnDk88sgjzJo1i4kTJ/L6669TWFiI2+3m3nvvZf369RQVFREKhXj33Xe7+xEtLI5LUmIKOxp2gCUePZ6em57kieQuqPPEZxdNnjyZfv36AZCfn09paSkpKSkUFRVx5ZVXArHZUNnZ2Z2WX758Oc888wzBYJC6ujpyc3O57rrrTv8ZLCzizOENoALDIJKjUuIrYahh7WXT0+nB4nHy00jjidPpbPmsqiq6riOlJDc3lzVr1hyjJITDYe655x42bNhA//79eeKJJwiHrRW7Fmcn0TIfAK4bB5BV08TqPZ9zlZnbzVZZdDVW2CpOeL1efD7fMe8ZMWIE1dXVLeKhaRpbt24FIDExsaX8YaFIT0/H7/ezePHiLrTcwuL0kIbJ2sTNZCZkMix1GLsadyGN01s/ZnH203M9jzNMWloaU6ZMIS8vD7fbTVZWVod7HA4Hixcv5v7776exsRFd13nggQfIzc3ljjvu4O67724ZML/rrrsYM2YMOTk5TJo0qRueyMLixAj6/YRtUdw2NwOTBnIgWAamJR49HUs84sjChQs7Pf/CCy+0fM7Pz2flypUd7pk5cyYzZ85sOZ43bx7z5s2Lv5EWFnGmqakR6YzNBHSqTgxhWJ7HVwArbGVhYXFahPx+hKv1PdRtTwCzJWuERQ/FEg8LC4vTIhwIYktwtBx7nV6kghW66uFY4mFhYXFaGCENu7uNeNi9oGCFrno4lnhYWFicFjJsYk9onZrusXssz+MrgCUeFhYWp4USkTg87pZjr8OLFNLyPHo4lnhYWFicFmpU4PImtBy7VTemIi3Po4djiYeFhcVpYddseLyJLccO1YFULM+jp2Ot87CwsDgtXJodmzep5dihOjCFtLai7eFYnkecKCgoYOzYsYTDYQKBALm5ucycOZN//as1U/0dd9zBm2++2Y1WWljEH7thIykxpeXYqToxFYm0wlY9GsvziBMTJkxgxowZPProo4RCIW677TZGjhzJokWL+PrXv040GuWTTz7hj3/8Y3ebamERN6RhIoAkV3vPwxAmWGGrHk2PFY8xr8V/j6ktt2855vXHHnuMSZMm4XK5eP7559E0jfvvv59IJMIHH3zApZdeitvtPmYdFhbnEnpEI6JE8Tg8LeecqhNTmNaYRw+nx4rH8Tr6rqCurg6/34+maYTDYTweD1OnTmXp0qUsWrSIW2655YzbZGHRlYRCQaKKjiJaI+AtnocVturRWGMecWTu3Lk89dRTzJ49m4ceegiAm2++mVdffZXPPvuM6dOnd7OFFhbxJRjyoyl6u3MOxRFLjmiJR4+mx3oeZ5qFCxdis9m49dZbMQyDiy66iGXLlnHVVVfx3e9+lxkzZuBwOI5fkYXFOUQoHERTjXbnYpl1TWu2VQ/HEo84ceutt/KDH/wAiO0cuG7dupZrtbW13WWWhUWXEg6FMJT24uFQHehWWvYeT1zCVkKIq4UQO4UQe4QQD3dy/Q4hRLUQorD53/fbXLtdCLG7+d/t8bDHwsLizBAJhzFs7UXCqToxsMJWPZ3T9jyEECrwB+BKoAxYL4RYIqXcdsSti6SU9x5RthfwODARkEBBc9n607XLwsKi64lEwphHiIdDdaDhs6bq9nDi4XlMBvZIKUuklFHg78D1J1h2OvCRlLKuWTA+Aq6Og00WFhZngGgkjDziFdSu2K2w1VeAeIhHX+BAm+Oy5nNHMlMIsVkIsVgI0f8ky1pYWJyFaBENaRPtztkUG4YwwLQGzHsy8RgwF52cO/KV4x3gb1LKiBDibuA1YNoJlo01IsRcYC5ARkYGK1asaHc9OTkZn893cpbHEcMwurX9zuhKm8LhcIefwYng9/tPqVxXczbadS7YVFF2kNSou925naGdZGqC7UXb8dUfGb3uepvOFs5Wu+JFPMSjDOjf5rgfUN72Bill2+lGfwJ+06bs1CPKruisESnly8DLACNGjJBTp05td3379u0kJiZ2UvLM4PP5urX9zuhKm1wuF+PGjTvpcitWrODIn93ZwNlo17lg0/uVh/CoTi5tcy6xMpGyHZsYOWIEnom9z7hNZwtnq13xIh5hq/XAMCHEICGEA7gZWNL2BiFEdpvDGcD25s9LgauEEKlCiFTgquZz5xwNDQ3Mnz8fiP3SXHvttSdVfsGCBZSXlx//RguLswgjqqM42r+D2hTbUcc8mpqa+Oyzz86UeRZdyGmLh5RSB+4l1ulvB96QUm4VQjwphJjRfNv9QoitQogvgfuBO5rL1gFPEROg9cCTzefOORobG1vE41SwxMPiXMTUTBS72u6cTbGho3dIT2L4A2xeuZJPPvnkTJpo0UXEZZ2HlPJfUsrhUsohUspfNp97TEq5pPnzz6SUuVLK86SUl0spd7Qp+4qUcmjzv1fjYU938Pjjj1NcXEx+fj4PPvggfr+fWbNmMXLkSGbPno2UsT+kgoICLrvsMiZMmMD06dOpqKhg8eLFbNiwgdmzZ5Ofn08oFOLJJ59k0qRJ5OXlMXfuXKSUbN++ncmTJ7e0WVpaytixY7vrkS0sQDOxOe3tTtmEDQ29g+dR/MQT1L/4IkDL34PFuYuV2ypO/OIXv2DIkCEUFhby7LPPsmnTJp577jm2bdtGSUkJq1atQtM07rvvPhYvXkxBQQFz5szhkUceYdasWUycOJHXX3+dwsJC3G439957L+vXr6eoqIhQKMS7777LqFGjiEajlJSUALBo0SK+/e1vd/OTW3yVkZqJzdFePOyKHe0Iz6Ni9WoWej1UnHceAJqmnVE7LeJPj01Psn3kqLjXOWrH9uPf1MzkyZPp168fAPn5+ZSWlpKSkkJRURFXXnklEJsNlZ2d3Wn55cuX88wzzxAMBqmrqyM3N5frrruOb3/727zxxhs8/PDDLFq0iEWLFp3+g1lYnCKKLlA7G/NAb7fCvGzjJgDK7TGhCYfDVq63c5weKx4n09F3BU6ns+Wzqqrouo6UktzcXNasWXPMsuFwmHvuuYcNGzbQv39/nnjiCcLhMAA33XQTN954I9/61rcQQjBs2LAufQ4Li2OhGspRB8zbrjAPlpUxJDODQ7pOIBgkVFNDUlLSkdVZnENYYas44fV6j7umYsSIEVRXV7eIh6ZpbN26FYDExMSW8oeFIj09Hb/fz+LFi1vqGDJkCKqq8tRTT3HTTTd1xaNYWJwwqtG556GhtfM8QpWHSExP58F//3dSdB3/hg1n2lSLONNjPY8zTVpaGlOmTCEvLw+3201WVlaHexwOB4sXL+b++++nsbERXdd54IEHyM3N5Y477uDuu+/G7XazZs0a7rrrLsaMGUNOTg6TJk1qV89NN93Egw8+yN69e8/U41lYdIrNULE724efbIoNTbaOeZjhMOEmH670dAAabDYWbdvGf5xxay3iiSUecWThwoWdnn/hhRdaPufn57Ny5coO98ycOZOZM2e2HM+bN4958+Z1Wt9Pf/pTfvrTn56mtRZdiZQSITpLoNCzsBlqhwHzmOfROtsqsnsPpKXhcLla7omeUSstugIrbGVhEWeCGzawY9RozGCwu03pcuxmJ+IhYmGrw55HZOcOyEjHZrPeVXsSlnhYWMSZL/73f9kwYQKBDQXdbUqXYzds2NtMDoHmqbqyVTyipaXI5GTsdntnVVico1jiYWERR2Q0yiabjeJhQzlYvKe7zely7Kat0zGPKDqyeRva6L59mF5vB/GwFgqe21jiYWERR2o3byGYkMBQu53qunMy085JYTdVnE5Xu3NCCKQiMZvFY29dPVuqqjqEraJfgbBeT8YSDwuLOLL/y0IyFYXUhAQaAoHuNqfLsUkb9k4W+0kFTMNASsk+Wyz31ZGexyfvv39GbLToGizxsLCIIw1V1SR7PKQkJdEU6dlzigzTwC5tnY9lKGCaJjIYxK7pAC2ex5133gnAF0VFZ8xWi/hjiYeFRRxp8vtITk4mITmZiN6z8zdFjAg2qSJsaseLisDUTfT6egxPQrtL/fv373i/xTmHJR4WFnHEF46Qkp5OQmoqkR6+DWs0GsFEIpSO61mkAGmaGHV1RLze2LkjBshdaieiY3HOYIlHnCgoKGDs2LGEw2ECgQC5ubkUHeGWl5aWMnLkSL7//e+Tl5fH7Nmz+fjjj5kyZQrDhg3jiy++ACAQCDBnzhwmTZrEuHHjePvtt1vKX3LJJYwfP57x48ezevVqACoqKrj00kvJz88nLy/P2mynG/FJk9SsLNzJKUQ63WW55xCNRtAVvfOLKpiGiV5bS8jtBmJhrMNM83jIsdZ9nNNYP704MWHCBGbMmMGjjz5KKBTitttuIy8vr8N9e/bs4R//+Acvv/wykyZNYuHChXz++ecsWbKEX/3qV7z11lv88pe/ZNq0abzyyis0NDQwefJkrrjiCjIzM/noo49wuVzs3r2bW265hQ0bNrBw4UKmT5/OI488gmEYBK1ZLN1GWFXxZmTgdDiIKj373SyqRWMJEDtBKAJpmBh19YRsdnr37t0uXOVISiJaUXGmTLXoAnqsePzh7mVxr/NHL0475vXHHnuMSZMm4XK5eP755zu9Z9CgQYwZMwaA3Nxcvva1ryGEYMyYMZSWlgLw4YcfsmTJEv7zP/8TiCVK3L9/P3369OHee++lsLAQVVXZtWsXAJMmTWLOnDlomsYNN9xAfn5+nJ7Y4mSQUhJVVTwZGThsNqKdjQX0ILRoFF3pXDxQBFI30etqCSqC++bMaZeC3ZWSQnTfvjNkqUVX0GPF43gdfVdQV1eH3+9H0zTC4TAej6fDPW1TtSuK0nKsKAq6HgsBSCl58803GTFiRLuyTzzxBFlZWXz55ZeYpomrOVfQpZdeysqVK3nvvff4zne+w4MPPsh3v/vdrnpMi6NgBgJE7XYSkpJQVRVDVdFCIezNYZuehhaNYihHGddRBNKURJsakHScpuvu1YuofpSQl8U5Qc/2q88wc+fO5amnnmL27Nk89NBDp1zP9OnT+e///u+WAcZNm2Ib6TQ2NpKdnY2iKPzlL3/BMGJvffv27SMzM5O77rqLO++8k40bN57+w1icNJH6ekBgt9tRFAWHrhOqre1us7oMXdOOKh6Hw1ahQACnqnZIEulKSUGzVpif01jiEScWLlyIzWbj1ltv5eGHH2b9+vUsW3ZqobOf//znaJrG2LFjycvL4+c//zkA99xzD6+99hoXXHABu3btavFsVqxYQX5+PuPGjePNN9/k3/7t3+L2XBYnTqCmBqfZGsaxGybBHrzKXD+G5yFUAYYkHArh7GRg3JmYiP4VyDrck4lL2EoIcTXwe0AF/iylfPqI6z8Bvg/oQDUwR0q5r/maAWxpvnW/lHJGPGw609x666384Ac/AGI7B65bt67DPTk5Oe1mYC1YsKDTa263m5deeqlD+WHDhrF58+aW41//+tcA3H777dx+++1xeQ6LUydYW4ujzdu0U5oE6hu60aKuRdM0TKWj9/BpYTm28l5IVRIOR3B1sojQmZSE3sMnFPR0Tls8hBAq8AfgSqAMWC+EWCKl3Nbmtk3ARCllUAjxQ+AZ4PA2eCEppTXCa3HOE6xvwNnmbdopBKHGnisehqZjqB09j8rdP2LqedtoLE4iEgm3G+c7jCspCU1VvzL7nvRE4iH9k4E9UsoSKWUU+DtwfdsbpJTLpZSH54+uBfrFoV0Li7OKsN+HU2mdYeVUFEI+fzda1LXomoY8wvMIBPaSlrYZoeo0Zb3Ph717dyoeDrcb3WbDDIXOlLkWcSYe4tEXONDmuKz53NG4E2ibEc0lhNgghFgrhLghDvZYWHQLoWAQZ5vpuU6bjVCg54qHoemYR8xG3lW8vOWzllSMomiITsY8VFVFSInu77nfT08nHmMenfmcnU6jEELcBkwELmtzeoCUslwIMRhYJoTYIqUs7qTsXGAuQEZGBitWrGh3PTk5GZ/Pd2pPEAcMw+jW9jujK20Kh8MdfgYngt/vP6VyXU087Ko5eJColC31RMNhDh4oO+V6z8bvqq1NB/ftJ0Nzt7OxYEt/tMp55F/2BHZVJzGxjiZ/VqfPoZgmq5ctQ/TuHTebzibOVrviRTzEowxom+msH1B+5E1CiCuAR4DLpJSRw+ellOXN/5cIIVYA44AO4iGlfBl4GWDEiBFy6tSp7a5v376dxMTE03yUU8fn83Vr+53RlTa5XC7GjRt30uVWrFjBkT+7s4F42LV09WrsdntLPe+vW4cGp1zv2fhdtbVp2b+aUH0RLmtjY0HBF3gzUqnSBtFX3U1iYg3pqX07fY41H3/MeSNH0us0F7Weye9Jmp3n8uqMs/HnF0/iEbZaDwwTQgwSQjiAm4ElbW8QQowDXgJmSCmr2pxPFUI4mz+nA1OAtgPtFhbnDNFoFIejNb7vcruJRCLHKHFuY+oGqO070uChIAOHp1KvZuPcfwk+X1qnYSsAVYIWxz1P/GvKkXrXJaOUUnLwPz7HjB5lVf1XjNMWDymlDtwLLAW2A29IKbcKIZ4UQhyedvss4AX+IYQoFEIcFpdRwAYhxJfAcuDpI2ZpnTM0NDQwf/78luMVK1Zw7bXXnlQdCxYsoLy8g9NmcY4Q0XWcrtZd9dwJCYS1npuW3dTNduJR37CF/AueYEDff9Kg9Me149s0Nvbm0ksv7bS8IkCL45hHw9vFaIeOLUZNy/dT/T9bjnnP0fCviv1tSq1nZ0s+UeKyzkNK+S/gX0ece6zN5yuOUm41MCYeNnQ3jY2NzJ8/n3vuueeU61iwYAF5eXn06dMnjpZZnCmiuo6jjXi4PF4iRs99S5W6gWyTVn3nntUkpB7AplagqImYwsQT0EhNTe20vCoEWuDMJvEMbalBKz81b0c72Cx0XejdnEtYq3TixOOPP05xcTH5+fk8+OCDQGzAbNasWYwcOZLZs2e3pBspKCjgsssuY8KECUyfPp2KigoWL17Mhg0bmD17Nvn5+YRCIZ588kkmTZpEXl4ec+fO7bAfAsAdd9zBD3/4Qy6//HIGDx7Mp59+ypw5cxg1ahR33313y30ffvghF154IePHj+fGG2/E3/zGd7Q2nn/+eUaPHs3YsWO5+eabu/rr6xFohokzoXXjI3dSYo/e08PUTYSttQupriwEIDEpD0VV0VxVpPQ5QCDQYQgTAJcQ1DY2xteo42U8UWP2nkroyd6neV+SOIiHVhlAauf2i4UlHnHiF7/4BUOGDKGwsJBnn30WiOWkeu6559i2bRslJSWsWrUKTdO47777WLx4MQUFBcyZM4dHHnmEWbNmMXHiRF5//XUKCwtxu93ce++9rF+/nqKiIkKhEO+++26nbdfX17Ns2TJ+97vfcd111/HjH/+YrVu3sm3bNgoLC6mpqWHevHl8/PHHbNy4kYkTJ/Lb3/4W4KhtPP3002zatInNmzfz4osvnpkv8RxHkybONrvmuZOT6dEb0RqynXhg7gQgMTEPoQi0gZ8y+LxVVFV/0GnxdFXFdxJTmcN7Gqh/e89pmXx4sLthSeeCdixkpDlx6WmKhxnWqfzdRho/KO30hfBcocdm1f2vm05uvOFE+H+LOu+8j8bkyZPp1y+2HjI/P5/S0lJSUlIoKiriyiuvBGLTabOzszstv3z5cp555hmCwSB1dXXk5uZy3XXXdbjvuuuua0nrnpWV1ZLyfeTIkZSWllJWVsa2bduYMmUKEBvYvfDCC4/ZxtixY5k9ezY33HADN9xgLb85ETQpcTbvmgeQkJLSo/f0MHUT4Wp+kzcjuNxlSASJ3tEo6seIptjvfkPjl52Wd9nthMMnPqEguKmKYEElqdcPbX9BQnBzdezj8TrjZvEwfScv62Y45imc7phH43t7gdgYinNYKu6RvU6rvu6ix4rHyXb0XUHblbWqqqLrOlJKcnNzWbNmzTHLhsNh7rnnHjZs2ED//v154oknCIfDx2ynbYr3w8e6rqOqKldeeSV/+9vfTriN9957j5UrV7JkyRKeeuoptm7dis3a+e2YRBG42kyNTkhLI3qKW61urdlKox7nkE68MUyUZs+jrn4bimLgdA7GZvOgqApmY0w86usLO01D4nQ6CURaO/GKigpqampaXn6ORE2J/W53qEtC3cIdJ2SyODzAbzt5UZeRZvE4Tc9Db2j9Oz5c57lIz30tOsN4vd4TWpA3YsQIqqurW8RD0zS2bt0KQGJiYksdhzvx9PR0/H4/ixcvPmXbLrjgAlatWsWePTGXPxgMsmvXrqO2YZomBw4c4PLLL+eZZ56hoaGhZYzE4ujoisCVlNRy7ExNxRQitr9LcQMHH1+NNI8fpiisKuTm927mD1V/QDPP4tlaBijNK+p37I4lAk1NGQuATbVjhlPRo06kWUsk0nHXQJfTRURrFY/Fixfz5ptvHrU522HxiLbvvMVJRH4Oi0d468mnyjcPh63iOdvqHO6BrVfJOJGWlsaUKVPIy8vjmmuu4Rvf+Ean9zkcDhYvXsz9999PY2Mjuq7zwAMPkJubyx133MHdd9+N2+1mzZo13HXXXYwZM4acnBwmTZp0yrZlZGSwYMECbrnllpZ1B/PmzWP48OGdtmEYBrfddhuNjY1IKfnxj39MSkrKKbf/VUFT1HbiobpcODSNcFMTHAwhIwbaoQCOPt5j1AKLdi7i77W/pTiyj+X7l3NVzlVdbfopIQzZIh5l+7PQg9cwJi9mq6qo6JiEGtJJzDxIU9NmXK72swhdCW4iVa1v3sd7QTkckpK6Cc5Wj87WNj3W8YTkBBf4dUZL2CqOs63OZc/DEo84snDhwnbHbVeXvvDCCy2f8/PzWblyZYfyM2fOZObMmS3H8+bNY968ecc8IwVqAAAgAElEQVRs82hp3QFefPHFlhXm06ZNY/369R3KH62Nzz///JjtWrRHRqPodhvOI1b02w2DQG0t9rJYJ6FXBzuIx97qYlSnnQFJAzBMgx17i0iu+jrjGcHvt/zfWSsebT2Pg3t6406/k8zMWNYBm2LDwEBvSofMgzQ1fUlm5tXtirsTEtpNZY5GY16IqesonYVIm722tm/+UkoGft4mNHicMQ/ZNtp1khl9pWagJNjiKx7GuTtgfg47TRYWZw9GIICuqu326QZwSEmothbTr2Hvn4he037cKhqKYP+vcv77jd9gSpPNNZs5P3oeai8X1YM1JhUNoTFydo59CANUe6yT16vDDBreup5DFTHPQw2kYxo2IlrHkK7L4yHaSWf/VvNMwA4Yh8WjVXDM4BFb2R6nX9eERomzLFbPSU7XlZqJkmBH6pKioiLeeeedkyrfKScQxjxbscTDwiIOhBsbUU0T5YjZVU4hCNTVEfGHiGaBXts+Bfm+VTFP8VsVl/P5wc/59MCnXKJPxHtRH5qGKEzy5VK0+osz9hwngzBj4tHUtJfs7BWMHNbUcs2m2NCFgd3fhy1LniciHuhQ3pWY2E48FC0mBFVH2UDr8K1Sby1jBtuPCR1vTCkajfB6+r/Q3OYJh4zefv11VvzPK8ioiZJgA83kk08+oaCg4ITKH4tT8TwMf5Syhz877bZPlx4lHufynOlzCet77kikqQm70fG116WoBBsbqW+o5eWa19Dr2nsevr01rDxvG33Dmby17f/4ZN8n9C9Pwz2qF1KFxuEGDYUHz9RjnBTCEKg2Gzt3fkTfiX8l2LCg5ZpNxMJWDtWJnpRA0ZaqDuXdvXqhtQkbuSIRrsnLI2ToHe41wzqN75YA7T2PIwfPj/cmr0c1NKGjKfoJD3xv2r2bgq1FzWErO1IzqK+vP6Gyx6I8N9AuzFZVVUWo1k/jh6XHLGf6z45JFD1GPFwuF7W1tVbH1sVIKamtrcXVJg2HBYR9PuyytTPy19VyqHg3LoedQGMDCZqT9cpmtJr26ThEnYEnKwV7egKhg40M8fXFnujCluYGYMTVk8mpzaJgX8fxqu5GMcFmt1Nd3byyPDGv5ZpNsaFjYrPZSe7roaKkHsNoffYvP3qfZf/8O1qzp2b4/UQcDoZfcgl+hwPziLQuZqC1w2w35nHEKu3jeR6GbqApGlFVO6lZU76kJGRER3HbWjyfjpvrnhiHx0xWV6wGU6JVx76X+fPn8/GSpfiWHehQxgxqrWMtpzHoH096zIB5v379KCsro7q6ulvaD4fDZ12H2lU2uVyulsWPFjEifn+7zuSzZ+5l614fQ8dcQGNTIwKBJysZ84COGdZRXLE/PY/PQXrfbBIiacxTH0VKiT2zdQDY3TsJhiaw9+/r+Tj7HfrVpzNtzo1kJ3a+sPRMohgKqs2GaewC2ouHqqgYmNhsNgaP2IipP8ee4lmMGP4EAEXLP6SieDfGyAkYhkHj/v2oUpKalYVqmvjKykgeOLBNY206zDYD1sEjs/IeRzykZqDbDCJCO6EUJW3rNyM6SoINMxITMnGKqWcOi5YhTKQJlf9VgPq92LNGjc69ivIn15IwIYteNw7vNCV8uClA4+5KsiYMPiWbToUeIx52u51BgwZ1W/srVqw4pf0tupKz0aaeStjvx94mBLM5KHhzxve4uqGGEVXlBO0RBiQNJJxioFUFcQ5IwgxqKCYM6J2DQ/cQXVOO4YvimZ7Tru5Rt1yM8xUb4yvG4KiH919ZyKwf3kWSI4nuRJECmx2c7v1IKUhMHN1yzabY0DBRbXaGDR1McXGI+vrNQMx73WF34cvOIUPTiTQ24j90CFez5+Y1DGr27m0vHm1Eoa3H8HnhMsbR+X1bK4v49LMPuP3aH+JxeWJlDZNenjRCjZET8jzqiotxaBqK3R6bXea2YTTFphRHFYUlS5YwY8aM49TSHjXRgQYYGC32vvn+27GLx3AqjPpwu3va7i2ycvE7jN7VF+O8AahnaDFvjwlbWVh0J5FQCEdzCEZrrGRT9hj29xnCmpQMwlGdqF1jQNIAaj0+9MpYmCJSHeCgo4re3mycQ5KJ7GlArwziHNp+TY3iVBn6wykMfugSsh89n8m+PBa9/me0o7ylnilUQ8GQZSiKgc0xAJutdQqyTdgwhYlqt9O3zwQAAoHtmKbGg/fdzZ+m3sTfr/8+td5kGisqOHjgQMv03CRFpa6srF1bbQeWN5VvBMAf9ZNX1H7Ha6NNuGvL+6uYseF81r3/cWs9uiTNm05IhE5IPP7vgw+I2u1EAYmJcKgY/tbw28aNG49bx5EIp8pz/V7HFJKoFlt31TslA4iFAo9HS2iuzRibqIuNExXv2n7S9pwqlnhYWMSBSDCIvTkVybr1K5lcuwMhJduyBlCv2tGckoFJAzngqkSrinU+9RVVVLsasKt2FJcNNdVJr5tGoDiOntJE9ToYevdFXLNzEq//5Y+E9NBR7+1qVKnQ0BQLWaWljm13zabYMKREtTmw25MJB7OAKIHAbvyeVo9pzbAxVO7dy9K9e6lv/v6SE9zUHRl+buNRDFjmRkrJpt3rCdmjVI1u7UQbQrGZWoZpkLM3jfL8ILYdbSYpGJL0xAwChE4oq63WvKjWa7fTIPyYqsTwtR+3+vTAp5jyxENYmhYFRZDkSsIf9RNGo6h0BwmBAOa+WN3VgU7C74e9kk5mnbmCdio99Rzate+E7ThdLPGwsIgD0VAYR/Ob808jvXjmGz8myaZgqDaKsvoi3ZCTlMNOtQSt2fPwVdYT8Lam58h+aDIJ4zKP25YrPRHvVf2ZtiOfv7743yzeubhbJoqopkp9fSO67iQ5qX0+KlWoSCFR7bGRIC0aS2bY2PQlw0q3M7k8loG3PDmNyBFCkZKcTGNT+3Uh0pBois4rGf8EYE/tbio37yXY20B3tT774h3/AKCsfj8ZWi/GXHcxvX29qKmPzfYSBjHxkEFk1MTwR5GdzJIDkKZJanU1M8aPp5cnkSbp48kN8yhvqmw3S+rRD3/G7oqdJ/y9hbUwXlciHoeXQNjPDjU2m84TCKAR8yB2/qWTRbqHw6KHF0saJsvm/5GSDV+QEvESGiowys7c/iiWeFhYxIFIJILDbqdJN9jnTkWVJg8OjqXj2NG7P8JtY1DyIFbLAqIHfEhTotUE0VJOrdNPmZZDn4cnc1lkMhe8msWHH791xgXEZiocKplOwaY/0bfvbe2vKTZMaaI0LyJ0OnMB2F9ZiK6o3GCLvfW79CiRysp2ZZMzM/GFYx6VlJKqqiowJRUJtXzzu9+jNsXHpk3rsO8zSM3rSzCjtazeHMo7UFJCQ4Ift8fDobQGir6IzVZTDEGaN52ACGFqOhXz1tH0yf5On6/x7SWEnU5Sx4wh0ZtEwAwSFVGqQw0MsdlaOs+/7P4VtkU1HcpXVOzl7d/+meVP/43aptbrkWiYJFcSXpeXYDiA2byyMUHTiYrY95JTmt6hvt3BA8x/7LfULY55e+FgmJVVlXz29hK8ZgLJudl46xwdynUVlnhYtMM4hVTVPYlg0M++nbs67YjDWhhD77gGAQ7vX+5gbXUdUiicl2DjhsxUFGmyv1cmEbeDVFcqPkcQnAK9JoSo01F6OTut70SwpbgY/v+mYtySwYBPE/j9i0+xt7bklOs7GdbW+3gkP5udEZ2sfsmoavvnUBUVE4nNHuvMhuScD8DLDdk8f+fPCV4wDYCg3UlgbyxF+dR+fQg2NdKrbz/8zTOZDhw4wPz58ymvqiBkhBicMhj70CQObtrN2KahDJqcCyI2jgBQG6jFlCYN+6sJp8XqUIclEtkRW5ehmIJEdyKGYhAJxcJZbRcLyubM14vnzeO5Lwup8njwer0keJOJmGGiQieiR7Hbbdxy8cWkBgPYUFEbY23VVlfh9/loDDUyclsa/frl4E70sPEP7/PJh+/wqzcf51BFGcnuZLxOL6FwCKW5G07NyqJErcTAxOhkqfxm/x6qlCa0stiA/e//FEt5pOkmTfYAg4eOpFcokWjkxNPcnw6WeByF/cV7aCjvnmm/3cUnS5dQ8ct1FLz8QWx/6maaquvims/nbGbNn95BfbWSDa8tBaAp3MTbf3yVzY+9R83P11P0y6Udp4cCUS2K0+nkk+YBywvS00l32DjPpmMqCpsTYp1rTlIO/v4mgYJKEhrsuPskn7bNA88byeC5F3JN4GJK5q/mrR3/PO06j8dPt+7my14u3htqZ+iwjtvM2hU7ppCozelaBg2bRPnG2RSG8jBUG5OSvfxbbSHf3PopkZpYhtu1y9/ngg9WcXnIxkFvErcvmk1TJLZqfcE7C0EVeOweciaM5sa6K7GbtpYpz4fHA35UfhMNVTXIyjD27NgMq9EXTWRAVTr11TWopkKCy4vmMAlXVGFiogVj6V/0+np2fu0KNo89j6I2LwkOdwKaN4kwEQwZJSzslOwvprR8H/UJnlioyYB1a1dQ/9stlD29hpUvvInPHWbCt6/g/LuvJXlQJiOWpfDd9VcwJNKfZHcKXmcig0taPYzsIbFpthoGutDRw60vcgHCHIrWtRxLJNHmjMQBE4LOCJ4EL9WuBvbt2X3qP9iT4Jyfqhs4dAh3r14ojvi5ayuXL2Xw0gRqlX0UT1FoMBsJBgN49wjSoymUTwxx8RXTsdsdrHhrCU7pIJR8bn+V/qYm+qx0Uj3FwLHeZO2SpQz62nls+59PGVHVj/0JftK/PwZVqqRn96Yh1EDQ76dvVv/uNj1u+HyN9K9Mo+l7STj/2sSG//uEQ3Xl9GtIxzV7IEmu3ux8+2OUpz/Fn6nhHZzOqKvPx6baiOo6TpeLdU1h8CZxQUqs47pr2BBef/d9BhJbbzMkZQj79y0jYfMlRJQmsnrFZ72Gc0ASw39yOc4/rWPTO5v5WcXDPHnZU9gVO5WBSjYcWsOk9JG4FB2kiRB2hGLDpnpwOrM7JAjU6+spfu9feNLTkIbBgb17cSYlYxg60cmTORjSweagItWBw/sG8ON25VWhYmKiNnsedoeH7YGpHErohVdIxid56J0Q5e3yPRSOia0PKek/jKqMWKjvsxHjeH3jRXyc0JqGI6DEQlLunFRSrh+CUNu++7ba7z9Qh7fOQfpFsZlYqenpfJ5TydpXX2WaOZkEuxcUG9q+SpY6StE3N/GdISZbn/1PPrx8aks9P/nJT/jtb3/LL3ds5389aVw+Mof8QBl1Sgg1HGTtik+QA4azT6lhqNYbx/v1hK7OpM5fS8a2VCLnxZJkClVh8s3T4Waoe3sPwTUVeJ1ePN5kwMAQBufV6Szf/xEMGI6JSbWrDkfpfvqNGILUNIw2eed3qeXkGJloisqqIWPI8jUwzhfznnxZUULb9jAst3XNTVdxzvZ4gUCAJS+9xO76ejyhEJePHcv47373tOuVUsKqeuq+kURVUy1ZXzhIddpQUx0knZdByC1JLAixf+3nRFSNLJsbqUBCNMIG90omXnLpMes+kSye+z/9lB2ff86kWbNIHTECrb4e34ED1O/eTdTuwG1T8dXXY3O7GXHttXERzi8+WoaZEeKK625hT+52XH8+iPFFMYn9E/H8+yj2Lv4M2x+24jUSKBZbcUknOgbvj1/NxV+/mkRv52/Q0pSxsMJJZC/99LnnKNq3D7fNxtDMrNiWpppOQ1Mj5aEQpqIwPLUXffJyyTrvPLymScKgQSAEUtMQioLp96OeZBr5L1evwejVyGUjrmL3XQ4if96Bx6Uy9AdTSE6L7fZ2+Y++zbYP1+LYXEfqZyaHPltDRNUIGw5I8LDb3QshJZOTY+Lxrew0ikuLSbDFVoxPcI8g9ZXfsP22dGxL36OP+zcnZeOxMMwgnusDDPm8gtTycp5Y9CtG9foaK758m1mjVrLF0zEuD6Cbo5k29S3szRlyI4cO8fqvf01dYhJIiSkgw2bDrKjgELDq6af5jhC8fsnVBFQ32xjIhUfUaVNsSCSqvTWctX1AE9CLb2WnY1cEnkHjca6sBGId38Hs1vUapWm9KXNWc7B0L4LY1r67tdjYiBAC74Xt07u3XR9R11RD32AG/Ye2Lpi7bOo1bHv9M8JKhHfmlzB23HtoW3pTJRox7ZLfvfsujBpJzsCBTJw0if79+5OYmMj3vvc9zi+JhbyWDxnM1zZvoVGEOZSSzt+umxN71i82MbQeAvYwUy49P/a7/o3YOqsjObx5VrI7hdTRfeHd/eiY7E5M5r9n/ISEaIQr14XwJ0U4tP8Am//2V9YL6G9La6ljpX07GWYS1Zn92dEnhx3A5bv2cimQPCKb4BeHOv05x5u4iIcQ4mrg94AK/FlK+fQR153A/wITgFrgJillafO1nwF3EvsNul9KufR47Ukp+dMf/kDvrdv4yeOPUXagjLeWfkDFI4/iUBXK/H4aVBWbUOilqqSnpJCakY4RCCJDQdy9etF/7FjSJ0/uUPem7V+QHklh5IXnx37QnW3L8TWoq6qmomQfo8bng03hvVf/zuClAVZ9+g9s2JAXJZLcL5HgmhJc/Rzsr9lBdoWdQ1lV+BIUBo7+ISmuXthUQW3lL1GEDZczEY/Wn0Xvb6aXzU7Ba6+RHYlQ7nAgVRWPKbEZBrVOB2mGQVRK3ty4kZRQCNMwMOwObNLEkKBGIyQJwcYdOzHdLmxC0P/CC0kbNqzD4/gDTaR+qeCZGRvUHDp4FIfu8iDLw0y6YApCVbhk7jdprKxFEQreujDenDRqq6tIe72Bg79eiy8xQlANkaA7sQ8ME4rUoCl1JAY0Aik+3Lnp2BwO6n0eKg5OQKiCSHQ3Tb6PQQFFkThtDny7FNYdquAbX7sCX1MjO7ZsAacTYZpk9e3LlePHo1VWsnP7dtZ+/jlNn32GvzkNuj0axVQUhJTodjsDo1Fy+vTBk+DBm5xE9qjRJI8YjqKqnQp5dEs9zryYSAwbMIrQfwzEYXeittkNUFEV8q65CK6J/R6WHizmwD83oR3yUpaYgqHaGOmAFHvrn5ZTKjQ2xTqgvG0BXrniMlb3689F48dy79plcN1oTpVIpIrivW9Quu8j7Op2FMWA5l1Nr1n+DZaHi3lYvZaGujr8aiGKlkitLUSCw4PAABo4tGsYz773d9zecob2CRO0rcbZP58HHni8w+6Ry5cv58KJE3nhyUe5NvoBi9zf5ItIP+48wq6Y5yFRHM2zrbQoRVkxw6axDLgd+g6nakCIlck1zNHq2VZRRb/GcmpT+hBSFJZmQ4o/iTdzx5MYDvLNPR03lDqMEK1beTTsqURxuLB7W7MruBISyNBSMKJhlAYbIqGGg5Oew7X5coKBVK6cPJkaTeP6669vX3FmbyhpzWNVmgKJdSZvfL31RfX9QZncUS9hSMJxX5IOL+obmpjMitcWkZ+ciREw+NeYMRiqDZ/bxsL+NVzntOPbVUahrnH1+PF8sGVLu3qaRIi8ynI2JiVTlj2If6YnczeQO2kCZR+tobrmEBnpvY9py+ly2uIhhFCBPwBXAmXAeiHEEinltja33QnUSymHCiFuBn4D3CSEGA3cDOQCfYCPhRDDpZTHnIAdCYXI3LqVa779bYJ9++PO7ss1iUls/Mv/YrrdjJkyhexBg4jU11NWsJHqmhq2V1UStdlIAWRtLW+XlZH6t7+R5HDQN6s37qnT2NMrE9/yepIm2Rh9nG0qk3q5EHaDfQcXUF6+CTNjL1/afoisSESNQE7ZXynnM2iO6jgyoDYjlg8nq6kf6X++lq3hYsp1yZBvvYlo45bmX+pl2Ki7kIG+7Fi5jyn5kxl20UUdbDBNk7rdu6kvK0P1eLBFIoTCYaSiUFtXz86iIr4oLQVpIk2T97dvR5GQKiDRZqP/+RdQmT+Jf2zawZ1pEcad1zpXv/egAXDEgv3krDR03UfAVUVF9edUHdqOb/JuqoM64c23Eta9BDSdIRlPgBoLMRyO0kaaN24bUnYzuz9dx/6oRMv+ggHnv9K+ESeMuyyDlPPGMzr7Fi649dYOzx0yTHKvvx4hBFJKpGEQDYcJNTTgSk5Gj0aR0Shb3nmHAwfLCUcP0qTr+DZujKVNj0axRzXcukav/jnUT7mUDWHBwMS+XD8ht6Udtyuhk+9cx+/fRlPTdsort1LbOI3dTg+qAmOC1Tzx3nwu/k377X6DriT+0W8gkfIakncf4i+X30rY7kQMO48Rb/2VWy6/GcWTxheNAcrCUS7rlUS649h/mrpu8v6H7+F2/AShmDjtIKWCzZ5LVuZE3K6+OEsHkrNHxzO5N0Nv+B8AqhYUcaj8AE8OfpmHpv4HE7MmsC9zE6+XvwVNmVT33s7AIbuQcg/btmsMHHArSUn5CBH7exAittWu11/BeMdmFvFNVjSoaKbE3iZthk2xYSJRHTHP470NG/G5k0iXVXhqXoMRt2N3J/Cn4R6iaiL96qLcsOpTbv33/8c/a/z8qGgve5whEo1sStNjXsbWPoOZEY7Sz9XR0/Zc2AffJ/vR0BlakknJ0IM0ajqJqqSp6UuCoTIK+73PwPKxkDkan5lNsv0AEya8i1k3mOQcjdw+30RKg1iXFmN1batwZDfWkRq2E8bgsTee5tU7fkFpRKMiOY0QAXqPGIkpJQLYH47ikx2FxBCS9/tFSS17iF65lewHUqJuKhzzAbi4eCdT9n+A65LxNOwJ08duJ+HKq6kt2YdLi/BFzmjyD+zmIzaTUh/kxo8X8tzsn7ElJYXqqEaGN5HyPg3sX/Y5zvIyiisqCBoGQrUxpE98U9rEw/OYDOyRUpYACCH+DlwPtBWP64Enmj8vBl4QMYm+Hvi7lDIC7BVC7Gmu75gbfEuXj09uvITfOhIpW7215fw10y7jSW8U36ESfrVfssXZC5E7jiq7h0Z7LGzQWwtwSWMp127+kKA3gYcunEmT2wuNEhorYXRMrT9etZ4F44bTWLyZhEQv8wNOtoXC1PuLUfVq3EoDPpJIp5qb+ACvF/bsr+YvuWOwCxv9bddQwXX0owopHGg4eSTpUzyuJNZnjOOd1F4kFjeSEhQU1X6XUYMVojsKMZP34fXUsXfv79jMefxf/7uJNJp4lq7AJwRl9lh46LmSD8iqKMbt9fDrEV9npyExhAuhuGiyOSEzA6YN55U9/yQzGqBRk/xo9AyQEkMKfM7Y98HucvAmMWPHC2x+aT0533mc35TVs7e+lpJAiCEJTqK4OOSv5ELzXabbYoOxQRL4nMuoYBTSaefQ4EwaPCo5uo1CeQc36Muw2zIocJxPidoPn2nHY5MwVOIY4CTQaDIyMIYBB65ATbaRPmIAJas/ZX8fBy8678G2TSe68XMMh517/ds5P1KAi75sqgnyUN5MEvQoLqkTUu2ElNjb7VVNpfyobB3oEdaIJP448iqSB4xEEwqNqgM7Egm4tSjfK/qIhH37eDWzL5sjNnAmw3B4eXMpt/RuBFNnxoGVZFXvI+2SqTxUpePw7cAnImxVchlNKSlECZcfYNCBTNxC5+Ce3QxLlOQleVp/V6Wk3pvC8lFjWb6zDPXiazBUlV51B5i2by0HPH25+pPVVKQOoKb5lcll6rw8diiONnXsD0fxqCpJBHj73UMULz9I1OZm0DUjGJ7ch0EDv4Un+QJqTTc1ms6WYIS9U8NsHl1FeoLJzDofl/RKJOP2XMRSD//+5U94/Z0/UX7ZQba8VUT5yLGE+mVzSZ8LUQ850bWPWFu9hdurK3DI/ZSLvuioKDIRY3khWdPn8F3lz9wS/gtXHbBhv3xCu7/Rw+Jhc8bEY21ZKaSPZIJZQDSyD01rINmewuU+k6UpCn8JDebq9F6g2rk6PZn5y4sotJUwUu/Hu82OmakoTFyzjV9le0h56RHKDvmZ9s2r2JkxgalXDqRg7aesNEr4VuR8Xmqo58uV6/ip/hT97btZxSXMH/kAt2R+yAybwT7jChzhd9ASo2zp1Zfxh95i5aFNbAhcx/l9L2b22NG4pEn6zrVctGUf142aStnGleTWF/PiedMZ4ZUsGz2E8eu20eBwsdVexqsFeymqr0dB4FdsOEwPH20tIceTwF190kg0/LwVrOHnuWn0kw/zNA9iaioBhx2fSMJthrnYv4zMy1ZiiJX4Lu7L7+RjVBXshonTWr7bndkDGVJVxo1r19DXoTO8poqdmb15fv0WphmLUEZoHNoXYmXaYKKDJ4LiokmTbKvsmNn4dIiHePQF2qaBLAPOP9o9UkpdCNEIpDWfX3tE2b50ghBiLjAXwDZ8FO95JrZcyzDqqBdJDNr1Fu9uLCczRaF4yu3sSe7VoR6/CZML3iHgi40ZNLlbUyr09vlwRAJUJaeyUpf8449XIKTCl3tG89qsezFVFRgGamvox20Emb7ufUINdtSGNzmUOx6AA4wAYC9DAOhXUcoXLx9AMxUq+wf4yzfyYNDhTmYG+IC+1/L1je9zWdV7pI3Q+Tz7cnZ7O180VpR0kNTwLgINEq3h/7f35nFyFOf9/7u6e7rn2t3ZW7valVbX6kRaHYAQkpAAgcDcxgEb23ztEGI7TkwSJ7Zjx45JbEN8xvklxsSOjcE2FiCOAOKwkBCnhNAtdN/X6th7du7u+v0xrb20q4Od3dld1/v1mtd0V1dPP1PTU5+up6qeqqFxWE23+U7t2Eo0kcQyIaeqkUN5nZ8+CqNJoppNQ2AYmzasZ3XDTfzy0h+6he5lfxQgDnqIRm0Ri1LPkGgy2R8ZwSMj7knnM4BS3O8NRvJKqn71DrrTxP6xB/m/K2aT9JiQcPMagB8+OFbPyJUagdxqtqwX/Mel36Dl9NO+DrjF87AYwYTS79BsQ9SaDHyUiGESofMTaF1TEycObINEgrqqS2jy+OluGaWL96ymfO86PN5y5jcZ7E06hFqbyW1tYFv5SB47kR7h07pyG9MbDlBV9nteMh7HNq5o+4xj7m1amHuSSbt/wohbIwSCtejrpnXydcedONPqw+REI2WKGEoAACAASURBVLT4/Ni6zvD649ymb2VkcSVvWZLNuSPABn8ySpkdZY+3gM9s2sMNCeCPL5Pav5pPjknHTwrJeprzQlg3Bol6TODf+Mnbj9H09P+wMf9VfjjrU2d+4WiE5Xvf4RvLfkDAb7Irr4IHr/gcweTnWflBPSfmXoejpZ+239jVxN8/vg8zOIK8WSmOjRneqT/BdrcbcvLJo4nxzZuw10VYuWI5dHhiP5w4jMThgx072NlyksvXPMnUUCHRSfWQB2+++RhCTGF6s8nLIYMXhnt4sfzL5K1YiSlgjJNP3f5DVHstPv32MhKGwZJZV+FoGt86WM93c71MG13J/UdsVhXn8K0VGwjOHMf8XWGeaFzDgYkzOKUF+JbnX8ijmRMi/T/6IFTEZUdfIHY8zvrmK1kYCrF8/KX8t99dbyQILzbZfOuNzSw+uYz5m15g0cE8anKmclBA4/EI746Zwlp7AtetfpcpjUHW5yV4sqyRU4XDiWjt4TETmsGSE81AM/InX8A4nuLI9Fvg4hkcFiPYzHfxvfAkOy8aD2OhsCVK1aj1CAHHnXK+p3+TelFEUDYzrWEbocMpXph6OQB7Sip44KaP8ZHa57n4WC07Sobx7PEIV+QupUX38a+jf0qz6NznNyOW2b6QTIhHd06+roPke8pzPuemE6V8GHgYwDN+kgS4yn6Nm7XfU6jVE8GHPtFk48kfE843WZj0cZv9v+iGxDZy2R8vBhFkYVkc382TcDblMOzgZFYsb+HwmM3kVTdTMrWUnWuW0WLv5X1rFgXTm3DiATy+z/OxhIlZYnA0dohyXw4lOWUELYv6lmbm3fRTtmxYwzWzF/B+i0kgFcPngBfByFAuAQ1qZi6icmY5WqCAXbVH2NXYQrglQqMNjV4/TYG03z48bgp33v0prKIK8upbuKi+mbF+L/6IzeG938Oj7aRJy2NC4QcYhS0YwKd5iI80LyRh3E2oyEdefjOidSlGfT2Vt81CxHKIOg5frN1C6aE9WC2jiIRSFE3JpXKmQ0vtFjZO20r+sMPEdYPL5euMYRfBxkqcgpvZbUbQnDiXFA1nbtlqhNAZ19LIpn21YPqZlJ+P1HROJpP4UwkKUiaf+NkjBC2Lvbs3UhSWJEwPCMHBw4co0XUOhKM0OLC7MITuHMExi2jx+fE4NlcVBLmxrJjJOT62h2OET6RIHq3GNHYyJvQBv5IfJ4mHOBYnZRkHnH9gSnEVpdU3MW3xCOzUKWZ6CrjDjrPnSB2p5jjx2jhanZdaEaS6cQJjQxNpyK3FW9LAXeNHsG/XAU4ceIFTIckm30R2H1pEuPAWThgORYnHucW3iZgo5Ug8yBYtl4WWQ7lpMKJ8DMNDDicDXv7N+yOuujzGjzosP3wicoL3XzvCx9euYvmIUYQch/++eg4jR1xLLBJh33e/y2+GBTkkNG4ePYVCj8431m/iVw3gvPESG/duJKdAMqZyEnvMsTSKAhAQ1dqFM3moFls3qKw9wqjwCZrMAHnCZqLfYlblSJrDLWywLYbNu4ZAuJFCx8a0U4Q9BuG8QoSULPbDlJJSIk0ad/3j3+IbMQ0jr5Qp4Sj7GnYS2/sCJ7eX0rBlFBpQNmoFFdP3UjXtW7z6/OP85egAYuTsNpt2Nezi6Tf3UzNzJkXVI3jpqW9z0cTFHPBsBdZRVQWjRi2g6pldPEB66HOOcLhm4QJiqRjHXn6HT37zn7FbfPzZ42to0iJ433mV94uKKRw7mhGf+jZTC0NM23OAVe5k9LDPx4tT53Dp3i38tfMg/y6/whFRyQm86I5N1amjbCmq4b7hNXyKTez3J7j+WDWjGgPs8ENQpggLA8u2ies6BwtGMvLKY4hmH6MDo9EOvM7Ls24AYHgiwrx5c9jy63VsyJUMa6pjyuG9XPrpz+AbVsbFuT7+ffmv2UU9Yd0gt7qcxvxbMIPtEyIPFE2jwPsOh5wqAEJNNtvyJ/KkvJ0jetrfPdbey9e0b3DoVA36qdkEjtSxZHh75/me0lF8bucpnkgmKT+5g9otxdgl+fxV4Hf8sehKyo2DCOIUcJKi8DiWdVe5fkgyIR6HafPsA1ABHO0hz2EhhAHkkXaHn8+5ZzAmmuDvN7/M3V/4GxrrLuLgkfehcR9aY5RZoWYOBEppPBxm7PBl6bDJCRh3WqbqIAkkE7fzavMUYk6CwtpGtJG/pGUv6EUQAua2vkviVDXHGwsoP/YEk08EGFk1ktKSEpoP7KO5cT0Rx+bamTMpnD6d1qdf4bU9S5nZ3ExC10maJramUWfbnBKC+kSCMiGoFxqJVJIZlkV5IsHIyhFMv/EG7IoRPP/YixSaMayidLjzeQU5zCvosCb22B9j23HC4Q+or1/P4SMbaI0cJdc5Sbze4Mj2Y2jxJHnFW8m97DcgoO50WB8NKsqBcljz2vdJncpH2yEZf+lPyRu2hUK3vZfjjOfvmveyaUeMOruRKWIp915/HY0HT7Lrzdd5PZnEk59PQWkp92k6+7Zu4XAkSqOAkG1jCkG9afKzVIrcWIyAYVDkONT7/Ti6zsREgoKUzVyvRfmoUYz93OcoqKggJQSFjz7FCCwWX9UepXRCwAels+CiF0kmG2hoWMP+/auob/gAkyMUeLbS+loLx1p2EbYl0bk/JVjWvo57W7uyFML6RbDjc+whwJ78OibN+hdMYO+edPkUT4ViYLy9B9lo836DTa7jcHHFX3JbTXvLTkpJMhKh8eBBwof38ZavgpfkTI6LMo77Oo9oCifD5GhBcsM7eOjd/SyrqGRE5Z1AuhM337YZvn0z19x6a9s535kxjbubw9Q1jsB/43Bqm/+H+z1fISHzKaj+PvXWdCYHfZRaHkwhYMGjbR21d3a4tpSSWCyGVVmCNnkckG45bX79df7mj88iUw75kxZxLLqeb/zFfe5nlAHtfV+Tc/xMzqmBETWwID2CaNyEWby1fAVHj4znivl3sGnCPq7e0co/5zSzoCAdtyrttgLd9FJ/dCvxFFjlE6j0BThV9xyNTesByEPwT1tjfHeyl7+oTLcOWlqbcXCwRlcR/aCOYTKE6Rh4U1HmHd3HLZPGsfTRX7Ma+NKX/4JhL32Wfy38NjGRdsVO3qNxqHYm/7NoL0dGzKE1ZXOFZfDz//o/npyRw6mcEI9UpH/PW6IR/mVLjH/dHCN4WRmhG0bTuvY461/ZzZqRSWS5Brl7icT38OqkWewsTf83RxgnwZHcdCTJluR6/Ik4lxTks/Xp71NccJBTZce5NNjMpYCUhYy9/i+pqrqaZ/7rcY5uepsXp87h8VNhJk27nEv2fcCo5gih8BRGWLdx7NLhCMdhXEMjX8/LZcGcVfz7Wz+iFMmXt5h8fNdOni9dj1OVZLp3FQWXxrhxi87s4To1ntt5YddJ7vvmP3PRz56j+kT7OLj6sZmdAJwJ8XgPGCeEGAUcIX3/du3lfA64m3Rfxu3Aa1JKKYR4DvidEOJHpDvMxwHnXnPT0llwYiYv73yFGyfdTEnpIt748VPEtTiJ3AauOOwjrsVJvfc16sbWUTgsl+JRBSRSTTRH6rCTCaxr51K1eBoej4bATzjcgqHr+H3l5Pins+HRt0h4TBZMGEedZy/hRIJN27cT+WAbfiEI+nx4gSeefY74smUEo1HGFRUxffJkTK+XEVdfjWZZhBsbMSyLI++tZef6dYwO5RMI5TFy3jz8RZ1DEFwxdzzR3+wlnoxjeSwc2yHRGMFb2O5a03WLvLzp5OVNRzZspfatHYxoKMbGQRcaeA1qRSGR3XfS6DtB/ph8UqlTOE4Cx7FB2sy4cgweqwDTqyPtRWiimmFFozmyvJ6V+6MUJ5JcdvFcho8dy+tLl/KrJ54gGA5TVVBAQ0sLqdZW9h8+TFxKhvkDzJk5g7Ka6aQa6kkmEpRMm0bTgQM0HjvG8V27CBYVM+Xmm9A1jVUrVrDwmmvO+ElN4LLZY9AeO46TtNE8ZwYH9HjyKSm5lpKSa3Fshy0b1hJetZ8FgQQFWHikQVPTVE5pFpoRJR5sRRqAjAEJpFlCsGwYjibQjQQpO9cNF6SRTPrwB4YjdwZZfaCEUDTO1dXVRGNxHluyhJGP/4GC4eVE6+v5IB4naZr4YjG8UvLTRZ+h1XW3jRX7OtkcTUbJk0EiXovDm/Yz4vLLO43IqczLY+/27UwGtmzZQigUoqKignE5ATbpm8iPvorhgdy8uVw05UG81rlH0MTjcd5btow3160jCZQGAlxy5ZXEmprY+M47tDY2srCgkOn3fYnEiRSbHqlnR/12JhROPOdnAwwfFsQMTGDnOoNUwsYZXc1WTyEvnGxqEw/dFjhIhG5w8/Y6Ti36J35uBZk5bj6n6qChYS1S2iAltx1Ocv3RJGO/m67QW5oaafW4Tz1uJ7zuzmd2NJ2lry3n1vx83ju5hTdW3UxVYSM/TPw1a45cg3nY4u/++l6W/+dWaldr3HhJ+in9zUceBaCkpYFTOWl3TknDcebUBdBdX0frO8fwlPhpfHYPo4BRH4ymVs6nqXIlx1lKafPl7HTds6V8gJQfQQMW1+eiVVcRLX6dSdby9t8h5icvdQ1jJ/w5219cybrmB9kUi1IuNAKRFlr9ORwoKOWGplqSrQf5zJzr2fn6ST6x+hU8doq5+aV4mwrxEIKUlwIZRANyE3l4TlhcnNeEt6wOTLjIfIdP3vFbnv6nrzOxdBiWz8/C++5IT+5NOdiRFBVFPviL8/qJz4tei4fbh/FF4GXSnur/lVJuFULcD6yVUj4H/BJ41O0Qr8d9QHLzLSHduZ4C/upcI60ApAZ2tZeiJxtxvppi06a1hOp9jPraNQT9OZyor0XYUJhXfNYIpe1c5r7auerv2/fHnk7r5kzHcXDicd5cvZoFHdwVp8ktcId+LriCcQuuOON4R0ZVj+edwBbef3o5l33sOl79+e+ZfHAEewuOYYwIoIcswvvqGH+gnGM59eRGfERmQWJGKdG6FsaMmYBH91ARnAeknxLnzTnTps58sf3698DlXYaw3v4h1wPxTplC6ZQpjF+0qFO6OMuclCnV01nh/R2sXsfkuRcDUH843cxvaqyntKAcX1kuhzbvJLrkIDFPC5EJOiEzB8/kkZRVjSDfmcFF3pwer9GZ9W1bK1euZMH8BTAf5jc0oIdCbeUwftMmtq1cSePRo2g+H382cyZVixbhyU1XlO+ufIcVbgVUEXmDjv/QSCpCoe3Dm+un9rrrmNhlqPSYCRN4/d132bJlCy+88AKpVIovfOELbN+7nlDOH5HSYPz4b1Ax/JNnHQbq2DZHd+zg7eefZ1dzM6WNjdw8ZiwV02t4+8mnWPuzh7CQTKocwawvfhGfu/aNVSXJ03NZvuYlhl8xnJdffYbJY6YycUr3fWiQDntest2HaUsijY3cWFnJM0l49UQ9sroCIQRGysERkq3xODu1PHzeVkplCr9/OK3HJ2Jb5aRSLTTob3Ni+rPYeoySliJycyYSaQ4T86Sfkk8PbQ3K9mG3c4IpgjcFqNyxGsOKEIsPZ9v7c/ClTOYkq8kvK2NazTSe3byZxY5Dw549vLFjG7fIuRxoPM4H7hSRiQdeQ5c3dPpuqVMdohQLyD02h6bKldRZy7ilbBvrEveT8ujMN/6PWPQuToz/HRNP1vDmOwFaSyczcd5KKobfRHHRfN59dC0bjhxn1TuPUqFplObmMjpicsTn8IXlS9mZl88lrS3ccPU9PLHlD/gCHhIiRTCRFs7QJWPwvhJm77Fd3B2/AuF6+QPSYuqIiXgbq6ktNRm7qZxTdc00HzzITjvFp66/rq3shKmDqaP5P+y6hz2TkXkeUsoXgRe7pH2zw3YM+FgP534H+M6FXrP6ztls+beX2fqz1/CctIksDhL0pyuNkoK+Hd/cEU3T0Hy+jH2e/7YqzEdP8Zq9lJITueifqSC29hi5h5O0HGvCLtKp/6hF5JSBFcrl6svcp/iRZ//c8+VCJvNlGiEEsakmLauP4MyZyZsvLKPibR+m9CBEij36XpKWTTDqY98VLSxadDO61vnhwEPvJ0wa+Z3DbZROnUrp1Kk95IbLq6pYse84fhlmBO+STDbhcUfFRRNRDEdjzLhxbN68mVsnTOh07pi5c3liwwaee+YZrm9oYG8oxFvvrGHjSx7Kaj7NTTfNpajoyu4uS31tLXtWrODA3r1sj0TwJJOMAj47fz7DPvKRtt/y2gULkI6D0M4cfi6EIDSzghEbDvD7rf/FgqaL8b/Twt5Pb2P0pM4tEelIWg7V8vb3l5IX8+NJRIk2NXH1jOn4V66n1hdkbzTOGL8XLZnCQfLM8cOAydym44xcsBiAxvh32b+rmSkXPczB4M/bfIvrNn2TBZc/Qayllbjphgdxb0cdjRnJUazz7GOPE0Tf/wCGBU0nh3Fw1xWkUun7wCPT76MWLUJ/910O7N7NW7/+NVPy8ihqyGHGqc1ENr9NXriJSGAPosyLPNoesj38VtprXvz5abSuPoZc5xCJT8VvbSLfOMGd615lytgdFBbWsXrbIhgJTeVvcdHlTzJr9kIQn0JzO82D0wVfuO8KcByEO1eo7nfbeH7bCo6ZYUaePELuiNFYphfbtpFISp0QxYX5fOLWjyIKgpx45j2c/z2MRrt4GugsnnklG1a9RXJYDXmvlZGbeo1Vjz6KX9cpr67u/kbNMIN2hrlmGrR+MpdTS7bjn1/KVXN7ntk9mJg2fiavFT7O+I3DEZ+vpGxkFWXjs7dCYn8z64r5HF+9lg33P09ASJxPlBCsLMOr+whorezasoWysjEsHjEi26a28eeVpWx6az2TQ89g+GyamzdRWJhu/cViEVK6yeLFi7nkkksIdZn17i0q4sZUiuSLy6j4zP/Dfv55nk8KrPz5jBo1j6KihUQjEdYtW0awsJDRM2ey6823WPPWmzSkUpTG4pTl5XHPRz5C8eTJ6Hndz/TvTjhOUzinippVJ6mhmmFfvZg3VrxM6KlGnDHVbHv8TfRjKeR4H807T1AQ1TBGBphwx5Ws+sZrxMNhLH+Aya0nec8X5K2GMGP8XvSUg0SyJpoAw+QL116N5U+79mpqSqnbvpGDh34OQLi1iGDgFKnYepLJJhKtMVJm5/W6pUgRcCvQ0Ogr8PkPMbrqWk6shU2p9gWZDNKVtJGfT7XQeOaRR0g6Drd/7nOc+t4mfLrBJ3ZvZbdmsGGmlz3zo/znsu+Tkwpy/+EvpH+T8fmYlTlE1h5HoHH17F+x7f8e5Zm6nXjikHdgGjK0HuHOZSrafRtTPj/ObSV1LmchBHSYZOodX0DyEMSiXiqPJyidOAldN/DgISVT5Ek/t916G/nuMs9vjqml4mCIko9PIvz79qCXwtIxHQ8nIyfwO6MY7vezNpnkypEZeoo8DwateABcVj0PvjEv22ZknIVf/Bh2JIWR9+Ejrg5WSnJLSXxhMrUHD1EzYzaG2d7c9uKn+NKFWbSue3y6xg0nj+EVVezZ8wkunzO27VgiGiNp6AQCAQKBQLfnz7j/fpwvfxmRG+S9/NfI31fP7KtziLQ2EWlp4aEHHyTYEiYmHZ5esYLiU3XMHF/NjLvvxuxBLC4EI+Rl+HfnggShCy6/8TpWbnuco996mz35u2gYl6BsW4DEGA+eokKuvepaADxI4m6QyAVlJbyXhLcaWvj08CJEIkXcMNil+9Ecm5q89n67i6aV8Pyjwzm2fTHlpQfZ2TSDOYk11HuasJ0oydY4dmgvL7/0CbRUE/pVe5F6gt1v/DVI+OhNMzHNtFvZP78Z1p4pHgCX/8U9RH71K6YvWIDXLSfTsggePII2fjw5wVwe2vIQ2337+c11v+GN/1lFcOYwlltP8Tctf0P5tGJa36vF41gURy4loe3HC7TaBVRs+P8IROvwxPPRbF+364p3R2BmKWKDBYcg5vNhlZQgUmAJk6STFqOg1e52/chnP4mTsJHhJGE6iIdHw7QNGhrriOkJLrvlZpzn/o85GQjRdL4MavEYqgiPjpF3Pn01Q5OK8ioqyquybcaFYWjkeGbTuE2ie0rbkhOxBLZx5kz1jghNw/abvLbsLzFL1jHRv5XVbwxj0rSZ/PaHP6Q8FueOH/4AHIfY3n14R486a9/Rh6Fj5WcaJmM/O4dd23Zy1eUfJ2C2i17HOSweIdrE44ZpNXx/7S7eqmtAyiqIpagL5uMIjTGJFnwdghgKIRhWFCR24FLytevwBrcQ2r+YrQdH8rLZSjCxFyoewdCTYLaP3a+avovrp38Vs8N3z8np3L9V+un2gIChCRP42IOdY4eZfj+tKTu9TkeewRuH3uB7877H9JLpNHyqgS+t+BIA9bF6ZpbO5I5hc3HiNk7CxnEXnWrOiZDTZOKJpDtP/DPOvYBXR1JuxN6TJSXp7yI1TGESt+NogM9sd4MLIdAtg1S4fcnhwrsnoVk6HtugpbmJqBGnuqaG22t67qfqC1RIdoUiAwhdoHscPEKwdU97SItULIFtnH2RpqOHtvLqsmvx+FYCFmOid9Fa38xbr7+OrKvjtn/+BsIwEKaJb8L4jAtHd4weNpaFC6/vJBxd8QhBPJJeua466GfRnnf57Ml1OIATT3AiJ913NCrafMa5i24Zy0WXXw7SQ743hK9+Kk48l8PP7MfxPoXQkwRyFzOl/GeEDlxN2abPsej6/6SysnMUZyEEc+fObds3/Gcvm6ZUjHWzZhLXNApz0yOxaorTle7sstlcPeJqHr3uUfyGn19s/gVRLY5M2DhJB/LSrjTHJxHukhkn8hop+LPxZ71mVyKR9tX+hBAITWBh0pJIT1gR+tlbMb6JhQhTx5PUyT3lJeHpfo2ZvkaJh0KRAaQhkCkbX9UODuz5AbFYOoifHU8iPT2LR6T1CJs2fwpvzlFM7yguuWQpoz76Fe7UDRa+u5pPfPKTGXFN9QUeXScRTY9OEkLwN4kDTNuwHF0IZDzB9MP7uefFp/jMyPIzzq2cWMClN42h+ICfMnMYUkiG3dPMkQIdI1xAonUUl8z4ESH/bEp3fJLc2tk9Vqpah/4c7Sx9OwBJp72izTHTrZaKnHT/gt/j58cLf0xNSQ0PLXqIv5/59xxL1uLEbUg46D6DGTNmQECgu+LhMS5cyO+66y5uvPFGAPLz80EXjG8eQTjqznY8jwUhhanhbdb5/P6PkjzdP9TPKLeVQpEJdHBSNmXVrxG01tHYeBnDht2EHU/heLqv9KSUrFp1Hx5vEzm5lzBz+i/R9bSLq+rb/8L+lSsJXto10s/AwdT1TqvWlU6Yzt6N6eHPqXgCy3a4NFXPVTPOPty7vLEQqSVJ6XH+6m8vZsfvriZQMgpNs0CmP7/489N6HAmoaRr33nsvDz/8MH7/2V2EC+bM51S0kXnz5iGF5MYxN/aY94YxN7AysYTq1hZIOngsi5sW38T/PP+fCDfo4YcRj5KSEkpKSpg5Mx0PLFJ/gsJ4HvV70i7A06sino2OUxBsq//XrwfV8lAoMoIwNJyUg9d/EQDNzRsBcBIpMLuv9A4dXI/u2Ygkh2kX/bRNOAYLHsMgHuuw5On42bxWOp2lR09hx+NoCPw5uef+nPF5eBMeZj5dyvDiAGa0FH/Q7ctwlwO2Rp79c8rLy/nmN79JQcGZ8exOU/HAPKZcWsOCBQvQdR1DMxgW6HlYf5GviBxfLgf27U53anvTo72Er73iNjwZeP52+5siRFlTtaPbuWld52mIDnmkNzvD61XLQ6HIAMLQkAmHMWPncGD/IzQ2bQDS4iE8GpGWMCuf/wUp5xiWtwC/9lHWvRWmtfJ+7r2rFMsqzvI3uHBMj4dYoj3kxYlAAc8uvIOdew9xfyLFc1Nm0JAM09N4SGk72NjkTx1O9OkmPAl3rkZSxx9wR2ddgEfmXC6rD8Pk2pFQC44msXxp8ehYkXsPZ+Aibt0fS8WxTG+3WTSfgW9aMdGN7tLYHVx4mi871bgSD4UiAwhDg4jDyMpLOLAfWlo+wHESyISDMGHl63dglW7HAppbS/j9ihl4Ckwe/PNbKQgOziHZHsuiOdkuHhOC6VFCuxKS7Y7GrpIyck/78bshHo0R0xJUevPpMK8bK2kQdFssUmbHJXMGEgJmWtD0TM/Wdr+ik7Txes5vwnFHF57p715w+holHgpFBtAMHWlLPJ5cIpEy/P5jhMPbkUmH1tDrWP7tCC2fkZUfxzQLufXGRef+0AGOZVokwu3iEDR0imLNnPLm8o6RrtCq9J4r2nC0hZRmo4nOLQavbZLjxp8iy+Kxe04jVatzcIRsG3nW3SJhvcL9jnpK4DEvPFqFz8yOu1OJh0KRATSPDql0JZCSE4BjNDVvQHfCtOYuRQAXTX6A4uKrs2pnJjG9FsnGhk5pI5wYp8jlHTe+2Cir56fiZCJBSnQOZZe0k/hsixy35aHnZrdVppf4iHji6FIn6LY8fEbmwhF1xJIm1ocQD3+mxew8UR3mCkUG0Ayd0/VgfvFMYs1lCOEhv/BthBHD8s2lqKi70JqDF8vnI+l07pQY409X9g3uKKQqs+fKP5lIkNI6i0dLuImkZmN40i0WT4mfigeyF0Ui6AtiJQ0SWpKgp2/FoyJRiv9DtCJGzpty7kx9gBIPhSID6B6jTTwurrmHLa98G4+4DjMWQNomM6bdn9Wgk32B6fOR6CIeE0o6j16qPIvbKZlMYGvp8yOV7uztlkZierzHc/qbgC8HyzaJ64k+E4+ORRRo7nnor+bv7CjKXVxF4d2TMHx9P2m0W3uyclWFYojRUTwCXg/NQY1f/MdGrHX3Umr/BL+//wLW9ReW30+yizhMKm0PzaLbNsWpnldYSCaTbeLRsthL2BMl3NJM3MjOjOnuyPGl3W+1vrr2Pg9XPCLeBOX3z+n9RTqUYcDf83ICedeNYtg/Xty2n7ugEt/Ewh7z9zVKPBSKDGB4PHR031987Ug8KUldaD9lBRcWvmKwYAWCdK3m5xfmy3hv2AAAGHRJREFU8Y9PfZ/p+zYx4eTx9EqePZBKJnFc8fBaXnRHo67xFElz4IhHbnG6ctaTWtuM9NPiIXRxnusFnZ3zbZFqpo5RkJ2RVd2hxEOhyACGx4Nmt1cCt1w1mn/4wRU4WrxtctlQw8oJkuxS8elCMNJMce27L/OxTetx7J7Fw04mcTR3EqDlw2db1P1xD/ZZwrn0N34r3QdhxnVCVnoE2Gnx8LVmZsiu76IOK4oOnK9+TpR4KBQZQPcYaE7nijThJLCkhWFlxyfd13hzckh2MzEvVDmOqGYhhMQ5i9sqlUy1iYfXm66QL2mdgqEPnEGgp1sFpuMh10yPADvdAsnYNQwNc0RmP7M/UOKhUGQAj2mi253/TtFkFJ+00DxD82/mCQSQQmDbnQWitOYKEAKhcfaWRyqFdBcQz/e2r95oaANHPDpy2q5CX+b7GWTSLaeBMinyPBiad7VC0c+YponudBGPVBSvtBCeobk2ixYIYKRSJDqEKAGYNP9KxgTzQZfI1NncVilOF1nA0x76XfoGXrWkyb4dKdcmHoOIgfcrKRSDEMM0MZzOItEmHubQ/JtpPh9GKkUymeycruuYQgMhkGdredh2W8ujIw3TBl5Fqou+fQAwStz5HYOn4dE78RBCFAghXhVC7HLf87vJUyOEeEcIsVUIsUkIcUeHY78WQuwTQmxwX/27FJZCkSEs00LvRjwsxzNkWx7CsjCSKeLR6BnHUrYD53BbyaTdKcAfQKs3xuTJZw/hng0qg5XnztQLCj8xoU8/vy/o7SPRV4HlUspxwHJ3vysR4NNSysnAYuAnQohQh+P/IKWscV8bemmPQpEVPJaFR3YWiUgqguWYiCHa5yGEwHBs4i1nBj+0HRsEZ215lG70YjqdRyzlGDmUB89cPCrb9HXLQxjpe8QoHjxh+Xt7V98MPOJuPwLc0jWDlHKnlHKXu30UOAEMvvjTCsVZME3rDLdVLBXD4xhDVjwAPFIS60Y8Uo6D0M/utvI3exh5tEtV4AxMv03X6L7W2FAPOT88w79zOcG5A084e6K3d3WplPIYgPt+1pXghRCXACawp0Pyd1x31o+FEIMzNrXiTx6v6QUE0m6vZOKpOB57aIuHASTC4TPSbSmRBmCfXQyk1vm4HHjdHYRuGUPoI6M7J/ZB/7nQtUEVwkacK16+EOKPQHfLbX0deERKGeqQt0FKeUa/h3usDFgJ3C2lfLdDWi1pQXkY2COlvL+H8+8F7gUoLi6euWTJkrN/s34mHA4TDAazbUYnlE3nT2/tsqXNyFckR64y0pUm8H7zWj76ziz2X5sdm/qCrjbteuIJ8idPoWjSxE75dv1hCbHKEqb5puJM7351v7Ev6awbtofcmqq2fUeX7F10YQqSjXLytKZfkbM8Lg/E32/hwoXvSylnZeTDpJQf+gXsAMrc7TJgRw/5coF1wMfO8lkLgOfP57rV1dVyoLFixYpsm3AGyqbzp7d2OY4jt/7TMhlvibSlPbN5qdz99eVZs6kv6GrTo1+6T76zdOkZ+R7+q7+SP/+P78ntP3xN2vFUt5/1wb++Ih9d9b9t+4e+skoe/sabvbZpoDAQ7QLWyl7U+R1fvW1PPwfc7W7fDTzbNYMQwgSeBn4jpXyiy7Ey912Q7i/Z0kt7FIqsIIQgKVIk4u0RYZPxOLYxAP0wGcTUNeKRM0db2emDBE4YNL9yoNtzhQTD6NxhLgdon4fiTHorHg8Ai4QQu4BF7j5CiFlCiF+4ef4MmA/8v26G5P5WCLEZ2AwUAf/WS3sUiqyR0jqLh51IYXczj2Eo4dF1EvHYGekpIRCetP/OifYQ6FCCp2soknP0kSgGDr2KAyClrAPOWOFGSrkWuMfdfgx4rIfzr+zN9RWKgURKs0kk2sUjFU/iGEO7MvQYRifBhLQr3BYCzTJOJ3R/sgS9g3gIS0fGe46FpRhYDN1hIApFP5PSHJIdQnU4yVRb5/lQxTQ8Z4pHMomj6+jmafHo4WQHPEZ70EjNOzQnUw5VlHgoFBnC1hySifZQHU7CHvriYXpIJDqHJ5GxGLZuoLtLyfbU8hASPHp7n4evpgQ9b2hGIB6KDPFbW6HoP5yuLY+EgzQGz7j9D4NpeUkkOwdGlPE4jqHjcVsePXmthBSdxCNvcRV5i6v6ylRFhlEtD4UiQ9i6Q6pjkMCkDZ6hLR7eYIBEl8CITjyOresYbssjvrep23OF7Oy2EkIMqklyf+oo8VAoMoSjS1IdXDgyKWEIzy4HMHNySKY6j6aSsRi2pmGYafFwWhLdnYqQAt1Q/RyDlaF9ZysU/Yijyy4tD2fIhmM/jTcnl2SXdcqdWBxb07Css0cbEoCpqT6OwcrQvrMVin5E6uAk24eaihRo5tB+srbyQyS7dGrY0QgAHnf5XWF1XwZCCjweJR6DFSUeCkWGkHp6dbzTiOTQFw9ffj7JLmmJSARdyrY+j54i62pSYBpKPAYrSjwUigwhDYHTQTz0lED3DO0Bjd6CApJa52okGYthQHurIiU59uAaUnWdw5gIqWEZKpD2YEWJh0KRIaQhkYn2p2zNFuiW5yxnDH58hYXYuo7Tod8j2dKCDng87d/dboiTONra6VwdDdOjxGOwosRDocgQ0hTQQTz0lNbm9x+q6F4vmuMQb2wfjhsLh/FoGobX5ISvodtBA9LtJ1Etj8GLEg+FIkM4JpBo7zw2bA1jiIsHgJlK0XryRNt+PNyKR9OwLC/fr/kdMpUuk05TOBxwcLB0JR6DFSUeCkWGEKaG1qH32LD1Id/yAPDaDuFTp9r2E5EIHl3H1E1ixLs/SUpsocRjMKPEQ6HIFKaG1mE+nMcxMM8x12Eo4BPQcrJdPOLRKKbHg6mbxO14t8vw2raNg4NHG9p9QkMZJR4KRYYQlo6WTPtmpJR4bB3T+ycgHh4P4fq6tv1EPIZpmli6lRaPboYrJ1IJHCFVOJJBjBIPhSJDaKaOnkpXhiknhSUtdHPoP1kHfD5aGxrb9uPRGKZlYeomSTvZbYd5IhVH9hirXTEYUOKhUGQIzTIwkum/VMyO4XOsIR+eBCAQDNIaDrftxyMRrGAQU0u7rTSP2/Lo0MhIpBJIocRjMDP072yFop+wAj6MVLqijNtxvNLs1mUz1AiEQkSi7RMAE7Eo3txcLN0iYSe6b3kk4zhKPAY1SjwUigzhDwTxdBAP0zHRhnhUXYBgYSERd00P6ThEbIdgYSGGZmBLG9rWNGlveiTshHJbDXKG/p2tUPQTQX8OZsqDlJJ4Ko7leBCeod/yyK2oIGKnA0KmTp4kEQwQzMtDCIGpmziJM9clTyq31aBHiYdCkSFyfLk4woGUJJ6MoUutw1P30KV03DiaAwFSLS3Ed+8mkZdHIBAAwNRNUodbzzgn3efR35YqMkmvxEMIUSCEeFUIsct9z+8hny2E2OC+nuuQPkoIsdo9/w9CiKE/o0oxZMkxc4hqcZx4imR9jEar9U9iKGogEMByHI5t3kJiz15iPl+beFi61V7LdAjdnkwlOnWgKwYfvW15fBVYLqUcByx397sjKqWscV83dUh/EPixe34D8Oe9tEehyBpBM0hEi+HEbVItMcJWJNsm9RslQnBo5w6a9uyhVdMoLCwE0uIhg2nXnXTS4pFqjJOMK7fVYKe34nEz8Ii7/Qhwy/meKNKPZFcCT36Y8xWKgYZH8xDT40Raw9jxFEnPmb7+ocrI4hLeP3CAD06coKq4GMNIh6L3GT5kl5ZH7QNrCK1ylNN8kCOk/PDqL4RolFKGOuw3SCnPcF0JIVLABiAFPCClfEYIUQS8K6Uc6+apBJZJKaf0cK17gXsBiouLZy5ZsuRD290XhMNhgsFgts3ohLLp/MmUXfaqwziT8mgM1xGsFfhmj8y6TZmkJ5uM7dvZuGUrJ4sKmTx+PMVlZQD88NgP+cHO+whETWqnOoTLJWNfah9EsHtx7wV2IJYTDEy7Fi5c+L6UclYmPuucK9UIIf4IDOvm0Ncv4DojpJRHhRCjgdeEEJuB5m7y9ahkUsqHgYcBxo8fLxcsWHABl+97Vq5cibLp3AxEmyBzdr36zqOMHjWK2uMmkZa6Xn3mQCyrnmxyLr2U3LvuYnt5Gbd+7GNtLY/HXnkMj8+EKEwcP4HAzFIOv/RG23mZ+H4DsZxg4NqVKc4pHlLKq3s6JoQ4LoQok1IeE0KUASe6yyelPOq+7xVCrASmA08BISGEIaVMARXA0Q/xHRSKAYPtcYhFIhC1SVrdL786FNF8PqYuXcrULuk+w5cegYbWqcNcMfjprdfxOeBud/tu4NmuGYQQ+UIIy90uAi4HPpBpf9kK4Pazna9QDCZSliQRjiIiDrYv29ZkH5/hw8EV0T8dLf2ToLfi8QCwSAixC1jk7iOEmCWE+IWbZyKwVgixkbRYPCCl/MA99hXg74QQu4FC4Je9tEehyCqtOQlkXQIRkThKPPAbfg5MS3uoe9O/qhh4nNNtdTaklHXAVd2krwXucbffBi7q4fy9wCW9sUGhGEjouSb28QRGHAgM/dnl58Jn+Dg6vJFZl04CR4nHUEINllMoMkgwlIdocbCiBuQo8fB7/ERSEdCEEo8hhhIPhSKD5I4uZlh9iIKmIOSrgAk+w0c0FUUIofrLhxhKPBSKDFJdOoE1eVsAsALeLFuTfXyGj0hStTyGIko8FIoMUuQr4r/HPsV9s36C3/Bn25ys4zf8RFPRdE3TpemhAiMObpR4KBQZZnLhZHa07sRnqOFWfk9aPIQmkF2H6qraZ1Cjfj6FIsPUlNQAUOAtyLIl2SdkhWiINYA4020lNNX0GMwo8VAoMszVI9JBGYr9xVm2JPsUeAuoj9WDJtqi6p5G6Kr6GcyoX0+hyDCVuZWsuWsNuWZutk3JOoW+Qupj9QjBGX0eQlctj8GMEg+Fog9Q/R1p8sw8wokwjpBnhCcpuGNCdoxSZAQlHgqFos/QNZ1cK5eYEzsjPIm3utuFRxWDBCUeCoWiTynwFqRnmat5HkMKJR4KhaJPKfGX0JJqVeIxxFDioVAo+pTyYDlNyaazLPWmGIwo8VAoFH3K8OBwGhONZwzVVQxulHgoFIo+pSJYQX2iQa0kOMRQ4qFQKPqU8mA5DYkGcCB+oDnb5igyhBIPhULRpwwPDqc+Xo90JCd/thGANfMOZNkqRW9R4qFQKPqUAm8BCZkk0RprSxteMTKLFikygRIPhULRpwghyPXmkTja0pY2qWhyFi1SZAIlHgqFos8JefPQmtvjk3gNK4vWKDJBr8RDCFEghHhVCLHLfT8j3oAQYqEQYkOHV0wIcYt77NdCiH0djtX0xh6FQjEwCfm6VA1CBUUc7PS25fFVYLmUchyw3N3vhJRyhZSyRkpZA1wJRIBXOmT5h9PHpZQbemmPQqEYgBQFirJtgiLD9FY8bgYecbcfAW45R/7bgWVSykgvr6tQKAYRVTlVADTrrekE1fAY9PRWPEqllMcA3PeSc+S/E/h9l7TvCCE2CSF+LIRQjlCFYghSGkmvqnjUPAGkO9EVgxvRNUzyGRmE+CMwrJtDXwcekVKGOuRtkFJ2G2dZCFEGbALKpZTJDmm1gAk8DOyRUt7fw/n3AvcCFBcXz1yyZMk5vlr/Eg6HCQaD2TajE8qm82cg2jWUbCrYKSjYq3G4uJGKkyH2X2GTytCSJwOxnGBg2rVw4cL3pZSzMvJhUsoP/QJ2AGXudhmw4yx5vwQ8fJbjC4Dnz+e61dXVcqCxYsWKbJtwBsqm82cg2jWUbEqejMhDX1klm1YclIe+skqmWuJZt6mvGYh2AWtlL+r8jq/euq2eA+52t+8Gnj1L3o/TxWXltjwQ6TbsLcCWXtqjUCgGIEaRj4oH5qEHTQCEoWYJDHZ6+ws+ACwSQuwCFrn7CCFmCSF+cTqTEKIKqARe73L+b4UQm4HNQBHwb720R6FQDGCEke7rELoSj8GO0ZuTpZR1wFXdpK8F7umwvx8Y3k2+K3tzfYVCMcjQRed3xaBFyb9Coeg3To+yEpoSj8GOEg+FQtFvyJRz7kyKQYESD4VC0W84cTvbJigyRK/6PBQKheJCCMwoxTMskG0zFBlAtTwUCkW/ITwa1sjcbJuhyABKPBQKhUJxwSjxUCgUCsUFo8RDoVAoFBeMEg+FQqFQXDBKPBQKhUJxwSjxUCgUCsUFo8RDoVAoFBeMEg+FQqFQXDDnXElwICKEaCG9ENVAogg4lW0juqBsOn8Gol3KpvNjINoEA9Ou8VLKnEx80GANT7JDZmopxQwhhFirbDo3A9EmGJh2KZvOj4FoEwxMu4QQazP1WcptpVAoFIoLRomHQqFQKC6YwSoeD2fbgG5QNp0fA9EmGJh2KZvOj4FoEwxMuzJm06DsMFcoFApFdhmsLQ+FQqFQZJFBJR5CiMVCiB1CiN1CiK/243UrhRArhBDbhBBbhRBfctMLhBCvCiF2ue/5broQQvzUtXOTEGJGH9qmCyHWCyGed/dHCSFWuzb9QQhhuumWu7/bPV7VhzaFhBBPCiG2u2V2WbbLSgjxt+5vt0UI8XshhLe/y0oI8b9CiBNCiC0d0i64XIQQd7v5dwkh7u4ju77v/n6bhBBPCyFCHY59zbVrhxDi2g7pGft/dmdTh2NfFkJIIUSRu98vZdWTTUKIv3a/91YhxL93SM9KOQkhaoQQ7wohNggh1gohLnHTM1tOUspB8QJ0YA8wGjCBjcCkfrp2GTDD3c4BdgKTgH8HvuqmfxV40N2+HlgGCGA2sLoPbfs74HfA8+7+EuBOd/sh4PPu9heAh9ztO4E/9KFNjwD3uNsmEMpmWQHDgX2Ar0MZ/b/+LitgPjAD2NIh7YLKBSgA9rrv+e52fh/YdQ1guNsPdrBrkvvfs4BR7n9Sz/T/szub3PRK4GXgAFDUn2XVQzktBP4IWO5+SbbLCXgFuK5D2azsi3Lqk8qjL17AZcDLHfa/BnwtS7Y8CywiPVGxzE0rIz3/BODnwMc75G/Ll2E7KoDlwJXA8+5NcarDn76tzNw/3GXutuHmE31gUy7pilp0Sc9aWZEWj0Pun8Nwy+rabJQVUNXlj35B5QJ8HPh5h/RO+TJlV5djtwK/dbc7/e9Ol1Vf/D+7swl4EpgG7KddPPqtrLr5/ZYAV3eTL2vl5F7rDnf748Dv+qKcBpPb6nQFcJrDblq/4rowpgOrgVIp5TEA973EzdZftv4E+EfAcfcLgUYpZaqb67bZ5B5vcvNnmtHASeBXIu1O+4UQIkAWy0pKeQT4AXAQOEb6u79P9ssKLrxcsvE/+CzpJ9as2iWEuAk4IqXc2OVQNsuqGpjnujdfF0JcPABsug/4vhDiEOn7/mt9YdNgEg/RTVq/DhUTQgSBp4D7pJTNZ8vaTVpGbRVC3ACckFK+f57X7a/yM0g3o38mpZwOtJJ2x/REf5RVPnAzafdBORAArjvLdbN+r53Fhn61TQjxdSAF/Dabdgkh/MDXgW92dzgbNrkYpF09s4F/AJYIIUSWbfo88LdSykrgb4FfuukZtWkwicdh0v7O01QAR/vr4kIID2nh+K2UcqmbfFwIUeYeLwNO9KOtlwM3CSH2A4+Tdl39BAgJIU6Hnel43Tab3ON5QH2GbTp9ncNSytXu/pOkxSSbZXU1sE9KeVJKmQSWAnPIflnBhZdLv/0P3I7TG4C7pOvPyKJdY0iL/0b3nq8A1gkhhmXRJtxrLJVp1pD2AhRl2aa7Sd/jAE8Al3SwNWM2DSbxeA8YJ9IjZEzSHZnP9ceF3SeJXwLbpJQ/6nDoOdI/FO77sx3SP+2ObpgNNJ12TWQKKeXXpJQVUsoq0mXxmpTyLmAFcHsPNp229XY3f8afWKWUtcAhIcR4N+kq4AOyWFak3VWzhRB+97c8bVNWy6qba51PubwMXCOEyHdbVNe4aRlFCLEY+Apwk5Qy0sXeO0V6RNooYBywhj7+f0opN0spS6SUVe49f5j0IJZasltWz5B+cEMIUU26E/wUWSonl6PAFe72lcAudzuz5dSbjpr+fpEeLbCT9GiFr/fjdeeSbsZtAja4r+tJ+8GXuz/OcqDAzS+A/3Lt3AzM6mP7FtA+2mo06Zt0N+mnjtOjQLzu/m73+Og+tKcGWOuW1zOkm/VZLSvg28B2YAvwKOlRMP1aVsDvSfe5JElXfn/+YcqFdB/Ebvf1mT6yazdpP/jp+/2hDvm/7tq1A3dUj5uesf9ndzZ1Ob6f9g7zfimrHsrJBB5z76t1wJXZLifS9dX7pEdyrQZm9kU5qRnmCoVCobhgBpPbSqFQKBQDBCUeCoVCobhglHgoFAqF4oJR4qFQKBSKC0aJh0KhUCguGCUeCoVCobhglHgoFAqF4oJR4qFQKBSKC+b/B5AqtP7hJsqTAAAAAElFTkSuQmCC",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8c0c92e8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(xs_encoder.T, '-', linewidth=1)\n",
    "plt.plot(xs_pixel.T, '-', linewidth=1)\n",
    "plt.plot(measurements.T, '--', linewidth=2)\n",
    "# plt.plot([switch_point, switch_point], [-1000, 1000], c='black')\n",
    "# plt.ylim([-.25,.25])\n",
    "plt.xlim([0,len(loop_times)])\n",
    "plt.legend(['x', 'theta', 'xv', 'thetav', 'x meas', 'theta meas'])\n",
    "# plt.legend(['x', 'theta', 'xv', 'thetav', 'x_pixel', 'theta_pixel', 'xv_pixel', 'thetav_pixel' 'x meas', 'theta meas'])\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1633,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6ffed898>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(xs_pixel.T, '-', linewidth=1)\n",
    "plt.plot(measurements.T, '--', linewidth=2)\n",
    "# plt.plot([switch_point, switch_point], [-1000, 1000], c='black')\n",
    "plt.ylim([-.25,.25])\n",
    "plt.xlim([0,len(loop_times)])\n",
    "plt.legend(['x_pixel', 'theta_pixel', 'xv_pixel', 'thetav_pixel', 'x meas', 'theta meas'])\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1634,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.411529469041\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8c036d68>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(controls_encoder, label=\"encoder controls\")\n",
    "plt.plot(controls_pixel, label=\"pixel controls\")\n",
    "# plt.plot([switch_point, switch_point], [-1000, 1000], c='black')\n",
    "# plt.xlim([0, 500])\n",
    "plt.ylim([-0.7,.7])\n",
    "plt.title(\"control\")\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "print(max(controls_encoder))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(np.abs(controls_encoder-controls_pixel))\n",
    "plt.xlim([0,len(loop_times)])\n",
    "plt.ylim([-.2,.2])\n",
    "plt.title(\"control diff\")\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract snippets of trajectory data where x_ref = 0 using traj_snippet_start_indices and traj_snippet_end_indices\n",
    "# xs_snippets = xs[:, np.asarray(x_ref) == 0].shape\n",
    "assert len(traj_snippet_start_indices) == len(traj_snippet_end_indices)\n",
    "num_snippets = len(traj_snippet_start_indices)\n",
    "frame_snippets = []\n",
    "control_snippets = []\n",
    "meas_snippets = []\n",
    "xs_snippets = []\n",
    "for start_idx, end_idx in zip(traj_snippet_start_indices, traj_snippet_end_indices):\n",
    "    # print(\"{}, {}\".format(start_idx, end_idx))\n",
    "    frame_snippets.append(frames[:, :, start_idx:end_idx])\n",
    "    control_snippets.append(controls_encoder[start_idx:end_idx])\n",
    "    meas_snippets.append(measurements[:, start_idx:end_idx])\n",
    "    xs_snippets.append(xs[:, start_idx:end_idx])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame_snippets_np_array = np.empty(num_snippets, object)\n",
    "control_snippets_np_array = np.empty(num_snippets, object)\n",
    "meas_snippets_np_array = np.empty(num_snippets, object)\n",
    "xs_snippets_np_array = np.empty(num_snippets, object)\n",
    "\n",
    "frame_snippets_np_array[:] = frame_snippets\n",
    "control_snippets_np_array[:] = control_snippets\n",
    "meas_snippets_np_array[:] = meas_snippets\n",
    "xs_snippets_np_array[:] = xs_snippets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save snippet data to npz to transfer to laptop\n",
    "now = datetime.datetime.now()\n",
    "file_name = \"data_from_jetson/snippets_cartpole_train_data_\" + now.strftime(\"%m-%d-%Y_%H-%M-%S\") + \".npz\"\n",
    "np.savez(file_name, frames=frame_snippets_np_array, controls=control_snippets_np_array, measurements=meas_snippets_np_array, est_states=xs_snippets_np_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for traj, meas, cont in zip(xs_snippets, meas_snippets, control_snippets):\n",
    "    plt.plot(traj.T, '-', linewidth=1)\n",
    "    plt.plot(meas.T, '--', linewidth=2)\n",
    "    plt.plot(cont)\n",
    "    plt.legend(['x', 'theta', 'xv', 'thetav', 'x meas', 'theta meas', 'cont'])\n",
    "    plt.grid()\n",
    "    plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}