{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 MPC\n",
    "This notebook contains the CVXPY implementation of a MPC\n",
    "本篇笔记包含了一个基于CVXPY的MPC实现\n",
    "This is the simplest one\n",
    "这是最简单的一个"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MPC Problem formulation MPC问题的表述\n",
    "\n",
    "**Model Predictive Control** refers to the control approach of **numerically** solving a optimization problem at each time step.\n",
    "**模型预测控制**是指在每个时间步上**数值**地解决一个优化问题的控制方法。 \n",
    "\n",
    "The controller generates a control signal over a fixed lenght T (Horizon) at each time step.\n",
    "控制器在每个时间步上生成一个固定长度T（视野）的控制信号。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![mpc](img/mpc_block_diagram.png)\n",
    "\n",
    "![mpc](img/mpc_t.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Linear MPC Formulation 线性MPC表述\n",
    "\n",
    "Linear MPC makes use of the **LTI** (Linear time invariant) discrete state space model, wich represents a motion model used for Prediction.\n",
    "线性MPC使用**LTI**（线性时不变）离散状态空间模型，该模型表示用于预测的运动模型。\n",
    "\n",
    "$x_{t+1} = Ax_t + Bu_t$\n",
    "\n",
    "The LTI formulation means that **future states** are linearly related to the current state and actuator signal. Hence, the MPC seeks to find a **control policy** U over a finite lenght horizon.\n",
    "LTI表述意味着**未来状态**与当前状态和执行器信号之间是线性相关的。因此，MPC试图找到一个有限长度视野上的**控制策略**U。\n",
    "\n",
    "$U={u_{t|t}, u_{t+1|t}, ...,u_{t+T|t}}$\n",
    "\n",
    "The objective function used minimize (drive the state to 0) is:\n",
    "用于最小化（将状态驱动至0）的目标函数为：\n",
    "\n",
    "$\n",
    "\\begin{equation}\n",
    "\\begin{aligned}\n",
    "\\min_{} \\quad &  \\sum^{t+T-1}_{j=t} x^T_{j|t}Qx_{j|t} + u^T_{j|t}Ru_{j|t}\\\\\n",
    "\\textrm{s.t.} \\quad &  x(0) = x0\\\\\n",
    "  & x_{j+1|t} = Ax_{j|t}+Bu_{j|t}) \\quad  \\textrm{for} \\quad t<j<t+T-1    \\\\\n",
    "\\end{aligned}\n",
    "\\end{equation}\n",
    "$\n",
    "\n",
    "Other linear constrains may be applied,for instance on the control variable:\n",
    "其他线性约束也可以应用，比如对控制变量的约束\n",
    "\n",
    "$ U_{MIN} < u_{j|t} < U_{MAX}    \\quad  \\textrm{for} \\quad t<j<t+T-1 $\n",
    "\n",
    "The objective fuction accounts for quadratic error on deviation from 0 of the state and the control inputs sequences. Q and R are the **weight matrices** and are used to tune the response.\n",
    "目标函数考虑了状态偏离0的二次误差以及控制输入序列的二次误差。矩阵Q和R是权重矩阵，用于调整系统响应\n",
    "Because the goal is tracking a **reference signal** such as a trajectory, the objective function is rewritten as:\n",
    "由于目标是跟踪参考信号（例如轨迹），目标函数被重写为：\n",
    "\n",
    "$\n",
    "\\begin{equation}\n",
    "\\begin{aligned}\n",
    "\\min_{} \\quad &  \\sum^{t+T-1}_{j=t} \\delta x^T_{j|t}Q\\delta x_{j|t} + u^T_{j|t}Ru_{j|t}\n",
    "\\end{aligned}\n",
    "\\end{equation}\n",
    "$\n",
    "\n",
    "where the error w.r.t desired state is accounted for:\n",
    "其中考虑了相对于期望状态的误差：\n",
    "\n",
    "$ \\delta x = x_{j,t,ref} - x_{j,t} $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem Formulation: Study case  研究案例问题表述\n",
    "\n",
    "In this case, the objective function to minimize is given by:\n",
    "在这种情况下，要最小化的目标函数为：\n",
    "\n",
    "https://borrelli.me.berkeley.edu/pdfpub/IV_KinematicMPC_jason.pdf\n",
    "\n",
    "$\n",
    "\\begin{equation}\n",
    "\\begin{aligned}\n",
    "\\min_{} \\quad &  \\sum^{t+T-1}_{j=t} (x_{j} - x_{j,ref})^TQ(x_{j} - x_{j,ref}) + \\sum^{t+T-1}_{j=t+1} u^T_{j}Ru_{j} + (u_{j} - u_{j-1})^TP(u_{j} - u_{j-1}) \\\\\n",
    "\\textrm{s.t.} \\quad &  x(0) = x0\\\\\n",
    "  & x_{j+1} = Ax_{j}+Bu_{j} \\quad  \\textrm{for} \\quad t<j<t+T-1  \\\\\n",
    "  & u_{MIN} < u_{j} < u_{MAX} \\quad  \\textrm{for} \\quad t<j<t+T-1 \\\\\n",
    "  & \\dot{u}_{MIN} < \\frac{(u_{j} - u_{j-1})}{ts} < \\dot{u}_{MAX} \\quad  \\textrm{for} \\quad t+1<j<t+T-1 \\\\\n",
    "\\end{aligned}\n",
    "\\end{equation}\n",
    "$\n",
    "\n",
    "\n",
    "Where R,P,Q are the cost matrices used to tune the response.\n",
    "R,P,Q是用于调整响应的成本矩阵。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PRELIMINARIES 准备工作\n",
    "\n",
    "* linearized system dynamics 线性化系统动力学\n",
    "* function to represent the track 轨迹函数\n",
    "* function to represent the **reference trajectory** to track 跟踪的**参考轨迹**函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-23T06:09:14.320605Z",
     "start_time": "2024-10-23T06:09:13.499103Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.integrate import odeint\n",
    "from scipy.interpolate import interp1d\n",
    "import cvxpy as cp\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use(\"ggplot\")\n",
    "\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-23T06:09:15.094392Z",
     "start_time": "2024-10-23T06:09:15.092291Z"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Control problem statement.\n",
    "控制问题陈述。\n",
    "\"\"\"\n",
    "\n",
    "N = 4  # number of state variables (x, y, v, theta)\n",
    "M = 2  # number of control variables (a, delta)\n",
    "T = 20  # Prediction Horizon (time steps)\n",
    "DT = 0.2  # discretization step [s]\n",
    "\n",
    "\n",
    "def get_linear_model(x_bar, u_bar):\n",
    "    \"\"\"\n",
    "    Computes the LTI approximated state space model x' = Ax + Bu + C\n",
    "    计算LTI近似状态空间模型x' = Ax + Bu + C\n",
    "    \"\"\"\n",
    "\n",
    "    L = 0.3  # vehicle wheelbase\n",
    "\n",
    "    x = x_bar[0]\n",
    "    y = x_bar[1]\n",
    "    v = x_bar[2]\n",
    "    theta = x_bar[3]\n",
    "\n",
    "    a = u_bar[0]\n",
    "    delta = u_bar[1]\n",
    "\n",
    "    A = np.zeros((N, N))\n",
    "    A[0, 2] = np.cos(theta)\n",
    "    A[0, 3] = -v * np.sin(theta)\n",
    "    A[1, 2] = np.sin(theta)\n",
    "    A[1, 3] = v * np.cos(theta)\n",
    "    A[3, 2] = v * np.tan(delta) / L\n",
    "    A_lin = np.eye(N) + DT * A\n",
    "\n",
    "    B = np.zeros((N, M))\n",
    "    B[2, 0] = 1\n",
    "    B[3, 1] = v / (L * np.cos(delta) ** 2)\n",
    "    B_lin = DT * B\n",
    "\n",
    "    f_xu = np.array(\n",
    "        [v * np.cos(theta), v * np.sin(theta), a, v * np.tan(delta) / L]\n",
    "    ).reshape(N, 1)\n",
    "    C_lin = DT * (\n",
    "        f_xu - np.dot(A, x_bar.reshape(N, 1)) - np.dot(B, u_bar.reshape(M, 1))\n",
    "    )\n",
    "\n",
    "    return np.round(A_lin, 4), np.round(B_lin, 4), np.round(C_lin, 4)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "the ODE is used to update the simulation given the mpc results\n",
    "I use this insted of using the LTI twice\n",
    "ODE用于根据mpc结果更新仿真，而不是两次使用LTI\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def kinematics_model(x, t, u):\n",
    "    \"\"\"\n",
    "    Returns the set of ODE of the vehicle model.\n",
    "    返回车辆模型的ODE模型\n",
    "    \"\"\"\n",
    "\n",
    "    L = 0.3  # vehicle wheelbase\n",
    "    dxdt = x[2] * np.cos(x[3])\n",
    "    dydt = x[2] * np.sin(x[3])\n",
    "    dvdt = u[0]\n",
    "    dthetadt = x[2] * np.tan(u[1]) / L\n",
    "\n",
    "    dqdt = [dxdt, dydt, dvdt, dthetadt]\n",
    "\n",
    "    return dqdt\n",
    "\n",
    "\n",
    "def predict(x0, u):\n",
    "    \"\"\"\n",
    "    预测车辆的真实轨迹，使用ODE求解 \n",
    "    \"\"\"\n",
    "\n",
    "    x_ = np.zeros((N, T + 1))\n",
    "\n",
    "    x_[:, 0] = x0\n",
    "\n",
    "    # solve ODE\n",
    "    for t in range(1, T + 1):\n",
    "\n",
    "        tspan = [0, DT]\n",
    "        x_next = odeint(kinematics_model, x0, tspan, args=(u[:, t - 1],))\n",
    "\n",
    "        x0 = x_next[1]\n",
    "        x_[:, t] = x_next[1]\n",
    "\n",
    "    return x_\n",
    "\n",
    "\n",
    "def compute_path_from_wp(start_xp, start_yp, step=0.1):\n",
    "    \"\"\"\n",
    "    Computes a reference path given a set of waypoints\n",
    "    给定一组路径点，计算参考路径\n",
    "    \"\"\"\n",
    "\n",
    "    final_xp = []\n",
    "    final_yp = []\n",
    "    delta = step  # [m]\n",
    "\n",
    "    for idx in range(len(start_xp) - 1):\n",
    "        section_len = np.sum(\n",
    "            np.sqrt(\n",
    "                np.power(np.diff(start_xp[idx : idx + 2]), 2)\n",
    "                + np.power(np.diff(start_yp[idx : idx + 2]), 2)\n",
    "            )\n",
    "        )\n",
    "\n",
    "        interp_range = np.linspace(0, 1, np.floor(section_len / delta).astype(int))\n",
    "\n",
    "        fx = interp1d(np.linspace(0, 1, 2), start_xp[idx : idx + 2], kind=1)\n",
    "        fy = interp1d(np.linspace(0, 1, 2), start_yp[idx : idx + 2], kind=1)\n",
    "\n",
    "        final_xp = np.append(final_xp, fx(interp_range))\n",
    "        final_yp = np.append(final_yp, fy(interp_range))\n",
    "\n",
    "    dx = np.append(0, np.diff(final_xp))\n",
    "    dy = np.append(0, np.diff(final_yp))\n",
    "    theta = np.arctan2(dy, dx)\n",
    "\n",
    "    return np.vstack((final_xp, final_yp, theta))\n",
    "\n",
    "\n",
    "def get_nn_idx(state, path):\n",
    "    \"\"\"\n",
    "    Computes the index of the waypoint closest to vehicle\n",
    "    计算最接近车辆的路径点的索引\n",
    "    \"\"\"\n",
    "\n",
    "    dx = state[0] - path[0, :]\n",
    "    dy = state[1] - path[1, :]\n",
    "    dist = np.hypot(dx, dy)\n",
    "    nn_idx = np.argmin(dist)\n",
    "\n",
    "    try:\n",
    "        v = [\n",
    "            path[0, nn_idx + 1] - path[0, nn_idx],\n",
    "            path[1, nn_idx + 1] - path[1, nn_idx],\n",
    "        ]\n",
    "        v /= np.linalg.norm(v)\n",
    "\n",
    "        d = [path[0, nn_idx] - state[0], path[1, nn_idx] - state[1]]\n",
    "\n",
    "        if np.dot(d, v) > 0:\n",
    "            target_idx = nn_idx\n",
    "        else:\n",
    "            target_idx = nn_idx + 1\n",
    "\n",
    "    except IndexError as e:\n",
    "        target_idx = nn_idx\n",
    "\n",
    "    return target_idx\n",
    "\n",
    "\n",
    "def get_ref_trajectory(state, path, target_v):\n",
    "    \"\"\"\n",
    "    Adapted from pythonrobotics\n",
    "    获取参考轨迹\n",
    "    从当前位置开始，截取路径上的一段作为参考轨迹，其中v=固定的，参考的方向转角为0\n",
    "    \"\"\"\n",
    "    xref = np.zeros((N, T + 1))\n",
    "    dref = np.zeros((1, T + 1))\n",
    "\n",
    "    # sp = np.ones((1,T +1))*target_v #speed profile\n",
    "\n",
    "    ncourse = path.shape[1]\n",
    "\n",
    "    ind = get_nn_idx(state, path)\n",
    "\n",
    "    xref[0, 0] = path[0, ind]  # X\n",
    "    xref[1, 0] = path[1, ind]  # Y\n",
    "    xref[2, 0] = target_v  # sp[ind] #V\n",
    "    xref[3, 0] = path[2, ind]  # Theta\n",
    "    dref[0, 0] = 0.0  # steer operational point should be 0\n",
    "\n",
    "    dl = 0.05  # Waypoints spacing [m]\n",
    "    travel = 0.0\n",
    "\n",
    "    for i in range(T + 1):\n",
    "        travel += abs(target_v) * DT  # current V or target V?\n",
    "        dind = int(round(travel / dl))\n",
    "\n",
    "        if (ind + dind) < ncourse:\n",
    "            xref[0, i] = path[0, ind + dind]\n",
    "            xref[1, i] = path[1, ind + dind]\n",
    "            xref[2, i] = target_v  # sp[ind + dind]\n",
    "            xref[3, i] = path[2, ind + dind]\n",
    "            dref[0, i] = 0.0\n",
    "        else:\n",
    "            xref[0, i] = path[0, ncourse - 1]\n",
    "            xref[1, i] = path[1, ncourse - 1]\n",
    "            xref[2, i] = 0.0  # stop? #sp[ncourse - 1]\n",
    "            xref[3, i] = path[2, ncourse - 1]\n",
    "            dref[0, i] = 0.0\n",
    "\n",
    "    return xref, dref"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MPC \n",
    "\n",
    "test single iteration\n",
    "测试单次迭代"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-23T08:23:39.847687Z",
     "start_time": "2024-10-23T08:23:39.780867Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============================================================================\n",
      "                                     CVXPY                                     \n",
      "                                     v1.5.3                                    \n",
      "===============================================================================\n",
      "(CVXPY) Oct 23 04:23:39 PM: Your problem has 124 variables, 166 constraints, and 0 parameters.\n",
      "(CVXPY) Oct 23 04:23:39 PM: It is compliant with the following grammars: DCP, DQCP\n",
      "(CVXPY) Oct 23 04:23:39 PM: (If you need to solve this problem multiple times, but with different data, consider using parameters.)\n",
      "(CVXPY) Oct 23 04:23:39 PM: CVXPY will first compile your problem; then, it will invoke a numerical solver to obtain a solution.\n",
      "(CVXPY) Oct 23 04:23:39 PM: Your problem is compiled with the CPP canonicalization backend.\n",
      "-------------------------------------------------------------------------------\n",
      "                                  Compilation                                  \n",
      "-------------------------------------------------------------------------------\n",
      "(CVXPY) Oct 23 04:23:39 PM: Compiling problem (target solver=OSQP).\n",
      "(CVXPY) Oct 23 04:23:39 PM: Reduction chain: CvxAttr2Constr -> Qp2SymbolicQp -> QpMatrixStuffing -> OSQP\n",
      "(CVXPY) Oct 23 04:23:39 PM: Applying reduction CvxAttr2Constr\n",
      "(CVXPY) Oct 23 04:23:39 PM: Applying reduction Qp2SymbolicQp\n",
      "(CVXPY) Oct 23 04:23:39 PM: Applying reduction QpMatrixStuffing\n",
      "(CVXPY) Oct 23 04:23:39 PM: Applying reduction OSQP\n",
      "(CVXPY) Oct 23 04:23:39 PM: Finished problem compilation (took 2.905e-02 seconds).\n",
      "-------------------------------------------------------------------------------\n",
      "                                Numerical solver                               \n",
      "-------------------------------------------------------------------------------\n",
      "(CVXPY) Oct 23 04:23:39 PM: Invoking solver OSQP  to obtain a solution.\n",
      "-------------------------------------------------------------------------------\n",
      "                                    Summary                                    \n",
      "-------------------------------------------------------------------------------\n",
      "(CVXPY) Oct 23 04:23:39 PM: Problem status: optimal\n",
      "(CVXPY) Oct 23 04:23:39 PM: Optimal value: 5.630e+02\n",
      "(CVXPY) Oct 23 04:23:39 PM: Compilation took 2.905e-02 seconds\n",
      "(CVXPY) Oct 23 04:23:39 PM: Solver (including time spent in interface) took 3.982e-03 seconds\n",
      "CPU times: user 60.9 ms, sys: 5.23 ms, total: 66.1 ms\n",
      "Wall time: 62.7 ms\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:27: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[0, 2] = np.cos(theta)\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:28: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[0, 3] = -v * np.sin(theta)\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:29: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[1, 2] = np.sin(theta)\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:30: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[1, 3] = v * np.cos(theta)\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:31: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[3, 2] = v * np.tan(delta) / L\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:36: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  B[3, 1] = v / (L * np.cos(delta) ** 2)\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# 限制条件\n",
    "MAX_SPEED = 1.5  # m/s\n",
    "MAX_STEER = np.radians(30)  # rad\n",
    "MAX_ACC = 1.0\n",
    "REF_VEL = 1.0   # 目标路径参考速度\n",
    "\n",
    "#获取参考轨迹，线性插值，三个点[0,0],[3,0],[6,0]\n",
    "track = compute_path_from_wp([0, 3, 6], [0, 0, 0], 0.05)\n",
    "\n",
    "# Starting Condition 初始条件\n",
    "x0 = np.zeros(N)\n",
    "x0[0] = 0  # x\n",
    "x0[1] = -0.25  # y\n",
    "x0[2] = 0.0  # v\n",
    "x0[3] = np.radians(-0)  # yaw\n",
    "\n",
    "# starting guess 开始猜测\n",
    "u_bar = np.zeros((M, T))\n",
    "u_bar[0, :] = MAX_ACC / 2  # a\n",
    "u_bar[1, :] = 0.1  # delta\n",
    "\n",
    "# dynamics starting state w.r.t world frame 与世界坐标系相关的动力学起始状态\n",
    "x_bar = np.zeros((N, T + 1)) # 4x21\n",
    "x_bar[:, 0] = x0\n",
    "\n",
    "# prediction for linearization of costrains 用于约束线性化的预测\n",
    "# 这部分应用线性模型，得到预测的轨迹\n",
    "for t in range(1, T + 1):\n",
    "    xt = x_bar[:, t - 1].reshape(N, 1)\n",
    "    ut = u_bar[:, t - 1].reshape(M, 1)\n",
    "    A, B, C = get_linear_model(xt, ut) # 获取在t - 1时刻的线性近似模型\n",
    "    xt_plus_one = np.squeeze(np.dot(A, xt) + np.dot(B, ut) + C)\n",
    "    x_bar[:, t] = xt_plus_one  # 获取t时刻的状态\n",
    "\n",
    "# x_bar是根据猜测的u_bar获取的预测状态估计\n",
    "\n",
    "# CVXPY Linear MPC problem statement CVXPY线性MPC问题陈述\n",
    "x = cp.Variable((N, T + 1)) # 4x21维，状态向量\n",
    "u = cp.Variable((M, T)) # 2x20维，控制向量\n",
    "cost = 0\n",
    "constr = []\n",
    "\n",
    "# Cost Matrices\n",
    "Q = np.diag([10, 10, 10, 10])  # state error cost 状态误差成本\n",
    "Qf = np.diag([10, 10, 10, 10])  # state  final error cost 最终状态误差成本\n",
    "R = np.diag([10, 10])  # input cost 输入成本\n",
    "R_ = np.diag([10, 10])  # input rate of change cost 输入变化率成本\n",
    "\n",
    "# Get Reference_traj 获取参考轨迹，根据当前位置截取的路径上的一系列点，并赋值目标速度和转角\n",
    "# x_ref 表示参考状态，d_ref表示参考转角\n",
    "x_ref, d_ref = get_ref_trajectory(x_bar[:, 0], track, REF_VEL)\n",
    "\n",
    "# Prediction Horizon 预测视野\n",
    "for t in range(T):\n",
    "\n",
    "    # Tracking Error 跟踪误差\n",
    "    cost += cp.quad_form(x[:, t] - x_ref[:, t], Q)\n",
    "\n",
    "    # Actuation effort 执行努力\n",
    "    cost += cp.quad_form(u[:, t], R)\n",
    "\n",
    "    # Actuation rate of change 变化率\n",
    "    if t < (T - 1):\n",
    "        cost += cp.quad_form(u[:, t + 1] - u[:, t], R_)\n",
    "\n",
    "    # Kinrmatics Constrains (Linearized model) 运动学约束（线性化模型）\n",
    "    A, B, C = get_linear_model(x_bar[:, t], u_bar[:, t])\n",
    "    constr += [x[:, t + 1] == A @ x[:, t] + B @ u[:, t] + C.flatten()]\n",
    "\n",
    "# Final Point tracking 最终点跟踪\n",
    "cost += cp.quad_form(x[:, T] - x_ref[:, T], Qf)\n",
    "\n",
    "# sums problem objectives and concatenates constraints. 求和问题目标并连接约束。\n",
    "constr += [x[:, 0] == x_bar[:, 0]]  # starting condition 初始条件\n",
    "constr += [x[2, :] <= MAX_SPEED]  # max speed 最大速度\n",
    "constr += [x[2, :] >= 0.0]  # min_speed (not really needed) 最小速度（实际上不需要）\n",
    "constr += [cp.abs(u[0, :]) <= MAX_ACC]  # max acc 最大加速度\n",
    "constr += [cp.abs(u[1, :]) <= MAX_STEER]  # max steer 最大转向\n",
    "# for t in range(T):\n",
    "#     if t < (T - 1):\n",
    "#         constr += [cp.abs(u[0,t] - u[0,t-1])/DT <= MAX_ACC]     #max acc\n",
    "#         constr += [cp.abs(u[1,t] - u[1,t-1])/DT <= MAX_STEER]   #max steer\n",
    "\n",
    "prob = cp.Problem(cp.Minimize(cost), constr) # 构建问题\n",
    "solution = prob.solve(solver=cp.OSQP, verbose=True) # 求解"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-23T08:23:43.320874Z",
     "start_time": "2024-10-23T08:23:43.203207Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 4 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_mpc = np.array(x.value[0, :]).flatten()\n",
    "y_mpc = np.array(x.value[1, :]).flatten()\n",
    "v_mpc = np.array(x.value[2, :]).flatten()\n",
    "theta_mpc = np.array(x.value[3, :]).flatten()\n",
    "a_mpc = np.array(u.value[0, :]).flatten()\n",
    "delta_mpc = np.array(u.value[1, :]).flatten()\n",
    "\n",
    "# simulate robot state trajectory for optimized U\n",
    "x_traj = predict(x0, np.vstack((a_mpc, delta_mpc)))\n",
    "\n",
    "# plt.figure(figsize=(15,10))\n",
    "# plot trajectory\n",
    "plt.subplot(2, 2, 1)\n",
    "plt.plot(track[0, :], track[1, :], \"b\")\n",
    "plt.plot(x_ref[0, :], x_ref[1, :], \"g+\")\n",
    "plt.plot(x_traj[0, :], x_traj[1, :])    #根据mpc优化后的a和delta，预测的轨迹\n",
    "plt.axis(\"equal\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.xlabel(\"x\")\n",
    "\n",
    "# plot v(t)\n",
    "plt.subplot(2, 2, 3)\n",
    "plt.plot(a_mpc)\n",
    "plt.ylabel(\"a_in(t)\")\n",
    "# plt.xlabel('time')\n",
    "\n",
    "\n",
    "plt.subplot(2, 2, 2)\n",
    "plt.plot(theta_mpc) \n",
    "plt.ylabel(\"theta(t)\")  # 航向角\n",
    "\n",
    "plt.subplot(2, 2, 4)\n",
    "plt.plot(delta_mpc)\n",
    "plt.ylabel(\"d_in(t)\")   # 前轮转角\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# 下图展示的结果并不准确\n",
    "# 这是因为在做约束条件中，xt+1 = Axt + But + C时，A，B，C是线性化的模型，且是基于猜测的x_bar和u_bar来线性化的\n",
    "# 所以需要通过滚动优化，获得更准确的猜测和状态猜测\n",
    "# 这里有一个问题，那是否要将这次计算的u，作为下一次的猜测基础？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## full track demo "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-23T09:22:02.254395Z",
     "start_time": "2024-10-23T09:21:47.178587Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:27: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[0, 2] = np.cos(theta)\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:28: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[0, 3] = -v * np.sin(theta)\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:29: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[1, 2] = np.sin(theta)\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:30: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[1, 3] = v * np.cos(theta)\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:31: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  A[3, 2] = v * np.tan(delta) / L\n",
      "/var/folders/hd/8kg_jtmd6svgg_sc384pbcdm0000gn/T/ipykernel_12777/1770301921.py:36: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  B[3, 1] = v / (L * np.cos(delta) ** 2)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CVXPY Optimization Time: Avrg: 0.0757s Max: 0.2766s Min: 0.0519s\n"
     ]
    }
   ],
   "source": [
    "track = compute_path_from_wp(\n",
    "    [0, 3, 4, 6, 10, 12, 14, 6, 1, 0], [0, 0, 2, 4, 3, 3, -2, -6, -2, -2], 0.05\n",
    ")\n",
    "\n",
    "# track = compute_path_from_wp([0,10,10,0],\n",
    "#                              [0,0,1,1],0.05)\n",
    "\n",
    "sim_duration = 200  # time steps\n",
    "opt_time = []\n",
    "\n",
    "x_sim = np.zeros((N, sim_duration))\n",
    "x_sim[0,0] = 0  # x\n",
    "x_sim[1,0] = -0.25  # y\n",
    "x_sim[2,0] = 0.0  # v\n",
    "x_sim[3,0] = np.radians(0.0)  # yaw\n",
    "u_sim = np.zeros((M, sim_duration - 1))\n",
    "\n",
    "MAX_SPEED = 1.5  # m/s\n",
    "MAX_ACC = 1.0  # m/ss\n",
    "MAX_D_ACC = 1.0  # m/sss\n",
    "MAX_STEER = np.radians(30)  # rad\n",
    "MAX_D_STEER = np.radians(30)  # rad/s\n",
    "\n",
    "REF_VEL = 1.0  # m/s\n",
    "\n",
    "# Starting Condition\n",
    "x0 = np.zeros(N)\n",
    "x0 = x_sim[:, 0]\n",
    "\n",
    "# starting guess\n",
    "u_bar = np.zeros((M, T))\n",
    "u_bar[0, :] = MAX_ACC / 2  # a\n",
    "u_bar[1, :] = 0.0  # delta\n",
    "\n",
    "for sim_time in range(sim_duration - 1):\n",
    "\n",
    "    iter_start = time.time()\n",
    "\n",
    "    # dynamics starting state\n",
    "    # 获取当前时刻的状态，x_sim是通过ode计算出的真值\n",
    "    x_bar = np.zeros((N, T + 1))\n",
    "    x_bar[:, 0] = x_sim[:, sim_time]\n",
    "\n",
    "    # prediction for linearization of costrains\n",
    "    # 获取各参考点处的线性化模型参数\n",
    "    for t in range(1, T + 1):\n",
    "        xt = x_bar[:, t - 1].reshape(N, 1)\n",
    "        ut = u_bar[:, t - 1].reshape(M, 1)\n",
    "        A, B, C = get_linear_model(xt, ut)\n",
    "        xt_plus_one = np.squeeze(np.dot(A, xt) + np.dot(B, ut) + C)\n",
    "        x_bar[:, t] = xt_plus_one\n",
    "\n",
    "    # CVXPY Linear MPC problem statement\n",
    "    # 构建MPC问题和求解器\n",
    "    x = cp.Variable((N, T + 1))\n",
    "    u = cp.Variable((M, T))\n",
    "    cost = 0\n",
    "    constr = []\n",
    "\n",
    "    # Cost Matrices\n",
    "    Q = np.diag([20, 20, 10, 0])  # state error cost\n",
    "    Qf = np.diag([30, 30, 30, 0])  # state final error cost\n",
    "    R = np.diag([10, 10])  # input cost\n",
    "    R_ = np.diag([10, 10])  # input rate of change cost\n",
    "\n",
    "    # Get Reference_traj\n",
    "    x_ref, d_ref = get_ref_trajectory(x_bar[:, 0], track, REF_VEL)\n",
    "\n",
    "    # Prediction Horizon\n",
    "    for t in range(T):\n",
    "\n",
    "        # Tracking Error\n",
    "        cost += cp.quad_form(x[:, t] - x_ref[:, t], Q)\n",
    "\n",
    "        # Actuation effort\n",
    "        cost += cp.quad_form(u[:, t], R)\n",
    "\n",
    "        # Actuation rate of change\n",
    "        if t < (T - 1):\n",
    "            cost += cp.quad_form(u[:, t + 1] - u[:, t], R_)\n",
    "            constr += [\n",
    "                cp.abs(u[0, t + 1] - u[0, t]) / DT <= MAX_D_ACC\n",
    "            ]  # max acc rate of change\n",
    "            constr += [\n",
    "                cp.abs(u[1, t + 1] - u[1, t]) / DT <= MAX_D_STEER\n",
    "            ]  # max steer rate of change\n",
    "\n",
    "        # Kinrmatics Constrains (Linearized model)\n",
    "        A, B, C = get_linear_model(x_bar[:, t], u_bar[:, t])\n",
    "        constr += [x[:, t + 1] == A @ x[:, t] + B @ u[:, t] + C.flatten()]\n",
    "\n",
    "    # Final Point tracking\n",
    "    cost += cp.quad_form(x[:, T] - x_ref[:, T], Qf)\n",
    "\n",
    "    # sums problem objectives and concatenates constraints.\n",
    "    constr += [x[:, 0] == x_bar[:, 0]]  # starting condition\n",
    "    constr += [x[2, :] <= MAX_SPEED]  # max speed\n",
    "    constr += [x[2, :] >= 0.0]  # min_speed (not really needed)\n",
    "    constr += [cp.abs(u[0, :]) <= MAX_ACC]  # max acc\n",
    "    constr += [cp.abs(u[1, :]) <= MAX_STEER]  # max steer\n",
    "\n",
    "    # Solve\n",
    "    prob = cp.Problem(cp.Minimize(cost), constr)\n",
    "    solution = prob.solve(solver=cp.OSQP, verbose=False)\n",
    "\n",
    "    # retrieved optimized U and assign to u_bar to linearize in next step\n",
    "    # 将本次计算出的u_bar作为下次猜测的起点\n",
    "    u_bar = np.vstack(\n",
    "        (np.array(u.value[0, :]).flatten(), (np.array(u.value[1, :]).flatten()))\n",
    "    )\n",
    "    \n",
    "    # 本次的执行值\n",
    "    u_sim[:, sim_time] = u_bar[:, 0]\n",
    "\n",
    "    # Measure elpased time to get results from cvxpy\n",
    "    opt_time.append(time.time() - iter_start)\n",
    "\n",
    "    # 用ode模型仿真车辆运动\n",
    "    # move simulation to t+1\n",
    "    tspan = [0, DT]\n",
    "    x_sim[:, sim_time + 1] = odeint(\n",
    "        kinematics_model, x_sim[:, sim_time], tspan, args=(u_bar[:, 0],)\n",
    "    )[1]\n",
    "\n",
    "print(\n",
    "    \"CVXPY Optimization Time: Avrg: {:.4f}s Max: {:.4f}s Min: {:.4f}s\".format(\n",
    "        np.mean(opt_time), np.max(opt_time), np.min(opt_time)\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-23T09:09:06.324409Z",
     "start_time": "2024-10-23T09:09:06.142923Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1500x1000 with 5 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABdEAAAPeCAYAAADj01PlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hUZfrG8e+ZzKT3TihCIIFQAojS1BULgsiqWFexsOraERZF11XXXoAfIKK7q7vuooC9rSWKoGJvgEIQpHfSe08mc35/DJlkSCGYMkm4P9eVa2bOOXPO+yYjJvc887yGaZomIiIiIiIiIiIiIiJSj8XTAxARERERERERERER6agUoouIiIiIiIiIiIiINEIhuoiIiIiIiIiIiIhIIxSii4iIiIiIiIiIiIg0QiG6iIiIiIiIiIiIiEgjFKKLiIiIiIiIiIiIiDRCIbqIiIiIiIiIiIiISCMUoouIiIiIiIiIiIiINEIhuoiIiIiIiIiIiIhIIxSii4iIiIiIiIiIiIg0wurpAXhKXl4edrvd08NosaioKLKysjw9DOnE9BqSltJrSFpCrx9pKb2GpKX0GpKW0OtHWqqrvIasVithYWGeHkan1pycqqu8XjSPjqerzKWpebT036ljNkS32+1UVVV5ehgtYhgG4JyLaZoeHo10RnoNSUvpNSQtodePtJReQ9JSeg1JS+j1Iy2l15DUdaScqqu8XjSPjqerzKWt56F2LiIiIiIiIiIiIiIijVCILiIiIiIiIiIiIiLSiGO2nYuIiIiIiIiIiHR9mzZt4t1332XXrl3k5eVxxx13MHLkyCM+54UXXmD//v2EhYVx7rnnctZZZ7kd89133/Hqq6+SkZFBTEwMl1122RHPKyKdkyrRRURERERERESky6qoqKB3795cc801zTo+MzOTxx9/nKSkJObMmcOUKVP473//y3fffec6ZuvWrTz55JP87ne/Y968efzud79j4cKFbNu2ra2mISIepEp0ERERERERERHpsoYPH87w4cObffzHH39MZGQk06ZNA6BHjx7s2LGD9957j9GjRwPwwQcfkJyczJQpUwCYMmUKmzZt4oMPPmDmzJmtPQUR8TCF6CIiIiIiIiIiIods27aN5ORkt23Dhg3js88+w263Y7Va2bp1K+ecc47bMUOHDiUlJaXJc1dVVVFVVeV6bBgGfn5+rvsNcXz8DtVfrCDN6oXdy4rXZTdg9Ev6LVPzuJo5NjbXzqKrzAO6zlzaeh4K0UVERERERERERA7Jz88nJCTEbVtISAjV1dUUFRURFhZGfn4+oaGhbseEhoaSn5/f5Lnffvtt3njjDdfjPn36MGfOHKKiohofDw6K0vdjP/TY96dvCD/l9KOZUocTGxvr6SG0iq4yD+g6c2mreShEFxERERERERERqePwalbTNBvcfvgxR6qCnTJlCpMnT653naysLOx2e4PPMYePxat3f/x3/ELRm0spzUijIi2tWfPoaAzDIDY2lvT0dNf3tDPqKvOArjOXI83DarU2+WbVkShEFxEREREREREROaShivLCwkK8vLwIDAxs9JiCgoJ6FeyHs9ls2Gy2Bvc1GmBGxmBExeLtbQWWYhbmd+qwE5xz7exzgK4zD+g6c2mreVha/YwiIiIiIiIiIiKdVEJCAhs2bHDbtn79euLj47FanfWoiYmJpKamuh2zYcMGEhMT22xcXiFhzjuF+W12DRFpmEJ0ERERERERERHpssrLy9m9eze7d+8GIDMzk927d5OdnQ3ASy+9xNNPP+06/qyzziI7O5sXXniB/fv38+mnn/Lpp5/y+9//3nXMpEmTWL9+Pe+88w4HDhzgnXfeITU1td5io63JKyzCeaeooM2uISINUzsXERERERERERHpsnbs2MGDDz7oevziiy8CcOqpp3LLLbeQl5fnCtQBoqOjufvuu3nhhRdYsWIFYWFh/PGPf2T06NGuY/r378/MmTN55ZVXePXVV4mNjWXmzJkkJCS02TwsNZXoFeWYFeUYPr5tdi0RcacQXUREREREREREuqxBgwbx2muvNbr/lltuqbdt4MCBzJkzp8nzjh492i1Yb2uGnz94e0NlpbOlS1Rsu11b5Findi4iIiIiIiIiIiIdnGEYEBTqfKC+6CLtSiG6iIiIiIiIiIhIZxAc6rxVX3SRdqUQXUREREREREREpBMwgkIAMFWJLtKuFKKLiIiIiIiIiIh0BqpEF/EIhegiIiIiIiIiIiKdgUJ0EY9QiC4iIiIiIiIiItIJGN4+zjuVFZ4diMgxRiG6iIiIiIiIiIhIZ2CzOW+rqjw7DpFjjEJ0ERERERERERGRzsB6KES3K0QXaU8K0UVERERERERERDoDmzcApkJ0kXalEF1ERERERERERKQzqKlEr6r07DhEjjEK0UVERERERERERDoDVzsXu2fHIXKMUYguIiIiIiIiIiLSGdjUE13EExSii4iIiIiIiIiIdAY2tXMR8QSF6CIiIiIiIiIiIp2Bqye6KtFF2pNCdBERERERERERkU7AsHk776idi0i7UoguIiIiIiIiIiLSGVitzltVoou0K4XoIiIiIiIiIiIinYFVC4uKeIJCdBERERERERERkc5A7VxEPEIhuoiIiIiIiIiISGeghUVFPMLq6QGIiIiIiIiIiIi0tRUrVvDuu++Sn59Pjx49mDZtGklJSQ0e+8wzz/D555/X296jRw8WLFgAwOrVq/n73/9e75hly5bh7e3duoOvYTsUolfbMR0ODIvqY0Xag0J0ERERERERERHp0r755huWLFnCddddR//+/Vm1ahWPPfYYCxcuJDIyst7xf/zjH5k6darrcXV1NbNnz2b06NFux/n5+bFo0SK3bW0WoENtJTpAtR0sbXgtEXHR21UiIiIiIiIiItKlvf/++5x++umcccYZrir0yMhIPv744waP9/f3JzQ01PW1Y8cOSkpKOO2009yOMwzD7bjQ0NC2nYitToheVdm21xIRF1Wii4iIiIiIiIhIl2W329m5cyfnn3++2/bk5GS2bNnSrHN8+umnDBkyhKioKLft5eXl3HzzzTgcDnr37s2ll15Knz59Gj1PVVUVVXX6mRuGgZ+fn+t+Y2r2GXUq0Q27vcnndESueXSycR+uq8wDus5c2noeCtFFRERERERERKTLKiwsxOFwEBIS4rY9JCSE/Pz8Iz4/Ly+Pn3/+mdtuu81te1xcHDfffDO9evWirKyMlJQU7rvvPubNm0e3bt0aPNfbb7/NG2+84Xrcp08f5syZUy+cb0y3bt3YZ/OGqkqiw8OxRsc263kdTWxs5xz34brKPKDrzKWt5qEQXUREREREREREuryGKlSbU7W6evVqAgICGDlypNv2xMREEhMTXY/79+/PXXfdxYcffsg111zT4LmmTJnC5MmT610/KysLu93e5NhjY2NJT0939kWvqiTzwH6MavOI4+9I6s7DNDvX2OvqKvOArjOXI83DarU2+82qhihEFxERERERERGRLis4OBiLxVKv6rygoKBedfrhTNPks88+45RTTsFqbTpGs1gs9O3b1xl0N8Jms2Gr29f8sGsdiWmacGgcZlUldNLQ0zTNTh3Y1ugq84CuM5e2mocWFhURERERERERkS7LarUSHx/Phg0b3LZv2LCB/v37N/ncTZs2kZ6ezumnn37E65imyZ49e9pvcVF7VdPHiUirUSW6iIiIiIiIiIh0aZMnT2bx4sXEx8eTmJjIqlWryM7OZvz48QC89NJL5Obmcuutt7o979NPPyUhIYFevXrVO+frr79OQkIC3bp1c/VE3717N9dee23bTsbq7bytUogu0l4UoouIiIiIiIiISJc2duxYioqKePPNN8nLy6Nnz57cfffdrh7JeXl5ZGdnuz2ntLSU77//nmnTpjV4zpKSEp577jny8/Px9/enT58+PPjgg/Tr169tJ6NKdJF2pxBdRERERERERES6vAkTJjBhwoQG991yyy31tvn7+7Ns2bJGzzdt2rRGA/Y2ZVWILtLe1BNdRERERERERESks6ipRK+q9Ow4RI4hCtFFREREREREREQ6i0OV6KZ6oou0G4XoIiIiIiIiIiIinYWrnYvds+MQOYYoRBcREREREREREeksrGrnItLeFKKLiIiIiIiIiIh0EoZNC4uKtDeF6CIiIiIiIiIiIp2FVSG6SHtTiC4iIiIiIiIiItJZ1FSia2FRkXajEF1ERERERERERKSzsHk7b1WJLtJuFKKLiIiIiIiIiIh0Flar81Yhuki7UYguIiIiIiIiIiLSWdT0RK+q9Ow4RI4hCtFFREREREREREQ6i5p2LuqJLtJuFKKLiIiIiIiIiIh0Fj4+ztvKCs+OQ+QYohBdRERERERERESks/B2huimQnSRdmP19ABERERERERERKTrKS4u/k3P8/f3x2JR3WejvGsq0dUTXaS9KEQXEREREREREZFWd+211x71cwzD4LHHHiM+Pr4NRtQ1GDYfTFA7F5F2pBBdRERERERERETaxGmnnUZERESzjnU4HLz11lttPKIuwFs90UXam0J0ERERERERERFpE2eeeSb9+vVr1rEK0ZtJIbpIu1ODKRERERERERERaXVXX301UVFRzT7eYrFw9dVXExkZ2Yaj6gJqQvQq9UQXaS+qRBcRERERERERkVY3adKkdnlOc61YsYJ3332X/Px8evTowbRp00hKSmrw2F9++YUHH3yw3vaFCxfSvXt31+PvvvuOV199lYyMDGJiYrjssssYOXJkm80BAG9v560q0UXajUJ0ERERERERERHxiMrKSrxrQuE29M0337BkyRKuu+46+vfvz6pVq3jsscdYuHBhk5XvTz75JP7+/q7HwcHBrvtbt27lySef5NJLL2XkyJH88MMPLFy4kIceeoiEhIS2m4zauYi0O7VzERERERERERGRNvXNN9+wYsUK1+P09HT+/Oc/c+WVV/K3v/2N4uLiNr3++++/z+mnn84ZZ5zhqkKPjIzk448/bvJ5ISEhhIaGur4sltoo7YMPPiA5OZkpU6bQvXt3pkyZwuDBg/nggw/adC51Q3TTNNv2WiICKEQXEREREREREZE29t5771FRUVs5vXTpUkpKSpg0aRIHDhzg7bffbrNr2+12du7cydChQ922Jycns2XLliafe+edd3L99dfz0EMPsXHjRrd9W7duJTk52W3b0KFD2bp1a+sMvDE1Ibppgt3ettcSEUDtXEREREREREREpI1lZGTQs2dPwNnCZf369fzpT3/i1FNPJS4ujvfee48rr7yyTa5dWFiIw+EgJCTEbXtISAj5+fkNPicsLIzrr7+e+Ph47HY7X3zxBQ8//DD3338/AwcOBCA/P5/Q0FC354WGhjZ6ToCqqiqqqqpcjw3DwM/Pz3W/MTX7DMPAqAnRAaOqEqMd2uG0lrrz6My6yjyg68ylreehEF1ERERERERERNpURUUFPj7O8Hf79u1UVVUxfPhwAHr06EFubm6bj6GhcK2xwC0uLo64uDjX48TERLKzs3nvvfdcIXpDTNNsMsR7++23eeONN1yP+/Tpw5w5c4iKimrOFIiNjQVgn5cXVFcTHRqCNTK6Wc/tSGrm0dl1lXlA15lLW81DIbqIiIiIiIiIiLSpsLAwdu/ezcCBA/n555+Ji4tzLdJZUlLiCtjbQnBwMBaLpV6FeEFBQb3q9KYkJiby5Zdfuh43VHV+pHNOmTKFyZMnux7XBO5ZWVnYm2jNYhgGsbGxpKenO/uge/tAWSmZ+/dhVFU3ew6eVm8enVRXmQd0nbkcaR5Wq7XZb1Y1RCG6iIiIiIiIiIi0qZEjR/LKK6+wadMmfv75Z8477zzXvj179hATE9Nm17ZarcTHx7NhwwZGjhzp2r5hwwZOPPHEZp9n165dbu1bEhMTSU1NdQvFN2zYQGJiYqPnsNls2Gy2Bvc1J8A0TdMtRDcry5290TsZ1zw6ua4yD+g6c2mreWhhURERERERERERaVN/+MMfOPnkk0lPT+fkk092C9HXrVvHkCFD2vT6kydP5pNPPuHTTz9l//79LFmyhOzsbMaPHw/ASy+9xNNPP+06/oMPPuCHH34gLS2Nffv28dJLL/H9998zceJE1zGTJk1i/fr1vPPOOxw4cIB33nmH1NRUzjnnnDadCwC2Q33Q6yzWKiJtR5XoIiIiIiIiIiLSpry9vbn++usb3Pfoo4+2+fXHjh1LUVERb775Jnl5efTs2ZO7777b1d4hLy+P7Oxs1/F2u52lS5eSm5uLt7c3PXv25C9/+QvHH3+865j+/fszc+ZMXnnlFV599VViY2OZOXMmCQkJbT4fahYXrVSILtIeFKKLiIiIiIiIiEi7y87OZv/+/fTt25egoKA2v96ECROYMGFCg/tuueUWt8fnnXeeW7V8Y0aPHs3o0aNbZXxHpSZEr6ps/2uLHIMUoouIiIiIiIiISJt65ZVXKC8vZ9q0aYCzd/icOXOw2+34+/vz0EMP0bNnT88OsjNRJbpIu1JPdBERERERERERaVPff/89PXr0cD1+9dVXOe6445g9ezbR0dG8+eabHhxdJ+Tt7IluKkQXaRcK0UVEREREREREpE3l5uYSGxsLQFFREdu3b+eSSy7hhBNO4LzzzmPLli0eHmEn46pEVzsXkfagEF1ERERERERERNqUaZqYpgnAli1bsFgsDBw4EICwsDAKCws9ObxOx1A7F5F2pRBdRERERERERETaVExMDGvXrgXg66+/pl+/fngfakmSl5dHYGCgJ4fX+ShEF2lXWlhURERERERERETa1Pjx43n++ef54osvKCkp4aabbnLt27Jli1u/dGkGm/MNCIXoIu1DIbqIiIiIiIiIiLSps846i4CAALZs2UK/fv343e9+59pXWVnJqaee6sHRdUI1lehV6oku0h4UoouIiIiIiIiISKvbvXs3vXv3dj0+6aSTOOmkk+odd8MNN7TjqLoIH1/nbUW5Z8chcoxQiC4iIiIiIiIiIq3urrvuIjo6mlGjRjF69Gj69evn6SF1Hf4BAJglxR4eiMixQSG6iIiIiIiIiIi0urlz5/L999/z/fff89577xEeHu4K1Pv3749hGJ4eYuflf2gh1lKF6CLtQSG6iIiIiIiIiIi0uuOOO47jjjuOSy65hAMHDrgC9Q8//JCQkBBOPPFERo8ezaBBg7BYLJ4ebqdi+AdigkJ0kXaiEF1ERERERERERNpU9+7dueCCC7jgggvIzMzk22+/5YcffmDVqlUEBgYyYsQIRo8ezfHHH+/poXYOh9q5oHYuIu1CIbqIiIiIiIiIiLSb6OhozjvvPM477zyys7P5/vvv+eGHH5g3bx4vv/yyp4fXOQTUtHMp8ew4RI4RCtFFRERERERERMQjIiMjOeecczjnnHPIz8/39HA6j5qe6GUlmI5qDIuXZ8cj0sUpRBcRERERERERkXaxb98+srKyqKqqcttuGAYjR4700Kg6oZp2LgBlpRAQ5LmxiBwDFKKLiIiIiIiIiEibSk9PZ8GCBezZs6fRY1599dV2HFHnZlht4O0DlRXOvugK0UXalEJ0ERERERERERFpU8899xz5+flcffXV9OjRA6tVkVSL+Qc6Q/RSLS4q0tb0L5aIiIiIiIiIiLSp7du3c8MNN3DSSSd5eihdR0Ag5OcoRBdpBxZPD0BERERERERERLq24OBg/P39PT2MruVQX3SzpMTDAxHp+lSJLiIiIiIiIiIibeqss87ik08+Yfjw4R4bw4oVK3j33XfJz8+nR48eTJs2jaSkpAaP/f777/n444/ZvXs3drudHj16cPHFFzNs2DDXMatXr+bvf/97vecuW7YMb2/vtppGLf9A560q0UXanEJ0ERERERERERFpU+eeey4vvvgid911F8OHDycwMLDeMZMnT26z63/zzTcsWbKE6667jv79+7Nq1Soee+wxFi5cSGRkZL3jN2/eTHJyMpdddhkBAQF89tlnzJkzh8cee4w+ffq4jvPz82PRokVuz22XAB0w/AMxQSF6K3GkvI656Wcst/0Nw9vH08ORDkYhuoiIiIiIiIiItKlt27bx+eefU1xczO7duxs8pi1D9Pfff5/TTz+dM844A4Bp06axfv16Pv74Yy6//PJ6x0+bNs3t8eWXX86aNWtYu3atW4huGAahoaFtNu4mBRx6I6JEIXprMN9e6rz9aiXG6W33WpTOqVOH6G+//TYvv/wykyZNqvePm4iIiHRsGzdauewyuOceK4MGVXl6OCIiIiLShv7zn/8QFBTETTfdRPfu3bFa2y+Sstvt7Ny5k/PPP99te3JyMlu2bGnWORwOB2VlZfUq6MvLy7n55ptxOBz07t2bSy+91C1kb1MBaufSJgryPT0C6YA6bYi+fft2Vq1axXHHHefpoYiIiMhvsGWLlc8/h4sucoboGRkWli0L4IorSoiJcXh6eCIiIiLSivbt28fMmTM54YQT2v3ahYWFOBwOQkJC3LaHhISQn5/frHO8//77VFRUMGbMGNe2uLg4br75Znr16kVZWRkpKSncd999zJs3j27dujV4nqqqKqqqagtIDMPAz8/Pdb8xNfvqHmMEhTrbuRQXNvncjqSheXQ45aVHHF+nmEczdZW5tPU8OmWIXl5ezuLFi7nhhht46623PD0cERERaQWZmV4sWBDEWWeVAyhQFxEREelCIiMjMU3To2NoKFxrTuD21Vdf8frrrzN79my3ID4xMZHExETX4/79+3PXXXfx4Ycfcs011zR4rrfffps33njD9bhPnz7MmTOHqKioZs0hNjbWdb+0V29yAFt5KTGNhPYdVd15HA1HUSEAlqDg1hwOAPsO3foZJhHN/H7+1nl0RF1lLm01j04Zov/73/9m+PDhJCcnHzFE/63v8HUGXeWdIvEcvYakpfQakqO1caOVH3+08dVXPnh5Obd98YVz0Z59+7xcx9UN1GNjTTIyLCxd6s+VV5YqVBcX/RskLaXXkLSEXj/SUsfaa+j888/nvffeY+jQoe228GaN4OBgLBZLvarzgoKCetXph/vmm2/45z//yaxZs0hOTm7yWIvFQt++fUlPT2/0mClTprj1fq/5+WdlZWG32xt9nmEYxMbGkp6e7nozwqx2/l5cmZNFWlpak2MzTRP27YJuPTBs7fv9r6uheTSXWV1N9Q3nA+D1j7cwbLY2GCGU5WQf8fvZknn8VqZptsm/F56YS1s40jysVmuz36xqSKcL0b/++mt27drF448/3qzjW/oOX2fQVd4pEs/Ra0haSq8haa7LLoPPP3ff9vrr/rz+ur/r8b59URx6vxuIols3SEuDBQtg6tQg1+Nnn4UbboBOVnQjbUD/BklL6TUkLaHXj7TUsfIa2rlzJ7m5uUyfPp1BgwbV6y1uGAZ//OMf2+TaVquV+Ph4NmzYwMiRI13bN2zYwIknntjo87766iv+8Y9/MGPGDI4//vgjXsc0Tfbs2UPPnj0bPcZms2FrJPxtToBpmmZtiB546A2AooIjPtfx7WeY/1kIA4fj9ecHj3idtlZ3Hs1+Tnlp7f2cTIiJa+1hOc9dVtrssf2WefwWjh+/wlz6NJbrZ2MMHtEm12ivubS1tppHpwrRs7OzWbJkCffcc0+z37X8re/wdQZd5Z0i8Ry9hqSl9BqS5qqpJL/xxkpGjbIxd24wZ55ZzqpVvvWO/dOfau/Pn18OFLFtmxUIIysri7Q0Oxs2WHnwwSjGjMkiI8OhKvVjlP4NkpbSa0haQq8faamu9BpqToXnihUrXPe//vrrBo9pqxAdYPLkySxevJj4+HgSExNZtWoV2dnZjB8/HoCXXnqJ3Nxcbr31VsAZoD/zzDNMmzaNxMREVxW7t7c3/v7OApDXX3+dhIQEunXr5uqJvnv3bq699to2m4eb4EMhelkpZlVlkxXm5mcfOO9s+qlVh2A6HJgpr2H0TcJIGtqq566nbo5XXNiqIbrbf4NlJa123tZiPjcXAMeiB/H617seHs2xqVOF6Dt37qSgoIC//OUvrm0Oh4PNmzfz0Ucf8dJLL2GxWNye09J3+DqDrvJOkXiOXkPSUnoNyZFs2mRlwYIgFi/OIyrKGXRHRVUDcNVVxUyYUM6SJYGsXOkeqq9c6eu2LTXV+f90Z6julJFhcbV+iY6udlugFNRb/Vigf4OkpfQakpbQ60da6lh5Db366qsevf7YsWMpKirizTffJC8vj549e3L33Xe7wv+8vDyys7Ndx69atYrq6mqef/55nn/+edf2U089lVtuuQWAkpISnnvuOfLz8/H396dPnz48+OCD9OvXr30m5RcAXlaotkNhAUQ08UaGt0/bjGH9D5j/ewkT2j7crdOumaL81j13dZ2Avqy08ePkmNWpQvQhQ4bwf//3f27b/vGPfxAXF8d5551XL0AXERGRjiElxRmET58e5tr28ssBALz4YiCRkSbTppWwcqUvixfnUV5uMHt2aL3zHL4tNdWGr6/zj86cHOenzQ5foLTmfkyMwy1gV6guIiIicmyZMGECEyZMaHBfTTBe44EHHjji+aZNm8a0adNaYWS/jWEYEBQC+TnOULmpEL2N+oebBXm199uoZ7eLvTZEN/PzaNUr2RWiS9M6VYju5+dHr1693Lb5+PgQFBRUb7uIiIh41saNVl58MYBJk8qIj3f+UjpjRhEAixYF8ac/FbN2bSDXXJPL2LGVZGY6FxZNSKj9BXbx4jwSEuykptqOGKovWRJIRESRW5X64Q4P2BWoi4iIiEinFlwTohc0fZy1jRYTDajT2768DPz8Gz+2peqE6BTmNX7cb1FdXXu/I4bovn7O7694TKcK0UVERKTzePHFAJYvd37VWLQoyHW/tNRg7VpIS6twfYR51qwioqOr3QL1IUNqf1muCdXnzw86YuuXDz+svf/1184/GuoG7HUDdVWpi4iIiLS+O+64g9tuu63ZhY8Oh4M777yTmTNn0qNHjzYeXRcR5OyLbhYWNFmZbXh7U9M0qDUrxg2Ll+u8FOS2bYheVVl7v6C1Q/Q6AX21HbOiAsOnjVrg/Bb+AQrRPazTh+jN+XiNiIiItL9Jk8pZvjzArT3LvHn5+PqaTJ8exjnnlAO1AXtMjIPbby9yPa4J1OuqCdWb0/qlbmD/8MMhbvuO1AZGobqIiIhIy+3bt4/KysojH9jC5xzLjKBQZ4h9pB7hdRcdrSgD39YJu8261eEFeRDbhm9+1G3n0tohut397w6KC8Gn6cVy25V/IOQ6e/abdjuGtdNHup2OvuMiIiLSajIyLGzebCUlxc/VwqW83HAF1nFxdpKS7MyaVURSkr3R8xweqEdHV7uF6hERzlC7odYvX3/tzcMPh7i1jjlcc9rAqPWLiIiISMvNmzcPWxv14xac7VzgyO1c6q4jWFrSaiH64cF2G3ZEd19YtNUr0Q/726T4CAu1tjefOp/CLSqAsAjPjeUYpRBdREREWs2yZQEsWOAeWtcNrFNS/Bg3roDbby86qo+QNhWqN9b65eyzneH3okVBR9UGJjXV+UeeWr+IiIiItMypp576m54XHBzcyiPpwoLDnLf5RwiV6wbQpSUQ3koBcVsG24c7vOq9NR0eouflwHH9WvcaLVF34dPCfIXoHqAQXURERFqsJlSeMKGMPn3sTJ8exowZRSxaFMS8efnExVWTkuLLVVeVtMr1mtP6pa6jaQNz+LYjtX4BVamLiIiINOTmm2/29BC6vkNhqpmX1fRxdfuJlxa33vXdgu3c1jtvQ+oG9oX5mA4HRt0K+5awu4foZk5W21bVHy27+9yl/SlEFxERkRbbvNnGggVB9Oljp7zc/ddNX1+TpKQqxo2raJNrH6n1S3PbwKSm2o4YqjfU+kVV6iIiIiLiKUZ4pLMn+qF+2Y1x611e2jqFLUDbVocfxm0O1XZnmBwa3jonrz6sICf3CG9KtLc6b4KYhW3cNkca1Epv14iIiMixLCXF2Q5l+vQwV+hc04t8+vQwli0LaOypra4mVI+Jcbjdh/oBO9RWqde0glm8OI+PPspi/PjyeudeudKXiROjmD7d+bHZ1FSbK1A/vEo9M9OLjAwL8+cHkZHh/JXr8MciIiIiIi0SdqgtS34upqOJAo46VdxmG4Xorb7YZxPXAiDzYNudOyez9c7dGlSJ7nH6C05ERER+k40brdx5ZwirV3u7FhGdMaPItaDnzJmFTJ1awvLlOVxxRSv+ot4CdUP1hgJ1cG/9As5Qfd68/AbPN3t2qCtQX7Ik0C1UB/dAvaHHCtVFREREpEVCw8Gw1FZmN8Zep51LWSv+bl5Vpw1Kfju2cwHMjFYM0Q+rRDc7XCV6nblnZ3huHMcwtXMRERGR3+TFFwNYvtz5VaOm+hwgK8uLuXMLPDE0ZxVOWSmUFEJRIZQUYZYWg5cVw9cPfHyJ9vVj1pV+4OOHWeFHdJTR7NYvzV2g9PBe6odTb3URERERaQnDywtCwiA/B/KyG29vUjeELWmjnujZGa3bp7ypawFkHGi9cx++sOgR2uO0u7oV/2n7PDiQY5dCdBEREflNJk0qZ/nyALdFOufNy8fX12T69DAmTSpr1euZJUWQth+KCzGLncG4KyAvLoKabTW3jXyc1Wzk/JGGwUwfX5jnR7WvHwlefnxzYQDRK7wpM/15fHA4Y/KCiCmJ4LZJPUj9cgD3zPWivMJ6xF7qTz0VRG5uKdu3O3/1Sk21Aai3uoiIiIi0XHikM0TPzYY+iQ0fUzdEb81K9LrBdlWls5d4ZEzrnb+xawFmRlrrnbsmRA+PdH4fC3Ixq6owbLbWu0ZL1F0YViG6RyhEFxERkWbLyLCwebOVlBQ/VwuX8nLDVXEdF2cnKcnOrFlFJCXZmzpVk0yHA9L2Ye74FXb+irljC6TvP/oT+fhBYBAEBoN/gPNjmuVlUFHuvC0vg4pDYb9p1m4rABvQA2ALeANTewHfgfkdDAV+OB3Mj61UBUURN7InPYdF4N8zine+7M1HP/ZiX2kcmRWRmFj4/nsfvv/exzWsw0P3hqrWVaUuIiIiIs1hhEVisgUzL6vxBSfrtHMxV72Ledo5GNHdWn7xw6vD0/e3XYheEyRHRDt7lrdmJbr90N8uIeHOopzKSmdlf2t8j1rINM3a8QEUF2EWFWAEhXhuUMcghegiIiLSbMuWBbBgQZDbtrqBcEqKH+PGFXD77UVHdV6ztBh2bsWsCcx3bXG2YzlcRDQEh0JAEEZgcG1AHhCEEeS8pWZ7QHCzKkdMhwMqK2qD9YoyV9Bu1g3aS0sgNwszO5PqzEyMvCwsDjveBWmcEpkG+4H9cL0Vrh/jPHe1YWNPcTcsUdEQEc2ust7864NB/FrUj+zKiAa/h0uWBBIRUaQqdREREemSDh48SG5uLpWVlQQHBxMXF4e/v7+nh9W5hUc6b5tqQXJYP3HHa8/jdeu9Lb+23b1wxkzfjzF4RMvP25Ca/us9ejtD9Kw0TEc1hsWr5eeu6YlutUJUNziwB3PrRsDEiI5r+flbou4bFf6BUFrsrEZXiN6uFKKLiIjIEdWEthMmlNGnj53p08OYMaOIRYuCmDcvn7i4alJSfLnqqiN/NNR0OCDjAObOLeSm7cWeus75S6B5WKMVbx/ok4jRdwBG/ACI7+8MyluZYbGAr5/zKyTMfV8jz/ECzOpqyM8ld1sW36fkc3LSPgIr0inek03O1mx6BqThZVYRH7AXSvdCKfQGThvlPIfdL4RtJf34Zk8iW4r68mtRP7YWx7Nypf8Re6urSl1EREQ6k61bt7Jy5Up+/vlnCgsL3fZZLBZ69+7NKaecwrhx4xSo/xYRzspvM6uJBSdrgljDcP7evXtb61y75rw+vs6ilPRWrA5v5FpGdDfMuteL69XiU5s18/CyYgwchnlgD+YLizEtFiwPPI3RrUeLr/Gb1X0DpFc8/LoBM20/RuJgz43pGKQQXURERI5o82YbCxYE0aePnfJy92jZ19ckKamKceMqGn2+aZqw7RfMrz/B/Pl7Z/UE4Ba5R8VixPeHvkkYfftD997OhZI6KMPLCyKiiIiIYtLo2u1lGRbeWhbAFZcVkrcrj7/eWMGT922hh88BCjbvJ3vDPvoE7MNaVkCSZS1Jfda6nXdPSXd+LerHr0X92FLUj+ce7MvOEucfBqpSFxERkc5k9+7dLFmyhM2bN9O9e3dGjRpFfHw8wcHBeHt7U1xcTEZGBtu2bePll1/m1VdfZcqUKUyePBmrVZFVcxkxcc51f5pqb3IoiLXcswDHo7OgIA+zIA/jsCISs6IC880lGMePwRiQfMRru8LnHr1hx6+YbRmi17Rzsfk4w+RtmzB3b8NohRDd1RPdasUYNgpz5f+cjx0OzF83eDZEr1OJbvSKx/x1A+zf5bnxHKP0L5KIiIgcUUqKszJ6+vTaX7IXLQpybZs1q6jBFi5mThbmt59gfvMpZKXX7rB5Q+8EgoaeQElMD4hPxAgOq/f8zigmxnHoe2GAVyQnTQvA59TuWGIcVI628O6yAK64JIfo6j3s+34/Kf/K4LLfbcY3ZzfW0jyOCzjAcQEHmBD7ueucFdU2tpf0YWN6f5ZdP4gNBQOxGYFHrFI/PFQHVa2LiIhI+/nrX//KySefzFVXXUV8fHyTx5aXl/PNN9/wv//9j+rqai688MJ2GmUXUBPwZqZhVlc3XIhS0xM9IBCi45yB+75d9T6JaX76HuZnH2B+9gFe/3r3yNc+FM4bPeOd6xkd2I1pmhhGo93Zf7uaMNlmw+idgLltE+Z/F1H9zadY/vxQywpwatq5eFmhb5L7voN7fvt5W0NNJbrVhhHfHxMwt/+KuW8XdO/VOu1s5IgUoouIiEiD6i4iGhXl/KVyxgxnUL5oURAzZxaSleXFpEnlJCXVVkeYFRWYP32L+c0n8OuG2jYtPn4YJ56MMeY0iB+AxWYjtFs3ytLSnJXqXVBtoH74Y28gAR+//pTsD6D8ihL2Znpx+blW3nlmLX18dnDwx32krdlPcuR2fChnUPBWBgVv5dKe7wHOYH3T24mszx/IRd0HsWJJXyLCwti2w/3Xu8Nbv6hqXURERNrL/Pnz6dateQsz+vr6cvrppzNu3Diys5vo7S31hUWCt7dzMczsDIhx7+FtmmZtEGvzxujZBzPjAOb+XRiDj3c/V51q9mb1G68Jto/r6wygi4ucY4iKbemsGr+WzQa9E2q3b0mFg3uhZ58WnPtQJbqXFcPLC8uM+3G88m9nG8p9Hq76rjvvvgOc9/fvwvHQDIxLr8M481zPje0YohBdREREGtTQIqI11ecAWVlezJ1bADh/MTd3bMH8ehXmmq/cFwXtPwTjpDOdHwn18UVqHR6yT7vVl8ARg7HEDCQv2sb5i6P46MMMbIUZzLktl9mXrKN71a8Ye7YR4FXE8NBfGB76C/A6AMVP+lNQMIC/DhhE/ifH8WtBX7ZldG/0+uqtLiIiIm2puQF6XRaLhejo6DYYTddlWCwQ3d3Z4iP9QL0Qnerq2sIWm80ZNq/5CvburH+yuqF5Vv1Avp6aPuV+/pg9esOe7Tj+ej3G+VdgOeeS3z6pBq9V03LlUCV6nV3m3h0YLQnRD7VzqalmNwaPwHJTFI4HboX9ezAdDuf32RNq2thYbRihEc61oyqdrTTNlNdBIXq78NBPX0RERDq6K64oYfHiPKC2An3evHzXtkmTyjDzc3B8+AaOv92M44k7Mb/82BmgR0Rj/P4yLI89h9cdj2IZc5oC9COoCdRrAuzo6GpmzSoiOsakKqQbH2eMo/qcKwm57wHWTX2dU1a/w5qhf2VLjwv5IXcYpXZfAq2ljIlYx43xSxn7yyMkvPBHTv7fJbxwwm0ULHuZzW+sJ8RayNdfe5Oaamuwt3pmpvMPh4wMC/PnB5GRoV8XRUREpOVuvfVWdu/e3eC+vXv3cuutt7bvgLoYI9ZZOGGm76+/s6aVCziD2OP6OY9tYHFRMzer9sGB3Ue+sFuw3a/2PO8sw6zZ10pMV090m7PSvU4VvbnkKaqfegizpi3L0arTE90ltjtYbVBR5qyu95S6legA3XrW7isqoPqB6ZhbN7b/uI4xqkQXERERNxs3WnnxxQAmTSprcBHRxIRKnvnTh4z68R0cL/0E5qGqZW8fjBFjMcaeAYmDPVep0UUcXqU+a1YR0dHOPwoiIk32lPbA/1QfqjmFi56L4ulF2QyK2EnOuh1sWbGboaGbGBC0jQiffE6L/gZyvwHgwrNgy+p41r49lDV5yfQJSCZ1QzC+fs7rNNRbHVSlLiIiIi2TlZWFvZFQtaqqiqysrAb3taYVK1bw7rvvkp+fT48ePZg2bRpJSUmNHr9p0yZeeOEF9u/fT1hYGOeeey5nnXWW2zHfffcdr776KhkZGcTExHDZZZcxcuTItp5KfYdCdNL21d9XVdt6EasN+hxqhZKVjllUgBEUUrs/p/bnYB7Yi3H82KavW6dfN736uu1yLLwPY+yZWE46o7mzaJq9Tm9ww8BrxgM4vluN+fwC5/bUNbB/t7O1zFGfu7adSw3Dywu6H+esrn/rBYygEIxLrsOoCbPbi+t77A2A5fIbcLz8HNS8CXJgD47nF2Jc9EeM5BPcipfMXdtw/ONxLJde6wzfo+MwtGjvb6LvmoiIiLh58cUAli93ftWoaePyn/v288/T5/H78k21T+g3EGPs6RgnnIzh59/ewz0mHB6ou6rUo6tdleP9+pskDulBamQf7lkQxeLFedj6lLLl0/2seXMPl43+mW7lmwiv2k//oJ30D9rJ5b3eBiBnRShr85O5KT6Zr19IIjKkO9t21a9SVy91ERERaQsZGRn4+fm16TW++eYblixZwnXXXUf//v1ZtWoVjz32GAsXLiQyMrLe8ZmZmTz++OOcccYZTJ8+nS1btvDvf/+b4OBgRo8eDcDWrVt58sknufTSSxk5ciQ//PADCxcu5KGHHiIhIaHeOduS0auvc8HJBqrLXSGsl9VZ6OIf6AxU0/bBzq0w9ETgUO/03EzX08xmVaLXCbYHDces6c0OsPUXzK2/YA5IBj9/DP+Axs/THHUD+0OM4/q6t3XZsw3jt4ToDVWiA0bCQMw922HtN87v71crISAYy6XXUVBWiDl0DGb6AejdD/JzISzCeRse6ewPHxIGpqNli38eVoluxPfH6575VN90Ye2+3CzM5+bCuEnOCv2koRjePjiWPg152Tj+Ocf53DPPxQyNgMI8jFMmuD7BIEemEF1ERETcQtFJk8pZvjyAxYvzKC83mD07lDl3biVpy/MMq/oEynFWnZ8+GePk8RhH6pMora6pKvUaCQl2Bg8xMK3x3LZgFJc/exrpwOnnWnn2zm/oa6SS++NWepm/EuGTz1kxX3BWzBcAVD5tpaxgAPclJZP3ST+KogcCUQ1WqStUFxERkcasXr2azz//3PX43//+d72wvLKykj179jBw4MA2Hcv777/P6aefzhlnOKuip02bxvr16/n444+5/PLL6x3/8ccfExkZybRp0wDo0aMHO3bs4L333nOF6B988AHJyclMmTIFgClTprBp0yY++OADZs6c2abzqadvf+ftwb2YpSXugbW9ThuUQ4z4RMy0fZi/bsDcmuqsOI+KrQ3AAfbsOPJ1XSG6FSMiGsvj/8L88E3MVe+6DnH85VronYDXPfMbPY1pr8LxxF3gH4Bl5oMNf6q1pv+6zbt2W0ycc9xZ6c7zLP071d98iuX2R4+uYrymDYzX4SH6ILe5YLdDQS6O5+ZSCLD0n87tfv5QXgYR0ZCTCTHdIeMgJA6CHZuxXHc7Zl42xrhzjr4SvE5PdDfJJ8K6b9w2matTMFenwIixGN6+cNiiqG5zycvBuH720Y3lGKYQXURERNi82caCBUH06WN3tXApLzcItJYwO3E5l2xejld1JRgGxpjTMaZc4VzURjyuqSr1huRWhhF08khihgxn8wAfJl0ZxH8e+JGgrM2kfb2FE8I2EO2Tw/FhGzk+bCP8AvwCX42L48DSIexLSyStahhQW7Gl1i8iIiLSkMrKSgoLC12PS0pKqKrbWgSw2WyMHTuWSy5p5UUo67Db7ezcuZPzzz/fbXtycjJbtmxp8Dnbtm0jOTnZbduwYcP47LPPsNvtWK1Wtm7dyjnnnON2zNChQ0lJSWl0LFVVVW7fA8MwXG8sGIbR2NNc+xo7xggJxxEZ4+zdvXsbxqDhtTtrWpXYvGvPEz8A8+tPMFf9DwDz43dqQ24fP6gsd54rbT9Ed2s8+K0Jtr2d5zZCwnH0G+ge1gLs3oZj8cMYA4fBlTfUn0dmGuzZ7ry/eT0MGIJxeGhcVVuR7ZqHlxXjvoWYP36JY+nfnft3/Ao7NkO/JPfAvSl1KtHdxpY4qHnPLyt13tb0Tq/pTb8lFcBVCW6u+w7Dzw/LVbdCSHiTP/Mart7ydeYN4HX59TgiozE/fqf+kw5Vzjd53n27nD+zI7y2WsLMz8X8YgVmfg44HLVvVrQBr2m3AW0zD1CILiIiIkBKirNv3vTpYQBYqGbtotXc0f8fnNMvB6qBxMFYLrn2t308UtrNkUJ1t97qEQ4qHd5EjkwEErlxcRSLn8plYMwBPnt+F74HNjEibAMDgrbTy/8gvTgIn64gDlh3RhhlLw/mwM+DyLQPxUI40HSVOihgFxEROZacddZZrh7it9xyC7fffju9e/du93EUFhbicDgICQlx2x4SEkJ+fn6Dz8nPz2/w+OrqaoqKiggLCyM/P5/Q0FC3Y0JDQxs9J8Dbb7/NG2+84Xrcp08f5syZQ1RUVLPmEhsb2+i+nEHDKP18BQEHduFVnI/fyWdijYymsjifDMDLx5du3boBYD9tAmlLn3F7fmDaXgoA7/gEHCXF2PfupPpvN+N/2tlE3PFwg9c84KjGAUR1i8N26NyO8ZPJ+fELyn/6Hhy1oam54UfMDT/iuPjqevMoO7CT7EP3HU/ejy0+kZgnX8SoUxmeZpjYgYiYWHwPXauGPSiItJoQHXDMvxeviGhi/vkaFv/ARr9nNfJ8fSkGAkNCCa177m7dOBgVQ3VWKy0suu0XTKD6jmlgtRH9+D/xGTi0yaeUBAaQC/gEBBJ92NhIGkyuWU3JyveOfiyZacRGRrjeaGjqtfVbVGxaT9bfpmPWvMHQxmLvesR528rzqKEQXURE5BiVkWFh82YrKSl+REU5f7mdMaOInqXrGLT5WQYFbwUg29Kdskl/5LhzT2yzd/Wl7Rweqh+pt3pCYjUDhkSQbo9j6tRzWbw4j1+LS3lr/j5ODPuZUeHrGB66kUifPMj6ErK+JBbYMD6A4mWDyIscwojQseRmRgP1q9TVBkZEROTY9Mwzzxz5oDbW0O+yzan+rmGa5hGfY5pmk/unTJnC5MmT612jqYVXa46LjY0lPT3dNY7DOXr0AaDotf8CkP/5x1jvfBwz7SAA1RYLaWlpNWd0a4MCULDsHwBUdesFFeWwdycApZ99SMXF12J4+9S/ZoWz1UhWXj6GLa12x013Y/l1A47/u6fec9KungSnno1lyhW159nu/omAqp1bObjiXSzDx7i22UvLAMgtKMRIS3M73jRN6JvkrEA/pDonk7TVH7udozHVBfkAFJeVU3bYufnzw1jS92N++gHmLz+B2Uq/t9qryJx9LfQdgNc1f260Tabj0KK7lQ6zzs+vlvn7y7GEROJY81XtYqOHSxgE236pfewXAGUlpP20Bkuv+CO+to6WmZNJ9UMznRX6x/XDMmwkWLzAYgGjgVY9rSA9M4tu3bs3Og+r1drsN6saohBdRETkGLVsWQALFgS5HscH7Cb5q0WMj/kSgqHMCMT/4kuJPm1S/Y9SSpfQVG/1iAjnHwcJCXbAmy+zR3PJ/f0JSbiQ99abvPzEQUaF/8TIsJ84IWw9wbYSgnN/IC73B94e+zwVL/tQ+NUALL7JjI0Yi1EVi2nzdbu+2sCIiIh0bdnZ2Q0u2nkkubm5hIeHt9o4goODsVgs9SrECwoK6lWb12ioorywsBAvLy8CAwMbPaapc4KzfY2tkV7dzQkwTdNs/Liho2D5P2sfb92IY+fW2p7aNm+35xq9+mLWCdFd/dDj+0NRvvt1t/4CdVvE1DjUzsX0ssLh40ocjHHh1bB/N+b3tb3xHcWF8MGrcMahNxO8rJg5h+rQQyOcvduz0nGs/hBj2Oj617LZ6l8LsNz1BGz9Bcf//bX2Ws88huO4flhmP4bh41vvOS6unuhe9b+/UbEYUbHQNwmjMB9zx6/w83f4+PhQvuYb8A+AogIwDOe4vLyOrm3Jjl+pfmA69EnEcuXNGLE93Habh35+ptXa8M/eLwBjwhQsJ56C+f4rmJlprjYyNbzufBxz7w4c/5yDMeVKzE/egx2/4jiwB6On882XJl9bR6n65eegpMgZoB/pe99aDr0h1ZrzqEshuoiIyDGmpvp3woQy+vSxc+8sCy9c/AxDcv+HzVKNw7Dwwq6LGXDHhZw8vh1+2ZEOoak2MK4q9QQ7Q4ZUATbW5A3j6oeOIyZhMrPm+3Hgq/2MCl/HyEPBeoRPPj771zOA9bwyainV//Aiw3cAdyaOZPeHAzCqEtm2u3ZhMS1WKiIi0vXMmDGDM888k7PPPvuILRbsdjs//vgjb731FqNGjeKiiy5qtXFYrVbi4+PZsGEDI0eOdG3fsGEDJ554YoPPSUhIYO3atW7b1q9fT3x8PNZD/cETExNJTU11qyzfsGEDiYmJrTb2o2GERYC3D1RWuLaZK97COMm5mOrhC1MaF/8RMzsDY9BwzJTXa7f3HQD+AZib1kPqGud51n2L+f1qGHQ8xtCROP77JMaA5Npe4g28MWAYBsbECzFLSzB3bYPMg277ze9XY773KgQGY/SKdz7njMkYI07Ccc8N8MtPmFnpzgAb6ixi2vCbEIZhYPZJqL9jz3bnPE44ucHnuZ+78ajU8A8A/wCM2O4YJ59JZGQkabt2YBqGcxHRmDhnD/m4ns7bmDhnNX9gMOaaLyE7E/PHLxs+eVWl802PpX/HcvvDkJ+LEX6oavrQwrBH6u9uhEdiXHUrZnkZ5ucfYUR3w7Hs7xh/uN65v1dfvB57DgDH5vXONwP2727ynL+F+ctP8PP34OWF5Y8z2ydAbwcK0UVERI4xrkVEe1fRbfcKvjz1OULzC8EC6VGjKZn4Rwp+TCRhWAmg8PJY1VSVeo2aUP2qaRamrhzADY/GUFg+ieGzQ+gXsNsVqo8K/4k4vwziyn/h1n6/wDao3GKlOH8QtyecQMYXAyiOTgIgJ8dZQaJQXUREpPO79957eeGFF/joo4/o168fgwYNok+fPoSEhGCz2SguLiYjI4OtW7eyfv16ysvLmTRpklso3VomT57M4sWLiY+PJzExkVWrVpGdnc348eMBeOmll8jNzeXWW28FnP3cV6xYwQsvvMAZZ5zB1q1b+fTTT5kxY4brnJMmTeL+++/nnXfe4cQTT+THH38kNTWVhx56qNXH31zG5TdgLnkKkobC5vWY676FPodC/cOCbiMiGq97FwBQ/d1qyHW2DSEiGsMw8Lrtbzh+/BLzuXmYX3zk3Lfma5h4Iaz71nnuGk18ctXwD8Dr0X9i5mTiuPdG10Kn5mv/dbZGKS3GrAnYwyKdofnAYc4Q/YsVzmp2qK2ob+pa3j5Ybr0PM20v5psvuLabP3+P0VSIXqcSvbkMmw0jKMRZfR7f37mxn/N3WvoOcN4OHOY8tlc8ZnkZxvjzobgQx6p3neH41l/cT7p1I+arz2N++j7GpddiOfM8qKpZ9LR5nw42fP0wJkxxTmf46IYP6t0PvvwY8+O3cfQdAN2mNHPWTTNNE8fbS53jGDcJo3uvVjlvR6AQXURE5BiTkuKLv1cp1c8vZGT3D8EbNhf24+HNf+arnFHMiihyC09FjrRYqXvrFwCDGU+EkpDwO77++kxGPxzMfTdvo2fpzxSv+4UxEWvo7pfBieHrOTF8PfwMFdU2Xhs1hMwXh7KjbAA7ige7jaGh1i9XXlnKYWtKiYiISAeSlJTEE088wU8//cTKlSv58MMPqaxpGVJHdHQ0EyZMYPz48YSFhbXJWMaOHUtRURFvvvkmeXl59OzZk7vvvtvVIzkvL4/s7GzX8dHR0dx999288MILrFixgrCwMP74xz8yenRtKNm/f39mzpzJK6+8wquvvkpsbCwzZ84kIaGBauh2Yow9A6P7cdC9N46/PwYb12K+4eyRThOVzJYb7sTxf/dgnDrRrae7MWQEprd3bauXqkrMD16tf4JmBLzO0H4hoWVF5Mz5a4O9xY0I58/DcurZOH75CfOrjzHPOt8ZVtdUizfSDsd1jqEnYgw9EUdeDua3n0FZCeaGNZjpB6C8FKN3AmZ+LuTlwHF9MSwWzJp+9F5t18bS8PWDQ5XyXkNGYJYUw/bNmN99hrnmK9dx5qfvO2/ffAEzaXiddjytNzZjzBmYG9fBT99hfvoBTGqdEJ2Na52V/z5+GOdc0jrn7CAUoouIiBwDNm608uKLAUyaVMaIblu59qRH6Be4BwcW5m25Ce/J53Pccd7cNCmHpKQqTw9XOrija/0CYHDSuWHAaUxccgmLn8qlNHofX/1nGyEZ6xkbsYZY3yxGR6wD1sFbEFvtzSujhlD97mB2HBjEjqJBrusdHqhnZFhYutRfVeoiIiId1PDhwxk+fDh2u53du3eTl5dHZWUlQUFB9OjRo1X7nzdlwoQJTJgwocF9t9xyS71tAwcOZM6cOU2ec/To0W7BuqcZhgG9nUGt5fd/wLH559oq66YquOP7Y3lyeb2g3fD1dy7YuXl97UZHA79vNdEGxe18PXrjFxMDS56BjAP1D6hpYZJ8InTrCWn7cPznSSw33uWqYG9uRbblsusxL70Wx53XQEEejvtucm6/8S843noBMtMgrheWWQ/XtqU5ikr0ljICAmHoic4q9mGjoKIcc2mdBXjtdmfbnP5DnI9bcZ0qw2bDMuECHD99h5m2t9XO6/gsxXn+U85yvvHRhShEFxEROQa8+GIAy5f7U/35Sh4aNA/fwArSyqK59efH+DFvGFOzS5g7t8DTw5ROqjmtX+pKSKxmwJAo0qt7MHXqRSx+Khdr3kG+/PdWRkesZWz4GqJ9cxgbsRZ2r4XdEFPtw0sjh1L93kDyY4ZiM0LJzbUAzhBdC5SKiIh0fFarlX79+nl6GMcMI74/xuU3uoJZw8+/6eO9fRrcbjn7Ihyb10PiIPALgPU/1H9uner1I47LYsFyxu9xvORcBNWY/AfM919x7gxxvqFieHlhue52HI/fARvXOoPwGkcRJhsWL4zR4zBXvO3a5nhubu0bAQf34vjX/4HFcujc7R+VGkHBGKNOxbRX1Ybo0XFQXAh7tmPu2e7cdoSe6EetW0/nbX4ujuKWfxLZzM5wVqIDxrizW3y+jkYhuoiIyDHg9+NzGbnxcaZ0d/Yy/CTzJAqnzOKqC4L5cTpMmlTm4RFKV3Gk1i8NtoFJrAZiuOn+wYy58zSy+1Wx5ocMvnp+C2PC1zI6Yi1RPrmcHPkD7PoBdkHqeF92vTiEzekjyS5OxGo4P/qtXuoiIiIitSy/m4DZJxFz3TcYI3/3m85hJA3Fcvc8iIqF4iIcO7dgHD8G8/OPfvO4jFPGw68bMCJjMH7/B+fGsAiMOpXgRq94LDMfxPHvBZCf49wYEQ2+R7dQpXHS+NoQ3S8Aykqc94ecAFs3wpbU2oO9PBeVGlabs0r+f8uxXDsL8rKcAX9NKx1fv9a9nn8AhEZAfg5V+3ZBaFSLzmd++5mzP/yAZIyYuFYaZcehEF1ERKSLysiwsHmzlXXvHuDqyvsZ230/DsPC5sRruCblepb9OZekpApmzSoiKcl+5BOK/AaHh+rNawNjByOWG+8fwqjZZ5DVr4pFC3Jga6ozVA9fS4RPPoP4EVb9yO+ADeP9KVo2iNzIZIaGnEJOlvOPgIZ6qdcE6grYRURE2ldaWhorV67kwIED9XqjG4bB3/72Nw+NrGszevbB6NmnZeeoWTgzKATL/BcxDIPq9T/WhttHez6bN143/aX28XmXN3xc/yFYHnvW2U7GXuUMaC1H13LF6NYD4/TJmBkHsEy9Cce8v0JRAZZLr4OsdBzPPOrqt254oBLdbawjxuI1YqzzwXF9sfztKcwvP4bKcoyTzmz9C8b1coboe3e2KEQ3TRPzu9UAGGNOb6XBdSwK0UVERLqoZUv9yXhjJfcPnI+vVyUHy2K49edHWfPBMABSUvwYN65Ai4iKxzSnDUxNqD5hWjRTp17CiXeMZ1WZyb8eymVsxBrGRKxldPg6wrwLCMz9kW65P/LeSc9T9pI/+d8OwuEznOSQk8ERXq9KXVXrIiIi7Wfv3r3cc889hIeHk56eznHHHUdRURG5ublEREQQExPj6SFKM7lat0TF/OYQ/aiuZ/N29khvActl19fev38RlJZgRMVCTBwkDYXUNc6d7dgTvTmMmDiMi6a13fnjemJu+omqPTsgedRvP9Ge7ZB5ELx9MI4f03oD7EAUoouIiHQxGRkWXnsB/mg8QMiQLwDY4T+aKSsf4Z7H4M9xOaSk+HLVVSUeHqlIrSO1gXG1fklwfmpia3E/pj8ewQlj/8Dsv5Sy78v9jIlYy5jwNYyOWEeIrQh2/8hgfuT9k56j8h/+5EQkc23vsZRv74c5qP5HTJuqWhcREZGWefnllxk6dCh//vOfufzyy7nxxhuJj49n3bp1/OMf/+APf/iDp4coR8mIjMXctsnTwzhqRkAQBATVPu7RG9MVorfe4p2dQq++AJR99zlMurS2N/xRMjf97LwzaDhGK7ed6Sh+23dGREREOqy9X+/h7J9vImTrFzgMLx7ZPIN34h4lvyoUX1+TpKQq5s4tYPBgtXCRjqsmVK8JsA8P1cEZqB9/PFw9rYzNRYkMv30i+Zfdx9CVqzj7q2U8tHkmqzJOobAqAO/qUrplfsf9AxdwfMrNlN16FV7/eYIrer3B7u/TSd1gZdu22vqSmkC9ps1MRoaF+fODyMjQr88iIiK/xa5duxg3bpyritk0TQCOP/54fv/73/PSSy95cnjyGxgnnuK84+EWKC1Wt9VNB6tEb2vG8WMhMJjqjIOYa7/5zecxt2x0nq9/cmsNrcPp5K9yERERqWGaJubnHzLkw/9gC6jkQFkMt/z0OOvyk+Ep5zHTp4cxa1aRWrhIp9NQ65eagP3wKnUHXtz4aAwJCROYP/8irltpY3DIFsaEr2FsxBpGhv9EAIX0r/qcxwZ/Dt9DxueR/JpzIpf0OIEdP/THEeb8SHlOjvMPfVWpi4iItExJSQmBgYFYLBa8vLwoKan9VGR8fDxvvPGGB0cnv4UxZASW6fdBt56eHkqLGD16Y9Y8ONZCdB8fjNMmYb73CuYPn2OcePJRn8O022G78xMJRv/BrT3EDkMhuoiISBeQkWZSuezfxG19DxuwMuMUto65g1OSg1m3CGbOLCQry4tJk8pJSqry9HBFWqQmUK+pZIuJcTSyQGkV06aVsHJlBH96pBvl5edy9eyr+PNteYyI/AXLtg0YWzYwImwDMb7ZXND9Qy7o/iF8B3tLuzN3yAg2vzCMGJ9EtqXV9mlVL3UREZGjFx4eTmFhIQCxsbFs2rSJ5GRn1erevXvx9fX15PDkNzJa2Ku8Q4iu0+av5NgrNjISB2MCZtr+33aCPduhsgICg5wLlXZRCtFFREQ6ObOygry5T5FQ/CUO0+DxX6fz7K4rYa3hOiYry4u5cws8OEqRttPUAqWHV6kDTJhkZ8iQeFJT+zNx4s0882QGQwJSSX1jM90KfmJo6C/08j9AL/8DwLvwHzCKe/PwoBPJ+ySJwthkIEpV6iIiIkehf//+bN26lZEjR3LyySfz+uuvk5+fj9VqZfXq1ZxyyimeHqIcowwvL4zfTcD85SdIGubp4bQ7I7aH8052OqbdjnGU7XnMLanOO4mDMX5jT/XOQCG6iIhIJ2aWFON4+hESijdRbdiYvu4h+l46GhYZzJuXj6+vyfTpYUyaVObpoYq0i6YWKK2pUj9c3wEW+g4ZyD7/4VwwdTr/WHiAwIxf2Pz2ZsZGrmFw8K8kBO4mIXA3/AL8Ah+enMiBF4ezqzCJXWXDXOdSlbqIiEjDLrjgAvLy8gA4//zzyc/P56uvvsIwDMaMGcOVV17p4RHKscxy5S2Ypun6pOMxJTQcw88fs6wUstKhW4+jerqrH3rikLYYXYehEF1ERKSTMnOyKJv7ID65e7HbAvhi0EO8/8GpzMAZIPr6miQmVjFrVhFJSVpEVI5NTVWpH75YaU3Vep8kb0gazpVPnMXiW/Pw7pnHqr9vJ2D/esZErGFA0A4GBW9lEFvhPehuWvjf2CR4Zwj5McPwtZzcYJX64aE6qGpdRESOHbGxscTGxgJgsVi45ppruOaaazw8KpFax2SAjnPe1rheVO34FTL2H1WI7tYPfYBCdBEREelgzP27cSx6EJ/8HNLKornqy6fY8r9+ACxaFARoEVGRwx0eqDenaj0hwc6gIb5kXT2CqVPPYvHiPH4tzGfl09sYG/EjYyLWEh+wl+Ghv8DeX2DvK2w8y8rupYNI3zaYXON4vC1jXNc4vPWLqtZFRERExNNsPXtTteNXzLQDGMOO4omufujBnX6B2SNRiC4iItLJ5H67Ed8lj+LjKKEkpBfnf/p3/jrPh/LyfGbPDuW++wrYudOqRURFjlLze6sHclvaWZz11xMpT7Bzx/xSqjelMjZiDWMjfqS7XwaJrIcf1hPFclLH+1CwdDAHBwwhm+PxMsIavL56q4uIiIiIJ1i7H+e8k3F0i4uau7Y47/Qd0KX7oYNCdBERkU7F8eNXBC1ZiMVRRXbYEL4Y9BBpL8dSXu7sfw4wYEAVN95Y4uGRinRuza1SHzKkivOmBTJ16mTG/eUkviqDpx8oYWzEj4e+1hDlk4tf3lr4di0xLGHDmQFkPp/MXr/hDAw6ia+/igZg27baX83VW11ERERE2outhzNEN9MPHN0Td28HwOid0NpD6nAUoouIiHQSjlXvYr72PBbTJCX9NGZ89AgVDh8AZs8OdR2XkuLHuHGVHhqlSNfU/Cp12FPagzvmBJCQcDKfbrDyr4dyGROxhrERaxgTvpZQ70KCSr6lb8m3nHbK38n9LoTvPhjBDzkn0jfgRFI3hODr57xOQ73VQVXqIiIiItJ6rD16O+8cZYhu7qkJ0fu18og6HoXoIiIiHZzpcFC89EX8v3oLgJ9DzuPmlL8yfUYpUMmiRUHcd18BAwbYSUnx5aqrVIUu0paOpkodYGtxX6Y/Hs5xCafzxldevPVUJnee/zW9StcRXZhKuHcBk7p9yqRunwKQ+VEEX+ecyKU9TuD9JclERASpSl1ERERE2ow1rpfzTkkRZlEhRlDwEZ9jlpXWhu7HKUQXERERDzLtVZhLnsL/+88BeOLXW/n7zqsBw7WAKMDOnVZuvLGEceMqPDRSkWNXU1XqNeqG6g89MoDoyyMo51ySzw5jyYPfM8BYR/bXG4k3NxLtm8OU7h8xpftHAOx9Io7ynBFcEHcCO37shyPU2f6loSp1heoiIiIicrQsvr4QEQ05mZC+H4IGHvlJe3c4byOiMYJC2naAHYBCdBERkQ7KrCinfOFjeO/4GdPixU+Db+fvKZcwY0YRixYFMW+esw/69OlhTJpU5unhighNV6k3xG5aiRyZSLchfdgSfznnXRnIf//2LWEZP1Py00aGh6bSy/8gvfwPcmnP9+Bb2FfajYXJw9nxwhC6WfqxLes4t3Oq9YuIiIiIHC0jtjtmTiZm+n6MhCOH6Ob+3c47Pfu07cA6CIXoIiIiHZBZUYFj8cN470ilxO7H+tH3sS9opNsxvr4miYlVzJpVRFKS3UMjFZGmHClUP7y3eoXDh/DRg4BBXPSPKP6+8CBD/Dew6a1NxBRuIDlkMz390+jpnwakwFIILo/gmWHHU/bhALZmJ7Ett6/rek1VqYMCdhERERE5JKY7/PITZDSzL/qBPQAY3Y87woFdg0J0ERGRDsasrMDxzCOwJZVy/Jn6w9Os+zjZtb+mjcv06WHMmlXkFtCJSMd2eKh+pN7q8Uk24ockszfwRM6fGsHfFx4kMHMz69/YyqjwnxgW6mz/8vu4lbBtJWyD8MoQ/nX8MCo+SKIwZjBeRlijC5SqDYyIiBwLiouL+e9//8uaNWsAOOGEE7jmmmsICAho8Hi73c4rr7zCTz/9RGZmJv7+/gwZMoTLL7+c8PBw13EPPPAAmzZtcnvu2LFjmTlzZpvNRaStGN16YAJmMxcXNQ+F6ChEFxERkfZmVlZQOOcxAveux271Y0XfJ1iXksyMGc6gbdGiIGbOLCQry4tJk8pJSqry8IhFpLU01Vs9IsIZascn2SApmfmPn8HixXns6lPKwW93svaVrYwOX8eIsA2EeRcwIfZz2PE57IDU8f7sWjqYtJ0DyKsejL/X6AavrzYwIiLSVT311FPk5ORwzz33APDss8+yePFi/vKXvzR4fGVlJbt27eLCCy+kd+/eFBcX88ILLzB37lyeeOIJt2PPOOMMLr30Utdjb2/vtpuISFuK7eG8bUaIbpomHNgLgBGnEF1ERETakVlVieOZxwjc+xMldj+u+nYxP747DMBtEdGsLC/mzi3w0ChFpD001Qampko9IcHO4CEGpnUATz96Cv1nXsCe+HLeWpQG235hVPg6Rob/TIitiCH8AN/+QDTwy1kWcv7Zh4N+g7iw+/GkftIHzCi2ba/900CLlYqISFexf/9+fv75Zx599FESEhIAuOGGG7j33ns5ePAgcXFx9Z7j7+/Pfffd57btj3/8I3/961/Jzs4mMjLStd3Hx4fQ0NA2nYNIezBqQvSsNEx7FYbV1vjBOZlQUQZeVoip/99QV6QQXUREpAMwqypx/P0x2PQT1VZfrv72Ka566DguKc9n9uxQLSIqcoxrqkq9RkKCnSFDTHKuPo6pU49nyKzJrChz8PzDOYw6VKU+ImwDPfzSia7cQXTlDoYNfRd+gZx1oRzIH8ItfZNJ/6IPpVGJAA22gVGoLiIincnWrVvx9/d3BegAiYmJ+Pv7s2XLlgZD9IaUlpZiGAb+/v5u27/88ku+/PJLQkJCGDZsGBdffDF+fn6NnqeqqoqqqtpPkxqG4TreMIxGn1ezr6ljOgPNo+NxzSUsAnz8oKIMIzsDo1vPRp9jpu1z3ontjsXWRNjejtr6Z6IQXURExMPMqirKn3wC763rqMSXFfGP8cO7w7m43BmcA8TF2UlKsmsRURE54mKlNa1fEhKc/1ZsLkrk5seiSEg4gw+/9ua5uZXcN/V74so3wc5fGRKymQiffMbHfMn4mC/hZ7A7vPjgpH5kvTiQvVn9OFA+GKitulPrFxER6Szy8/MJCQmptz0kJIT8/PxmnaOyspKXXnqJk046yS1EP/nkk4mOjiY0NJR9+/bx0ksvsWfPnnpV7HW9/fbbvPHGG67Hffr0Yc6cOURFRTVrLLGxsc06rqPTPDqebt26kd7jOKp2/EpYRSl+3bo1emzR98XkA369+xHZxHGe0FY/E4XoIiIiHmRWVeH45xN4b11DWbUPV//4JN+lnADA7NmhruNSUvwYN65Ai4iKSD3Nbf0yZIiz6u3hiij6XTIKGMXEiVE882QGg0O28P0ruwjM3MzxoanE+WUwJGQLsAU+hu7Az2eGULm0HxnxfSmpTuQ4/xPA9FaVuoiIeMRrr73mFkY35PHHH290n2mazapYtdvtPPnkk5imyXXXXee278wzz3Td79WrF926deMvf/kLO3fuJD4+vsHzTZkyhcmTJ7se14whKysLu73xYhnDMIiNjSU9Pd3Zj7qT0jw6nrpzsUfGwI5fyd2ciqV3/0afU719CwDlwWGkpaW111CbdKSfidVqbfabVQ1RiC4iIuIhpr2Ksqfm4vPrjzi8vFk38mG+W3ECM2YUsWhREPPm5RMXV01Kii9XXVXi6eGKSCfRnNYvdfUdYKHfkH7s9x7E1KlXs3hxHkZ+Nh8+s4cRYes5PjSVwSG/Eu5dAHlrYe1aIoEvx0HlPwIoCO7HvQMGY1nTAzPyODIze6lKXURE2tzEiRM56aSTmjwmKiqKPXv2UFBQfz2hwsLCBivU67Lb7SxcuJCsrCz+9re/1Wvlcrg+ffrg5eVFenp6oyG6zWbD1kj7i+aEsaZpdvrQFjSPjsg0TYjp7ryftr/JeZmZB513ort1uPm31c9EIbqIiIgHmHY7jmfn4fPr95RX+7DuxIfYH3C82zG+viZJSVWMG1fhoVGKSGd3pNYvjbeBCeWD9AQm3jMC3wQ7//vZ5IXHsxkc/CuDQ35lcPCvDAjaji8lROWu5/r49fANOL6BRC9f3hzdn5jPj6M8qh8p/zqRs84IJCYGVamLiEirCQ4OJjg4+IjHJSYmUlpayvbt2+nXrx8A27Zto7S0lP79G6+0rQnQ09PTuf/++wkKCjritfbt20d1dbUWGpXO69DiombGgaaPy3RWnxvRHauVS1tSiC4iItLOTLsdx7/mwc/fUYU3166dz5crRrv2L1rk/AV9+vQwZs0qUgsXEWk1h4fqzW8DY2NDwUD+9Eg3EhJOYf78ID772EpC4E5XqD4k+FcGBm/Fn3JODF8P69cD8PEp4PiHjeruPbD59cLxfn/Ke4eT3TeOZSsTuewqu9rAiIhIm+nRowfDhg3j2Wef5U9/+hMAzz33HMcff7zboqIzZ87k8ssvZ+TIkVRXV7NgwQJ27drFXXfdhcPhcPVPDwwMxGq1kp6ezldffcXw4cMJCgpi//79LF26lD59+jBgwABPTFWkxYxu3TEB0vY12vLItNshJ9P5QCG6iIiItAXTbid//gKCt3+Lw2JjVfxDfJkymhkznEHWokVBzJxZSFaWF5MmlZOUVOXhEYvIsaI5bWBqQvVp00pYuTKCmx+Lorw8mtmzzwXAQjV9A/e4VawPDt5CkK0E9u0ihF3MSvwcPnKe7xbTwD43mupe3TGsvch4PYnigaFEnxRLZmk4y5YHKlQXEZEWu+222/jPf/7Do48+CsCIESO49tpr3Y45ePAgpaWlAOTk5LBmzRoA7rzzTrfj7r//fgYNGoTVaiU1NZWUlBTKy8uJiIjg+OOP5+KLL8ZisbTDrETaQEx3MAwoLYGifAgOq39MTiY4HODtDSHh7T5ET1GILiIi0k5MhwPzhacI3v4VFdU2/vTj/7H6fWcfx5rqc4CsLC/mzq3ft1FEpL0cqQ2Me+sXp8WL80hIsDN/fhxvr4zn7YOTADBw0Mv/AAmBu+gbsJu+gbs5c9AOgsv24l1VhHdhBmzMIIJ1PD7kHXgLHG9BmE8gp6T3wWrEUtgjjs9/6cXYc4II7xsOIeEYVv0pIyIizRMYGMhtt93W5DGvvfaa6350dLTb44ZERkby4IMPtsr4RDoKw+YNkTGQlQ5pBxoO0Q+1ciGqW7MW5+0q9JuniIhIOzBNE/O15zG/W43D8OKmn+Zw4d8Gck55PrNnhzJvXj6+vibTp4cxaVKZp4crIuKmqVD98NYvzip1XxYvzqO83GD27FD2lPZkT2lPVvE75wlSAUzCvfP5/YlbufCk7dj376dg60FG9dpJQHk6XhXFjAhLhc2psBkmAfwLHIBpGJR4heMTE44tJhIjLBLCIiEsAiP80H0F7SIiIiJHL7YHZKVjpu3D6D+43m6zJkQ/hlq5gEJ0ERGRdlH02hsEfPIeAKuPu5NVH/yOCeXO4BwgLs5OUpKdWbOKSEqyN3UqERGPa6r1S9NV6kGsXOl7aKtBbmUYL3w9ihe+HlV78jXgYymnd8B++gXs5uYLfyW0Yh8HUvMYetxB/MqyMartBNpz4EAOHNjm7N15iOu+YTirp8IinOF6YDD4B0JAEAQEYgQEYQYEUllaiFlWjukfCD6+x1RFlYiIiMjhjG49MFPXQPr+hg/IOvYWFQWF6CIiIm3OsfpDAlYtBeD+X+7gvykXAjB7dqjrmJQUP8aNK9AioiLS6bS0Sn3GjCL69bOzfbvV1dqqwuHLlqJ+bCnqxwfPnOk69/jgcm6fVcDeX0pY/FAF/3x8K9bibN75TwmXT9pLiCOT6uwcyMvBy7RDQa7za7d70A61YXtG3Y1eVggIPBS2OwN3IyAQ/ALA5g3ePs7+n7aaW2+Muo+9fQ4d534MVisYFgX0IiIi0vHF9gDAzDjQ4G5VoouIiEiry1v1NUGv/hMD2NJ3Kv9N+QMzZhSxaFEQ8+blExdXTUqKL1ddVeLpoYqItIqjrVI/++xyhgypIjXVxqJFQY1UrTutXOnrtu2b0m74+ps8viWMwX/LZty4Sjal2jh7YgQfv7WdGFsGX75bzGnDDxDkVQglJVBShFlaDCVFUFqMpawUR1EB2O1QbYfCfOfXIYeH74c70n43FgtYvMDLq/a+262l8X31trvvM4yaY+ocb1icAb63j/PLxwe8fcHbB8PH99BjH/DxdW13bbN5K/QXERE5BhmRMc7fb7IzGz7gUIhuRClEFxERkVZg/vITga/Px8BkV6/f83PPaW77fX1NkpKqGDeuwjMDFBFpY82pUj9cU1Xrh6u7bcmSQCIiiti2zYqJhWr/MA4Sxi3/iuKjj7IYMqSKjAwLy5YFcMUVJcTEODAMg27dunHw4EHMinIoKYbSIudtSRFmSTGUFkNpKVRVQFUlVDhvzapKqDy0rbLu/UO3VZVQXe0+YIfD+WWvao1vr5ujCvObc7xhcYbpAYEQGg6h4Rgh4bX3Q50LvBIaDv6BCtxFRES6ioho521uJqZpuv0/3qyuhuxDn+OLifPA4DxHIbqIiEgbMHf8iuPvj2Fx2Hn34HhuS7kXB87AqKZdwfTpYcyaVaQWLiJyzGiqSr1uwA5H01vd6fAq9dRUm2vdiZwc5x9/mZleLFgQxFlnlRMT42DjRiuXXQb33GMjMtLCsmVRzoC9v6Ne4F73MdDoPrfHlxUQHVZOVrqDN1/z4aILisFRzTtv+XL+uUVEhtvJyTJJec+HSWeXEBFaRW62ycoV3px1RgmYDj5bZeP0cSWEBleTn+vgqy9snDK2lOAgO4X5Jt9/a2X0ieXgqGbtj16ccHw5gf52igtNNvzsxdBBpQTYyinNr2T3Vjvx3YvxMSqoKq4gL6OK8KBSjMpyqoor8THKMKoPfb9NB1SUOb9ys5yb6ny/6963GzaM0HC8IsKp8I1g04EYEkcGEdgzglz/vry4IpGpV5Y3//t2NN/jFj63JcfWvn6sDBrU+m+MiIiIeER4pHNtmcpKKCqA4NDafblZzk/uWW0QGuGxIXqCQnQREZFWlr1hH4HPPoytsoLd/ifw5/UPMX1GKeAM0GfOLCQry4tJk8pJStIf3SJybDo8UG9pb/XDNValXteWLVY+/xwuusiKw4FbwH544F73MTT/2Jg4CxnFNh55KoqTJznD6AeejmL05CyiulWRlm3j7r9HMfzcLCLjqzhYYuP2f0bx0fnOY297LoqPLsgibEgV+1Nt3PjvKD66yFlZvy/VxjV/iuKjS5zHXnlLFB/9wblvT6qNS2fVVuHvSrUx8aHax5tSbUyc6HwMuO4PHljOpp+qmXpxIK+8eID+3XPZs6GAZ+dWMuPqPdhKcln/RRGjBqTjW54DJUVYzSrIy4C8DHyA4QArnEF7GHCd3Q/+3pfy6AR2vDKC/BNjiI6KIjPT1jrf4xY8tyXH1n39KEQXEZGuwrDanJ82y8+BnEz3EP3QoqJExWJYLB4Zn6coRBcREWlFZnYGtn/cj81exNq8IVy+YiFVpo1Fi2yuY7KyvJg7t8CDoxQR6fiOtrf60VapA+zb13BLmWOZ4eWFw8eXrMpIqkJNjPgoikpsvLgnisvHHgrr50fx0cPOMH7jTybXXQzLntlG34hMDm4u5K3/lnH5OfsJtR/EsXsnAZTBwY0EHNzI4mFvw1JwvOHPcREJ/LV/MsFbu2PG9AGzp4dnLyIiIgBERNWG6H0SXZvNmj7pkTEeGpjnKEQXERFpJWZhPo6F9xNoz6YwsDfTVj7J9bfaWbQI5s3Lx9fXZPr0MCZNKvP0UEVEOpW2rFIHeOcdX6KjncH8iy/6MWaMle3bnX8qffihL9u2WVm/3uZ6XOONN5z7Dj+2Jc9tq2Pb8jr7yoJ4a30w/frZ2Z5mZdGWIMomFtEvwc6GEgufv5rN7RevI7Z8K47d20kO24KtrJSA/eu5se96+AgcH0EfI4jlI5MoWtqPdN/+BHiN65Df43/+05/ExGrWrvUG4KOPfEhJ8eWkkyo48cRKBg+ufXNHRESkMzIiYjB3/IqZk4nbqid52c794ZEeGZcnGaZpHu0aNF1CVlYWVVWd+yN3NQshpaWlcYz+GKWF9BqSltJrqJZZVkrpw/fgm7WD8oBoPh76FLfe248ZM4pYtCiIxYvzSEysYsUKP1cv1WOdXj/SUnoNCVCvh3VqA21KaqrUU1NtDYbq0r6shp1+gbtIDtlEcshmkkM2kRS0DR8v97/Pyqp9WJnxO/53cCKrs8ZSZdoaOWPHMXp0BW++mePpYUgn0ZX+P2az2YiKivL0MDq1I+VUXeX1onl0PA3NxfHWi5gfvoFx2iQsl9/oOtbxnycxv/0U4/wrsJxziaeG3KAj/Uxa+u+UKtFFRERayKyqxPH0I/hm7SC7IowLVv+T3a/3ArSIqIhIWzuaKvUad95ZSM+e1Xz0kQ8ffODPGWeUER3t4OWXA7j88mLGjKli+3YrixYFMWNGEf362Vm/3sa//x3IjBnOay1aFMR11xUxdKi93rEteW5bHduRrjPt2jKGDo1k+/bTuXfRecyYUcTe+DLS1+5n52e7ufyk9fQoW084+zk3biXnxq2kzBLEW7vPxGvsqfgNTmL7Dm+PfY/PP7/EVYn+ySe+nHFGGZ984seddxZyxhnlbfAqFxERaWeR0UCd9i2HmIcq0Qk/9t40O7Y6wIuIiLSyjDSTLXcugq0bsdv8ufLHxdw+J4h58/IBuO++AqZOLWH58hyuuKLEs4MVETkG1ITqMTEOt0C9rtNPr+CCC8qYOLECgPPPL+fqq50LQF91VRkXXFDG2Wc7w9Czzy7nggvKuOiiMtfjmn0XXVTe4LEteW5bHdvRrzPlIjsnX96Tl/ZdgHXaraTf+ByTv36RnGFTICQcP0cRU3u9zR/2z+S876dyddAzDAzawtkTy9r9e3zjjaX84Q+ljBhRCeBqBfTTT95kZ3uRmmojI0N/aouISOdlhEY47xTkue/IPXbbuagSXURE5DcyTZPKZf8mofhLqg0bXwx6iF/+N4Dycmf/c4ABA6q48UaF5yIintBUlbp0cIbBhoKBZPwuiqibrmLXR5v59qnvuLjvJ3jlZROZ9wYfnfIG5ct74dj3O2whZwDtVxW3bFkACxY4P2328ssBgPsCtvr0mYiIdGqh4c7bglzXJtM0XT3RCVOILiIiIs1kfvgGcVvfw2EaTF/3EO9/MA5wX7AuJcWPceMqPTNAERFxc3io3r+/nVNPdd5GRroH7IcH7oc/PppjW/Lczj6m1riOYfEiYEQy6ePHkHfpNKIzf6Tsi8/x2vQjvrl7Md9ZRgLL+O7CQQTvPJmK5FOZNcu3Tcd0xRUl9O1r5/nnwzj11CIWLnQG6jX99/VGjYiIdGohh0L0wnzM6moMLy8oLoKqQ3/bHoMhuhYW7cS60iIG4hl6DUlLHauvoYwMCzkffEb/b+cD8MCm2wk6bzLg7JV6330FDBhgJyXFl6uuKmHwYLsnh9thHauvH2k9eg1JS+k11LmZpSWYP32H+f1q+DUVzEOLdvv5Y5x9McaZv8ewebfZ9TMzvXA4YvjmmzymTw8DYN68fFf//ejoai0kLk3qSv8GaWHRltPCop1LV5kHNDwX01GN46YLweHAMu+/GKERmHt34Hj4zxAUgteCpR4edX1aWFRERKSD+fKfv/D7vU+CBf6540r+s/syWFS7f+dOKzfeWMK4cRUeG6OIiEhXZ/gHYJx0Bpx0BmZ+LuaarzC/WgkH9mC+9QLm6hSMKVdijPwdhqX1e5QvXerPggUAYa5tdT+NppYuIiLSWRkWLwgOhfxc51dohKsf+rG4qChoYVEREZFmy8iwsOyRA5yXcT9WSzVvHTibkgnTAGfl2eLFzkVXJk0q8+AoRUREjj1GaDiWM8/F8rdFGNf82fkx89wszOcX4HjsDswtqa1+zSuvLGXtWnjppRzGjy93bV+8OI+PPsrSguIiItK51bR0ObS4qFnTD/0YXFQUFKKLiIg0264fMhm/9a9YqspJDxvB7A1/A8P5v1JfX5PExCpmzSoiKUntW0RERDzBsFiwjDkNyyP/wJhyJfj6wZ7tOP7vHqqffgQzbX+rXSsmxsHxx8O4cZVuFecJCXaGDKlSKxcREencDi0uauYfWlz0UCW6oUp0ERERaYxZmE/8+/cR6ZNHakF/TntlAVWmjUWLnAuJTZ8exooVftx+e5H+aBYREfEww9sHy6SLsTz6LMa4SWCxwPofcDxwK47l/8AszG+V66SlwYYNVrZtq+2U+vXX3tx5ZwirV/uQkaE/uUVEpHMyXJXoNSF6lvP2GFxUFNQTXUREpEkbN1p55QWDOywPE+E4wN7S7nw17DGuO8HBokUwc2YhWVleTJpUTlJS516wWkREpKsxgkMxpt6IefpkHG8ugfU/YK7+EPO71RgTL8Q48zwMH5/ffP5nn4UHH3SvyHv44RAAli8PUF90kQ6iuLiY//73v6xZswaAE044gWuuuYaAgIBGn/PMM8/w+eefu21LSEjg0UcfdT2uqqpi6dKlfP3111RWVjJ48GCuu+46IiIi2mYiIu0p5NCaH4cq0c3cY7udi0J0ERGRJix7wYfx2+4lKGobORWhXPnjU+xafZxrf1aWF3PnFnhwhCIiInIkRrceeN16L+aWVByv/xf2bMd8Zxnm5x9hnH8Fxuhxv2nx0RtugDFjnJV5qak2Zs8OZcaMIhYtCmLx4jxOOkmLjIt0BE899RQ5OTncc889ADz77LMsXryYv/zlL00+b9iwYdx8882ux1are4y2ZMkS1q5dy4wZMwgKCuLFF1/kiSeeYM6cOVjaYEFjkXZ1eDuXQz3RjWO0El3/RYuIiDTCNE1uC3uccVHfYvfyZd2Yh9lVcpwWERUREemkjP5DsPz1/zCuux3CoyAvG/O/T+KYc1dthd1R6NYNkpPtREdX4+truu0rLzfIzPQiNdWmti4iHrR//35+/vlnbrzxRhITE0lMTOSGG25g3bp1HDx4sMnnWq1WQkNDXV+BgYGufaWlpXz66adcddVVJCcn06dPH6ZPn87evXvZsGFDW09LpM0ZEdHOO9kZmDu3QE6m87Eq0UVERAQgI8PC5s1W7G8u5bTyVdgdXnwz5F5KYwYAEBdnJynJrkVERUREOiHDYsEYdSrm8WMwP3kPM+V12LkFxyN/xnLT3RgJA4/6nMuWBbBggXOdlJr1UmbPDnXtV1sXEc/ZunUr/v7+JCQkuLYlJibi7+/Pli1biIuLa/S5mzZt4rrrriMgIICkpCQuu+wyQkKcLZt27txJdXU1ycnJruPDw8Pp1asXW7duZdiwYQ2es6qqiqqq2jaQhmHg5+fnut+Ymn1NHdMZaB4dT6NziYp13qbtw/H47EMHWzBCIzrkvNv6Z6IQXURE5DDLlgWQ+cYKHhu8HIC/bPwrr3000bU/JcWPceMK9MewiIhIJ2bYvDEmXog54iQczzwKB/bgmH8Pxh+uxzh14lH9EX7FFSWMGFFBSoof8fF2V1/0xYvzSEhwVqqLiGfk5+e7gu+6QkJCyM/Pb/R5w4cPZ8yYMURGRpKZmcmrr77KQw89xBNPPIHNZiM/Px+r1epWnd6c87799tu88cYbrsd9+vRhzpw5REVFNfqcumJjY5t1XEeneXQ8h8/FjIpiv8ULHHX+H2Y6iOvRo51HdnTa6meiEF1EROSQjAwLy5YFcGHCZ/QYPBeAr8On8dr+85g3L5+4uGpSUny56qoSD49UREREWosRFYvl7nmYS57CXPMV5vJ/wN4dcNkNGDZbs84RE+MgJqaSceMqSU2tfU5Cgp0hQ7TwuEhbeO2119zC6IY8/vjjje4zTbPJN8vGjh3rut+rVy/69u3LzTffzLp16xg1alST523KlClTmDx5sutxzRiysrKw2xv/lKthGMTGxpKenn7Ea3RkmkfH0+RcwiMhO6P2cVAIaWlp7TvAZjrSz8RqtTb7zaqGKEQXERE5ZPNmG588v4dbT5mDgYOX953HwX5XAeDra5KUVMW4cVogTEREpKsxfHzh+tnQqy/m2y9ifvkx5sG9WG68CyM0olnnyMiwkJnpxbZttX9mz58fxLRpJUREOIiOriYmxtFWUxA55kycOJGTTjqpyWOioqLYs2cPBQUF9fYVFhY2WKHemLCwMKKiolwBYmhoKHa7neLiYrdq9MLCQvr379/oeWw2G7ZG3qBrThhrmmanD21B8+iIGpxLVGxtiN79OCyXXd/h59tWPxOtbiIiInLId+/l8N8T/ozVUcFnmWO5Z+PdLHoqGIDp08NYtizAwyMUERGRtmIYBpazL8Ry29/APwB2/Irjkdsxd/zarOcvWxbAxIlRTJ8e5tq2cqUvU6dGMHFilH6PEGllwcHBdO/evckvb29vEhMTKS0tZfv27a7nbtu2jdLS0ibD7sMVFRWRk5NDWJjzv/H4+Hi8vLzcFhHNy8tj7969JCYmtt5ERTzICAhy3bfc+ThG/yEeHI1nqRJdRESOaTWLiK5+v4Jby+4kzCePDJ8EUsfcg32NlZkzC8nK8mLSpHKSkvRxbBERka7OGDwCyz3zcTzzGBzci+P//opx+Y1YTjmryeddcUUJZ51VDkBqqs21sKj6oot4Vo8ePRg2bBjPPvssf/rTnwB47rnnOP74490WFZ05cyaXX345I0eOpLy8nNdee43Ro0cTGhpKVlYWL7/8MkFBQYwcORIAf39/Tj/9dJYuXUpQUBCBgYEsXbqUXr16uS02KtKZmRXlrvuGf2ATR3Z9CtFFROSYtmxZAM88aePlkXcSFr6ffaXdmPLJYjIrIgHIyvJi7tz6H/8UERGRrsuIjsNy91wc/10E677FfPFpHHt3Ylx6LYa14TYMNa1aMjO98PWt/Rh5ZqaF777zZ9KkcqBKLV1EPOC2227jP//5D48++igAI0aM4Nprr3U75uDBg5SWlgJgsVjYt28fX3zxBSUlJYSFhTFo0CBmzpyJn5+f6zlXX301Xl5eLFy4kMrKSgYPHsxdd92FxaLGD9I1WM6+CEfqGoxRp3p6KB5nmB29kU0bycrKoqqqc1cUGoZBt27dSEtL6/D9iKRj0mtIWqorvIYy0kwqn/k/4jK+pNwSyKTP/ssND4Th62syfXoYy5dnM25cpaeH2SV1hdePeJZeQ9JSeg3JkZgOB2bK65jvvgSmCf0GYrnpLozgsAZfP/PnB7FgQVCj55s1q4jbby9qr+FLB9eV/g2y2WwtWrBPjpxTdZXXi+bR8RxpLmZWOoRFYlg7di32kebR0n+n9NaYiIgckzZutHLnnSFUvLSEuIwvqai28U7cI2wv6YOvr0liYhWzZhWRlGT39FBFRETEQwyLBcvkS7Hcci/4+cP2TTgenoW5f3eDx19xRQkffZTF8uXZjB/v/Aj8jBnO0Hzx4jyuuKKkvYYuIiLSKoyo2A4foLcHhegiInJMevHFAHy//h/df30bgFkbHuDO504GnIuIrljhx+23F+kj1yIiIoIx9EQsf/0/iO0B+Tk4Fj2AmZtV77iYGAdDhlSRlGTn3HPL3PaVlxtkZnqRmmojI0N/iouIiHQm+j+3iIgcMzIyLMyfH0RGhoUrB6/kvqSFAPzc90+8lzaB++4rYOrUEpYvz1GlmIiIiLgxYntg+ctciOsF+blUP/kAjuKGW7MsWxbA9OlhACxa5GzvMnt2KBMnRjFxYhTLlgW027hFRESk5VSLLyIix4zNm20sWBDEiNCfGfvDHCyGybbu57En4WIABgyo4sYbFZ6LiIhIw4yAQCy33Y/jidlwcC/Zj9yBefM9cNjH3K+4ooQRIypISfEjPt7Oww+HAM6WLgkJdqKjqz0xfBEREfmNVIkuIiLHjJQUX+IDdjP4iwfwclSxIv1Uxv/rr0y/LfzQfj/PDlBEREQ6PCMiCstt94OvHxWpa3EsWYTpcG//FhPjYNy4SubOLeCkk2oXKE9IsDNkSJXaxYmIiHQyCtFFRKRLy8iwsHq1N3feGUKvsGxePHEGYd4FHPRNYvrPj3LPfcUsX57D1KklXHWVqtBFRETkyIyefbDcdDd4eWF+/znmO0vrHZORYSE11ca2bbVV6vPnB7F6tY/6oouIiHQyauciIiJd2rJlASxYEISPpZxXR91Pr7AD7CnpznmrnqLc4cvOndXceGMJ48ZVeHqoIiIi0olYBg0n9Lb7yF34AOaHb+IIj8IybpJrf83vIHWtXOnLypW+AMyaVcTttzfcU11Ejj1Wa/MiuuYe19FpHh1PV5lLY/No6fy6xndHRETkMBkZFpYtC2DChDL69K7EtuQJjg/bSF5lCBtPf5QHL4Lp02HSpDJPD1VEREQ6qYAzJ5O/cxuO/y3HfOk5zNAIjGGjAGdf9LPOKgcgNdXG7NmhgPqii0jDwsLCmnVcVFRUG4+kfWgeHU9XmUtbzUOfHxMRkS6pZhHRrVtt9P/l30yK/Qy7YeNPa/8Pe3h3EhOrmDWriKQku6eHKiIiIp2YMflSjFPOAtOB41/zMHduAZx90WuCcl9f03V8ebkBQGaml1q6iEizlZWVcdddd1FW1rmLgDSPjqerzKWt56H/Y4uISJeUkuL8qPQP81YxYN/rAPz5p/v5IW8406eHsWKFH7ffXqSFvURERKRFDMPAmHoTDB4BlZU4nn4EM/Mg4GzpMnFiFNOn11aYzp4dysSJUUycGMWyZQGeGraIdDKmabJr1y5M0zzywR2Y5tHxdJW5tPU8FKKLiEiXsXGjlTvvDGH1am/i4+2cHvUVDw+eB8DcLTfR55KxTJ1awvLlOVxxhRYRFRERkdZheHlhueFO6NUXigpwLHoQs6iAK64o4aOPsli+PJvx452tXWbMcPZBX7w4T7+PiIiIdBLqiS4iIl3Giy8GsHy582tQ8K+8MfpuLDh4Zd+5PL3jGqZmlTJ3boGnhykiIiJdkOHrh+W2v+F4fDZkpuF4+hGiZz1CTIwPABERRaxc6Uu/fs5WcgkJdn0iTkREpJNQJbqIiHQZkyY5K7z+NXcLb50+gwBrGelhx+N/3U2AoUVERUREpE0ZIWFYZjwA/oGwcwvm688DzgXPt21z1rBt3+68nT8/iNWrfUhNtak3uogckc1m46KLLsJms3l6KC2ieXQ8XWUubT0Pw+zsDW9+o6ysLKqqqjw9jBYxDINu3bqRlpbW6fsWiWfoNSQt1RFeQxkZFjZvtpKS4kd8vJ2Fj3vxzZQ/Elqyiy1F8eRcM4/EoT4sWxbAFVeUqOKrA+kIrx/p3PQakpbSa0haoqnXj7npZxwL/waA5Y5HWfD+WBYsCGr0XLNmFXH77UVtOl7peLrSv0E2m42oqChPD0NEpM2onYuIiHRqy5YFuP4otRp2/nPCnwkt2UVmeQTTflzEuF7BzD2rQH+YioiISLsxBg7D+N0EzC9W4HhhMVfc1J+zznJ+Yi411cbs2aGAsy96QoKd6OhqD45WREREjkSfGRMRkU4pI8PC/PlBTJhQxuLFeYDJO5c+zLiob7FbfDlw/oOMuzCYq67Sgl0iIiLS/owLp0FYJGSlE/XtUldQ7utbW3GcmWlh6VJ/Nm9WSxcREZGOTP+XFhGRTmnzZhsLFgSxdauN8nKDm+JfILnwA6pNC2uG/ZWeJ/dm7twCBg+2e3qoIiIicgwy/AOwXHkzAOaq91j1rz1MnBjF9OlhrmMefjiE5csDmDo1gmXLAjw1VBERETkChegiItIppaT4AjB9ehifz/+Ruwc8DcCDm2ZxySOT9IeoiIiIeJwx5ASM0aeB6eCi0idY8f4Bli/PZvx4Z2uXGTOc7eYWL87jiiv06TkREZGOSj3RRUSk06i7iGhUlPMj0U9c/z2XHPgbmLAu9AKqTv49yx/LISmpcy8eLSIiIl2D8YfrMDf9hDVrHwP3LCdrzFWce24ZK1f6uo4pLzfIzPQiM9OL6OhqLYQuIm5WrFjBu+++S35+Pj169GDatGkkJSV5eliNeu2113jjjTfctoWEhPCvf/0LANM0ef311/nkk08oLi4mISGBa6+9lp49e3piuG42bdrEu+++y65du8jLy+OOO+5g5MiRrv3NGXtVVRVLly7l66+/prKyksGDB3PdddcRERHRYebxzDPP8Pnnn7s9JyEhgUcffbRDzePtt9/mhx9+4MCBA3h7e5OYmMgVV1xBXFyc65j2+pmoEl1ERDqNZcsCmDo1kuXLA3jyyWC6+6Yxfsd9WM0qVmacwhvcyty5BYwbV6E/PkVERKRDMAKCsFx+IwDmh2+w4t8HXS1dFi1yLo4+e3YoEydGMXFilD5NJyJuvvnmG5YsWcIFF1zAnDlzSEpK4rHHHiM7O9vTQ2tSz549ee6551xf8+fPd+373//+xwcffMA111zD448/TmhoKI888ghlZWUeHLFTRUUFvXv35pprrmlwf3PGvmTJEn744QdmzJjBQw89RHl5OU888QQOR/v9jXqkeQAMGzbM7Wd09913u+3vCPPYtGkTEyZM4NFHH+Xee+/F4XDwyCOPUF5e7jqmvX4mCtFFRKTTuOKKkkOLiMId0zP4zwl/Jsonl4KgeKb//Chnn1Pp4RGKiIiI1GeMGAsjxoLDwaUVT/DS0nSmTi3hvvsKXMcsXpzHRx9lqa2LiLh5//33Of300znjjDNcVeiRkZF8/PHHnh5akywWC6Ghoa6v4OBgwFk1nJKSwpQpUxg1ahS9evXilltuoaKigq+++srDo4bhw4fzhz/8gVGjRtXb15yxl5aW8umnn3LVVVeRnJxMnz59mD59Onv37mXDhg0dYh41rFar288oMDDQta+jzOOee+5h3Lhx9OzZk969e3PzzTeTnZ3Nzp07gfb9mShEFxGRDm/jRit33hnC5s1WyssNLFRzTtrDJAVvp9wnnMyL7+fGGdUkJWkRUREREemYLJffAAFBWNN2ckrZK8ydW8BJJ9UWACQk2BkypEqfphMRF7vdzs6dOxk6dKjb9uTkZLZs2eKhUTVPeno6N9xwA7fccgtPPvkkGRkZAGRmZpKfn+82J5vNxsCBAzv8nJoz9p07d1JdXU1ycrLrmPDwcHr16sXWrVvbfcxN2bRpE9dddx0zZszgn//8JwUFtW/sdtR5lJaWArgC//b8magnuoiIdHgvvhjA8uXOL4D7khbQt/Q7yqt9uPjTBZzRpxe3317k4VGKiIiINM4IDnP2R39+IY73XmFbwMlsy+3r2j9/fhDTppUQEeFQX3QRAaCwsBCHw0FISIjb9pCQEPLz8z0zqGZISEjglltuIS4ujvz8fN566y3uvfdeFixY4Bp3Q3Pq6C1qmjP2/Px8rFarW1V3zTEd6Wc2fPhwxowZQ2RkJJmZmbz66qs89NBDPPHEE9hstg45D9M0eeGFFxgwYAC9evUC2vdnohBdREQ6pIwMC8uWBXDFFSVMmlTO8uUBLF6cR/cdH3DC1pcAeCv4L9z5924kJeljzyIiItLxGaPGYf7wJUbqGgqefoYZ3/7btW/lSl/XYqOzZhWpQEBEXAzDaNa2jmL48OGu+7169SIxMZHp06fz+eefk5CQANQfv2ma7TrGlvgtY+9o8xs7dqzrfq9evejbty8333wz69ata7IFjCfn8fzzz7N3714eeuihevva42eidi4iItIhbd5sY8GCIL7+2oeDB70ACDm4juO3PQXA7uSruPLJEVpEVERERDoNwzCwXHEzDh9/RoSl8t3jzzNvXr5rv/qii0hdwcHBWCyWetWyBQUF9SpvOzJfX1969epFWloaoaGhAPXmVFhY2OHn1Jyxh4aGYrfbKS4urndMzfM7orCwMKKiokhLSwM63jz+8//s3Xd4VGXax/HvmUx6I6RM6CRSDBgECxYsiAKRRRS7Jq5Ydi0Y2QVx11V3dXV1kRXlRVe3oKABG4oiIl1URMWyCgpi6C1MCmmEtMmc94+TGUACBFJmkvw+18U1M6fN/TCH5HDPfe7npZf45ptv+Mtf/kJsbKx3eXN+Jkqii4iIX1qwwKrEysyMYeLEdpwUvpUBXz+GzXTzzq5L+df2I88yLiIiIuKvjPZxBFx7CwAJn8+kHXnedRUVViVdbm4ATqf+uy7S1tntdpKTkw+b/HDNmjX07t3bR1Edv+rqanbt2kVMTAwJCQm0a9fukDG5XC7WrVvn92OqT+zJyckEBAQcsk1hYSHbt2+nV69ezR5zfZWWllJQUEBMTAzgP+MwTZPp06fz5Zdf8uc//5mEhIRD1jfnZ6J2LiIi4jecThvr19tZsCCU+PgaAMaNKyW0ppgRa39HdOA+iuP78m278fz65v0+jlZERETkxBjnD2PXnBV0LP+R/JlvAg8CMHFiO+82aukiIgAjR45k2rRpJCcn06tXL5YuXUp+fj5Dhw71dWhH9Morr3DGGWcQFxdHcXExb7/9NuXl5Vx44YUYhsGIESOYO3cuHTp0IDExkblz5xIcHMx5553n69CpqKhgz5493te5ubls3bqViIgI4uLijhl7WFgYQ4YM4dVXXyUyMpKIiAheffVVunbtesjElr4cR0REBG+++SZnn3027dq1Iy8vj9dee43IyEgGDhzoV+OYPn06K1eu5P777yc0NNRbcR4WFkZQUFC9zqfGGoth+ltTnmaSl5dHdXW1r8NoEMMw6NChAzk5OX7XW0laBp1D0lCNfQ49/XQkU6ZEHrIsyFbFrIFjOav9/9hr60DcP57CiPTv2/ykfvQzSBpK55A0lM4haYiGnj8FX66n3X//gGnYeLAqi6wlvRg3rpSpUyOZNq2QQYPUsq61a00/gwIDA4mPj/d1GK3WokWLmDdvHoWFhXTp0oWbb76ZPn36+DqsI3r22WdZv349JSUlREVF0bNnT66//no6d+4MWNXFb731FkuXLqWsrIwePXpw2223eSeL9KUff/yRRx999LDlF154IWPHjq1X7FVVVWRlZbFy5Uqqqqo45ZRTuP3224mLi/OLcfzmN79h8uTJbNmyhbKyMmJiYujbty/XXXfdITH6wziuvfbaOpfffffdDB48GKjf+dQYY1ESvQVrTb9wxTd0DklDNdY55JlEdPjwcn7+OZDMzJja/0RG8PGtD5K0ZzEl1eFkX/E0A6/o2IgjEF/SzyBpKJ1D0lA6h6QhGuP8qXnucfh+NSUnDeKUaVOZNq2QzMwYFi7MIzW1Zf9/VY6tNf0MUhJdRFo7NVkTERGf80wi+vPPgd5eoAB3Jc8kac9iTMPGsqQ/0+2czj6MUkRERKRx2UbfhGnYiNr0Gf2jf2DjRqvj6tNPR7JiRTBr1waqN7qIiIgfUE90ERHxuYMnEfVY99o3TD/jOQA+SriHq/+SAuiWZhEREWk9jE7dWBc1jL7FC/njydO4fuqLACxZEsKSJdb1kXqji4iI+J6+0hYREZ/44Qc7998fzYoVQSQnuwBrEtFx40rpFbGJF858GIDdvS6jX+YwX4YqIiIi0mQ6/OZa3AGBnBv7Da/+cYl3+bRphSxcmEdGRpkPoxMRERFQJbqIiPjIK6+EM2uW9cdj6tRIou0lzBt0H0FmOfROpfPvbsGwqwJdREREWqf43nGUnj2SsM/m0n/LfzG4BBObt8Vdbm4AgCYZFRER8SFVoouIiE+MGFEBWFVWkycXAfCPpwpYduNEksJ3UBGegO2OP2DY9X2viIiItG6v5N5McXUE0aWbubzjIgAmTmxHWlo8aWnxZGWFH+MIIiIi0pSUmRARkWbjdNpYv97OggWh3hYuFRUGISEmAOc4/0NC/jdUG8GUj3mI8MgoX4YrIiIi0iyuvtlOxQdXE/35DB4+9Z8s2HMxVe4gpk0rpGdPFwkJNb4OUUREpE1TEl1ERJpNVlY4U6ZEHrJs4sR2AFzecSFd1s8BIOg39xLXv3szRyciIiLiGw6HGzP9V7jXzSO+OIf0Lu/w8rbr6dnTRWpqta/DExERafPUzkVERJqc02nj6acjGT68nGnTCgFrElGAyZOLeHfaF0zp/1cAjEuvwnbm+T6LVURERMQXcotC2X16OgD39vgvEfZ9fPZZUO1E7ME4nfrvu4iIiK/ot7CIiDS59esDmTIlkp9/DvROkuURZezl1FWPEkgVnHI6xhUZPopSRERExHeyssIZNDGdTfu6EhtcxG+TZvHYY9HMmhVOenqs+qKLiIj4kNq5iIhIk1uwIASAzMwY77KpUyMJNKppP+dJAtrngaMTtt9MwLAF+CpMEREREZ/JyChj2LAKgjbeBAv+xm+SsggelsaTz3dj2rRCBg2q9HWIIiIibZaS6CIi0iR++MHOK6+EM2JEuXcSUU8Ll6lTI/nd70o4d9tUzqr8H+7gMOxjH8QIi/BlyCIiIiI+43C4cTjcOOPPpvCzk4kp/omzCmcBf2LevFDat3eTm+smIaEGh8Pt63BFRETaFCXRRUSkSbzySjizZll/PKZOPTCpaPedCzi78j0wDOy/mYDRobMvwhQRERHxK1mzIvhqyT3MGngPKQUfEBN4N0uWtGPJEuvOvvHjS5kwodTHUYqIiLQt6okuIiJNYsSICgCmTStk8uQiwJpEdNq0Qs6I+Y4rKp4FwLg8HePUM30UpYiIiIh/ycgo485nT2JnQG9CAyq5pfvrgHVNtXBhHhkZZT6OUEREpO1REl1ERBqN02ljxYog7r8/mp9+sm52qqgwCAkxAejY0cX5qbt49byJ2NwuOP1cjBHX+DJkEREREb/icLhJ6VODOfxqAMZ0e5PwgDLv5Oy5uQE4nfqvvIiISHNSOxcREWk0WVnhTJkSeciyiRPbeZ8v/CCQ82P/DjWF0KkbtjHjMAyjmaMUERER8W9ZWeE8O2UUyy54lZMitnNj17lMnJjhXa+WLiKNb926dcybN48tW7ZQWFjIfffdx8CBA4+4/ZdffsnixYvZunUrLpeLzp07c80119C/f//mC1pEmo2+vhYRkQZzOm08/XQkw4eXM21aIXBgEtHJk4uYNauA9PQyxidNg00/QWg4trv/hBES6suwRURERPxSRkYZCxbupeaSqwD4TdIsgmxVauki0oQqKyvp3r07t956a722X79+Pf369eOBBx7g73//O3379mXSpEls2bKliSMVEV9QJbqIiDTYunV2pkyJJCnJ5b3V2CMkxCQlpZoLoz7C/cK7ANhuGYeR0MEHkYqIiIj4P4fDjcPhxkw5j8q1r5BIHld2XEDPnoNITa32dXgirdKAAQMYMGBAvbcfM2bMIa9vvPFGvv76a7755huSkpIaOToR8bUWlUSfO3cuq1evZteuXQQFBdGrVy8yMjLo2LGjr0MTEWnTFiwIASAzM8a7bOrUSO+yR+/5iVty/g8AY9gVGAPObv4gRURERFoQp9NGbm4YNV2uIfWnF7nzpFdYvvICXn01jBEjKkhJqcbhcPs6TBGp5Xa7KS8vJyIiwtehiEgTaFFJ9HXr1jF8+HBOOukkampqeP3113n88ceZMmUKISEhvg5PRKRNcTptfP55MNOnw+mnWxOHelq4TJ0aye9+V0JeXgAjhxVz1id/hvL90CMFY/SvfRm2iIiISIvgmWsmLOBGPr/oNZLDtzP5v9/ywZ5LmDUrXH3RRfzM/Pnzqays5JxzzjnqdtXV1VRXH7ijxDAMQkNDKSwsxOVyHXE/wzCIi4sjPz8f0zQbLe7mpnH4l7Y0DrvdTkxMTJ3r6qNFJdEffPDBQ17ffffd3H777WzevJk+ffr4KCoRkbbp4ElEv/3WqrbwVJ8D5OUF8NRTxbhfeQ4zZzNERmP77f0Y9hb1q0dERETEJzIyyhg2rAKAXfNGEbP1VR45ZzofzL2YadOKGDSo0scRiojHypUreeutt5g4cSLR0dFH3Xbu3LnMmTPH+zopKYlJkybVO7kXFxfXoFj9hcbhXzSOY2vRmYz9+/cD6FYZEREfyMgow243eeqpKG64oYzXXgtn8uQiQkJMMjNjGDGiHPeq5ZifLgbDwHb7BIyYWF+HLSIiItIiePqiO502Vp90Bckb38JBNufHfUlFxcnk5gaQmxtAQkKN2rqI+NCqVat48cUXGT9+PP369Tvm9qNHj2bkyJHe14ZhzSmVl5d3zEr0xMRE9uzZ0+IrhjUO/9GWxmG324mPjz/h92ixSXTTNJk5cyYnn3wyXbt2PeJ2R7pNxvO8JfPE39LHIb6jc0hOxA8/2Pnqq0BWrgwmIMBalpdn8z4OGFDN+PGlpMZuwnzxnwDYLrsBW9/6T9IjbYN+BklD6RyShtI5JA3RXOePdfdfIn9OGc3tSa9xd/IMbpj4onf9+PGl3HffviaNQZqGfga1fCtXruSFF15g3LhxnHbaafXaJzAwkMDAwDrX1SeJaZpmi052emgc/kXjOLYWm0SfPn0627dv569//etRtzvSbTIN+ebB3yQmJvo6BGnhdA7J8bjhBvj440OXLV1qfTn51FNRXHghLF9QhvP3T+GqqiJ4wFnE3z4Ow5NxF/kF/QyShtI5JA2lc0gaoqnPn/vug2HDYOmb6dQ432JQ3Nf0j/6B+54/hZQU6NAhkg4dIo99IPFb+hnkHyoqKtizZ4/3dW5uLlu3biUiIoK4uDhmz57N3r17ueeeewArgf78888zZswYevXqRVFREQBBQUGEhYX5Yggi0oRaZBL9pZde4ptvvuHRRx8lNvborQFO9DaZlqC13HIhvqNzSE7Egw/aOeusYJ56KopLLqlg6dIQRo7cT02NwaBBlQw8s4rdk/+OuXMbxMTi+nUme3JzfR22+CH9DJKG0jkkDaVzSBqiOc+ffv2sP3lTLiJm3RLuPmkGcXF/oEMH6/+0OTlN+vbSRFrTz6CGtknwB5s2beLRRx/1vn7llVcAuPDCCxk7diyFhYXk5+d71y9dupSamhqmT5/O9OnTvcs924tI69KikuimafLSSy+xevVqHnnkERISEo65T0Nvk2kJWsstF+I7OoekPpxOG7m5VjV5fLy79rEGgD59XFx//X4cDjfujxZgrv4EbDZsv50IEVE6v+So9DNIGkrnkDSUziFpiOY4fzzXYTmx13ORuZS0xBW8tfQmXn21ByNGVJCSUq2+6C2Yfgb5h759+/Lmm28ecf0vE+OPPPJIE0ckIv7E5usAjsf06dP59NNPGTduHKGhoRQVFVFUVERVVZWvQxMRafWyssJJS4snLS2eiRPbAfDaa+GA1cYlKyscc2s25pv/BcC4agxGjz6+CldERESk1fBch93ywKksdA4GwLXwfWbNCic9PZasrHDfBigiIn7PrKzErKnB3LUN98xpuJe97+uQWpQWVYm+ePFi4PBv++6++24GDx7c/AGJiLQhGRllJCW5yMyMYdy4UqZOjeR3vyvhk0+iuPXWvQwasBf3i5PA5YIBZ2MMvdzXIYuIiIi0ChkZZQwbVgFAzqej4H8fcXW3Bfx9wz38dYrJoEGVPo5QRORw5o4tuOe9hhEUhLlnJ8YpZ2A7YxBmE8wDYLpcmF+ugOpq2LkFo/9ZGKec3ujv469M04TvV4OrGjNvD7SPx0jsBO3jMdd9B5t+wly1HCrLD9nPXV0Nt97jm6BbmBaVRD/abTUiItK0HA43PXtafTd79LAe09IqeeYZ2L27AveL0zALciE+EduYe71zUIiIiIhIwzgcbhwON06njWxHX9YWn0xq9E/c2HUu8+bdQPv2bnJz3SQk1Kiti4j4nJm3B/fsF+HH78B042lWZG7fTM2CN8nrPxDzt/dDYFDjvJ9pYmY9j/nZsgPLPl4IvVOxjbgGo0//hr+HuwZ++BZzz04rKV2+n93Fe6lxm+CqhuAQsNkgJAwCAiA0HAICMCIiITgU4h0YnbtDl2SMyOgGx+ONq6oSc95rmD98A7u2HbruaDuedDJs+gn3OzMpT+0PnU9qtJhaqxaVRBcRkebn6cFZUGAwY0YEABs3Wr8+srPt9OsH5qrlmN98BgEB2H4zESMswpchi4iIiLRKWVnhTJkSyVWdrueZUx/h113fYtDSm1iyJBaA8eNLmTCh1MdRikhLYTp3w56d0KMPRviB/8OZpom5+hPMTxZinHoWxjkX1Tvxa7qqrTuUt2+yFiR0wOidCpWVmNs2gnMXld+thr/cg+3X92Cc3K9hY9hXgvufT0D2OmtBYmeorIDCfNiwFvemn7BNeOyEW42alZWYS9/D/HYVbN98yLqag1+UFte9/y+fB4diDDgLY+CFGKkNq5Q395XgnjkNvvvywMLgEAgNg/37wNP+2jAg5VSM1DMwOnWDdu0xOnTBPesFzBUfUjjtb/Dkf8BoUV2/m52S6CIiclSe/6wdbOpU63VmZgyVO3dy7c//AsC47AaMpJ7NHqOIiIhIW5CRUcbpp1ey6INB7N8XQ4fQXC5NXM6wP51Jz54uEhJqjn0QERHA/ckizKx/gmdS24hIjAHnYFx9C+Y3n2G+8hwA5s8/Yr71Esbw0da8V0e549isrMD9wpNWAj0sHNsdf7CStwfvk/0j5r+ewp23B/eLk7D9eSpG+7gTHof5/utWAj0oGCP9LmznDrFam2zdiPvN6bBxHe5/PITx67HYzr34+I7trsH976dgzVcHFiZ0xOh2EsQn0q77SRQXF2EGBUPZPjDdUFYGmFYS2+3GLC2GinLIzYGCXKgsx/xiBeYXK+C0c7BdfBlGr1OOf9z5Ttx/mwD7SqyK90suxxh0CUaHztZ604SaGsxvV2EkdMDofvj/041rb8f8aiU1BXnYNvzQ4C80Wjsl0UVE5Kg8PTizs+1kZsYAMHlyEamp1eCuoc+Ch62+aj37YFx6lY+jFREREWm9rFYtLmJjTbYvGMnJG1/llu6vs6liIAC5uQEHbSciUjczdzfmG/85kEAH2FeK+elizO2bIS/HWhbnAHcN7M3HXDQXYuIxLh555ON+OAd+/B8EBWO74/4626gYvU4h8aV57Bp/C2zbiPu1fxMw9k8nNo69eZifLATANvZB7/sZhgFJPbGN+wvu6c/Ad19gznoBs0cfjIQO9T/+6k+tBHpAAMbgERjnD8fo1NX7HhEdOlCak2MlrOtzPFc15qplmP/7En74Br79HPf3X2Hc9nuMM847rpao5pwZVgLd0Qlb+p0YKacest4wDLDbMQZecMRjGIGBGKefi/nJIszVnyiJfgyq0xcRkSNyOm2sX2/n1VfDyM098CsjJMS6SOi+bjZsXguh4dhuG49hC/BVqCIiIiJtQlZWOGlp8aS/mE6V284ZMWt49fFdpKXFk5YWT1ZWuK9DFBE/Zy6ZZ7X6OLkftuffwvb7RzHG3AshobBtI+wvg4gobI88R8CklzCuucXa771ZmPtK6j5mRTnmRwsAsN0yDqPPgCO+vy0klIBbf2e1GfnuC8xtm45/DKaJ+9XnweWCXqfAL5LIAEZIKLa7H4CT+0FVlVWZfjzvsXKJdZwR12K7/jfeBPqJMuyB2C5Iw3bvn7H9/lEr5hoX5r8n437hSUx3/b4ANb/93GqnahjY7rz/sAT6ccV05vkHjunW3UxHoyS6iIgcUVZWOOnpccyaFc5jjx3ogZeZGcOD1+8mZPnrANhuuhsjNsFXYYqIiIi0GRkZZSxcmMezL8PXWK0Jbu3+OtOmFbJwYR4ZGWU+jlBE/JlZU2MlYAHb8CsxgoIx+gzANugSbL+dCFHtwGbDuPxGjOBgAIxLLofOSVBehvnav+tM9pqrP7FamDg6wWnnHDMOo1M3b5W0e/oUzL35xzeQ/30OP3wL9kBsGXcdsYrbMAxs6XdaCfvvV2Pu2Vmvw5vO3bBhLRgGxnmXHF9sx2AYhvV3fu+frbu57YHwvy8w35t9zKp2c28+7peesY5z8SiMzkkNi6XXKRjhkVBWCluyG3Ss1k5JdBEROaKMjDKmTSsEYNw4a5KqoUMreH3Gdt5I+xM23IQNGYHtKLeIiYiIiEjjcTjcpKZWM3hwFYk3/gqAkR2WkNIxl9TUarVyEZGj+2mNNQlmRJRVoX0QI/UMAp5+BdsL72AbPOLAcpsN2/W3g81mTTj6btbhx133nbXt2RfW+w5lY/RN0C4Wcnbg/ucTmDX1r4R2f7bMOsbFl2F06HL090nsDP3OBMBc8l69jm8uftd6csrpGO3j6x3X8TDsgdiuvBnjxjus91zwJubM/ztqIt38ZKE1cWpSL4yrbm54DAEBhJx2tnXsH75p8PFaMyXRRUTkME6njbVrA8nNDaCi4tBv9EeNKue0n6cRVOKEOAcxd93voyhFRERE2ibPtdra4hS+2nsqQTYX+xZ8yP33R7NiRTBOp/6rLyJ1M1d/AoBxxiAMe91TJRq2w3+GGL1TMW79vXWMhe9gbtt44JhuN+aGtdZ2J9e/tYgRm4DtD3+HsHDYtvFA4vpYYygthh+/tY4xqH6ThdqGjbb2/XQJ5o4tRz9+UQHmqqXWfmlX1uv4DWE7fxjGjXdCQADmZ8swP/+o7rhc1ZifLrb2GXbFET+/4xV6+rnW8dcqiX40+s0qIiKH8fTaTEuLZ+LEdgBMnRoJwJInviTku4/AsBFw+wRsYRE+jFRERESk7fFcq2VmxvDS1hsA6Lr1A+a8Zic9PVZ90UXaKNPlwvzhG8zc3XWvr67G/N/nwIFe2MfDdtaF1n6mG/ebLx1YsXubNcllcAh073lcxzTiHBjX3W7F994s3F99iuncffRq7DVfQU0NdD3pmFXo3vfp1Rfj9EFW7G/896jbml+ssHqtn3QyRq9T6j2WhrBdNALjMuvnufnWS5gV5Ydv9PMPUFJktdzpf3ajvXdwf6tKnx2bMasqG+24rY2S6CIicpi62rg8/HAxY6/fxLMDnwTAGHktRo8Un8UoIiIi0lZ5+qIvXJjHRb8fwK5yB3HBhVzWYTHTphWqL7pIG2RWV+H+5xO4pz6K+8E7cb/+n8MT0T9+A+X7rRYqPfqc0PsYV98Cdjv8/APmzz9Y7529zlrZI+WEqqONsy+Czt0PTLL50J24770e97tZdU92uekna7++/Y/vfa65FQLssGEt5oYfjrid+bXVM944Z8hxHb+hjLSrIKED7CvxTtJ6SFwbfrS26zOg0arQAQLiHFZ7H7cbdm9vtOO2Nkqii4jIYRwONz17ugDo0cN6HHROOX9wPIq9ugySe2P86jpfhigiIiLSZnn6oick1BAcZuOVbdcAcGv316goh9zcANauDVRbF5E2xFz0Dqz9+sDrZe/jfvAOq2rbs2zjegCM/gPrbNlSH0b7OIxB1kSb7unPYOY7IcearNPoknxix7TZsF1zKwQEWK1dAgKgohzzgzcxZ/3rsO3NzRus/ZJ7H9/7xMZjnD/Uin3Bm3VuY+bmwLaNYNgw6jFBamMyAgK8/8825792SMscADO7NvHfq2/jvq9heD+7Y7W6acv0G1VERLycThsrVgRx//3RfPZZEAAbN9Z+w734HcheB8Gh2G4bjxFQv8liRERERKRpZGWFk5kZw+wdoymvCeaU6J9568kt3rZ8ausi0jaYpom5ajkAxph7MW7OBHsg5O3B/dzfML9eaW2Xm2PtkFi/FihHYlyeDomdYG8e7n89hZmzw1rh6Hjix+zTH9vU17E9MwvbtDcwfn0PGAbmJwsxvz/oi4CK/QeqpZOOL4kOYAy/EgwbrPvuQNwH8fR2p2cKRmT0CY2lIYyzL4RTToOqKtwv/N3b1sWsroItP1vbNEWLma5J1uOOzY1/7FZCSXQREfHKygonPT2OWbPCeewx64Jh6tRI+kX/SM+fZgJg3PhbjIQOvgxTRERERLDausyalc/Ia+1sdViVobcmvca0aYUsXJinti4ibcWm9ZC3B4JDMc44D9t5Q7E9/YrVjsR0437lecy9eVCbRG/o/+eMyGhsv/8rhIbD1mz4aY21PLFTw44bHIxhs2EEBlmTbQ69HAD3G//BdFl3SLMlG0wTYhMwomOO/z3iHHCq1QPcXPb+4Rtst5LIRvdeJzaIBjJsAdh+ez/EJkBBLua82QficrkgOsZq+dLY79tVlejHoiS6iIh41dUL/em/5/L2yIcItNVQecr5zd4XTkRERETq5nC4GTy4iqeeKiZo+GUADHd8TEpiDqmp1Tgcbh9HKCLNwfxuNQDGgLMxgkOs52HhVkV6Ui8oL8P9xnTIq61Eb4QkrNE+HmN0xqELHQ1Loh/2HqNuhMhoyNuD+blVaW/u2mat7HbSCR/Xdsko61grl2DWtqLxMD2V2F1PrDVNYzBCw7Cl32nF89EHmHvzMZ27rJUdu2IYRuO/Z+faSvRd2446qWtbpiS6iIjgdNpYuzaQ9evtzJsXesi6U3e+QnDhDoiOIfT2O5vkF7aIiIiInBjPddwPe09iVcHpBBhuNvx3GStWBKsvukgbYW7fZD35Ra9sIyAAW21bFL5dBVVVYLNBbHyjvK8x8IJDF0RENcpxvccPDsEYcTUA5vzXMaurId9prYs/8S8CjN6p0O9MqKnB/dZL3uWmuwZqK7ENHybRAYzUM6BnH3C5MBfPPXAXQQPGfVQJHazzpHw/7Ctpmvdo4fTbVEREyMoKJy0tnvT0OJYssSoXrDYu60je+BYAtoy7MMIjfRmmiIiIiPyC5zouMzOGrG1Wsums6vmMyYhSX3SRNsA0TdhmJdGNrodXZxudux96N3FsAoY9sFHe+5f/P2ySCukLL4V2sbA3H/OTRQf6uickNui41kSmdlj7Nebab6yFzhyoqoSg4Ab1d28sNs8ko58uwtz0k7XQ0TRJdCMwCGLirBeev2M5hJLoIiJCRkYZCxfmeVu5APzlwTz+e/5fsNtqqOh3IUb/s30YoYiIiIjUxXMdt3BhHhf9vj+5FbEkhBTw+gMfqC+6SFtQkAv791kJ4Y5d69zEuPxGa6JRgEauZDauucV6HDyiUY/rPX5gEMavrgHAXPg27LHarxhxDUuiG4mdMIb8CgD3OzOtLyN217aK6dQNwxbQoOM3ij79oXtP6w4CT9/5ppyfrPbYpnN3071HC6YkuohIG+d02sjNtS4QKioOVA4MKp1FonsL7vBowsb8xlfhiYiIiMhROBxuEhJqAAgKszN7x2gAOm18n1dfDWP9erV0EWnVPK1cOnXDCKy7wtxoH48x1OoDbnTv0ahvbwy9AtvEJzGuurlRj3vIewwaCu3aQ1GBNYEqQHzDkugAxq+uheBQ2LkVfvgWsyDPWh7naPCxG4NhGNh+de2hC+ObrkLem6DPUyV6XfSbVESkjfPcApyWFs/Eie0A6BO5gZN+fg2AD6N/hxHZuL3tRERERKTxHNzS5bUdV1Bj2ui473tWv+ckPT1WLV1EWjFzx1YAjC5JR93OuOImbOMfwxhx7VG3O16GYWD06osREnrsjU/0PQIDMYaNPrAgIADaN7yvuxEeiXHBMADci96BvVYSvTGO3Wj6nWlNrurRwDY2R+VJoqudS52URBcRaeMyMsq8bVzGjSvFbrj493mPEGiroeSkQZx195k+jlBEREREjsbT0mXWrHxOOb8dS5zWZH8ZXd9m2rRCtXQRqYd169bx97//nTvuuINrr72W1atX12ufP/zhD6Snp3PPPfewePHiZoj0F2on2jxWD2/DZsNIORUjOLgZgmp8xvnDIKK2B3v7eIyAxmm3YlwyCgwbbFiL+eP/rIWNNPFqYzBsNoyhVxx4HRjUdO+VYJ1DppLodVISXUSkjXM43PTs6QKgRw8XdyXPoKuRDeGRtLv7tzgcbh9HKCIiIiJH43C4SU2tJiXFxahR5by63Zpg9KpO83HtqyA3N4C1a9XWReRoKisr6d69O7feemu9ts/NzeXJJ58kJSWFSZMmMXr0aF5++WW++OKLJo70UObeXOuJP1VPNwEjJBTj4susF0fo/X5Cx20fD6cOtF54+q17Jtj0E8awKzCuyMA27pGmfSNPixwl0etk93UAIiLiG06njfXr7SxYEEpyspVEL/xxB+N6/heA0kt/S7uoGF+GKCIiIiLHISsrnClTIjEYyJayLiSF72D1P7/g97V90sePL2XChFIfRyninwYMGMCAAQPqvf3ixYuJi4tjzJgxAHTu3JlNmzbx/vvvc/bZZzdRlHXw9PGOTWi+9/QRI+0qCI/E6FP/z6k+bBcMw/3dQV9++NkXEkZAgNW/val5xr1/H2ZlBUZwSNO/ZwuiJLqISBvl+U+WR4Dhov+afxDUzsUS5/n8uPZXTBi+z4cRioiIiMjxyMgo4/TTK1mwIBRn+K9I2vkiN3V9i3MnXkjPXjXeCUhFpOGys7Pp16/fIcv69+/PRx99hMvlwm5v+pSbWVMDhfnWi7aQRLcHYlz0q8Y/cK/UQ1/7UTuX5mSEhUNoGJTvh7350KGzr0PyK0qii4i0URkZZSQlucjMjGHcuFIq33+H/u3WURMUTrcH7mBA8n5fhygiIiIix8HhcONwVDF4cBU/fjWEihde5pTonwmP/IEeqT18HZ5Iq1JUVER0dPQhy6Kjo6mpqaG0tJSYmLrv6q2urqa6utr72jAMQkNDvc+PxLPukG2K94LbDQF2jHbtj7q/v6hzHD5mhITgbtceivZar8MjjxmfP47jRBw2jpg4KN8OhXkYHbv4MLLj0xyfh5LoIiJtjNNpIzfXmoSlosL6BdO+ajs39PwXAPt/dTsp50QB6oUuIiIi0tJ4rvWyd4SyJmcY13Z+n5w3FrEzqC+xsW4SEmo0541II/llws40zTqXH2zu3LnMmTPH+zopKYlJkyYRH1+/6ufExETv88qCPeQCAfEOOnbqdByR+97B4/AHud1OorI2id6x49EnaT2Yv43jRHnGkdehMxW7txNdU01Ehw4+jur4NeXnoSS6iEgb88s2LjZqSP3uaUJiqliRdw7frbucCSPUxkVERESkJTr4Wu/U6Ku4tvP7nGZ+xFljJlJYHau+6CKNpF27dhQVFR2yrKSkhICAACIiIo643+jRoxk5cqT3tSfhnpeXh8vlOuJ+hmGQmJjInj17vMl698/rrcd2seTktIzJIOsahz8wr74FfvoB48Lh9fq79NdxHK9fjqMm3Pr9UbRlI6Ut5JyC+n0edru93l9W1bn/Ce8pIiItUkZGGcOGVZCdbSczM4Yx3d/kjJg1VBBG6G/uJuMMtXERERERaak813oAa9d0Ys17KfSLXs/se97AGH6l+qKLNJKePXvyzTffHLLs+++/Jzk5+aj90AMDAwkMDKxzXX2SsaZperczC3Kthe3jW1wi9+Bx+IXEztj+bzaGLeC44vK7cZwg7zhi4qwFe/Na5Lia8vOwNclRRUTEbzkcblJTq+nZ00ViiJP7er0AQGjGGM79VbRu7xURERFpwRwOtzdRHhIKr267CoBu2+aD6SY3NwCnU6kAkV+qqKhg69atbN26FYDc3Fy2bt1Kfr41cefs2bN57rnnvNsPGzaM/Px8Zs6cyc6dO1m+fDnLly/nsssua76gS4qsx3btm+89WzHDFuDrEHyvvZVEN/fm+zgQ/6NKdBGRNsTptLF+vZ0FC0JJTnbx55QnibDvZ2+7PuyJ+RUJTlNJdBEREZEW7uCWLiG2NB5KmUo0OTxx02Y+yT9HLV1E6rBp0yYeffRR7+tXXnkFgAsvvJCxY8dSWFjoTagDJCQk8MADDzBz5kwWLVpETEwMt9xyC2effXbzBV1abD1GRjXfe0qrZrSPxwRQEv0wSqKLiLQhB/+H6oK4z8kauBSXO4Ab3n+I9bMd+g+ViIiISCvgaelSUGAwY0YE7+wawS3d3+DGLnO55i8nM2hQpa9DFPE7ffv25c033zzi+rFjxx62rE+fPkyaNKkpwzoqc1+J9SRCSXRpJJ52LoVKov+SkugiIm1IRkYZSUku7hsXxrRBT0I1bOp6Bc/8LgbIU49MERERkVbA4XB77y6MjS1l3DWjuaX7Gwx1fMzmjrfhcEQe4wgi0iLUVqIbEdE+DkRajegY67GqErNiP0ZImG/j8SNKoouItAG/bONy90kziKnezZ6KeDam/JqzEmrUxkVERESklXE6bWRn29lQ2oPdIX3pWPEja//9CbkVVxIba/VO1zWgSAtWWluJHqkkujQOIyQUgkOgsgKKi0BJdC/NJiIi0gZkZYWTnh7HrFnhvPp0MXclzwTg0XUTuOv3ncjKCvdxhCIiIiLS2LKywsnMtKoK//Hl1QCcWTGfjPQY0tLidQ0o0oKZpgmedi7qiS6NyVONXrzXt3H4GVWii4i0AZ42LpmZ7XhlxBOE7K9iZ9QZtBtyNrN+VUBKSrWvQxQRERGRRubpjQ6w7rszKV4WQbfwXcz+y0fEnNNPrfxEWrLy/VDjsp6rEl0aU1QM5OZgFhdh+DoWP6JKdBGRVszptLF2bSC5uQFUVBj8KnEZ3fd/TUVNED/1v4cJ9+1j8OBK3cYrIiIi0go5HG5vojwwPJh3d18KQJdtCwDIzQ3A6VRaQKRF2mf1Qyc4FCMwyLexSKtiqBK9TqpEFxFpxbKywpkyxZo4KjygjI8ufBqAFzbfzDOLTmF8bikTJpT6MkQRERERaUIHXw+mRI7m5m5vkbjnM84aFUBBVXvGj9f1oEiL5OmHHqGJgqWReZLoJYW+jcPPKIkuItKKeW7hzc62k/vPl0kMyaM4uCN7z7yGWY+ojYuIiIhIa+e5HiwoMJgxoyv/K+rLgHY/cnWn+Zwy/jIGDar0dYgiciJKayvR1cpFGpsniV6kJPrBlEQXEWnFHA43Doeb4LzNdOv2BgBFaXfzxMgKH0cmIiIiIs3Bcz0IEBtbysu3j2ZAux+5oeu7VPRIU1s/kRbKVBJdmkptEt1UJfoh1PxMRKSVcjptrFgRxB8mRhIx73nsthrm51zCd1VnsXZtoPpfioiIiLQhTqeN7Gw77+cMo8oIJTl8O/Of2ciKFcG6NhRpifZZ7VyMiCgfByKtzYGe6EqiH0y/JUVEWqmsrHDS0+Oo/mQZjrJ17HOF8ei68WRmxpCWFk9WVrivQxQRERGRZpKVFU5mZgz7a8J4c5s1wWiv3A9IT4/VtaFIS1S2z3oMV090aWRRSqLXRe1cRERaqYyMMnp12ss5H04DYEr2b7nv8SBSU/MASEio8WV4IiIiItKMPL3RAXauGgpfv8OljuX86+mtdOsbrmtDkZamstx6DA31bRzS+kTVtgjaV4rpdmPYVIMNqkQXEWl1PG1cnn46km5rZhITVExeUDIvb72ekBCThIQaUlOr1f9SREREpA1xONzeRHl5fA/WFKcQHFBNyeIVFBTYyM0NUEsXkZakfL/1GKIkujSy8NoWQaYbyst8G4sf0W9IEZFWxtPG5Zt5uzk5dz4AYz+5nxrTTmZmjG7VFREREWmjsrLCSUuLJzMzhte2XwHAaeXzSU9vr5YuIi2MWVFbia4kujQyIzAQQsOsF6Ulvg3Gj6idi4hIK5ORUUZS92riZ/2DAMPNBzkXM3RsT07aXMaIERWkpFT7OkQRERER8QFPS5eCAoPXZwymzPUsPSO2MuvRT4k9K0UtXURaEk8SPVhJdGkCEVHW3Q77ioFOvo7GL6gSXUSklXA6baxdG0hubgBxO1Zybuw3VBtBPL7+dyQkuJkwoZTBgyvVxkVERESkjfK0dImNNRk2ysa83cMB6LJ1AYBauoi0JLVJdMNTMSzSmCJqW7rsUyW6h347ioi0Ep7bcy8fEUnXr/4DwPM/38yuig5q4yIiIiIiwKEtXWbtGA1A4u5PuO6yILV0EWlJKtXORZpQbRLdVDsXL7VzERFpJTy35xoLXqPLxhx2lTuIuvYK0reqjYuIiIiIWA5u6TJjRjI/FPfilOifuarTAgZMSGPQoEpfhygi9VGuJLo0HSMiChNUiX4QJdFFRFoJh8NNQqAT19Y3AHjip3GM/YON39xd7OPIRERERMRfOBxub3u/2FiTWb8dzd+iJ3FDl7nU9LhYrf9EWgpNLCpNKVLtXH5J7VxERFoBp9PGihVB/O+hWdhclXxRcBrv5wwlO9vO2rWB6m0pIiIiIodwOm1kZ9t5d/elVBvB9I7czLvPbGPFimBdP4r4OdPtVjsXaVoR0daj2rl46beiiEgrkJUVztR7dnBq9XLcpsEj6yYABpmZMeptKSIiIiKHycoKJzMzhlJXBO9sHwZAzz0fkJ4eq+tHEX9XVXHgeYgmFpUmEBEJgKlKdC+1cxERaQUybixhzK6/Qymsjf4V60p7M3lyEampVh/0hIQaH0coIiIiIv7E0xsdYPfKofDt+4zssISwMbeR1CdE148i/szTysVmg8Ag38YirZIRqZ7ov6QkuohIC+Z02li/3k7e3CVcuX8TxdURfBZ7GwAhISYJCTXqaykiIiIih/FcI+bmBlCWcDI/lZ7EyZGbSNy2HPqMIDc34JDtRNqKRYsWMW/ePIqKiujcuTNjxowhJSXliNt/+umnzJs3j5ycHMLCwujfvz833XQTkZGRTRfkQZOKGobRdO8jbZennYuS6F5q5yIi0oJlZYVz981BXFg4HYBnsu/g7893ASAzM0a34YqIiIjIEWVlhZOWFk/mve2ZvX00AGHffEhaWpxaukibtGrVKmbMmMGVV17JpEmTSElJ4YknniA/P7/O7X/66Seee+45LrroIqZMmcL48ePZtGkTL774YtMGqklFpanVtnNREv0AVaKLiLRgGRllXFY+ndhtReQHdeOVbdfw8MPFbN5sZ8SIClJSqn0dooiIiIj4KU9Ll4ICgzdnDKGiZhopURvJeuxz4s7sqZYu0ubMnz+fIUOGcPHFFwMwZswYvv/+exYvXsyNN9542PY///wzCQkJjBgxAoCEhAQuueQS5s2b17SBVuy3HoOVRJcmEhZhPZbvx3TXYNgCfBuPH1ASXUSkBXI6beTmBhBUsI3k7e8BsCLuHlymnYQEN6NHl+rWWxERERE5KofD7b1mjI0NZP79l3B15w9ILZ5PXOo9Po5OpG4333zzCe336KOP0r179yOud7lcbN68mSuuuOKQ5f369WPDhg117tO7d29ef/11vv32WwYMGEBxcTFffPEFAwYMOKEY661SlejSxMIOuhOpfD+EN2F7ohZCSXQRkRYoKyucKVMiePXMR+kR72bRngsZv+AiwGrjMn58KRMmlPo4ShERERHxd57ijOxsO7N3jObqzh8Q8dMnPDzxd1z8qwBSUqpVnCF+paKiggEDBhAVFVWv7d1uN59++ilu99HP45KSEtxuN9HR0Ycsj46OpqioqM59evfuzb333suzzz5LdXU1NTU1nHHGGdx6661HfJ/q6mqqqw/cMWwYBqGhod7nR+JZZxiGt52LERrW4nqiHzKOFqy1j8MIDMIdFAxVlRj7yzAi6vfvzVea4/NQEl1EpAXKyCjjyh4r6Dr/CyprAnn8p9+rjYuIiIiIHDerOMNTYdiO7NIkekZuoWrlJ6TPvlrFGeKXrr76anr06FGvbWtqavj000/rfey6knBHSszt3LmTl19+mauvvppTTz2VwsJCsrKy+M9//sNdd91V5z5z585lzpw53tdJSUlMmjSJ+Pj4esWXmJhIaVAQRUBIuxjiOnSo137+JjEx0dchNIrWPI7dkdHUFOQSFxZKUAs5z5ry81ASXUSkBUpoX4n7y38B8N+t6Wzb35lBg/K4884yH0cmIiIiIi2Jpy86wNq1gcx+fjR/6TOFG7u8w1n3DWHQeVU+jlDkUJdeeint2rWr9/Y2m61e+0RFRWGz2Q6rOi8uLj6sOt1j7ty59O7dm1GjRgHQrVs3QkJC+POf/8z1119PTEzMYfuMHj2akSNHel97EvR5eXm4XK4jxmcYBomJiezZs4ea3D0AVGCQk5Nz1HH5m4PHYZqmr8M5YW1hHDW17YLytm/FFtHOB9HVX30+D7vdXu8vq+rc/4T3FBERn3A6bZTOmU9S3h7KAmN5buMtAGRnWz/SExJqdMutiIiIiNSLpy+602kjJMTO27tG8GDfaZwS/TNz52+jfWxXcnPdusYUvzFmzJjj2t4wjHrtY7fbSU5OZs2aNQwcONC7fM2aNZx55pl17lNZWUlAwKETLtpsNoAjJvICAwMJDAysc119krGmaWLWtnMhOKTFJnBN02yxsR+sVY8jtLYvellpixljU34etiY5qoiINJm5L5eT8PXrADz41b2U1Vi/2DIzY0hLiycrK/xou4uIiIiIHCYrK5zMzBiKqtvx/s6LAThp9wLS02N1jSltxsiRI1m2bBnLly9n586dzJgxg/z8fIYOHQrA7Nmzee6557zbn3HGGaxevZrFixfjdDr56aefePnll+nRowft27dvukCra+8QCQpuuvcQCY8AwNyvO95BlegiIi3OTZH/JMRezjeFqXS5+jz4P5g8uYjUVKsPekJCjY8jFBEREZGWJiOjjNNPr2TBglAC44fCzwsZ1XERUbfdQnJKoK4xxS/98MMPlJaWcs455wBQVFTECy+8wObNmzn11FP57W9/S1BQUL2Pd+6551JaWsrbb79NYWEhXbp04YEHHvC2gCgsLCQ/P9+7/eDBgykvL2fhwoW88sorhIeH07dvXzIyMhp3oL9UVZtED1QSXZqOERaOCbB/n69D8QtKoouItBBOp43S738m6buPAPjLuvu4aKB1Q1FIiKlbbEVERETkhFnXkS5iY/eT/XMqm//XleTw7SRs/xhSLiE3N+Cg7UT8wxtvvEG/fv28r7Oysli/fj39+vXjiy++IDExkauvvvq4jjl8+HCGDx9e57qxY8cetuzSSy/l0ksvPb7AG8pTiX6EtjAijSLMqkRHleiA2rmIiLQYWa+GUvyf/wLwxo7LWFPcl6lTIwGrlYtusRURERGRhsjKCictLZ7Me9vz+o7LAbB/sYi0tHi1dBG/lJOTQ1JSEgA1NTV89dVXpKenc99993Httdfy2Wef+TjCJlJt3YVMYP2r7EWOW1jtz3xVogOqRBcRaTFu6/s+kRvWUVodzt4LxsBaePjhYjZvtjNiRAUpKdW+DlFEREREWrCMjDKGDaugoMDgnRlDqXb/k9NifqB35EbueSKWQYMqfR2iyCHKy8sJD7cSfZs3b6aiooIzzjgDgB49evDWW2/5MrwmY7pUiS7NQJXoh1ASXUSkBTDL9xO5dAYAUzfeTuqoKAAGDarizjv1C01EREREGs7hcHvbtcTGBrLkgQsZ0WE5N3aZS8+eY9TKRfxOVFQUOTk5pKSksHbtWuLj44mNjQWgoqICu72Vpr3UE12aQ5hnYlFVooPauYiI+D2n00bujDlQUsQeszMvb72ejRuti8HsbDtOp36Ui4iIiEjjcTptZGfbmb1jNABXdlrA/z0dxIoVwaxdG6jrT/Eb/fv357XXXuOVV15h/vz5nHnmmd51u3bt8k4I2uqoJ7o0A8PbzkWFe6AkuoiI35v/0l6ivn4XgD9+fR/VZqB6oYuIiIhIk8nKCiczM4ZP889ix/4ORAeWEvzjZ6Snx6o3uviVG264ge7du7Ns2TKSkpK46qqrvOtWrlxJr169fBhdE3JZrTwN9USXpuRp51KmSnRQOxcREb93Y+A0gmwunPFnsjzvPAAmTy4iNdW6cEpIqPFleCIiIiLSynh6owMUvT+cLltmcEOXdxnywDn07OnS9af4jaioKB588ME61/3lL38hKKiVJplViS7NIdzTE11JdFAluoiIX9v76bcEbfiKGgL4OGGsd3lIiAlYCXT1phQRERGRxuRwuL2J8t3dhlFj2jg79lsC9+4EIDc3QC1dxGfuv/9+3nnnHXbu3HnU7cLCwlpvT/Rqq6BKPdGlSYWGWY/l+zFN07ex+AH91hMR8VNmdRXu1/4DwH8338B9k0/xrsvMjNGttCIiIiLSZLKywklLi+c39/diRd65AGyfvZy0tHhdh4pP9e3bl2XLljFhwgR+//vf8/rrr7N161Zfh9W8qiqtR1WiS1Py9ESvcR24+6ENa6VfyYmItHzmoneIqd5FRXB7pm68nXHjSpk6NZKhQysYM6aM2Fi3bqUVERERkSbhaelSUGDw3cxfcTErubrzfDrefQM9ehu6DhWfufnmm7n55pvZuHEjX375JZ9//jlz584lISGBs846i7PPPpsePXr4Osym5fJUorfSdjXiH4JDwbCB6bYmFw1q23c+KIkuIuKH8tY5aTf/LWzAtyfdxT5XBFAKwKhR5aSkVKuNi4iIiIg0GYfD7b3ejI1JxfmPOBwh+QywraR76tk+jk4EevToQY8ePUhPT2fr1q18+eWXfPnll7z//vu0b9+egQMHcvbZZ3PyySdjGIavw21c6okuzcAwDKuly/59UL4f2rX3dUg+pSS6iIifMU2T4n//l/Y11XyaP5D0f1wBwNSpkYDVymX8+FImTCj1YZQiIiIi0to5nTZycwPI3mRn2c7LyOzxMsZni7n/i+GMGFGhwg7xG927d6d79+5cd9117Ny505tQX7hwIdHR0fz73//2dYiNq1qV6NJMPEl0TS6qJLqIiN/57kuSyr7Ebdh5+Mf7GTduH1OnRvLww8Vs3mz3/odFRERERKQpZWWFM2WKVcjRNfRyMnu8TMfib/h4RTGzZnVUYYf4pc6dO9O5c2euuuoq9uzZw+rVq30dUqMyTfOgSnQl0aWJhYVDAVYlehunJLqIiB8xKytwv25VSRScfhWbP+hOjx6FAAwaVMWdd5b5MjwRERERaUM8fdEB1q6N4NO3BnJ+3Gqu6/we3e+9nkGDKn0cocjRJSYmMmrUKF+H0bhcBxVUKYkuTS3UmlzULC+jlTVFOm5KoouI+JF9b75J2N58KsIT+PPnvwFg40brR3V2tp2EhBrdMisiIiIizcLTF93ptBESYue17aOtJHqXeTw87ybat3eTm+vWNar4jNvt5sMPP2TlypXk5eVRXX34HbszZ870QWRNyFOFDuqJLk0vNMx6LFdBn5LoIiJ+wszZQfAncwEY+/EfWJLbDlAvdBERERHxLU9blyDbheytiiYxJI+ar78lPf0CAF2jis/MmjWL+fPn0717d/r164fd3gbSXJ4vCgwDAtrAeMWnjLBwTID9SqLrX5uIiB8wTRP3rBcJoIbS7gMZdWk/lmRa6yZPLiI11bpQSkio8WGUIiIiItIWZWSUcfrplSxYEMrOwKG0z53D9V3e5fKHU+nZ06VrVPGZlStXcvnll3PjjTf6OpTmU1XbRikwCMNo6w02pMnVtnNRT3Ql0UVE/IK5+hPYsJaagCBe2DuemFybd11IiAmg22RFRERExCesa1AXsbH7yflfGuTOYUj8Z3xQXABEk5sbcNB2Is2nqqqKfv36+TqM5uWpRFc/dGkOYbVJdFWiYzv2JiIi0pTM/WWYb70EwJR1t/Lc6z147LFo7/rMzBjS0uLJygr3VYgiIiIi0sZlZYWTlhbPLQ/0Z/Xe/thtNWx4+WPS0uJ1rSo+069fP7Kzs30dRvNy1fZEVz90aQ7qie6lSnQRER8z582G4kJqYjtycuZl8DsYN66UqVMjGTq0gjFjyoiNdes2WRERERHxmYyMMoYNq6CgwGDNzF8xkO+4vss8eo+7gp69dK0qvnHLLbfw97//neDgYE477TQiIiIO26auZS2aKtGlOdW2czFVia4kuoiIL5nbN+Fe/gEGsPP8sewvDj5k/ahR5aSkVOvWWBERERHxKYfD7b0mjYs6g+L/i6Br2C7MkK9JTk31cXTSVoWFhdGxY0dmzpzJzJkz69zmjTfeaOaompZZ7alEVxJdmp53YlH1RFcSXUTEV0x3De5ZL2KYbt7fPZSxvx3uXTd1aiRgtXIZP76UCRNKfRWmiIiIiAgATqeN3NwAsreG8uWuSxnT/S1qPl7M/R+fx4gRFSr+kGb373//m88//5wzzzyTTp06Ybe3gTRXlZLo0ozUzsWrDfx0ERHxT+ay+bB5A+6gUILSb4XvDrRxefjhYjZvtnv/MyIiIiIi4mtZWeFMmWIVe6REjmZM97foXPAZHy6vYtasWBV/SLP76quvuOGGGxg1alSjHXPRokXMmzePoqIiOnfuzJgxY0hJSTni9tXV1cyZM4dPP/2UoqIiYmNjGT16NEOGDGm0mA59Q/VEl2YUWtsOSUl0JdFFRHzB3LMTc+6rAARcewtd2rcDoEcPFwCDBlVx5536JSUiIiIi/sPTFx1g7doEvpvbh/7t1nF1p/mkjh/JoEGVPo5Q2hq73U5SUlKjHW/VqlXMmDGD22+/nd69e7N06VKeeOIJnnnmGeLi4urc55lnnqG4uJg777yTxMRESkpKqKlpwjkCXKpEl2bkrURXOxebrwMQEWlrTHcN7penQnUVhYmn8cf51/LZZ9YF0MaN1neb2dl2nE79iBYRERER/+FwuElNrSYhoYaQEJPXd1wBwPVd3qWiHHJzA1i7NlDXsdJsBg4cyPfff99ox5s/fz5Dhgzh4osv9lahx8XFsXjx4jq3/+6771i3bh0PPPAA/fr1IyEhgR49etC7d+9Gi+kwnolF7apEl2YQZk0sSvl+THfbnkBalegiIs3MXPIebN5ApS2ctNl/JafiwGzx6oUuIiIiIv7O09YlPGA4D6c8Q4+Ibfzxya1MLBwAoOtYaTaDBg3iX//6Fy6Xi9NOO42IiIjDtklOTq7XsVwuF5s3b+aKK644ZHm/fv3YsGFDnft8/fXXnHTSSbz33nt88sknhISEcPrpp3P99dcTFFR3pXh1dTXV1QdadhqGQWhoqPf5kXjX1bZzMYKCj7q9v/LE3BJjP1ibGUfYgX9TRmUFRtjh/8b8QXN8Hkqii4g0I3P3dsx3ZwFQdflt/Gl4MJmZB3qhT55cRGqqdUGVkNC2v+UVEREREf+UkVHG6adXsmBBKDtsgzm54ENu6DKXm/7anZ49XbqOlWbz2GOPAfDhhx/y4Ycf1rnNG2+8Ua9jlZSU4Ha7iY6OPmR5dHQ0RUVFde7jdDr56aefCAwMZOLEiZSUlDB9+nT27dvH3XffXec+c+fOZc6cOd7XSUlJTJo0ifj4+HrFGRkSQjEQGhVFbIcO9drHHyUmJvo6hEbRFsaxMygYs6qShIhw7A7/Puea8vNQEl1EpJmYNbVtXFzVlHY7g+9CL2Xem6GHbBMSYpKQUIPD4fZRlCIiIiIiR+dwuHE4qhg8uIqNS4bBmx/yqw7L2NplDH1TQ3wdnrQhd911V6Mfs65K1iNVt5qmCcC9995LWJjVO7q6upopU6Zw++2311mNPnr0aEaOHHnYsfPy8nC5XEeNKzExkdK9BQCUu2rIycmp56j8h2cce/bs8f79tURtaRxmSChUVZK7bSuG2z8r7+szDrvdXu8vq+rc/4T3FBGR42Iuege2ZlNpC2fIS3/F+cKBH95q4yIiIiIiLYnTaSM3N4Dskr5UlPQgJWoj37ywiryyS4mNdaswRJrF4MGDG+1YUVFR2Gy2w6rOi4uLD6tO92jXrh3t27f3JtABOnXqhGmaFBQU0KGOSvHAwEACA+vuZ16fZKxZ284Fe2CLTt6aptmi4/doE+MIDYeSIsyyfeDnY23Kz0OzfYiINANz1zbMea8BUDX6t8x8z2DatELv+ocfLiY9vYxZswrIyCjzVZgiIiIiIvWSlRVOWlo8mfe257XaCUZPK5tPenp70tLiycoK922AIsfJbreTnJzMmjVrDlm+Zs2aI04UevLJJ1NYWEhFRYV3WU5ODoZhEBsb2zSBVlVaj0fouS7S6LyTi7btXIWS6CIiTcx0uaw2LjUuKk8eyI6OQwGoqDhwG1RCgpubbtpPSkq1KnZERERExO9lZJSxcGEeCxfm0f+O86ioCSYlaiNZf13FwoV5KgyRJjN//vwj9ig/2j4lJSXH3G7kyJEsW7aM5cuXs3PnTmbMmEF+fj5Dh1r/h5s9ezbPPfecd/vzzjuPyMhI/vnPf7Jz507WrVtHVlYWF1100REnFm0wz6SkgUqiSzMJte60MPe37Z/rauciItLEzIVvw7aNEBbBTNf9PH5pwmHbZGbGAKiVi4iIiIi0CJ7Cj9zcAAIiw3k/ZyjXdJ5Pl60fUD6wF7m5AYdsJ9JYXn31VU4++WTatWtXr+3dbjevvvoqffr0ISoq6qjbnnvuuZSWlvL2229TWFhIly5deOCBB7x9lAsLC8nPz/duHxISwkMPPcRLL73EH//4RyIjIznnnHO4/vrrT3h8x3RQOxeR5mCEhmMClO/3dSg+pSS6iEgTMndswZxvzQZv3HgHV3YPwdGzkMzMGMaNK2Xq1EiGDq1gzJgyb+9IEREREZGWICsrnClTrLl9Tmt3Jdd0nk+HXR9z5sg/UuyKUoGINJnly5fz3Xff1Wtbt/v4vsgZPnw4w4cPr3Pd2LFjD1vWqVMnHn744eN6jwZRJbo0N287l32+jcPHlEQXEWkipqsa98vPQo0LBpyNMfACHIabnj2tGdd79LAeJ0woJTW12oeRioiIiIgcv4yMMoYNq6CgwGDGjJ6sr51gdHSnBZx+33AGDar0dYjSSi1btszXIfiOq7YSXT3RpbmEepLoqkQXEZEmYC54C3ZsgYhICoaPZd3HwSxYEEpyspU837jR+hGcnW0nIaFGt7qKiIiISIvicLi917CxsSaz7xjNY30nc2PXubh7DNH1rTSJN954w9ch+FZVbRJdlejSXGp7orf1JLomFhURaQLmT2swP3gTAOPGu3j13c6kp8cxa1Y4jz0WDcDUqdatr5mZMWRlhfssVhERERGRhnA6bWRn25m7awTVRjAnR27i3We2sWJFMGvXBuJ0KvUg0mjUE12aW20lurm/bbdz0W8yEZFGZu7Nw/2vp8DtxjjnImxnnkdGRhnTphUCMG6c1Rdy8uQiFi7MY+HCPDIy2vYs1yIiIiLScmVlhZOZGUOJK5K5O4YB0GvPfNLTY0lLi1fBiEgjMmt7ohuqRJfmEqZ2LqB2LiIijcqsrsL9zydhXwl0TSZv2D3krrUqBCoqjEO2DQkx1cZFRERERFo8T290gN0rh8K37zOyw1LCxtxG9z6hJCTU+DhCkVakWu1cpHkZoWGYAPvbdvGfKtFFRBqJaZqYs16EbRshIhLbXQ+Q9UZ70tLiSUuLZ+LEdoDauIiIiIhI6+JwuL2J8rKEk1lX0pOQgErabVjGq6+GsX69WrqINJpqTSwqzUyV6ICS6CIijcb8ZBHmZ0vBsGH7zUSMOAcZGWUsXJjnbeUC8PDDxaSnlzFrVoHauIiIiIhIq5CVFU5aWjyZ97Zn9o7RAMSu+5BZs8JIT49V8YhIY1FPdGlutT3RaeM90dXORUSkEZibfsJ87d8AGFfehNGnP2BV5fyyXcugQVXceaeS5yIiIiLSenhauhQUGLwxYwjlNVPpHbmZM2K+5+a/dmPQoEpfhyjSOtT2RFc7F2k2qkQHVIkuItJgZnEh7hf/DjUuOP1cjOFXAuB02lixIoj774/ms88OXOBkZ9tZu1a3tIqIiIhI6+FwuElNrSYlxcXQUQHM221NMJre5R0qKgxycwN0DSzSGNQTXZqbpxLdVY3pOf/aIFWii4g0gOmqxv3iJCjaCx26YBtzL4ZhTSCalRXOlCmRh+2TmRkDwPjxpUyYUNqs8YqIiIiINCXPNXD/6Ku4rsv7/KrDUs780wSKq+MBXQNL4/rxxx/59ttv2bBhA3v37qWqqorIyEg6d+7MKaecwjnnnENUVJSvw2xc6okuzS0kFAwDTBPKy9rsFzhKoouINID51suwcR2EhmG7+08YIWHedRkZZSQlucjMjGHcuFKmTo1k8uQiUlOt2+88ky+JiIiIiLQWGRllnH56JQs+6E5B5UnElm/iqk4LGDAhjZ49XboGlkaxYsUK3nvvPXbv3k1ISAjdunUjOTmZoKAg9u3bx/bt21m9ejWvvPIK55xzDtdddx3x8fG+DrvBTNM8qBJdPdGleRg2G4SEWQn0/WUQFePrkHxCSXQRkRPk/vwjzOXzAbDd+nuMxE6A1cZl/Xo7CxaEkpzsOmSfkBCThISaw/qki4iIiIi0BtacQFUMHlzFzllpsOJ50ru8Q3WPi0lNdR37ACLH8Ic//IHc3FzOP/98xo4dS3JyMjbb4W2C9u3bx+rVq/n444/5/e9/zz333MPZZ5/tg4gbkav6wHN726wGFh8JPSiJ3kYpiS4icgLMbZswX30eAGPk9Rj9z/Kuq6uNy9Sp1uvMzBjdwioiIiIirZrTaSM3N4At9qEMdr1Ez8gtPPXMRgpu7k1srFtFJdIgp512GpdddhlhYWFH3S4iIoIhQ4YwZMgQ1q1bx759+5opwqZjVh3Uj7qNttQQHwkLh715bXpyUc3oISJynMx9JbhfeNK6jS71DIzLrj9kfUZGGdOmFQIwbpyVLH/44WLS08uYNauAjIy2+82tiIiIiLR+WVnhpKXFc9f4zry7Ow2AlNz3SU+PJS0tnqyscB9HKC3Zddddd8wE+i/16dOHgQMHNlFEzcesqrSeGAbYVRcrzSjM+rltqhJdRETqw6wox/3PJ6AgF+ITsd023uoPxoGKG4CKCuOQ/RIS3IweXaqKGxERERFp9TIyyhg2rAKAHauGw9dzSUtczr//sYmup0SpL7o0mjlz5jBkyBDat29/2LrCwkKWLVvG1Vdf7YPImoY3iR4YiGEYR99YpDGF1n75Wd52k+iqRBcRqSdzfxnuZ/8C2esgJNSaSDQ8wrveU3GTlhbPxIntgEPbuKjiRkRERETaAofD7U2UV8SfxDeFqQTaaui4ZSEAubkBOJ1KR0jDvfXWW+zdu7fOdYWFhbz11lvNHFHT8rZzUT90aWaGkuiqRBcRqQ9zXwnuZx+BbRshLALb7x7F6Nz9kG08FTfZ2XYyM63Zqh9+uJjNm+2MGFFBSkr14QcWEREREWmFDp4n6KpOV3F6zFrar/uQ856/EzcBmidImlxFRQX2Vtby5EAlupLo0sxq27loYlERETkis6QI95SHYdc2iIjCNv4xjC5Jh23ncLgPa9cyaFAVd97Zdn/JiIiIiEjb5CkwKSgwyJpxPoVV0XQO3cOQhM+4/OFUBg2q9HWI0kJt27aNrVu3el9/++237Nq165BtqqqqWLlyJQ6Ho5mja1pmdW0lepCS6NLMQmvnIVAluoiI1MUsKsD99MOwZydEx1gJ9I5dD9vO6bSxfr2dBQtCSU52eZdnZ1s/ZhMSatQPXURERETajIMLTGJjTd783WXckZxFRtc5JPZM0bWxnLDVq1czZ84c7+u33367zu2CgoK46667miusZmFW1n75ZA/0bSDS9qgSXUl0EZEjMQvycD/9IOTtgfZx2MY/juHoWOe2B9+uejBPWxfdrioiIiIibZHTaSM7286s7VdyR3IWg+M/54GnSxk5JprYWLeKTeS4XXLJJZx++umYpsmf/vQn7rrrLrp2PbTQyW63k5iYSFArq9g2q9XORXyktie6Wb7fx4H4jpLoIiJ1MHNzrBYuBbkQ58A24XGMuCPfCpiRUUZSkovMzBjGjStl6tRIJk8uIjXV6oPumVhJRERERKQtOVBsEsMneWdxQfyXdNv+AenpmYCKTeT4xcTEEBNjFSv95S9/ITk5mZCQEB9H1Ty8E4sGqhJdmpcRFo4JqkQXEZEDzJyduKc8BEV7wdHJauHSPq7ObY/UxgUgJMRUZY2IiIiItGme3ugAe5dfCj98yXWd36PLXddy0sk2FZtIg/Tp06fRj7lo0SLmzZtHUVERnTt3ZsyYMaSkpBxzv59++olHHnmELl26MHny5EaPCzSxqPhQbSV6W+6JbvN1ACIi/sTcuRX35AesBHrHrtgmPnHEBDpYlTXp6XHMmhXOY49FAzB1qtXWJTMzhqys8GaJW0RERETEHzkcbm+ifG+ns8kpTyA2uIicBV9SUGAjNzcAp1OpCam/J598ki1bttR7++rqaubPn8/ChQuPue2qVauYMWMGV155JZMmTSIlJYUnnniC/Pz8o+63f/9+nn/+eVJTU+sd14lQEl18JkxJdP2mEhGpZW7bhPsfD0JpMXRJwnbfExjRMUfdJyOjjGnTCgEYN866DfXhh4tJTy9j1qwCMjLa7i8YERERERGwCk/S0uK5Z1wcr+24AoD+JfNIT48lLS1ehSdyXKKjo3nggQd4+OGHWbJkCbt37z5sm/LyctasWcNLL73EnXfeyaJFi0hKSjrmsefPn8+QIUO4+OKLvVXocXFxLF68+Kj7/fvf/2bQoEH07NnzhMdVHwfauSiJLs3Mk0Qva7s5DrVzEREBzE0/4Z76qPWtalIvbOMewQiPOOL2TqdVNQNQUWEcsi4hwc3o0aVq4yIiIiIiwoGWLgUFBu/OuBSXezoD23/HjCe+JfG0LmrpIsfl7rvv5tJLL+Xdd9/l5ZdfpqamhqCgIKKioggKCmLfvn2UlpZimibx8fGMHj2a4cOHE3iMPuIul4vNmzdzxRVXHLK8X79+bNiw4Yj7ffTRRzidTjIzM3n77bePGX91dTXV1dXe14ZhEBoa6n1+JIZhQO3EokZg0FG39WeeuFtq/B5tbhzhUdZjZTnUuDDs/tWXvzk+DyXRRaRNM901mAvfwZz3GtS4oEcfbPf+GSM07Kj7HZgg6YCD27hogiQREREREcuB4pIALhgVweKXL2BE4kd02TKf6tPu8hanqAhF6ispKYnf//73FBcX8/333/Pzzz9TWFhIVVUVSUlJdOrUib59+9K7d+96J9VKSkpwu91ER0cfsjw6OpqioqI698nJyWH27Nk8+uijBAQE1Ot95s6dy5w5cw4Zy6RJk4iPjz92jLWV6GHR0bTv0KFe7+evEhMTfR1Co2gr4zBrEthpGGCaOCLCCYiJbabIjk9Tfh5KootIm2Xm5uB+6RnY9JO14LRzsN36e4zgY8/s7qmmyc62k5lptXx5+OFiNm+2M2JEBSkp1cc4goiIiIhI23FwEcp5sVczIvEjOmxbysCR49nnilARipyQ6OhoLrjgAi644IJGO2ZdSfe6lrndbv7v//6Pa665ho4dO9b7+KNHj2bkyJGHHTsvLw+Xy3XUuEJrk+j7XTVU5uTU+z39iWEYJCYmsmfPHkzT9HU4J6xNjiMsAspKcW7eiNGxqnkCrKf6jMNut9fry6ojURJdRNoc0zQxP12M+eZ0qKyAkFCMG36Lcc6QelcpOBzuwyplBg2q4s47225/MBERERGRIzm4pcvMGals3NeNHhHbuKrTB5xx3zAGDar0dYjSAm3fvp2uXbs2yrGioqKw2WyHVZ0XFxcfVp0OVt/1TZs2sWXLFl566SWg9v+apsn111/PQw89xCmnnHLYfoGBgUdsLXOsJKZ3YlF7YItO3MKBv6uWrk2NI9xKopv7SsFPx9yUn4eS6CLSppglhbhnPgdrvrIW9OqL7ZbfYcQ56n0Mp9PG+vV2FiwIJTn5QKVAdrb1IzUhoUa3ooqIiIiIHOTgIpTYWJOZd1zLY30nc3O3N6nqcZGun+WETJw4keTkZC666CIGDRpEePiJT1Jrt9tJTk5mzZo1DBw40Lt8zZo1nHnmmYdtHxoayj/+8Y9Dli1evJgffviB8ePHk5CQcMKxHIk3iX6M/u4iTSI8EsiBshJfR+ITSqKLSJth/u8L3K88B/tKwG7HuOImjKGjMGz1613nUVc/dMDb1kW3ooqIiIiI1M3ptJGdbeftXb/i4VOeo0fENp5+ZgMFN/chNtatghQ5Lrfddhsff/wx06dP55VXXuHMM8/koosuol+/fid0vJEjRzJt2jSSk5Pp1asXS5cuJT8/n6FDhwIwe/Zs9u7dyz333IPNZjusCj4qKorAwMBGq47/JbO6toVGYFCTHF/kqMKtPIhZto+WPZ3qiVESXURaPbN8P+Yb/8X8bKm1oHN3bLf9HqNz0gkdLyOjjKQkF5mZMYwbV8rUqZFMnlxEaqrVBz0hoaaxQhcRERERaVUOLkiZteUybun+JqkFc0lPPx9QQYocn2HDhjFs2DB27tzJihUr+PTTT1m1ahXt27dn8ODBXHjhhcc10eC5555LaWkpb7/9NoWFhXTp0oUHHnjA20e5sLCQ/Pz8phrOMR2oRFcSXZqfERGJCbCvbf6MVhJdRFo18+cfrclDC3LBMDCGjca4PB3jBG5/O1IbF4CQEFNVMyIiIiIix+DpjQ6w9Ys0WP0mlyR8yvRJ6+h0arwKUuSEdO7cmYyMDG688Ua+++47VqxYwbx585g7dy6vv/76cR1r+PDhDB8+vM51Y8eOPeq+1157Lddee+1xvd/xUBJdfKq2Ep0yJdFFRFoNs7oa871ZmIvnWhNexCZgu/V3GL0On9ilvupq4zJ1qvU6MzNGVTMiIiIiIsfgKTrJzQ2gOrYLn+SdxQXxX9J583zMU28hNzfgkO1EjofNZiMxMRGHw0FYWBglJa2rd7NZ5Wnnop7o4gNKoouItB6macKar3HPfQV2bQPAGHQxxnW/wQgNa9Cx62rj8vDDxWzebGfEiApSUqobYwgiIiIiIq3awcUplyRcxwXxX9Jh00IGjriXCneIilPkuJWXl7Nq1SpWrFjBzz//TGBgIAMHDmTw4MG+Dq1RHUiiqxJdfCA8AgBTSXQRkZbLdLvhf1/g/uAN2LHFWhgRhe2msRinndOgYzudNm9FTEXFodNnJCS4GT26VJUyIiIiIiL15GnpUlBgMHPG6Wzf35GuYbt54753CB4yVC1dpN5++OEHVqxYwZdffklVVRUnnXQSt912G+eddx5hYQ0rovJHZrXVzuVE2pOKNJinEl090UVEWh7TXYP59WeYH7wJu7dbC4NDMAaPwBg+GiMyusHvoTYuIiIiIiKNx+Fwe4tQYmNNXrnrGh5KmUrKnncJO+VCDMM4xhFELI899hhRUVEMHTqUIUOG0LlzZ1+H1KTMSk9P9GDfBiJtkhFeO7Fo2T5fh+ITSqKLSItk1tRgfrkCc8EccO6yFoaGYQwZiXHJKIyIqEZ7L0+lTHa2nczMGAC1cRERERERaQDP3Z7Z2Xbe2DmKCb1eJDR/M/+csJ2+o3qRklKtuz3lmO677z5OP/10bDabr0NpFma1eqKLD6knuohIy2G6qjFXLcf8cA7kO62FYREYQ0dZCfSwiEZ/z4MrZTwGDarizjvLGv29RERERETagl/e7fnurku5oeu7dNowj/T0J3W3p9TLmWee6esQmpVZ5alEV0908YEITzuXEkzTbHN3DSmJLiItglldhblyKebCObA331oYGY0x9AqMiy7FCGmafndOp4316+0sWBBKcrLLuzw72/rxmZBQowoZEREREZHj5LnbE2Dt2kBe+uu13ND1XdISl/OfydmcfnHkMY4g0gapEl18Kaqd9VhdBZUVEBLq03Cam5LoIuLXzMpKzE8XYi6cC8V7rYXRMRjDr8S4YDhGcEiTvn9d/dABb1sXVciIiIiIiBw/z92eTqeNkBA760t7sTOkH50r1lC5dBHrO95Abq5bRSsiBzGrPEl09USX5mcEh0BQEFRVQWmxkugiIr5mVpRjrv0G/vc55pqvobLcWtE+DiPtKozzhmI00+1rGRllJCW5yMyMYdy4UqZOjWTy5CJSU60+6AkJNc0Sh4iIiIhIa3Rw0crfVt3IC6et4RzXPM656bdUuYNUtCJyELPKuntDlejiM5HtoCAXSoogPtHX0TSrFplEX7RoEfPmzaOoqIjOnTszZswYUlJSfB2WiDSAWVaK+f1qzG8/hx//B66DJuuMT7SS5+cOwbA3z8WCZ6IjgIqKQ/t8hYSYqogREREREWkEGRllnH56JQsWhHJS0gByPkugQ2gub9z/LqGDL1LRikgt0zQPqkRXT3TxkchoK4leWuzrSJpdi5u+eNWqVcyYMYMrr7ySSZMmkZKSwhNPPEF+fr6vQ2t2TqeNRx6xHj2vn346ss7XR1vXlrb1x5h8ue0//hFBTo7v/s5yNxax5KHllP/9z9SMvwnz5anw/WpwVVMT24Gv219P0R1PY3v8RfJ6X8qUqe2b7e/wxRcjSEuLJy0tnokT2wEwdapVIZOZGUNWVjgiIiIiItIwDoeblBQXN920n3iHjVe2XwNA8uZ3wDTJzQ3wXquLtGk1LjBN67kq0cVXIqMBMJVE93/z589nyJAhXHzxxd4q9Li4OBYvXuzr0Jqd02nj0UcPJNFzcwOYMiXSWz178OujrWtL2/pjTL7e1pNEb64Y3nqhBNfC96iZ9AfaT7qZIc5nCdr0HYbbzbqSnuSelYHtL//Hhhunc2XWfewO7oNhszX738uFF1Zy//0lANxwQxkADz9cTHp6GbNmFZCRUYaIiIiIiDRcVlY4aWnxVrHK9isprwkmZt9GHknfTlpavApYRACqD7pbWz3RxUeMKCuJTkmRT+PwhRbVzsXlcrF582auuOKKQ5b369ePDRs2+CYoETmqsID9hO7+Aff270n67HM+u2gTrLTWGcA3hal0HjmQkpPOJe36U1n4UB4dOldDoXHU4za12Fg3XbpYt456HgcNquLOO5U8FxERERFpTBkZZQwbVkFBgcGMGRHM2TmSm7q9ze1Js0l/9CQGDar0dYgivld10L8De4tK50lrEtnOemyDlegt6l9dSUkJbreb6OjoQ5ZHR0dTVFRU5z7V1dVUH/RtnWEYhIaGep+3NJ52FAA//GD1wFq4MITsbDsbN1of54cfWq+//z7Q+9pjzpzQNretP8bkT9vOnQv79oU0ynG3rKsk/38/cXvSIoyX15JQkc26YTuwzTExgVCgxrSxK+xUipLOZVnBhTyzIJlxA0sh1z8+x88/t/5dzZwZ5q1O9yxbvjwYmw1OOcWFWDw/R1viz1PxPZ0/0lA6h6ShdA5JQ+j8aTyJiSaJidY1dmxsKXdfdQM3dXubSxI+ZVP8dhITE7BKcFoXnUNyXDzzhgUG6ZwR36lt59IWk+iGaXoaKvm/vXv3cuedd/L444/Tq1cv7/J33nmHTz75hGefffawfd58803mzJnjfZ2UlMSkSZOaI9wm8cgj8Oijvo5CBKIDizklagOp0es5JeonUqN/Iil8R53b7i53sKY4haW557PEeSGF1e2aN9hGdOGFsGKFr6MQEREREWl9cnJg+XLIyIBPr/8d3UpWssK4loTM+4mPhw4drD8irVFeXt4hRaCHce6i5qG7ICycgKmvNV9gjcwwDDp06EBOTg4tKCV5mLY6DvcXH2FOfwZSTiVg/GPNEGH91GccgYGBxMfHn/B7tKhK9KioKGw222FV58XFxYdVp3uMHj2akSNHel97vq3Ly8vD5Wp51aRXXGHjnHMOVKLfd180v/tdKSed5GLjRjtTp0YyblwpPXq4+P77QP773wjGjSsFrEkRb799H6eeWt2mtvXHmPxp24cegn37Snn22Tq2vbeYvl3z2bGmkNWLSvn1sA04Kn8mJHcTXcN21XmOFgU4+HxXHyL7JuMM7snfXhnAFb8O5tRTq+mw0U6hn3+On38exOzZ4dxwQxm5uQEsWxbCyJHlDB9eAUDv3i5yclrez46mYhgGiYmJ7Nmzp0VfOIhv6PyRhtI5JA2lc0gaQudP4/vHPyKYMiUSgD8uuZHXzlrJwOp5nDXyTopdUYwfX8p99+3zcZSNpzWdQ3a7vUHJKamH6gOV6CK+YkS2wwT1RPd3drud5ORk1qxZw8CBA73L16xZw5lnnlnnPoGBgQQeYdbilvhLKiGhhoSEmkOWpaVVkJpazdq1gUydGsmll1qve/Z08d//RnDppVbyb+rUSK6+urzNbeuPMfnFtj2qeO+VCq4ZmMu+HT9T1K2CuztsJb4gl31le7lm8F66bM7F2GgljH9zOlBQe9KF1T7GJ1IS3YN/zu/PDX9IJOnC7uzeGssdafEsfCKP9kD+f2O5+uq8FvU5zp4dzs037yc7286yZSEMH17BlVeWe//NtcAfHU3ONM0W+TNV/IPOH2konUPSUDqHpCF0/jQeT290gLVrerJuXk/6RGXzeuZsjOFXkZBQ0yr/rnUOSb14eqIriS6+FKmJRVuMkSNHMm3aNJKTk+nVqxdLly4lPz+foUOH+jo0Ed8x3Zhl+wgsruSUqALCd2zHVlnG9Z0NYr/Nwb2xhMQd+3mufxXd5uRQMyuXlMK9fHOJC16EGOCvfYFvwATCgfAwwA0YBtVh7flhVyLJA+OoiO/BuCln8Mj0WPqeGcLOtYH88//iGdUtDyPyKLeeiYiIiIiIHIXD4QYgNzeAkFD475YbmXLqoyRtfY+tNZeTm2s/ZDuRtsRUJbr4g+gY63FfKWZNDUZAgG/jaUYtLol+7rnnUlpayttvv01hYSFdunThgQceaJO3DTkcbv7ylwMXEAkJNYwfX+qtVP/l66Ota0vb+l1Mbjd/HLeHxOB8zF376FhRztTfuuns3Iu7qIyueeW8eVM1SV8XY1TsZ9m1FXR7v5iad/fRu6SM7JH7CHpuP27TpCew4DxgrnWOPNUPWGklxtsDozoCu611BmBiYLSLozqyPVuLHHROjSGsU3uKbfF8+HkXhl4bTtxJ7SguCOLjrHC6ZJQRAJxdEE5c1zLA3ao/R8MwOfvsSnr10pcDIiIiIiLNISsr3NvSJcg2nD+e/BwJ5PHP279nXk4a48eXMmFCqY+jFPEBV5X1eIRuCyLNIjIabDZwu6G4ENrH+TqiZtOiJhZtTMecsKEFaC2TGLQGZnUVlO2D/fu8j2ZZ6YHX3mX7oLwM9pdBRTlU7LceG+vzCwqGsHAIi6j9E45R+0hYBISHQ3QsRkwstI/DiG5Pxy5ddA7JCdPPIWkInT/SUDqHpKF0DklD6PxpGk6njdzcAAoKDGbMiKDPlleZ0OtfFEb3JufXz5DgcLeaSvTWdA41dMI+OXaeyvzuC9zPPwEnnUzAH59qxsgaV2s579vyOGruvxUK87H96R8YSb2aOML60cSiIj5iVpRDSaHV46mkCLO46MDzkiIoK7ES4Z5EeVVVw980wA6hYdafkFAIDYfQMAzv81AICbOeh4VjhEdYz8NrE+ah4RjH+Y20Z6JdERERERERf+A4KEkeG1vKjaOuZuxJLxNTvIHYsDUYjj4+jlDER2oT7IbauYivtWsPhflQWABJvg6m+SiJLm2GaZpQWgQF+VCYbyXDaxPlZm2CnJIi63YUz4Qdx8OwWZXeYREQHnmgCjw8snaZ9ccIizgoWR524Lk9UEltERERERFp8zzV6NnZdvZWxTB31whu6Poua6YsoPDaAaSkVLeaanTxP4sWLWLevHkUFRXRuXNnxowZQ0pKSp3bfvnllyxevJitW7ficrno3Lkz11xzDf3792/8wDzFe0qii6/FxMIWMIv30payWEqiS6thVlfB3nzYm4e5Nw8Kcmuf50NBHuzNA9dxtPAJCrYmTIhqB1HtMKLaQZT12oiIPDQ5HhYBIaEYNltTDU9ERERERKRNOLgvOsD0rTdwQ9d3SalayQW3V3DNXVHqiy5NYtWqVcyYMYPbb7+d3r17s3TpUp544gmeeeYZ4uIO7/28fv16+vXrxw033EB4eDgfffQRkyZN4oknniApqZFLdKvVE138gxHdHhOsSvQ2REl0aTFMd42VDHfuxszdDXlOK1nu+VNSdOyDGIaVGI+Jg+iYQxPj0e1qE+a1r0NCm3ZAIiIiIiIicpiMjDKGDasAYO3aQCZOPIktYWeStP8rXhkzg+iM23wcobRW8+fPZ8iQIVx88cUAjBkzhu+//57Fixdz4403Hrb9mDFjDnl944038vXXX/PNN980YRJdlejiYzGx1mORkugiPmO6a6xq8tzdmLk54MyxEua1SXNqXEc/QFAwxCZYk2a2j4f28RCbUPs8DmJiMez61lZERERERMRfefqiO502QkKstMU37a4maf9XdN25kE3bbyA3N5KEhBq1dZFG43K52Lx5M1dcccUhy/v168eGDRvqdQy32015eTkRERFH3Ka6uvqQCUQNwyA0NNT7/EhMz531QcEtuhWsJ/aWPAZo2+Mw2sValehFhX4z/ub4PJREl2Znut3Wt1XO2kR57m5M527IzYG8PUdvuWIPhPhEcHTEiE+0EuSxtcny9vEQHuk3/4BFRERERETkxB3c1mX8f4fQ97wepERt5L0JH/P8plsYP75UbV2k0ZSUlOB2u4mOjj5keXR0NEVFRfU6xvz586msrOScc8454jZz585lzpw53tdJSUlMmjSJ+Pj4ox67OCiIEiA8OpqYDh3qFY8/S0xM9HUIjaItjqPipJ7kAQH7iungZ+diU34eSqJLkzBNE4r3Hqgk97Rgyc2BvJwDE2LUJcB+IFGe0AESOmI4OkJCB4iJU99xERERERGRNiAjo4zTT69kwYJQkpNdvDj910zt/2fGpc5m1NRhxHcM8HWI0grVVZhXn2K9lStX8tZbbzFx4sTDEvEHGz16NCNHjjzs2Hl5ebhcR7773l20F4D9VS4qcnKOGY+/MgyDxMRE9uzZY+WOWqi2PA6z9gYgV94edu/e7RfFrPUZh91uP+aXVUejJLqcMNNdY00ikLcHM28P5OVgOnMOJMorK468c0AAxDoOJModHTESahPlsfEYNl0MiYiIiIiItGVWW5cqBg+uYu3aQJ58fBj3936eTjjpU7oYm2O4r0OUViQqKgqbzXZY1XlxcfFRk+JgTUj64osvMn78ePr163fUbQMDAwk8wuSgR0timrXFiGZgYItO2nqYpqlx+JHjGYcZU5uIrijHLCuF8Mij79CMmvLzUBJdjsos3w/5TitBnueEfE/C3AkFuUfvUW6zWf3JvQlyT8K8A8Q6MAKUKBcREREREZEjczpt5OYGkJ1tx2Xa+e+WdP7SZwpl777L1uhLSUhEfdGlUdjtdpKTk1mzZg0DBw70Ll+zZg1nnnnmEfdbuXIlL7zwAuPGjeO0005rugBrW98amlhUfMwIDoaodlBSBPm5fpVEb0pKordRZmWl1W6lpBCKCzGLCmuf78UsLrLWFRbAvpKjHyjADnEOiHdgxCWCo4M3YU5cgibxFBERERERkRN2cF90gNd2XMG4Hv+lXekunr1lHX3Sz1RfdGk0I0eOZNq0aSQnJ9OrVy+WLl1Kfn4+Q4cOBWD27Nns3buXe+65B7AS6M8//zxjxoyhV69e3ir2oKAgwsLCGje4qkrrUUl08QdxjtokuhO6neTraJqFkugtmPubVZS6q3EXFmLWuKCmBtxucNdYPccr9kP5fquavPY5FeVQVmo91ldEFMQnYsQ5IL6DlTCPT4S4RIhpr9YrIiIiIiIi0iQyMsoYNsxqFbp2bSATJ7Zj5rZrGNdzOlNHTKcsPcXHEUprcu6551JaWsrbb79NYWEhXbp04YEHHvD2US4sLCQ/P9+7/dKlS6mpqWH69OlMnz7du/zCCy9k7NixjRtctVWJriS6+AMjNgFz8wbMfCe+74jePJREb8HcS+dRlP3jiR8gKAii20N0DETFYETHWM+ja5+3i4U4B0ZoI397KiIiIiIiIlIPnlYtubkBhIRYfW5nbLuOsb1eIdS5gZ8/3gCDT1ZLF2k0w4cPZ/jwuvvt/zIx/sgjjzRDRLWqrZ7oHKGfukizinNYj/lO38bRjJREb8GMk/sR2qET5VVVYAuwJuu02azngYEQGgYhYRAajhEaWvvcek10DISE+sUMuiIiIiIiIiJH8suWLgVV7Xlt6yhu6vY2+bPf5aOdj6mli7R+qkQXf1KbRDcLcn0cSPNREr0FC7j8RmI7dCAnJ6dVzAQsIiIiIiIi8kueli4FBQYzZkSwZEkIVReMxr31HS5OWMlpQ38Euvo6TJEmZbo8lehKoovvGXEOTGhTleg2XwcgIiIiIiIiInIkDoeb1NRqUlJcjBplze9VFNSJD/cMAcBYMpe1awNxOpXikFasSkl08SPxidZjvhPTXePbWJqJfsOIiIiIiIiIiN/LygonMzMGgKlTI3lh868BCF+3gluuqCErK9yX4Yk0LfVEF38SGw/2QOu8LMjzdTTNQkl0EREREREREfF7GRllzJqVT3p6GQ8/XMya4r58ln8GgbYaFkx4iYyMMl+HKNJ0anuiG6pEFz9g2ALA0dF6sWenb4NpJkqii4iIiIiIiIjfczjcDB5cxVNPFTNokFWV+2JtNXrsug9JiCjxZXgiTcvTEz1ISXTxD0ZiZwDMnB0+jqR5KIkuIiIiIiIiIi2C02lj7dpAsrPtAHycfw47zJOgspw9byxSX3RpvTw90e1Koouf6NDFesxRJbqIiIiIiIiIiN/IygonLS3e2xsdDP7x/c0A2FbM4/VXAnwXnEhTUk908TcdVIkuIiIiIiIiIuJ3MjLKWLgwj4UL85g8uQiAeTnDKAtNJC64kDG93vVpfCJNwTRNb0901BNd/IThrUTfYZ2jrZyS6CIiIiIiIiLSIjgcbhISagAICbGSNjWmnZ+6XANA0Mdzce52+yw+kSZRUwNm7XmtnujiLxI7Q4Ad9pdBvtPX0TQ5JdFFREREREREpMU4vKULXP9/15FX2Z6g0ly+efELH0Yn0gQ8rVxAlejiN4zAQOjc3XqxfZNPY2kOSqKLiIiIiIiISIvhaekya1Y+Q4dWAHBnZjXTt9wIwMWuWZhuVaNLK3JwEt2unujiP4xuPQAwt270cSRNT0l0EREREREREWkxHA43qanVDB5cxYQJpQD06OHi1e1XUxMUhj1vB3y/2sdRijSig/qhG4bh21hEDtbtJADMbUqii4iIiIiIiIj4HafTRna2HYCNG+2UuiL4sPwqAMrenoNzj5KN0krUVqIb6ocufsboblWis3UjprvGt8E0MSXRRURERERERKTFycoK9/ZFnzo1EoCHP7qJippgQp0/8/G/N/gyPJHG4/Ik0YN9HIjIL3TqDqFhUF4GO7b4OpompSS6iIiIiIiIiLQ4nt7oCxfmMXlyEQAFVe3ZnZwGwGWBr/owOpFGVKUkuvgnIyAAep0CgPnTGh9H07SURBcRERERERGRFsfhcJOQYLUPCAkxvcu/jLyOGgII2vw9Bd+0/j690gbU9kQ3AtXORfyPcXIqoCS6iIiIiIiIiIhfysoKJy0t3tvWBeAPT/Vi7k6rGj0/a66vQhNpPOqJLn7MOLmf9eTnHzAryn0bTBNSEl1EREREREREWiRPS5dZs/IZOrQCgHHjSnlh880A9Nj3KWbODl+GKNJw3p7oIT4ORKQOnbpDQgeoqsL87ktfR9NklEQXERERERERkRbJ4XCTmlpNSoqLUaMOVEBm70tmZ9wgAPa+NhenU+kPabnMKlWii/8yDAPjrAsBML/4yMfRNB39FhERERERERGRFi0rK9zb0mXq1EgA7nrvNwCE//gR771c6rPYRBrM0xNdSXTxU8bZg60n677DzNnp01iait3XAYiIiIiIiIiINERGRhmnn17JggWhJCe7eOyxaL4vPoW82P7EF3zHjfGzgN/6OkxpARYtWsS8efMoKiqic+fOjBkzhpSUlCNuv27dOmbOnMnOnTuJiYlh1KhRDBs2rHGD8vREDwxu3OOKNBIjoSP0Pwu++xJzwZsYt433dUiNTpXoIiIiIiIiItKiORxuBg+u4qmnihk0qMq7fP8F1wIQ+s1izJIiH0UnLcWqVauYMWMGV155JZMmTSIlJYUnnniC/Pz8OrfPzc3lySefJCUlhUmTJjF69Ghefvllvvjii8YNzNMTPVhJdPFftpHXAWB+sQLzx//5OJrGpyS6iIiIiIiIiLR4TqeNtWsDyc4+cNP9X988n9LYXlBdxb55830YnbQE8+fPZ8iQIVx88cXeKvS4uDgWL15c5/aLFy8mLi6OMWPG0LlzZy6++GIuuugi3n///cYNzNMTPVDtXMR/Gd16YAweAYD7P//A3PCDbwNqZGrnIiIiIiIiIiItXlZWOFOmRB6ybMmSUMY7fsN/Tp9IwKcfYF51JUZomI8iFH/mcrnYvHkzV1xxxSHL+/Xrx4YNG+rcJzs7m379+h2yrH///nz00Ue4XC7s9sPTbtXV1VTX9jgHa1LG0NBQ7/O6g/P0RA8+8jYthCd+jcM/NPY4bNfeSs32TbB5A+5//Ak6dIHIqF++62HvX/uiQe9t/v1fTfp5KIkuIiIiIiIiIi1eRkYZw4ZVALB2bSATJ7YDYOSD/aj8sgvBhTswV3yIcelVPoxS/FVJSQlut5vo6OhDlkdHR1NUVFTnPkVFRXVuX1NTQ2lpKTExMYftM3fuXObMmeN9nZSUxKRJk4iPjz9ibEVBQZQCBAWRmJhY7zH5M43DvzTmONyT/0vRi09RtmwB5OyAnCNvazbau1pHa8rPQ0l0EREREREREWnxHA43ALm5AYSEHEjNVFQGkH/GNXRaMoWaxe9hXDwSI0i9paVudVWyHq269ZfrTNM86j6jR49m5MiRh+2fl5eHy+Wqcx+z30AC4jsS3ucU9uzZ432PlsgwDBITEzUOP9Fk47jutwSkXYO5YwtU7D+w/OD3OOTtGvbeBoAt4KjjsNvtR/2y6liURBcRERERERGRVqGuli4TJ7bDblzLJ4Nn05k9mKuW4enbK+IRFRWFzWY7rOq8uLj4sGpzj3bt2h22fUlJCQEBAURERNS5T2BgIIGBgXWuO2ISs2NXjE7dCOrQATMnp0UnbT1M09Q4/EiTjCOqHUbfAY17zCMwDAMjIKBJPw9NLCoiIiIiIiIirUJGRhkLF+Yxa1Y+Q4darV3GjSvFZdrZe5rVxsVc+A5mTY0vwxQ/ZLfbSU5OZs2aNYcsX7NmDb17965zn549ex62/ffff09ycnKd/dBFpOVSEl1EREREREREWgWHw01qajWDB1cxYUIpAD16WC0yAgdfApHRUJCL+dUnvgxT/NTIkSNZtmwZy5cvZ+fOncyYMYP8/HyGDh0KwOzZs3nuuee82w8bNoz8/HxmzpzJzp07Wb58OcuXL+eyyy7z1RBEpInoazERERERERERaVWcThvZ2VbKY+NG6/Ef/xfPw2dcQffvZ1L9/tsEDbwQw6baQjng3HPPpbS0lLfffpvCwkK6dOnCAw884O2jXFhYSH5+vnf7hIQEHnjgAWbOnMmiRYuIiYnhlltu4eyzz/bVEESkiSiJLiIiIiIiIiKtysG90adOtR6XLAnhy4/G8PlFc4jM3Q5rvoL+Z/kyTPFDw4cPZ/jw4XWuGzt27GHL+vTpw6RJk5o6LBHxMX3lKiIiIiIiIiKtiqc3+sKFeUyeXORd/rdnXFSebU0q6v5wTquYEFBERJqeKtFFREREREREpFVxONwA5OYGEBJyIFE+b14ojuuupP1372LbvAF+/gF6p/oqTBGv+k5E2lomLNU4/EtbGEdDx9g6/oZERERERERERA5ycEsXjyVLQliypCeP972cX3ebg3vBHAKURBc/EBMTU6/tPP3ZWzqNw79oHMemdi4iIiIiIiIi0up4WrrMmpXP0KEV3uXTphVyzp9/hWmzwbr/YW7f7MMoReqnvLycP/zhD5SXl/s6lAbROPyLxlF/SqKLiIiIiIiISKvjcLhJSKghNtZk1KgDiZWKCoPq6ERKepwPgLn0PV+FKFJvpmmyZcuWFt/HX+PwLxpH/amdi4iIiIiIiIi0SnW1dJk4sR0Ap0bfwvuDPsZc/Snmlb/GaBfrgwhFRKQlUCW6iIiIiIiIiLRKdbV0GTeuFIDbH+9Edbc+UOPC/GiBL8MUERE/pyS6iIiIiIiIiLRKDoeb1NRqBg+uYsIEK3neo4cLgJ49XQSPuBwA8+OFmJUVRzyOiK8FBgZy9dVXExgY6OtQGkTj8C8aR/0piS4iIiIiIiIirZrTaSM72+pou3Gj9fj005F8XHQ+VVGJUFaK+flyX4YoclSBgYFce+21rSLZqXH4D42j/pREFxEREREREZFWLSsrnMzMGACmTrV6pC9ZEkL6TQk8/nkGAOaSeZhut89iFBER/6WJRUVERERERESkVcvIKGPYMKtdy9q1gd7JRadNK6RXt3NxzwjHlrsb1nwF/c/yYaQiIuKPVIkuIiIiIiIiIq2aw+EmIaEGgJAQ07u8osLADAplb98RALiXvOeT+ERExL+pEl1EREREREREWr2srHCmTIk8ZJmnIj0xZAyfD3mHgJ9/wNy2EaNbDx9EKCIi/kpJdBERERERERFp9TwtXQoKDGbMiGDJkhDAaunSs6eN6o/PJ+D7FZhL3sO4fYKPoxU5YNGiRcybN4+ioiI6d+7MmDFjSElJ8XVYR/Tmm28yZ86cQ5ZFR0fzn//8BwDTNHnrrbdYtmwZ+/bto2fPntx222106dLFF+F6rVu3jnnz5rFlyxYKCwu57777GDhwoHd9feKurq7m1Vdf5bPPPqOqqopTTjmF22+/ndjYWL8Zx/PPP8/HH398yD49e/bkb3/7m1+NY+7cuaxevZpdu3YRFBREr169yMjIoGPHjt5tmvMzUTsXEREREREREWn1HA43qanVDB5cxYQJpd7lPXu6SE2tJuyyUQCYX6/E3JvvqzBFDrFq1SpmzJjBlVdeyaRJk0hJSeGJJ54gP9+/z9EuXbrw73//2/vn6aef9q577733+OCDD7j11lt58sknadeuHY8//jjl5eU+jBgqKyvp3r07t956a53r6xP3jBkzWL16NePGjeOvf/0rFRUV/P3vf8fdjJMWH2scAP379z/k83nggQcOWe8P41i3bh3Dhw/nb3/7Gw899BBut5vHH3+ciooK7zbN+ZkoiS4iIiIiIiIibYLTaWPt2kCysw/cmP/ZZ0Hcf380H2/pS3X3U6CmBvOjD3wYpcgB8+fPZ8iQIVx88cXeKvS4uDgWL17s69COymaz0a5dO++fqKgowKocXrBgAaNHj+ass86ia9eujB07lsrKSlauXOnTmAcMGMD111/PWWcdPrlwfeLev38/y5cv59e//jX9+vUjKSmJzMxMtm/fzpo1a/xiHB52u/2QzyciIsK7zl/G8eCDDzJ48GC6dOlC9+7dufvuu8nPz2fz5s1A838mSqKLiIiIiIiISJuQlRVOWlo8mZkx3mWPPRbNrFnhpKfH8mH19QCYnyzErPBtVayIy+Vi8+bNnHrqqYcs79evHxs2bPBRVPWzZ88e7rjjDsaOHcuzzz6L0+kEIDc3l6KiokPGFBgYSJ8+ffx6TPWJe/PmzdTU1NCvXz/vNu3bt6dr1678/PPPzR7z0axbt47bb7+dcePG8eKLL1JcXOxd56/j2L9/P4A34d/cn4mS6CIiIiIiIiLSJmRklLFwYR4LF+YxeXIRAOPGWa1dpk0r5Nw7+kFCR9hfhvnFCt8FKgKUlJTgdruJjo4+ZHl0dDRFRUW+CaoeevbsydixY3nwwQe54447KCoq4qGHHqK0tNQbd11jOjiR62/qE3dRURF2u/2Qqm7PNv70eQ0YMIB7772XP//5z9x0001s2rSJv/71r1RXVwP+EVyTbwABAABJREFUOQ7TNJk5cyYnn3wyXbt2BZr/MzmhJLqnbF5EREREREREpKXw9EVPSKghJMQ8ZF1FhUFufiB7eo8EwFy1zBchihzGMIx6LfMXAwYM4Oyzz6Zr167069ePP/7xjwCHTGb5y/hN89B/j/7qROL2t7Gde+65nHbaaXTt2pUzzjiDP/3pT+zevZtvv/32qPv5chzTp09n+/btjBs37rB1zfWZnFAS/YEHHuDBBx/k008/xeVyncghRERERERERER8Iisr3NvSZerUSAAmTmzH/7N33+FR1Wkbx79nkknvkEyokkCAIEXFggYVV0GMWLAXROxt87KisKuuq4hrwQVF1F1X3VWBVRF1LUTsrIi90iEQeklCOumTOe8fJzOZQAgJKROS+3NdXjNz5syZ34ExZJ555n7Gjo0l9YGLcWGDzRsw9+zw5TKlk4uIiMBmsx3QMVtYWHhA9217FhQURO/evdm9ezdRUVEAB5xTUVFRuz6nxqw7KioKp9PJvn37DtjH/fj2KDo6mtjYWHbv3g20v/P417/+xU8//cQDDzxAly5dPNvb+u/ksIrot99+O6Zp8swzz3Dbbbfx+uuvk5ubeziHEhERERERERFpUxMmlLBgwV6uvrqE+++vjZCYOzef+e+5cA4YDoD59ee+WqII/v7+JCYmHjAAccWKFQwYMMBHq2q6qqoqdu7cSXR0NHFxcURFRdU5J6fTyZo1a9r1OTVm3YmJifj5+dXZJz8/n23bttG/f/82X3NjFRcXk5ubS3S09cFiezkP0zR56aWX+O677/jLX/5CXFxcnfvb+u/E/9C7HOj000/n9NNPZ+PGjSxZsoT333+fd999l+HDh3POOedw9NFHH85hRURERERERERancPhwuGoZNSoSlautHu2JyU5GTKkCrPiDFzrf8D8dinmhVdj2Px8uFrpzMaNG8fcuXNJTEykf//+fPrpp+zdu5fRo0f7emkH9eqrr3L88cfTtWtXCgsLeeuttygrK+P000/HMAxSU1N555136NatG/Hx8bzzzjsEBgYycuRIn667vLycPXv2eG5nZ2ezZcsWwsLC6Nq16yHXHRISwu9+9zvmzZtHeHg4YWFhzJs3zxNr0x7OIywsjIULFzJixAiioqLIycnhtddeIzw8nBNPPLFdncdLL73EV199xbRp0wgODvZ0nIeEhBAQENCo11JLnothtkCgTVFREZ9++imffvopubm59OzZk7Fjx3L66acTEBDQ3MO3ipycHE9g/pHKMAy6devG7t27212+khwZ9BqS5tJrSJpDrx9pLr2GpLn0GpLm0OvnyJeVZSM724+MDH9PtMv99xeSmenPuWcXccp/r8BWXoLtzocwBh3T4s/fkV5Ddrud2NhYXy+jw/roo4947733yM/Pp1evXlx77bUMGjTI18s6qKeeeoq1a9dSVFREREQESUlJXHHFFfTs2ROwOozffPNNPv30U0pKSujXrx833HCDZ2Ckr6xevZrp06cfsP3000/njjvuaNS6KysrmT9/Pl999RWVlZUMHjyYG2+8ka5du7aL87jpppt44okn2Lx5MyUlJURHR3P00Udz+eWX11ljeziPyy67rN7tt99+O6NGjQIa91pqqXNpkSJ6aWkpX3zxBR999BFZWVnExsaSk5NDTEwMd955Z7v8yoKK6CJ6DUnz6TUkzaHXjzSXXkPSXHoNSXPo9XPkmzUrnNmzww96/wdXPcTQgvcwRozCdsOUFn/+jvQaUhFdRDq6w8pEd9u6dSv//Oc/ufXWW1mwYAH9+vXjr3/9K8888wwzZ84kJiaGF154oaXWKiIiIiIiIiLSIiZMKGHJkhyWLMnhiScKAJg8uRiwstF7X34aAObP32CWl/pqmSIi0g4cVib6119/zUcffcS6deuIiIhg3LhxjBkzps5U06OOOoorr7ySv/71ry21VhERERERERGRFmHlorvIyrIRFFS3PPLee8HEXDuYE6N6EFiwE/OnbzBSzvTRSkVExNcOq4g+Z84c+vTpw2233cbIkSPx96//MLGxsZx66qnNWqCIiIiIiIiISGuZPz/UE+syZ451+cknQXzySRB39L2APw54DvObz0FFdBGRTuuwiujTp09n4MCBh9zP4XBw++23H85TiIiIiIiIiIi0ugkTShg+vIL09GASE53MmBEJWJEuyfEjMF/+O8b6lZh7szC6Ony8WhER8YXDykRvTAFdRERERERERKS9czhcJCc7ueaaUuLiXJ7t5eUGzvBYSnoOA8D89gtfLVFERHzssDrRRUREREREREQ6Cu9IF7epU6MAuKj7eJ465lfMb77APPdyDMPwwQpFRMSXDqsTXURERERERESko5gwoYQlS3JYsGAvo0eXe7bPnZvPLc8PxQwIguzdsGmtD1cpIiK+ok50EREREREREenUHA4XDocV5dKlSzGffBIEQFKSk8FD/HD9egrmN59jfvMFRr9BvlyqiIj4gDrRRURERERERKTTy8qysXKlnYyM2n7D5csDmDYtkhXBZwFgrvoJ0zR9tUQREfERdaKLiIiIiIiISKdXXy76jBmRALz9+qmsOdsPv7y9sDcLYuN9sUQREfERdaKLiIiIiIiISKfnzkVfsiSHJ54oAGDy5GIAZj5VjqtXEgDmhtW+WqKIiPiIiugiIiIiIiIi0uk5HC6GDKkiLq6aoKC6kS3l5QaFcUMBKPtNRXQRkc5GRXQRERERERERkRrz54eSlhYNwJw5VrzL1KlR3Pn3kQCUr1rjs7WJiIhvqIguIiIiIiIiIlJjwoQSFizYy9VXl3D//YWe7Vfc2xvTsBFVtQszb68PVygiIm1Ng0VFRERERERERGo4HC4cjkpGjapk5Uq7Z3vCoECMjETYuhFzwyqMEaN8t0gREWlT6kQXEREREREREfGSlWVj5Uo7GRm1vYezZoWzI2QYoFx0EZHORp3oIiIiIiIiIiJe5s8PZfbs8DrbPvkkCPO3FP51/FuUrlhDqI/WJiIibU+d6CIiIiIiIiIiXiZMKGHJkhyWLMnhiScKPNsv/lMCJgYxldsxC/J8t0AREWlT6kQXEREREREREfHicLgAyM72IyjI9GzflR/Bbr++dK/eSMGPa4g+a6SvligdTH5+Pk6ns8F9YmNjycnJaaMVtR6dR/vTUc6lofPw9/cnOjr6sI+tIrqIiIiIiIiIyH7qi3SZMSMSv+TjuT5hI5s/Wq8iurQYp9NJVVXVQe83DMOzn2maB92vvdN5tD8d5Vxa+zwU5yIiIiIiIiIish93pMuCBXsZPbocgMmTi/k27zgAjg74xZfLExGRNqQiuoiIiIiIiIjIfhwOF0OGVJGc7OT888s827+rKaL7Z29jzfelZGWptCIi0tHpJ72IiIiIiIiIyEHMnx9KWpqVoztnTjj5VVGsL04E4IlbdzB/fqgvlyciIm1AmegiIiIiIiIiIgcxYUIJw4dXkJ4eTGKikxkzIsnYl8iA8EwevnMj/mMG+nqJIiLSylREFxERERERERE5CIfDhcNRyahRlaxcaQcgrzIKgG4R+dgcLh+uTkRE2oLiXEREREREREREGpCVZWPlSjsZGVYvYl6lFe+ya/0+Vq60Kxdd2j2zvBTXO/Mwd2719VJEjkj6KS8iIiIiIiIi0oD580MZOzbWk42eW9OJ/suXZYwdG6tcdGn3zNdfxEx/E9ej03y9FJEjkuJcREREREREREQaMGFCCWPGlAOwcqWdL2dbxfQTB+Ww5NEc4uKqfbk8kUMyf/3OulJR5tuFiByh1IkuIiIiIiIiItIAh8PlKZQHBZmeTHR7RREA2dl+inSR9q2k2NcrEDmiqRNdREREREREROQQ5s8PZfbscAAGhlud6FX5RYwdGwvAlCnF3HWXCpUiIh2RiugiIiIiIiIiIofgjnTJzTV45+VgAGICCzFw8fTcQlJSKny8QpH6mS6vuKEQ5feLHA4V0UVEREREREREDsHhcOFwuADoEuUHz4INF1H2IpKSnJ77RNqd9atqr4dF+G4dIkcwBXaJiIiIiIiIiDRSVpaNjMwgCqvCAIgJKGDWrHCWLg1k5Uq7stGlXTFX/ohr9v21G6o1BFfkcOgnu4iIiIiIiIhII82fH0paWjR5lVYuepeAfD75JIirr+7C2LGxzJ+vuAxpP8zNGXU3VFX6ZiEiRzjFuYiIiIiIiIiINJI7G92xMAz2QExAPgBz5+aTlOQkLk6dvtKOFOTWvV1V5Zt1iBzh1IkuIiIiIiIiItJIDoeLuLhqqoMjAasTHSA728a8eSGsXatIF2k/zHyriG6Mu8LaoE50kcOin+oiIiIiIiIiIk0wf34oi7+MA2o70WfMiGTBglCuvrqLIl2k/XB3osfGW5fOKkzT9N16RI5QKqKLiIiIiIiIiDTBhAklnHVBAADD+uUBMHlyMWDFukyYUOKztYnU4e5Ej+tWu82pSBeRplIRXURERERERESkCRwOF7GhRQD0GhBU577ycoPsbD9WrlSsi/iWWVkBJdaHO3gX0RXpItJkGiwqIiIiIiIiItJE5t4sAP75ViIAc+aEAzB1apRnnylTirnrruI2X5sIUBvlEhAA4ZFg2MB0abioyGFQEV1EREREREREpKlqiuiT7g4j6McSEhOdzJhhDRudOzefpCQncXHVvlyhdHb5VtQQUV0xDAPsdqisUCe6yGFQEV1EREREREREpAlMVzXk7QXg2LOiOe6yQlautHvuT0pyMmSIun2PdGvWrOG9995j8+bN5Ofnc/fdd3PiiSd67jdNkzfffJPPPvuMffv2kZSUxA033ECvXr18uOpaZr71GiW6i3VpD6gpouu1KdJUCucSEREREREREWmKgjyodoKfP9kVXVm50k5GRm2f4qxZ4SxdGqhc9CNcRUUFffr04frrr6/3/nfffZfFixdz/fXX8+ijjxIVFcXDDz9MWVlZi6/F3LOTvY/fg7ljS+MfVFQAgBEZbd2213zQo050kSbTT3IRERERERERkabYm21dxnRl/n8iGDs2lrS0aM/dn3wSxNVXd2Hs2Fjmzw/10SKluY499liuuOIKTjrppAPuM02T9PR0xo8fz0knnUTv3r254447qKio4KuvvmrxtVTPfYiyLz+h+rFpjX9QyT7rMjTMurQHWJcqoos0meJcRERERERERESawMytKaJ3dTDh6hLGjCkHYOVKu2ewqHLRO7bs7GwKCgoYNmyYZ5vdbmfQoEGsX7+e0aNH1/u4qqoqqrziVAzDIDg42HP9oLJ2WZflZQ3v5620ZqhtaHhtJjqAs6rxx2hh7uf11fO3lI5yHtBxzqW1z0NFdBERERERERGRpqgZKmp0icPhcAGQne1HUJDp2aW83PBsBzz7ScdQUFAAQGRkZJ3tkZGR7N2796CPe+edd1i0aJHndkJCAo8//jixsbENPt92r+vdunVr1BpzXdWUApHdehDerRt7gkOpAmLCwwhu5DFaS3x8vE+fv6V0lPOAjnMurXUeKqKLiIiIiIiIiDRFrlVEp0scAPPnhzJ7dnidXdwd6QBTphRz113FbbU6aUP7d72apnmQPS3jx49n3LhxBzw+JycHp9N58AfabOCyPojZvXt3o9ZWnZsDQJHTxb7du3FiPVdeVha2Rh6jpRmGQXx8PHv27Dnkn1V71lHOAzrOuRzqPPz9/Q/5YVVDVEQXEREREREREWkCc29tnAvAhAlWpEtursHLL4fxySdBTJ5czJw54cydm09KSoUPVyutISoqCrA60qOja/Pwi4qKDuhO92a327G7Y1X202AB0+bnKaI3ttBpemWim6bpiXMxKyt8Xiw1TdPna2gJHeU8oOOcS2udhwaLioiIiIiIiIg0RU0mutHV6kR3OFwMGVLFqFGVno7zfv2sruKkJKeiXDqguLg4oqKiWLFihWeb0+lkzZo1DBgwoOWf0M+v6Y8pcWei7zdY1FlV//4iclDqRBcRERERERERaSSzuhryrJgMujjq3JeVZSMjwyq1bNxoXc6aFc6kSSV06eIiLq5aBfUjSHl5OXv27PHczs7OZsuWLYSFhdG1a1dSU1N555136NatG/Hx8bzzzjsEBgYycuTIll+M7XCK6DWd6CHuInpNB3xVZcusSaQTURFdRERERERERKSxCnKtWA1/f4iMrnOXdzb6nDnW5SefBPHJJ0GAstGPNJs2bWL69Ome26+++ioAp59+OnfccQcXXHABlZWVvPjii5SUlNCvXz/uu+8+goODW34xfk0LkzBdLigrsW6EWq9Fwz8AE6BKnegiTaUiuoiIiIiIiIhIY7nz0GPiMGx1C5vubHSAlSvtnuGic+fmk5TkJC6uui1XKs109NFHs3DhwoPebxgGl112GZdddlnrL6apnehlpeDOhVYnukizKRNdRERERERERKSRzC0brCtx8Qfc53C4PIXyoKDawXbl5QYA2dl+ZGWpFCOHwa+JfbClNVEuAYEY7uK5OxNdnegiTaZOdBERERERERGRRjK/XQqAccyIeu/3jnRxc3ekgyJd5DA1Mc6ldqio12tRnegih01FdBERERERERGRRjB3bIYdW8DfH+P4+odHuiNdcnMNXn45zJOHrkgXaRavOBezuhrD7xDxLp6hoqG129yd6E51oos0lYroIiIiIiIiIiKNYH6z1Loy9ASM0LB693E4XDgcLgC6dCn2FNGTkpwMGaLipRwm70z0qgrwC2lwd9Md56JOdJEWoSAuEREREREREZFDMF3VmN//DwDbiDMa3Dcry8bKlXYyMmp7F5cvD2DatEiWLg1ULro0nc2ovV5Zcej93XEuIV4f9ngy0VVEF2kqdaKLiIiIiIiIiBzKuhVQkGcVJQcPb3DX+nLRZ8yIBGDBglCmTCnm7rv3tdpSpQOq9ooBqmhEEb24CAAjPKJ2mwaLihw2ffQpIiIiIiIiInII7igX44SRGO5YjIOYMKGEJUtyWLIkhyeeKABg8mSrM3ju3HwmTChpzaVKR+R01l6vbEQneXGBdRkeVbutpohuVpS32LJEOgt1oouIiIiIiIiINMCsKMf85RsAjENEuUBtLnpWlo2goLqll/feCyYmxkV2tqtV1iodVJ0i+qGL4GZRgXUlIsqzzQgJxQQo04c4Ik2lTnQRERERERERkQaYv3wDFeUQGw99Bzb6cfPnh5KWFg3AnDlWvMsnnwRx9dVdGDs2luefb5XlSkdU7V1Eb0ycS6F1GRFZu82dj16iKCGRplInuoiIiIiIiIhIA8xvlwJgjBiFYRgN7+xlwoQShg+vID09mMREpycXfe7cfJKSnAwdGtsay5WOqKlF9JpOdMOrE53QmiJ6qTrRpX5mfi6uV+diO20sxrEjfL2cdkVFdBERERERERGRgzAL8mDNb4BVRG8Kh8MFOOnSpZSMjNoSTHm5VYjfvRtsNhtxcdUHOYJIDWdTi+g1nejh9XSil6oTXepnvjMPVv2Ma9XP2J55EyMw0NdLajcU5yIiIiIiIiIichDm91+C6YK+AzHiujf58fPnhzJ2bKwn1gVg6tQoxo6NZfhwmDcvpCWXKx2VVxHdrGi4iG46q2oL5d6DRd1F9KpKzKpGDCeVTsWsrsZc+UPt7a8+9uFq2h8V0UVEREREREREDsL89gug6V3obhMmlLBkSQ4LFuxl9OjagZBz5+bz009wzTWlLbFM6cBMV7X1QY7boTrRi4usS5utNsIFICgYjJpSoHLRZT/mut9gX3Ht7W++8OFq2h8V0UVERERERERE6mFuyYDtm8HPH+P4kYd1DIfDxZAhVYwaVcldd9UWqJKSnBx3nDvyRaQB3lEugPnefzALcg++f3GBdRkeiWGrLf0ZNhuEhFo3FOki+9ucYV0mD7Mut23CdH8gI0dOET07O5u///3v3HHHHVx99dWkpaWxcOFCnPv9IOlMsrJsPPigdem+PWtW+GHdbs5j2/OxVq3y5+KLu7BqleL/RUREREREpPFMpxPXq88AYAxPwQiLOOxjZWXZWLnSXicXfcmSQIYPh7ffDvS8hxX44IMPDuu/oqIOXOzbv/ZVXIj53/kH39+Thx514H0qostBmLt3AGAkD4OefcA0Mdf+6tM1tSdHTGVx165dmKbJzTffTHx8PNu3b+f555+nvLyciRMn+np5PpGVZWP6dDj5ZGsISXa2H7NnhzNmTDkOh6tJt4HDfmx7PtaGDXa+/TaQDRvsDB7ceT9wERERERERkaYx09+0utDDwjEuv75Zx5o/P5TZs8PrbHvqKaso//PPMUyZUlynS70zmzdv3mE9btCgQUREHP4HHe1a9YH1DDNj7UF3N4sKrCsRkQfe6c5FLylpgYVJR2Jm1RTRHT1g0LGYO7bAml/gxNN8u7B24ogpoh9zzDEcc8wxntsOh4Ndu3bx8ccfd8oiurk5g0FP38W2VNjzy82Y/r3wK+0LxPp6ae1SYSHMmhXOhAkl+qqciIiIiIiINMjclomZvhAA46pbMSKiD/GIhk2YUMKYMeXk5tp4+eVQPvkkiCuvLOG110KZNq2IK65QLrq3u+++mz59+jRq3+rqaiZPnty6C/K1+lIY4nscfP99Vld+vd+eqMlIN0v3YbTE2qRDME0Tdu+0bnTriWG6MAFzz06frqs9OWKK6PUpLS0lLCyswX2qqqqoqqry3DYMg+DgYM/1I4074qTLDytx1GyLX/ZPXMtgAPDzmdGUvtCHDXFHsaOsH8dGHc2ni+PIyAhm40brr/vDD4PIyPDnt9/snttuixYFk5Hhf8C+h7rd3o71yish9OpVzU8/Wcf64otgPvssCH9/k7POqlBXeg33/wNH4v8L0j7oNSTNodePNJdeQ9Jceg1Jc+j103GZzipc/34KqqsxhqdgO+HUw/57zsqyMW9eCNdcU8rQoU7eeSeITz6x3uvm5PgBsHmzP8uXBwIwYIBT71eB6OhoYmMb1yTocnWCRjlnbV0LewBUVUJ5Ax+8lJdZl0EhB9xlhIRhguJcpI7q3ByoKLOG0cbGQ0nNN2Pc32oQDNM0TV8v4nDs2bOHP/7xj0ycOJEzzzzzoPstXLiQRYsWeW4nJCTw+OOPt8USW8WDD8L06WCjmvuTnyIucC9+NicDwzfRJ2Q7NqP+v85tpT1YX5zIuuJ+rC/uy7rifmSW9MFpHtGfoxyW00+HpUt9vQoRERERERFpjwrn/YOi11/EFhFF/N8X4hcVc9jH+vlnGD4cfvoJjjvOuv7zzwffX+9XrYbJoKAgbLbG58QfzmPam5ycnDpNoN7MPTtw3X87trAIuOkuXE8+AD0T8HtgTr37u978N+bH72CMGY/t0uvq3jf/Ocz/LcE470ps51/Z4udxKIZh0K1bN3bv3s0RWpIEOs55gHUu0VnbybnvdnD0wO/hv2Nm78Z13y0QEIDtmTePiA+MD/V3YrfbG/3hXH18XkHdv8hdn0cffZS+fft6bufl5fHII49w8sknN1hABxg/fjzjxo3z3Hb/pefk5ByRQ0kvvNDGySe7h2beyB13R/KHPxRT1dfJ+xucfPzKXtIuXkW/4I34Z28lOG8LjqC99A7ZSe+QnYx2LPMcqxp/MoqPwux2FHsDE/j3R0czLLUbfY6LYeOmAObMCWfy5GL69XOycaN/g7d/+83Oiy+GMXmy9UnVnDnh3HjjPoYNqzrkY1vjWFdeWUJ0tIsffgjghx8CGT68gp9+CuTKK0sYMqSSCRMCuPba0k7/Cb9hGMTHx7Nnz54j/oe++IZeQ9Icev1Ic+k1JM2l15A0h14/HZO5ZSPVC/9l3bjqFrLLKqBsd5OO4d19npNjA2L5+ut8cnKcnH56ED//HM7gwZVER7tYtiyIceNKOfvsCsDqRN+9+8h7n+rv79+s4pS3kJADu6db4zFHFHf9yt+O4e4uL2sg09zdiR4YdOB97kx0daKLl6ptmdYVd0xQZE2EVWWl9XoK7uD/jzWCz4voY8eOJSUlpcF9vH8Q5+XlMX36dPr378/NN998yOPb7Xbsdnu99x2Jv+jExVUTF1ddZ9vYseUMGVLFypV2Zs1NpvflXRkwJIWVK+2cNjaWT97ZRHLkJnb+sJ3P5+1h/EnrCSnYgl9ZKQPDN8G+TbAPTj0eyAa+CKY0+ii6Dx7IGd3i6T6oJ2t79mPOnHDOOaf2ubxvJyU5efHFMM45xxoGOmdOOJdcUlbvvoe63RLHuvbaUj7+OIgffrC+EvfTT9bla6+F8tproZ4/u5kzC1v/L+0IYJrmEfn/g7Qfeg1Jc+j1I82l15A0l15D0hx6/XQcZlVNjIvLhXH8SIzhKYf1d7tmjR+zZ4eTkOCkvNxq5EtLq5upvmpVgOd6dbXBRReV1a5DLyfZX81gUcPuD8E1NY2yBuJcKtxxLsEH3heqIrocqHKjNajW6J1oXQYGWa+f8jIozFcRnXZQRI+IiGj09GR3AT0hIYHbb7/9iP6aTluqDo7AGDCY/MpjueePsRz7txwGD65k/df5/PWOAh6f/BuBuVvY9cMOkqM2Y1SUEbJnHVf2XgdfgutLK2/92zMchL93FK7MBMLNJHoGnwjtOA5mwoQS/P1NZs6M8AxseeKJAoKCTNLSoklNLScry8b8+aEaOCoiIiIiItLJmR+8Dju3QngkxlW3Numx3u8t09OtwuX+hXNvTzxRQE6OjZkzI0hJqWjWujua6dOnN3pfwzD4y1/+0oqraSdqOtENfzumu+u+vBTTNOuN2TA9megH70Q39xW3ylLlyFS5YQ0ARp+k2o0R0bVF9IYG2XYS7bcCup+8vDwefPBBunbtysSJEykqKvLcFxUV5buF+ZDD4eKBB/AUf+PiqpkypdjTqd7QbcMwiO7XlWOuOQq/1H44gY+NUOKuLCSOHRSs2cbaT3dxTNxGAvdugZw9dA/Ogi1ZmFu+pxfw9RngeiGU6qMSSeiSyAs3JNPN1ZPq2J6NXkdjbh/uYx0OF2eeWc6XXwYyeHAFEEpQkOnpBNi1y4+8PBuzZ4czfHglDod+cREREREREemMzM0ZmEveAsA24TaM8EM3+3kXzteu9fd0nycmWgVP74jS++8vJCWlkowMf9LSohkypAqbDb77Dk48sf4c7M5q/8Lwrl27KCgooGvXrkRFRVFQUMDevXuJioqie/fuPlxpG/KKc/EMC3W5oLKi/siWCuub/QQe2IluhEdag0X3FR1wn3ROZnkp1Tu2WDf69Ku9IyoasndhFuXT/hPRW98RU0RfsWIFe/bsYc+ePdx6a91PhBcuXOijVfmWw+HiwQdh924Xpmndvuuu4jr3N+W2dd0G9Ca6e29OOav2ucyyUti+GXP7Zti+CXNbJuzajq28BNavJJiVnM278Azgb+cPPY7C+CgRV69E4nonMuX3fayvghz2ug7vnAYPdvLWW7lMmxYJ1O0EmDo1ynM9PT2I5OQqdaWLiIiIiIh0MmZVZW2My4mnYRx3SqMel51txbaMGVNeb/f5nDnhnuuZmf7cemvdDOvBg50sXQq7dzsV4eLlwQcf9Fz/9ddfef7555kxYwb9+/f3bF+/fj1PPfUU5513ng9W6APV1gcthr8dMzAIbDariF5WUn8RvaYT3agvziXcqo9QrHhbqbEt08qRiumKEVH7M8yIiLY+cCnM89nS2pMjpog+atQoRo0a5etldFpGcAj0Pxqj/9GebaazCnZtx9yeCdsyrcL6js3WD+utGzG3brT2AzAMcHTH6NMf+g7A6JsMPXpj2PzaZP0TJ1q/rKSmlrNunT8zZkTW6QpITHSyfHmgutJFREREREQ6GfP912D3doiIwrjy4LPX9o8Dzc21ejMzMvwP2n0eF+fyxInCgd+mloa9/vrrXHrppXUK6AADBgzgkksu4fXXX+e4447z0erakLM2E90wDKsbvXQflJVBVD37uzvRVUSXRjB3bAXA6N237h3u4aKFBW27oHbqiCmiS/tj+Nuhd6I1dKBmNqzpcsHePVZRfftmq7C+PdPKT9qzE3PPTvj2C6uwHhgMCUkYiQMx+g2ExAEYoeENPeVhGzzY6Rkimp5ufUrr3RUwY0ak53p6ehCjRqmILiIiIiIi0tGZ61ZgLnkHANs1t2OEHTzGxd15npDgJCnJycsvW9nSDXWfjx9fzJQpxSQnW53Edb89rYCEQ9m+fTtdunSp976uXbuyc+fONl6Rj3jHuYA15LF0n9WJXh/3YNH6utQjauofFeWYFeWe1ADpvMyCXOtKTGzdOzxF9Py2XVA7pSK6tCjDZoO47hDXHeP4kZ7tZmE+bNuEmbkec9M62LzB6lhft8L6pcW9Y3wPjMSB0HcgxsChGHHdWnyNqallLFgQyty5+WRn2+rtSl+6NID09GAmTixh8GBni69BREREREREfMtc+SOuvz8GpgtjxCiMY0YcsI9397lbQwNDR48u5/zzyzzd5/tHjkrTREVF8d133zFs2LAD7vvmm286zYw8s7p2sChgFdEBykrrf4BnsGg9neiBwWAPgKpKqxvdx0V01yfvQkgoxiln1jskVdpAvlVEN6Ji6m6vKaJ7iuydnIro0iaMyGgYcjzGkOMBMF3VsGsb5qb1sGkdZuZ6yNpZ263+9WdWYb2rA2PQMRiDjoWBQzFCw5q9luRkJ1OmFJOSUsGsWVaXwMG60gFPB7uIiIiIiIh0DK4fvsJ8aRZUV8PQEzCuucNz38EGhpaXWwW+yZOL6dfPycaN/syZE84TTxQQFGSSlhbNpEklJCdX1ek+l8M3ZswY/vOf/7Bv3z5GjhzpGSy6bNkyvv/+e6666ipfL7FtOA9WRD+wE900zYYHixqGFemSl2MV0bs6WmXJjWHu2Ym58CXrxvbNcPmNKqT7QkFN5nl03W99GLHdrNpc9u42X1J7pCK6+IRh84OeCRg9E+D0sQCYxUWQuR4zcx3mxjWwaT3szcL88iPMLz8CwwZ9+tUW1RMHYPg3/SXs3Qng3ZVeXm4wdWpUnV+AUlPLD8i9ExERERERkSOXa9nHmPOeszrQTzgV4/o767y3bMrAUIAhQ2qL5V26uNR93oIuuOACKioqeO+99/juu+882+12OxdddBEXXHCBD1fXhpw1rzH36zQ4FACzrPTAUCBnlfXhENTfiQ61RfQi3zYNmts3117/7H3oEocxupP8nbYjZmFNp3nUftFJju7WZV4OZlUlhj2gbRfWzqiILu2GER4Bw07AGHYCAGZ5GWxYhbnmV8w1v1qDXjZvwNy8AXPxQusT1YFDMJKPwTj6GHD0aPInlt5d6WvXWv87BAWZng6DXbv8yMuzaeCoiIiIiIhIB+D65F1P56tx2tkYV99Kdo69yQNDU1Iqycjw9xTXNTC09Vx22WWMGzeODRs2UFxcTHh4OElJSYSGhvp6aW3HHeditzrRjaAQq0O4vjiX8vLa64GB9R8vIgoAs7jAt8n8u7bWuWn+dx7mGam1HffSNmo60Y3I/eJcwiOtD2zKSiB7D/To7YPFtR8qoku7ZQQFW1+rG1pTVM/bi7n2V3AX1fcVwW/fY/72vfWPR3xPq4vghFMxuvVs1HN4dwjMmnVgh8HUqVGe6+npQSQnV6krXURERERE5Ahjmibm+69hvv86AMbZ4zEunoRhGIc1MPTWW0vqFM7Vfd66QkJCOOaYY3y9DN/ZP84lpIFM9PKabQEBVgpAPYywCKuOUuzjTvQdVhHduPxGzPdfg9IS2LUNevf16bo6E7OiwvpzhwPjXAzD6kbfkmFFMKuILnJkMGK6YqScBSlnYbpcsGMz5upfrcJ6xmrYs6Pml6LXoGcfjONHWgX1Rg4nnTjR+qGRmlrOunX+9Q4cXb48UF3pIiIiIiIiRxDTNDEXvoT56XsAGBdOIGf45cyfHXbYA0MBFc7bUGlpKbt27aKysvKA+wYNGuSDFbWxmk50GpGJ3lAeukdEzSw4H8e5sHMLAEaPozB794V1KzC3bsJQEb3t1ES5GEHB9cb/GI7umFsyMLN3+fZbC+2AiuhyRDJsNujd1/rBes7FmGWlmL9+h/nDMljzC+zYgrljC+Z/58NR/axi+vEjMbrEHvSYgwc7PUNE09Ot6dQHGzj61lvB/PRTgDrSRURERERE2jHTVY356rOYyz8F4Iu4NIYcf7YGhh4hqqureeGFF/jf//6Hy1X/e+833nijjVflAwd0olvflqBk34H7lpdZlwfLQwcIj7IuiwtaZHmHw6woh71Z1o2efTCO6ou5bgVs3QinjvHZujqdmigXv5hYMAxrMK03Rw/rMmtXGy+s/VERXToEIzgE4+Qz4OQzMEuKMX/+xiqor1sJWzdibt2Iuejf0HegVVAfnoIRFXPQ43kPHM3Oth3QlR4T4/L8wpWSUqFCuoiIiIiISDtjOqswX5yN+dNyMGzsPOsPXHvnVSy5IkcDQ48Qixcv5qeffuK2227j2Wef5YYbbsDPz4/PPvuM0tJSrrvuOl8vsW24i+j2mjJeuNXkZ+4rOnDfRnWiR1mPLypooQUehq2bwDQhMgYjPBLzqH7WmrZu8t2aOiEz3+pE9+sSS70THWqGi5q7t7fdotopm68XINLSjNBwbKeOwW/KDGx/+zfGVbdC/6PBMGDTOszXX8A17Tqq/3Yfrh+WYdb8Y+TNe+BoZqb1j9ScOeGeX6pefLE2I2/+/E40zEREREREROQIYFZU4Hr2EcyfllONP0VX/InMOKu7df+Boe6GqfvvL2TJkhzmzs33HEcDQ33ryy+/ZPz48YwcORKAfv36ceaZZ/LII48QGxvL6tWrfbzCNlJd84FOTSe6ERZh3a4v09zTiR500MN5mgprCqi+YG5cY13pNxAAo6aIzo4tmE5926PN7NoGgF9NsXx/RveaHPRd2w/sUu9k1IkuHZoREY1xRiqckYqZn4v503KrQz1zPaxfibl+JWZUDMbpY63J7BFWF4J3h4G7K/3hh/PJybG+1nfJJaUsWhTC5MnFJCZWMm1aJBMnljB48IEFeREREREREWkbWVk2Fr5iclPlg9i3rqbaL5CJ38zisnMG8N57DXefa2Bo+5OVlUWfPn2sAYdAVVVtcXX06NH8+9//5qqrrvLV8tqMcfRxGEEhBA8fQTmAu4heTye6WdGIOJfortZl/l5M0/T8+bYlM8Mqohv9ajLtY+MhJFTDRduYuW4FAEFDhnPgxAEgvgf4+Vn5+/m5ENO1TdfXnqiILp2GEd0F46zz4azzMfdmYS7/DPPLJVCQh/nufzAXL7Ry0383DiOhv+dx7q70bdvs/POfVgf6okXWEI/9v+7nzlQXERERERGRtlf823rO/XU29tCdEBzCC/4zWbZ3BMvS6t9fA0Pbt6CgIJxOJ4ZhEBYWRk5ODgMGDAAgICCAffvqyQTvgIwBQzAGDiWoWzfYvRvCD15E93SiBx68E53oLtZlRTmUlVrF6zZkulyYG9cCYCRZRXTDMKzCuYaLthmzrBS2ZAAQOPR4qD6w09zwt0Ncd9i93fpwoxMX0RXnIp2S0dWB7YKrsD32EsYNUyChPzidmN8uxfXI3VQ/cjeub7/ArKry/AJ16637PF/rc3/d74knCjzbUlPLycqyMWtWOFlZ+l9LRERERESkLWRl2Xjyb8EUz19An0VTOSp0J6XBDjIveBy//snAgbEt7vdxkyaVkJJSoYGh7VT37t3Jzs4GoH///ixevJjc3FwKCwt599136d69/giKDi/MykSnohyzsqLufTXDRg338NF6GIFBtcNJfRDpUv7Ld1Znc2Aw9EyoXddRNYXzrRvbfE2dUsZqcLkgrhv+cfEH3c0d6WLu2tpWK2uX1IkunZpht2OMGAUjRmFuzsD8/APMH5fB5g2YL23AfPPfVszL6WNxOLp4frlKTLS+5BIUZHomue/a5Udeno3Zs8MZPrwSh6OigWcWERERERGRlrDlu92c/t2ThERZ8RCLdpzLA2umUvxWbRFx/9iWlJRSQAND27tTTjmFXbt2AXDZZZfxwAMPcPvttwPg7+/PXXfd5cvl+U5wCPj5Q7XT6kaPia29rzDPuoyMrv+xbtFdoHQf5O+FHr1bb637MU2TotdeAMA4dTSGn1/tna0wXNR0VmF+/yVsWAVdHBjjLvdJfE17ZGauB8DoP7jhHXscBT8thx0qoosIYCQkYdxwJ+alkzC//Bjzfx9aUS8fvIH54SKM404h7nfnMmVKMn/8YxRQN0tv6tQoz/X09CCSk6uYPz+UCRNKcDhcbXw2IiIiIiIiHVdWlo3580K4sf+bDH3/XwREVVBQGcE9q+5l8Z6zDtj/iScKCAoyPbEtGhh6ZDj77LM91xMSEpg9ezY//PADhmEwdOjQTtuJbhiGlYtemAfFdYvoZmGBdeWQRfSusHMrZv5e2rSkvGsblWtXgL8/xtnj69xlHNUXE6zhoi2Q1W6aJq4nH7AK6O7nGHq8p1jf2ZnbNwMcMjrH6J2ICZjrV2C6XBi2zpm+oCK6yH6MiGiMcZdjjr0Y85dvMT//ADauwfxhmTWUtP/R3HLmJOBEUlPLWbfOnxkzIj1fDZwzJ5zERCfLlweqK11ERERERKSFZGXZPI1KG38uYuiyRwhb/zUAX+acxNoT76Lf0bEwx4psSUmpJCPDn7S0aIYMqfIUzpOTq9R9fgSorKxk0aJFjBgxgsTERAC6du3KOeec4+OVtRPh7iL6frPZiqyoIiOi4SK6Ed3FKli3cZyL90BRI6pL3TvdA0+dVVbcSwORNI2yboVVQA8IgEorUcDM3IDRjoroZnkZbMuEvgPrduW3hW2ZABi9EhreL3mYNag2by9sWgc1OfadjYroIgdh+PtjnDASThiJuW0T5ueLMb/7H2xYTZ8NU3l08HBsCRNITz8OqPv1wBkzIj3X09ODGDVKRXQREREREZHmyM72Y/bscC7u+xlD0ucSGldIeXUAj677P17eehnmD7XdkZmZ/tx6a0mdx6twfmQJCAhg8eLFHHPMMb5eyiF99NFHvPfeexQUFNCzZ08mTZpEcnJy6z5puFV3MPcV1e0kL7SK6I3qRAco8E0Rvb5CrGEPsHLSK8qsDvtmFNHNqkpcH71tHffk30F4FOYHr8PmDXBG6mEft6WYzirMb5divv865OVAXHdsdz2M0UaDO83iQuvv3jCgV58G9zUCAjGOHYH5zReY33/pGQbb2XTO/nuRJjJ698U26f+w/fUfGKedDTYbrPoJ18N3clfYfSSFZTJ3bj733299Auw9tCYx0cnSpQFMmxbJqlX63EpERERERKQxsrJszJoVTlaWVboo2FPGzCEP0Wvxw4Sahawq7M/rCf8g4sJzMbHVGRiamloOoNiWI1zPnj09g0Xbq6+//pqXX36Ziy66iMcff5zk5GQeeeQR9u7d26rPa4RFWFf21Xaim6bZhCK61QVu5uW0xvIOytxU24ler3D3eRUd/nO4qnE9cS+s/gUMA+OMczESkqz7tmQc9nFbimmauJ6fifnKXKuADpC9C/OLxW23iO1WFzqx3TCCQg65u3Hi6QCYPy3HdDpbc2Xtlip6Ik1gxMRiXHMH5tnjMd97DfP7L+m6/Ss+Oe1rKneP4unMm4DIg3alA8ycud9XrUREREREROQA7s7zhAQnQ8NW0G/hLE7ptQuXafCPzInM2nArVcvtnv0zM/0ZP77YE9kC6j4/0l188cXMnz+fgQMHEh8f7+vl1OuDDz7gd7/7HWeeeSYAkyZN4rfffuPjjz/mqquuar0ndhfRi71e36UlVhQKHLKIbnSJs+Jc9rbdhxTmxjXW89lsGH0H1L9TWATszTowpqYpz/PDV1bHeXAItmv/D6PHUZgRUdade3ZglpZghIQe3rGLi2DXNoiLx+lnWB9cNOXxZaWYH7wBv34Hhg3j/CshKBjzjRcxM1Yf1poOh/nVp4CVQ98oycOsbz8UF8K632Dw8FZcXfukIrrIYTDiumPceBfmOZfgencBtl++JejXz7nb+B/djr6QuEmXUEAsU6dGHTDAxjvHTwNHRUREREREanm/XwKwG1Vsefp1xvX7N36Gi+2l3bjzt+l8n2/Fao4eXc7555d53m+paN6xfPHFF1RUVHDnnXdy1FFHERUVVWfYpGEYTJs2zWfrczqdZGZmcuGFF9bZPnToUNavX9+6T14T50JxQe22mjx0QkKtaJSGdHVYl7lZbTIs0izKx/XcowAEjzyTqqCQ+gvQB4upaezzbFqH+dYrABhnX4Qx/BTrengkdImD3GyrC3vAkKYfe/MGXM8+YmXRA7sBgkMhMhojeRiEhEJ8T4ygYOtDjLISK56mdyL4+cGOrbj+9STs3Gqt6aJrsI29GDNnD+YbL8KWDMyKCozAwMM4c691FuTBxjUQEAg9Ew6IiDHX/GrN/DNsBwx3PRjDzw9jeArm0nRcS97G1m+QdZ77P7fTCeWl4KrGmkZqYl3B63YraeUoHBXRRZrB6HEUfrffi7k5A9d/52Nb8wvXHPUW5rL32Zl0HtH22wgKMikvt37079rlR16eTQNHRUREREREangXzteu9fd0n0ft/IGPT/0HfcO2AbA6fDSXfXwff3nUyTVB+aSlRTNpUgnJyVV1us+l49i2bRv+/v7ExMRQXFxMcXHdD0i8C+q+UFRUhMvlIjKy7jfQIyMjKSgoqPcxVVVVVFXVvlYNwyA4ONhz/WDc93kuo2Ks0mRBnmeb6YlyiTn0n02XOCuq1unEKMxv9Sxu1zvzrS7mnn2I+b/7yS6sP67FCI/ABIx9RU3++zXzcnA9+YCVqd7Vge3M8+p+6NI7ETM3G7Zvxhg4tGnr/+RdXAv/BWZNM6RhWP+VlUBZCeaeHbXr2P/BNhvY/Op8S8B2+U0YJ4y01hcbbxWA8/bC5vVWQf4wuFb9jOv916zhn16MU87EdvZ46N7b2u/tV63tZ6Ri65N0wGvrYGynj6V62cewfiWuqZOs47mL5mVl1mVV5WGtvSX4/+MdoPV+LqiILtICjIQk/O6cjrlhFa535mNsXEPPtW+x/IwPefHpq3hh8wQApk6N8jzmrbeC+emnAHWki4iIiIhIp+aObRkzppz09GCOCtlB8MuzOd3xJYRBTkUMf1k9jcV7zgJgyJDaDOcuXVzqPu/Ann32WV8voVHqK9odrJD3zjvvsGjRIs/thIQEHn/8cWJjYxv1XO5Ym7K+SewF/PcVEd+tGwAl638jDwiMdRBXs60hu+K6Ub1nJ11MJ4GN2P9wmNXVFL7yDMVffQJA3OT7sQWHEB9cfw53gaM7xUCoq5qoJqzJNE1yX5pFWUUZAQMGE/vQXGxh4XX2KRw0jKJfviVo7266NOHY1YX57H5nHpguQk4bQ/Tv78UICsJ0Oqnes5PKzA1UZqzBLC/DuXsHrpJiqvNz8YuIorogD1dBHrhcGMEhBA46hqhb7sbeo3ed58gdegKlSz8kbNdWIn83ttFrc5974avPUbzw355t9oT+YLqo2rIR8+vPqP76M/x7JWAEBFC9dSNGcAjdbpyMn1fszyEjk7p1o+Kxf5A76wGq9+yEzAa+beF+/RsGYOD5WoH7diuIj3fUXLZO9JOK6CItyOg/GNu0R2H1z5S8toCw7I38IelFbklexL0//YGeF58GhsGcOeHExLg8HRYpKRUqpIuIiIiISKewf8Rlbq5VUMlcW8Vlgc/z4KlvEuhXRTV+vJR5BQEXXUba1ADGZljd56CBodI+REREYLPZDug6LywsPKA73W38+PGMGzfOc9tdbM/JycHZwMBGwzCIj49nz549mKaJ6bIeV5Wzh927dwPg2rwJgMrgUM+2hriiu8KenexdtxpblwMLj+64lcPt7DVd1biefwLzp+XWccZdTn6Mg3jwnMcBa7L5AbAvaxdljTgHz+M+fQ/XN0vBz4/qK28hq3gfFO+ru0+09UFF6brVVDbl2O+/jllZAX36UXHN78kqKsYo3kd8fDzZgaGYA4+BgcfUeYwNqyPdME38CvOgogJiHThtfuwF2O/5Xb0SASj++VtKzzy/0WvznHtNAd048zxs51yMGWUNjrWt/hnXO/Ngxxac2zd7HmNcOIHs0nIo3X3Aa6tB0Q546Dn8tm3CzM8Ff39rMGlwzX9BIRAUjOHn16RzaAlZuXkNnoe/v3+jP6yqj4roIi3MMAwYPJzQh4+Dn7/B9d/5BO/ZwZPDHuSb747jz6v/BITz4othAKSlRXPzzfsICzPVlS4iIiIiIh2e98DQpCQnL78cyvndljD8vafpFpwNfvC/nBFMX3MXG0sSuHprCTcMKaxTOFf3ubQH/v7+JCYmsmLFCk488UTP9hUrVnDCCSfU+xi73Y7dbq/3vsYMqTRN0/ovKsbasK8IV2Ulht2OmbXT2hYb37iBlzW56GbOgUVHM3s3rsemQVmpFTtyxc1NHsbpWvKOVUD398e4/k5sJ5zqeR73eRxwfqFW97hZXNTooZ1myT5c7hz0S66DHkfV/9heCdblnu24KisOnRvvPo+vP7OOXVPc9j72wc6jjsiYOvvXK+lo6/7M9Z6/z8YwiwtxvbvAWt8l11mxLV7PYww6Fr9Bx2IWFdT8XdgxBg7FqOc10qhzAaub/Kh+GEf1O/i6WjP7/BAafR5N1LpTA0Q6McMwMIafgu2BOWw+5nrKqgM5ucvPfHzalfxpwFyuujgXgMmTi+nd28ns2eGsXdu4H5IiIiIiIiJHkqwsG7NmhZOVVVuGSEuLZsqledxSnMYzx/6ZbsHZbCvtwQ0//o1Xo55g8mNRAKSmlgN4CudqPOrYrr32WjIzMxu9v8vl4tprr2XLli2tt6gGjBs3js8++4zPP/+cHTt28PLLL7N3715Gjx7duk8cGg7+NTWEAqu+4Mnlju/ZuGO4h4vuzTrgLvObL6wMc2cV5jdf4Hp1bpOWZ+bswXyvprh79W3YTji1UY8z3ANT99WfmV7vc33/pZXF3bMPxpnnHXzH6K7W8M/qasja1bhj5+2FnD3WEM5hJx76AYcrvoc1VLWqErZmNPph5mfvQ1kp9E7EGH3BQfczIqKwnXEutlPHYMS2TtxJR6dOdJFWZvjbCb/kIv5TPJqRO59hQPlybu/7CttzPyYn7m7mzDnds296ehCjRmnYqIiIiIiIHPkONjC0vNwgyl7Aq5c8zbDCDzBwUeoMYmPSlWxNuoRPljpYMClXA0M7qfLyclyupn1QcjiPaSmnnHIKxcXFvPXWW+Tn59OrVy/uueeeZsVGNIZhGBDdxSrwFuRZwyn3WJ3oRnyPxh3E3YleXxH9t++sK8NOhN++h5U/YTqdGP6NKyWaHy6yhk4mD8NIOatx6wGrkAxWAb+RzOWfAmCknHXo4axRXaC0BIrygT6HPvaGVdaV3okYB8lxbwmGYUDSIPj5G8xN6zH6DWrU48yfvrYeP2Y8hk290q1JRXSRNuBwuLj5T6FkZd3Dd2//RI/lf6dXyG5eOv4uNoaewuexaTz8XBKJiU6WLg0gPT2YiRNLGDz44HloIiIiIiIi7dn+A0MB/vB/4Vzd+22+PP0fRBVanabv7RrNX9dN5t9T/Ohb81gNDO3c7rvvPl8voUnOPvtszj777LZ/4qgYyNmDWZALpftqC8+O7o16uBETiwmQv7fOdjM3B7ZvBsOGbeLvcd1/u3X87ZshIemQxzUL8jC//hwA2/lXNi1TPSzCuixuXCe6mbcXtm60OsVPOv3QD4iIgl3bMIsKGjfesqaIbgwY0qj1NIfh6GH9feRmN2p/c9c22LPDissZWn98kLQcFdFF2pDD4YKLhvP6vn8xcNN8Tq96g34lX9Oj6CfyEm/isYevpsqsjXSZObPxn7yKiIiIiIj4mnf3uXtgaEaGP4mJTk6K+YlnT3ucuEorqiM3OJHic27BLDuO3WnRQI4GhgqXXHLJYT0uJibm0Dt1MEZUl5oieK6nC52oGGvQY2PE1HTL5+/FdFVj1Az1NFf/bG1P7I8REQX9kmHFD5gb12A0poi+8keodkKfpEZ3VHu4O9EryjArKjACAxt+rnW/WVf69KuNgmmAERFl/ZkVFTRqOebGtdbj+h/dqP2bJaar9Zx5OY3a3fzlW+tK8jGt2iUvFhXRRdqYw+Fi8lQXS5dO5JxbLuD1Cx6ma/5K/jTwGW477n1WDk7jqgdHkZpafsDUehERERERkfZk//cs3rEt771ndZ8/d28O0wY8x5sjvoJKKKiM4IkNt8HIMTx2TglhWRUaGCoel156qa+XcOSI7mJd5ufW5qE7GhnlAhAVDTYbuFxQWFB7vPU13dfJw6zLpEGYK37AzFgNDeRuu7mL8MaQ4xu/FrfgELAHWNngRflWTE1D1v5WZ62HFBFlXTaiiG5WVYF7WGvvvg3v3AIO9s2AgzE3rrEed/Rxrbco8VBYjoiPJCc7GXdzHEx5hPUn383eimgiS7cy8vu7mT30AXK3FLF8eaAGjoqIiIiISLvljmzJzrY6WN2xLWlp0WxYnsPTx9zHR6dexZlxX+F0+fFF9YV8fc6/mbftUsaea8VXamCoyGHq3hsAc8PK2tiRnn0a/XDD5mcN2wSo6X42TdM6HmD0H2xd9k609nF3uzfArK6GNTWF7aOPbfRaPGsyjEYXuk3TxGzFIjpZO6wPGIJDreic1ub+ZkAjOtFNlws2rQfA6JfcmquSGiqii/iI5xfFeJOX153HGV8uYv62i3CZBpf0XMyoL27gk0esQR7p6UH1TrMXERERERFpa/W9N8nI8GflSjuJiU4cgTm8f8V0lo66hAu7fwTAjm6jOHPZQvwn3saJZwRqYKhICzCGngCGDbZlYi7/zNp27IimHSR6vwiR7N3WoFJ/f+g70NoWHmVdljTiWyLbNkFZCYSENSo/vV7ugnVhfsP7FRdY+xgGJA5o3LFriuhmYzrRd26zrvTo3bRc98PlLqLvK8asKG943907rD/ngEBowgcncvgU5yLSDkycWAKEclTqLbz30+/o+91chkSu55lj/8xZjmUU9r6N5ctDmT07nOHDK3E4Kny9ZBERERER6aS8I1vKy63CUlpaNJH2Qu5IfJlloxYSVGS9Z/k8+xRW9b2Osy7tyeaXYunSJUeRLSItxAiPhAGDYd0Ka0N4JCQ1LYPcEyHi7kT/5RvrjsSBGAE1eeTuYZ8lxZim2WBB2dy6ybqSkOTJWG8yd6G7ML/h4Z97dlmXMbG1az2EJmWi77KK6EZNx39rM0JCISgYyssgby9063nQfc1NVlY7Cf0x/A7zz1maRC2tIu3A4MFOZs4sZNSoCr7LGsIFX7/Ckxk34XT5cWH3jxjz7c288eAGQF3pIiIiIiLS9rzfg3hHtkydGkWIXym/7/sSy0edz6195xHkV8HeiKP56qRZTPrxaY49v7cGhoq0EiPlzNrrJ53e9MJ1F3ecy15Mlwtz2cfWsU4+o3afsHDrsroaykobPt52a3CwJwLmMBiR0daVooY70U13XnlTcuA9cS6Fh9zVrCmi0/2oxh+/uRob6bLN+rDCSOzfygsSN3Wii7QzqallLFgQSuL/XcYHm4cx9KeZJIZu4z8n3cFLm6/E6HONJytdXekiIiIiItJavIeGenefJyZaWeZT0nIZWvQBQ3YsIDYwD4DC8ET+8EUaU18ZwECHiymFVmyLus9FWodtxBmYRyVBQS4cTjZ2TdHW3JIB3/3PinMJCsY44VTPLoY9AAKDoKIc9hVBSOhBD2dus4ro9GrGIM6ImiL6oeJcsqxOdCO+CUV0dzRNcQGmy4Vha6A5sSYD3migI7zFxcTCrm2YeTkNduGb2butK442XFsnpzZWkXYmOdnJlCnFpKRYXennfLWAV7deAsANCa9x6pd38Px9WYDVlS4iIiIiItIavIeGenef/3VGGJf0+ICLV07idzlziQ3MI9fWHePGu9g5aS6fZZ8KhqGBoSJtxOjWEyN5mFXsbupjk48Bfztkrsf815PWtt+dhxG4X73BHemyr+igxzKrq2HnVusYzehEJzLKOt6hBovWFNFxdG/8sSMirUuXC0r2NbyvuxM+ukvjj99MtV34BQ3v6P4AwdGtdRckHiqii7Qz3r9opqaWUVYdTOStt/Bhv0fILu9CUvhm3h95LXf0/Rd9EypYujSAadMiWbVKXywREREREZHDt39sZG6u1QeZkeFPYqITAxfPXP8BP154GbOHPUivkN2UB8Zw76o/sfbyF7CddDpxDlOxLdKiSktL+e233/jiiy/46KOP+Prrr9m2bZuvl9VhGI7uGJP+zxrOCRgnnIpxwZUH7tiIIjp7dkJVJQQGQ2z84a8psmawaEFewzvWxLkYTYhzMfzt1tBTsAaTHoRZVQWlJdYNdwRMWwgOsS7Lyw66i1lVCfl7rRtxTfgAQZpFVTeRdsy7K33Wtyn8admJPDrkr6TGf8EfBzzHj59+xR9mPcS2MivDbObMQ2d6iYiIiIiI1MfdeZ6Q4CQpycnLL1uFpv9LiyQ1/nM+OvUFBu6xcngLKiP4JvJKTpg6mriFXRh4tFVsUmyLtITq6mq+/fZbPvnkE9avX4/LdeC3GcLDwxk5ciRnn3023bqpG7c5bCedjpl0NGBiuDO591eTi27uKzp4zEiu9a15HN0ajkk5lIhDd2ObLhfk1ESaxDXx7z84BEr3QUUD8bjFNfUVPz8IPnh8TYsLchfRG8iez94DpmmdR3hk26xLVEQXac+8fwG1stK7UjXpHr7begKDVjzL8TErWHrWldzzy12cPGIks2aFM2FCib4uKSIiIiIijeKde+6WlmYVsAxcjIv/hMlJLzAg3Mo5LjVD2d7vQi7++438/ZVKHL0qVDSXFvXjjz8yb948srOzGTp0KFdeeSUJCQlERkZit9vZt28fWVlZbNiwgR9++IGPPvqIM844gyuuuIKIiAhfL/+IZcR0bfj+sAhMaDjOpSDXuhLVzPiTmjgXivIxTRPDqKdsX1IMTms+A9ENr/0AAYHWZWX5wfdxd6mHRzbvA4GmCrKisxrqRCenJsYmrnv9fzbSKlREFzlCeLrSR1aytsvvGPPsqbx/8b10zV/JE0MfZtOXp/Dguw+QkBBISkqFCukiIiIiIlKvgw0MLS+3ijF/+L8CTg37goQ18+laaeUbV/mH8szaqxhxz9kkHRPEjXZITq7y5WlIB/Xss89y7rnnMnr0aCIj6++yTUpKYuTIkVx//fWsXLmSt99+m48//phLLrmkjVfbiXjiXBr40Czfil8xmltED615rupqqCir7c725u5SDwvH8G9iedNTRG+gE919/LaMcgFPEd1sKM4ly+rAN5ragS/NoiK6yBHCuyt91qxgdpZ35fgFL3Jjwn+Y2v85+pZ8zcenXsGd06ez8qKhhIWZ6koXEREREZEDuGNbxowprzMw1EY153dbwnm/vERS+GYACqvCqBh5IXnHXMCTFySwpHsODkeVus+l1TzzzDOEhjY+PmPIkCEMGTKEkpKSQ+8sh68xmejunO7mDuIMCAA/f6h2WrnkDRXRw6MO7/jQYBHdLKqJc2nruJTGdKK7Y3OakTsvTaciusgRaOJE65eDk08uJyPjQs771whePu0+ugdm8uqJk1nJVZw/+/8YPrwSh6OBT1ZFRERERKRT8O4+339gqI1qnr3uPUbkzaNLlTWwsTowjA29LuLS565j4V3lxMVVa2CotImmFNBb4nHSSDVFdLMxcS7NLKIbhgEhoVYueWkJ1JPTbjanUzwwyDpGRcXB891rjm+0cSe6ERRixeaUNZCJ7i7wt3WXfCfXhqE+ItJSBg92MnNmIZmZAcyZE8664iRO/3Aer2y9FAOToTsWsODEO/jyA30SLyIiIiLSGWVl2Zg1K5ysLOttvzu2ZfnyQM/A0MlpEax86Ws+Pe0yzs36K12qtlFQGcEnQddjn/kCsZMu48b/g7i4as83Y/VNV2lLl19+ORs3bqz3vszMTC6//PI2XlHnZYTXdKIXN9CJXtBCcS5QO8yz9CB1jZrBn8bhdIo3JhPdx3EuVDQQ5+L+IENDRduUiugiR7AJE0qYOzcfgGuur+T+1X9kcfyfqTSCSOn6I3eW3MAvr69l2rRIVq3SF09ERERERDoLd2RLdrYfQJ3Yls8/9Wd893Q+Pe0ynj7mfvqFbaXEDGdt0iROWfoeQRdfjhESqsK5tGsul0tDFdtShDVwmMK8g++T30KDRQFCrQ/7KDtIEb0ZRW6jMZnonsGiTT9+szQmzsXdJa8ieptSVU3kCOZwuEhJqWDKlGK2bLF+Ob7tXxfSN/QY/n7cHxkYvomjP72H6A23MM+8jMefUG6hiIiIiEhH5R3Z4paRYb3tT0x0EmCr5LmJb3Fi/mtEVe0CoNIezpOrruHU+8+i/9AAbvYzNTBUjgiZmZmEhNSTlS2to0ucdZmXg+mqxrD51bnbrKyA0n3WjeiY5j9fTSe6WVpSf+RKczrFG1FEb1ZcTHMEN6KIXuyjvPZOTkV0kSOcuztk6dIA3n47hLlz8ykvj+L8P77CkkkzSNzzEdMG/J284O/JzpzCvHe6a+CoiIiIiEgH5I5sSUhwUl5ulZ3S0qIJspVzVe93WHb6PLplZwOQWxHFD5GX0mfSWJ49/yjOi9fAUGkf0tPTSU9P99x+4oknsNvtdfaprKyksLCQESNGtPXyOq+oGPD3B6fT6jh3F9Xd3HnoAYG1USzNYISEWtngB4lzMZtTSA6wMtEb7kRvRlxMc3h1opsuF4atboiI6aqGkpqf0xEqorclFdFFOojkZCdTphSTklLB2rX+lLuCWHns3ezdPIQhq+cSs/snyp78A//7/DGGD++pgaMiIiIiIh2Ad/e5d2QLQJj/Pib2XsSNCQvoGmjFQJYGdGFT4qVcMudqXny1lK49qzQwVNqViIgIevbsCUBOTg4Oh+OAjnO73U7v3r1JTU31xRI7JcNmg5g4yN4Fe7PqKaJbP2OIimmZmJ0Qdyb6vvrvb87gT3cnekUDdRH384aFN/34zRHo9VqvLIeg/b5tsa8YTNO6HhrRdusSFdFFOgp3RzrArFnevzxfwYDw4/n7sX+kH1tZOOJmPn77FrIGnsP8BWHcfbcPFy0iIiIiIk3iXTR3OFx1us8TE50A/PH3Oziu4C0GZf2XSLv1HqEkOJ6Hv7+OiX8fQbfuftyGk+TkqjrvI0Tag5EjRzJy5EgApk+fzo033kiPHj18vCoBoKtVRDf3ZmEMGFL3vpYedtnIwaKH14keYF021IleVhOnsn8Ru7UFBIDNBi6XFemy//O7zzssHMPP78DHS6tREV2kA5o40fpHJjW1nHXr/Jkxox/pw55jTNYsBu77nHPLnmP33F95af7DjBkDQ4f6eMEiIiIiItIo7oGhY8aU43C46nSfxwbs5d6Bc7hmwyJC/cvADtm23jgmXczWkDNZ8FY81/grtkWOHA888ICvlyBejK4OK2Jlb9YB95nuInpYC3VHuzvRyw7sRDdNs3mZ6IENZ6KbplmbSe6OV2kjhmFYz1laYhXyo/bbwfPhwf53SGuzHXoXETnSDB7sZObMQkaNqiAz0/qs7G9zHYxZ+Dj3rvoTFdV2umV/zeKR1/DN62vIyrIxa1Y4WVn6kSAiIiIi0t7U9/t6RoY/K1faSUx00iNoN+9dOYPvRp/HrYnzCPUvoyC8L7f+/Bjrr3ge28lnEBePYlvkiJCRkdHkx1RWVrJ9+/ZWWI3U0dVhXdZTRHd3ohstFX8SEgZYg0UPUFkBVZXW9fDDKNrXxLmYB+tEr6wAs2aOXLAPhtcGHXy4aLOy4KVZ1Iku0sGlppaxYEEoc+fmk51tY8aMS0g+J4Hzdj9I75CdTMq5gZX/uYPZsycwfHilstJFRERERNqZgw0MTQjdyu2Jz/HlqHTshVZx/Mf8oazqdTXjpg1iYI8wkgdZBSjFtsiR4sEHH2TYsGGMHTuWoYf42nRBQQFffvklH3zwAampqfTq1auNVtlJ1RTRzQaK6C3eiV5fEb2sZpvNBoGH0SnuHixaUV7//WWl1qVhq81Pb0vucyovPfC+IncRXXnobU1FdJEOznvg6KxZ1ifC9z0/nMf9/8MTQx/inPgvOGb1Uzw2eCsfLb6dUaN8u14REREREWl4YOiA8I38vu+/GNftU/wMq1tyT/SxbEq6iisfHMWC3+fhiK9Q0VyOSLNmzWLevHn89a9/JSoqiuTkZBITE4mIiCAgIIB9+/axZ88eMjIy2LhxI2FhYVx66aWcddZZvl56h2dExlhxLu4oFW8tXEQ3QkKt5yqrr4heU1wOCjmsIaZGQKB17IN1oruL18HBLTMktanc3e8VB3ais88qohuKc2lzKqKLdHDeHSf7d6XfMmMmb974Cifueparer/DrvL1zLh7BqeOCyU52YnD4fLx6kVEREREOg/vwnl9A0MfveV7TsqbT7+Srz2P2R03glv/ewuPvh7PgLhqphTtIzm5ylenINJs8fHxTJ06lR07dvDxxx/zyy+/8M0339TZJyAggP79+3PzzTczcuRI7Ha7j1bbybijWvYd+AGd6d7WUp3oDQ0WdW873KiVgIYz0X02VNStJs7FLCvjgBK+58OKForNkUZTEV2kEzmwK93g0hcncXrX/jxz7H10Zw03FtzMrb9/nNOu66vOFRERERGRNuQ9NLS2+zyKk2J+Zv4J/+K07d8B4DINVgWM4ph7LiS/oD+/vBwL5CiyRTqUnj17cv311wNQVFREXl4elZWVRERE0LVrV/z9VdJqc+4CeVkJZnU1hp9f7X2tlIlO6YGDRT2d6O5Ce1N5iuiV9d/v6UT3bRG9vkx0Spt57nLYNEVQpBNx/1LtcLhITbV+GM+fD+P+OIhxy+eRE5BIXFAui065hcu7LWLW38I0bFREREREpJXsPzA0N9fqOczI8CcxoYpRscv55qLreHPELZwW+x0u/NjWYwy/+/JNCi/7E0avBOLiqjUwVDq8iIgI+vTpQ//+/YmPj1cB3VdCawrkpnlgcbu1MtHLSjFddb8lb7qL6CGHWeQObGQmetBh5K23AMPdAV9PlI3p6wJ/J6afOiKdlLsr/eijw8nPN9la2pP/9HqGxGVPcl73T+j2xbPEb9/OumNvwuHw9WpFRERERDoed+d5QoKTpCQnL78choGLxQ//Qlq/f3HTCeugHMqrA1i443x2D7mEG24L48LwUJKTNTBURNqW4edndUCXlViRLuGRtXe2VhHdNK1it3fR2F1cbnYnev1xLj4vVLuHhhYXHXhfzbkbKqK3ORXRRToph8PF3Xfv4/nnw5k+3RpQNGtuHPAIKwqT+dPAZ7ii13tsf3MDOT3/yKsf9GHChBLlpIuIiIiININ37rlbWlo0foaT87t9zCenvkz/8EwASp1BLDMuxDzrQv48tR8L7s3F4dDAUOlc1qxZw4cffsjOnTup3C9+wzAM5s6d66OVdVJh4VYht6S2wGs6nbXd2y01WNQeAP7+4HRaGeh1iujWcx12IbmRmeiGrzLRI6waDUX5B97X3CgbOWzKaRDp5G65BRYsyOXqq0v4wx+KAIOg88fzTo/Hya+MpFf1OkKevpOv/p3B2rUa1iIiIiIi0lTesS3ugaHLlweycqWdAFslL056jVUXjWfOMX+hf3gmlf6hrO97NSd/8QEhE6/j+DPDmDKlWANDpdNZt24dM2bMoLS0lJ07d9KjRw9iYmLYu3cvfn5+JCcn+3qJnY+7SO49XLSk5rphq+0gbwnuQvH+sSZlLTRY1FmF6aonCsvXnegRUQCYRQUH3lemOBdfURFdpJPr1g3OOKOSmTMLycmxhoLMmRPOlBfPYNzyV1ld1J+gygJeO+k28t9ejGmaPl6xiIiIiMiRxR3bkp3t5xkYOnVyMGueWcKy0y9kTPYsQst2k1sRxePr7yDzhleoPncC+VVRdOniqjPbSKQzWbhwIaNGjeK+++4D4PLLL+ehhx7i8ccfp7y8nBNPPNHHK+yEanLRzRKvIro7yiU0DMPmV8+DDpO7UOwuHLuVtlCcC9Tfje4e6OmrTPTImk70wvo60Zt57nLYVEQXEQ/3sNG5c/O5//5Ctpf14NNj57A27HfYbdWcX/Y0ux+dy71Tg1i1SmlQIiIiIiIH49197j0wdMBRhdyW+DK/njuO6Uf/jW7B2ZTYu7Dn1Jv5ZtyrPLvpOlyBoRoYKgJs3769TqHcVTNg8qijjuLiiy/mrbfe8tXSOi0jrGa4aJ1O9JohoyFhLftkB+1Eb2Y3dkBA7fV6i+juwaI+jnMpLqiz2TRNT9SMOtHbnoroIuLhHjaaklJBZqZVJJ81N5azFz7OQ2v/QLVpw7H5Uy7dOpl3Xz5wSrSIiIiISGflXTQH6sS2vPxyGJH2QjY/vZDxP1zNPQOfIaS6gG2lPfjTynt5NPR1ekwcx4jTbZ7CubrPRaCiooKgoCBsNhv+/v4UF9cWbrt3786OHTt8uLpOKtRdRPcaellVk1Xv3eHdEmoKxeZ+nehmM7uxDcOoXWtFPUV0X0em1MS5sK/Yypt3qygDs+bfBHWitzkV0UXEw/sXde+u9CeeKOTFzRP48tjHqbBHMDRyLVMqbib3h/V13iiIiIiIiHRW3pEtgCe25aG7qjlh2/N8c8Z5/CHpBSLtxWTs68OLzj/z6/iX+M/2izj7XKsoosK5SF1du3alsLAQgJ49e/Lzzz977luzZg1hYS3c+SyH5u5E945zqaopRNtbeI6aO1+9tIU70aHB4aKmj+NcCA0Dv5pYnOLC2u3uLnSbrW43vbQJ5TGISL28u9LXrrV+VBR1O4aPg56j78fTGUQGfi/cy7Zf72Xt8FNwOA4y1VpEREREpIPavRv+9rcwJkyoLfBkZFi/Ow/puZPpg/7LhIT/YjetLs3c4L5sGnAVlz0yjnkLCkhOrtLAUJEGDBo0iNWrVzNixAjOPPNMXnrpJXbu3Indbue3335j3Lhxvl5i51MzWNT06kQ3K1unE90IDsGEgw4WNZrTjR0UbHXT75+3DrXbfBTnYthsEB4JBXlQlA/RXWrWVduBbxiGT9bWmamILiL1cnfBAMyaZX36mpYWDUQT4vcSTw57gHPiv2D2sOksW3QZWQOuZv5/IpgwoUSdMyIiIiLSKaxYAbNnh5OQ4KS83Cpo/O2P+7i978tc0mMxAX2cYMJP+UOYu/EGuo0+hmtOK8P1iF+dgaEiUr/LLruMffusvO0xY8ZQWVnJsmXLMAyDiy66iIsuusjHK+yEQq0iet1O9Joiur2Fu6M9mej7Fbrdt0OaUUR3d7GX11NEr9lmBPuoEx2sXPSCPCgqqN3m65iZTk5FdBE5pIkTrU87U1PLWbfOnxkzIlkz8s9E5fXk5Lx5nFqxkKynN/Pif2YyfLhdXekiIiIi0mFlZdmYPz+Ua64p5e23rW1padH0D9vI08c8wXndPsHPsJpKlu89gcqzLqMofhif/18MC87N1cBQkSaIiIggIiLCc3vcuHHqPvcxIzTM6g53DxMF8HSit3QRvaZY3NKDRcFToDfLSjmgp7u83Lr0VZwLeHLRzcL82vV5OtFVRPcFBRmLyCENHuxk5sxCRo2qHTg65+lILp8/mdt/fpSy6kAce3/gv6dM4vv3cw4YqiQiIiIicqQ62MDQr74KICkJhkau4bNL/8Cnp13Bhd0/ws9wUdznRL4cMYcrv/87jtMGkzKy0hPbotxzkcabPn06O3furPe+Xbt2MX369DZekXgKy+7ccPBkohtt0IlummadWJPDP/ZBCvQAzlbqrG8Cwz1c1KsT3TNgVUNFfUIVLhFpEu+Bo/ffX8gHe0azqM/TFPvH0i9sK78vuZUN765i9uxw1q5t4aEiIiIiIiJt7GADQ+f9ZQuOhWl8kDKRpJKvcJkGi3efydPhLxB135/pemJ/zzFUOBc5PGvWrKGsrKze+8rLy1mzZk0br0g8RfSK8tptrZSJ7o5rMb0Hi1ZVgstVdy2HwThYVAxAVc2cCn8f1jTC3LE5Xh3/6kT3KRXRRaRJvAeOurvS73t+OKOWzOPH/KEEVu/jxO/u47qjXid9cQv/AyoiIiIi0gbq+2ZlRoY/K1f4c2rXb1l40s0sOvkmRsV+g9PlR0bMaL447QVu++Vxjj2/N4BiW0RaWX5+PoGBes/Z5gLr60Rvnc5to75ucfdzQfOK9u6889J6iujOmiK63YdFdHfeu3f2fJk7q11FdF9QJrqINIn38KPU1DIWLAhl7tx8srPtXPHXf/DfS6czuPgjph/9N1a61nDP1Cmcfa6T5GSnOm9ERERE5IjgjmxxDww1cPHejN9I6/cvUqPWQBeoqLazaOc4/r7pWk69KJq7zi5mSo4V2QJoaKjIYfrhhx/44YcfPLcXLVpUJxcdoLKykjVr1pCQkNDWy5OgIOvSWYXpdGL4+9d2orfFYFF3Ed1mw/Dza4Fj1xPn0h460UPDATBLvTrRSzVY1JdURBeRw+bdlT5rVjiVrgBS33iYmxKSuXfg0wwpSqcsbxe3XDeTa38fqjcRIiIiItJuuQeGTphQ4olsmZwWwbndPmXJyH+THLERgLLqQBZsu4i4qy+gV59+bJsAqam5KpqLtJAdO3bw7bffem6vXr0aw6g7+tFut9O7d28mTZrUxqsTAoNqr1eWg3+YJxO99QaLehfR3V3izXwu97HL63aim6ZZ24nu0yJ6mHXpHedSUdP9H6Qiui+oiC4ih63+rvQCysvHcd3MBF446V5OjPmV5eMmsOe4vzBr1tFMmFCijnQRERERaRe8C+fe3ed9E8q5tOdn3Df8X8RU7QCg0hZC0XHn8UPExTx0dyJLjs9h6FA8A0NFpGWMHz+e8ePHA3D55ZfzwAMP0K9fvzZfx9tvv83PP//Mli1b8Pf35+WXXz5gn7179/Liiy+yevVqAgICSElJYeLEifj7d9xym+FvB39/cDqtSJeQMK9O9BaO16mvW9wTHdPMAnfNsc39M9GdztrrvhwsGhqGCeDdie4+95b+sEIaRZnoItIi3F3p/ftXERRksjQnhf/0epbNJb0IKc+m9xt3s2bBDxo2KiIiIiLthvfQ0PT0YAJtFXz/xKeMXX4ts4Y+REzVDvIrI/nbhlt5NHwhjluu5qjB4Z7Hd+sGd9+9T00iIq3kjTfe8EkBHcDpdDJixAjGjBlT7/0ul4tHH32UiooKHnroISZPnsx3333Hq6++2sYr9YHA/YaLtlZx19MtXobpqq77XM0t2NfX5Q61XejQLuJc6nSiu8/dl+vqxFREF5EW4e5K/+ijYNLSogF44O+DOX/5KyzbeyL+1eX8c/g0yt96naw9xgGDmkREREREWtv+A0Nzc62IiMy1VVwQ8h+Wjzqfvw5+nJ7Be8iu6MK3PW5h+bnzeHrjjfxunFW0cA8MVeFcpGO77LLLGDduHL179673/t9++40dO3aQlpZGQkICQ4cOZeLEiXz22WeU1jessiNxR7rUDBc1W2mwqKcTHaCsJsqkhTrR6x1a6n18sDrufSXEHefiFRPm7pL3YYd8Z9Zxv18iIj4xYUIJw4dXkp4eRGxsNU89FcEPIx4hdO9zHFfwNqPL/83OZzfx3MuPMHy4HYejwtdLFhEREZFOwt15npDgJCnJyRsvm/xfvxdJWfwa0QGFEAQ7yuL5R+ZE3th+PpfEV3PX6cV1IlvczSP7ZzSLSMu44447Gv3/l2EYzJ07t5VXVL8NGzbQu3dvYmJiPNuGDRtGVVUVmZmZDB482CfrahNBNZ3oNUV0KlsnE92w262CcVWlVewODWv5TPSDdaL72337c96diV5ZgVlVhWG3Y7aHgaedmIroItKiHA4XDkcFo0ZVMG1aJABPPR3FU9zLFT0H8fDgx+ix50veOvkGFn/wMMnJwZ4cSnXziIiIiEhL8849d3vgLrixz0IeOWohEf2t7ZtLevHspkkUJf+Oc+928mpakAaGivjAoEGDjogPqQoKCoiMjKyzLSwsDH9/fwoKCg76uKqqKqqqaiNDDMMgODjYc/1g3Pe1iz8bdxG9ssJaT033thEQeMj1Nfk8gkOgqhKjvAzDMOp0vTfrz8Ld6V1WWvc4nm7vhovorf73ERwKhg1MF0ZZCUZANIazEhMwmnvu+2lXr61maO3zUBFdRFpN7bDRfLKzbcyYcSHHpcZy/u4HGBK5nr4lN/PjBw8ye3YKw4dXqitdRERERFrEwQaGGoW5/CX5Va5NfBu7af3uua64L3knXUFO71NZ+H9dWfB4LsnJVRoYKuIjd9xxR6sde+HChSxatKjBfR599FH69u3bqOPVV6wzTbPBIt4777xTZw0JCQk8/vjjxMbGNuo54+PjG7Vfa8oOj6QCiAoKJMB0sresBCcQ44gnuFu3Rh2jseexOzwCZ1EBMSFBBHXrRummUHKBwNAw4hr5XPVx+hvsBigvJT4+3vN3VllRQhZgCwyiWyOO35p/HzvDwnEVFxIbEoS9WzeybTYqgOjYWEKace4H0x5eWy2htc5DRXQRaTXuYaMpKRXMmmUNxZj2zxTmBM3jpeOnMCgig5OW380lPe4lPf13jBqlIrqIiIiINJ87tmXMmHLS04PpFbyT4udf4dIe7xOYUAUm/FYwiKc3Xs+n2afx4X25RGEC0KWLS93nIh3U2LFjSUlJaXCfxhazo6Ki2LhxY51t+/bto7q6+oAOdW/jx49n3Lhxntvu4m1OTg5Odxd0PQzDID4+nj179mCaZqPW2FqqbdZcifyfvsX82/2e7Xn7SrDt3t3gY5t6Hs6aAaK527dh69INV3Y2AJWmye5DPFdDTHeMi9PJ7m1bMQKs5zFrjumy2Ro8flv8fbiCQ6C4kJwtmzHswThLrG9O5e8robAZ576/9vTaao5DnYe/v3+j//+uj4roItJqvN981O1KD+GiR17i/YvuI6lkGbOHTWeFfTVLP7+O9CVhTJxYwuDBB//lQURERERkf97d5+6Bobt/2cn1xhvMOP1z/G3VAHyXdyy5J11Bn7FDOH+jnU/SrGKQe2BoXFy1z85BRA5UVFTEBx98wOrVqykuLmbq1Kn06tWLTz75hH79+pGQkNDoY0VERBAREdEi6+rfvz9vv/02+fn5REdHA7BixQrsdjuJiYkHfZzdbsd+kKGYjSlgmqbp+0JnzWBRc9nHdbf72xu9tkafR4g1XNQsLbEeUxPnYtoDmvXnYAYEgmGAaWKWlngy1s2qmua+Rp5Lq/59hIYDuzFLisE0a4eeNuHPuSnaxWurBbTWedha/IgiIvXw7krPzPSntDqEs96cxVMZNwEwNHsRzjl/5f03XLz6aughjiYiIiIinV1Wlo1Zs8LJyrLe1rpjW5YvD+Szl3fz92P/yBlf3kRS3if426pZmnMyl3zzApd++wLL9o5gyFAnKSkVnsK5uwFEc3pE2o/s7GymTp3Khx9+iGEYZGVlefLEt27dyocffthqz7137162bNnC3r17cblcbNmyhS1btlBeXg5YQ0R79uzJM888w+bNm1m5ciXz5s3jzDPPJCQkpNXW1S7UFNE9Qzjdarq5W5RnAGjNXIvKmvz1Zg4WNWy22mz3stqZGS02uLQluD9AKKn5ZpRn6Kl6on1BRXQRaRPeb0pSU60J3k/PLaTbzZdz28+P4bQFckbc1/z3lElcPHLjAW+KRERERES8uSNbsrP9AEhPD+aYyFWEvvwQD9qv49xun2EzTJbsGcW45a8wL+oJrnmoDwCpqVYRTIVzkfZt/vz5hISEMGfOHKZPn17nvoEDB7J+/fpWe+433niDadOmsXDhQsrLy5k2bRrTpk1j06ZNANhsNu655x7sdjv3338/Tz75JCeccALXXHNNq62p3XAXn/fXCoVnI7imyc4Tv+IeLFp/N3+TeAr0ZbXb3JE6/i1w/GYyQq1YXEr3WZdVLXju0mT66EJE2px3V/ratf4s3nMWl4+I4MSfHqAfW6n8cDI/7r6P2bNHa+CoiIiIiHh4R7a4ZWT4E7xrNXdUv07PlB8BcGHjvV2jcZ51CfZz+rAiLZoFkzQwVORIs3LlSm666SZiYmJwuep+2BUdHU1eXl6rPfcdd9xxyCGnXbt25U9/+lOrraHdCjxIET2gFbq33YXu0pqf+55Ccgs8V0BNR31lee02T2RKOyiZuovoxUXWpbvA3x665DuhdvCKEJHOxjsrfdYs6x/fiX8+kdiAeTw/fBrHR6/gpB/u4/o+e0lffB7JyVWeN0vqEhIRERHpvNyRLQkJTsrLYETMj3Sd9yIJXa3iudPlx9u7Unl20yQ2lxzF1UeXcM1ZVveiBoaKHHmqqqoICwur976KigpsNn1z2SfccS77a43irqcTvW6cS4s8l/s8ymuL6KazHcW5RFpZ+xQVWJeeOBd1ovuCftqIiE9NnFjC1VeXsGBBLrf+0c4V3/2DVeFn42e4eHDQLK71e5yvl9mYPTuctWv1D4WIiIhIZ+Md85eeHgyYvPHgBvq8PY2FI24lpeuPVLr8+c+28Yz631uY10xmymPW4MDU1HINDBU5gnXv3p0VK1bUe9+aNWvo1atXG69IAAhqyyK6O3KlJs6lJTPLa2JpzDqd6O2oUB0RBYBZmG/d9hosKm1Pnegi4lODBzuZObMQgPT0ICpdAaS+8TA3JiRz38CnGZj7IUWv7aZLwEzS04MYNUrRLiIiIiIdnXdsi6f7vE8Vp3VZziUnv8bw6JUAVFTb2Rh/DvZxFxO6pzvb0qIZMiTHUzhPTq5S97nIEezMM8/k1VdfJSYmhpEjRwLgdDr59ttv+fjjj7n++ut9vMJOqi3jXNzDNd2d6C2Zie7pRPfORG8/RXQjIhoTDuxEVya6T6gTXUTaDffA0blzC+g24Tyu+/FJKmyhnBjzK++nTCQ5YgPTpkWydGmABo6KiIiIdGDeQ0PTFwcxOu5/9Hn9D5yz8V6GR6+kvDqQf22+gpFL32W+8y6ST4kmKcnpebwGhop0DGeffTannXYar7zyCjfffDMAf/nLX3jyyScZOXIko0aN8u0COynjIINFDZtfyz/X/oNFWzAT3XAX0Su8OtFrCtVGeyhUR0ZZl0UFmKbZroaedkbqRBeRdsN74OisWeEszUlh7Bev8NLxU0gM3cYlm9L4w28PcfWC3zFlSrE6ikREREQ6CO/Oc4fDRW6ugYGLfcu+4a6K/9D1+I0AVBlB/GvTJYReeAFdxkWRlRZNamougGJbRDqoW265hTPOOIOff/6ZwsJCwsPDGT58OAMGDPD10jqvmNi2e679B4u2RiZ6RX2DRdtBobomzoWigtp1QftYWyekIrqItBveX7VNTS1jwYJQ/vBYJL8Wz2HHO49xWux3/HP4NNb2mwhjLmfWrHANGxURERHpANyd5wkJTpL6VrD6le/4+NRXGPBLJgD7nCG8uvVSXth8NbmVMVy9vYS7Liv2RLYAim0R6cD69+9P//79fb0MqWH0SsB253TM77/EXLcScrNb78n260Q3WzIT3VNEryfOpT10oodHWZfVTnDnokP7GHraCSkPQUTaJXdXev/+VfiFh3Htj3P4Kepi676NrxKx8HH+Psdfw0ZFREREjlDeA0MB/Awnnz/6DfbHfs+t/g8wIDyToqpQ5mTcwClfvMdPvW/iwVkGYA0MVWSLiIjvGIOOxTZpMsaIUa37RJ7Boq2RiV4TS1PhNXutqiYypR0Uqg27HULDrRveH1T4qyfaF/SnLiLtkvtN0axZ4cyebf2jMf4/93B5z2T+Ovgxeuz5kkUjbmTxBw+TnBxc5+u/IiIiItI+1TcwNPGochxbP+fz014nIXQ7AOW2MJ5ddzUJ159Dn/BQCtKimDQpl+Tkqjrd5yLS8Vx++eVN2v+NN95opZVIYxgjR2MuXghDjm+dJ6gZLEplBaazCjyd6IHNP3ZQfZ3o7jiXdlIyjYiCkmLM3Bzrtr8/hmH4dEmdVTt5RYiI1G/ChBKGD68kPT2I2NhqnnrqQoanxnH+7r8wJHI9fUtu5scPHmT27BSGD6/E4ag49EFFRERExCfcsS1jxpTz0WJ/ruz1Dse88296h+yCUMirjOSFzVfzytbL2OcMY8lxOYDVFdili0uRLSKdwMUXX1ynSLh06VLKy8sZPnw4UVFR5Ofn8/PPPxMYGMgZZ5zhw5UKgNHVgW3Oa7UF6ZYWEmZlgDurID8XKq33/C0y+DOgZs3l3pnoLRgX0xIiomD39tpO9Payrk5IRXQRadccDhcORwWjRlUwbVokANP+eQpzgubx4vF3cXTEBk5afjeX9LiX9PTfkZxcpa50ERERkXaivoGhgbYKqj5N508lbxA2xCoKlPpF8eSqiXS/cgzn3e3HwIwq0tKsY2hgqEjnctlll3muv//++0RFRXH//fcT5FWkLSsrY8aMGQQGtkA3sjSb4e4Wb41j22zWINPsXVYhuSWL3DWvKdN7sKg7E72dDO80IqMxAbJ2WRvaybo6I2Wii8gRIzXV+orV3Ln5XD81hIu/eZENoacS6FfF7GHTudI+l+VfWV8LVla6iIiIiO+5O8+XLw9k1S8utr/6IctGXciwNXMJq8omu7wL09fcyTGLP+D5zRPZsDWcIUOqSEmp8BTOlX0u0nl9/PHHnH/++XUK6ADBwcGcf/75fPTRRz5ambSpLrEAVqRJC2aiG+7BopX1dKK3l2L1Uf0AML//n3W7PQw87aRURBeRI4Z72GhKSgWZmf6UVocw+s1ZPJlxEwBDsxcR8epDRPgXk57eSl8lExEREZEG7T8wNNivjBWzF9PlyRu4ym8O8UE57CpzcP/qqaQsfZdtSRfzxByrWSI11SpkqHAuIgB5eXn4+fnVe5+fnx8FBQVtuyDxCaNLnHVl83rYm2Vdb4lMdPdg0fJ6OtHbSbHaOONc6HFU7Yb2UtzvhFREF5EjhvebKXdX+tNzCwm74gpu+/kxqoxAzoj7mndPuZZju29m6dIApk2LZNUqJVeJiIiItCbvwrl7YOh3/6um6oNFfD3qPO5Pfoq4wFwK/R3cs/Ielo/9N8ffPYYKVxCTJpV4Os81MFREvPXo0YMPPvgAp9NZZ7vT6eSDDz6gR48ePlqZtCl3J/r/loD7tdASRW53J7pXnItZ5R4s2j6K1YbdjjHspNoN7WRdnZEqSyJyRPLuSp81K5zFe85iy7KevDj8LvqGbSP21zv4/cuPsDQnBYCZMwt9vGIRERGRjst7YOhni6tJ6/sipyx+jeiAQgiErSU9mLvpet7eeS5O059rhmlgqIgc2hVXXMETTzxBWloaJ554IlFRURQUFPD9999TUFDA1KlTfb1EaQtdHAdua4lMdE8Rvax2WzvLRAcgIrL2ugaL+ow60UXkiFRfV/qtf3Xww1nP8H3eMUTYS3jlhD9wS8KrpJ5TdsDXikVERESkebx/v8rNNYi0F2JLX8A9xZcxdcA/iA4oJM/ekzt/e5BPTv031794Ck8+XVso18BQETmU4447jnvvvZeYmBg++ugjXn/9dZYsWUJMTAz33HMPxx13nK+XKG3AqOlEr6NFi+jecS7uTvd2VKwOi6i97q9+aF/Rn7yIHPG8u9LXrg3nyu/+zmc3P0yf7Yu5L/lptny2mm/23sns2eEMH16Jw1Hh6yWLiIiIHHGysmzMnx/KhAklOBwuT2zLgB65uD5+l69HvU34xhIAMooTmLPxBj7YPRoXfgRtLuGW2wrrFM7VfS4ijTFkyBCGDBlCRUUFJSUlhIaGEhjYAnnYcuRwZ6J7a4kid1BtEd00TQzDgJo4F8PefkqmRkQUpvtGe+qQ72TUkikiRzzvrvT09GCqTDunPf8g9636I06XH32yPqP3wmk4ArN5661gdaSLiIiIHAZ3ZEt2tjXk78sPyrh3wBxO++gazvWbR7i9hLVF/bjt58c4a9kblA0exZy5RYAGhopI8wUGBhITE6MCemcU3RWSh0G3XrXbWuJ14B4s6nLVxri0xziXcK9O9PbUId/JtJ+PVUREWsDEiVb3U2pqOevWjeHqZxN4+ZRpDItaw+KUa3g/7CGmzz6JhAQnKSkVegMnIiIi0gDv7nO37SsLcHz5Bn8s+hD/vtY3/LICk7jv61s46aZhjL0cFqfZmDSphOTkKg0MFRGRZjFsNvymzADA/O0HqHZiBLREEd3rGOXlVoG6qubfq/ZUrA6Pqr3u5+ezZXR2KqKLSIcyeLDTM0Q0PT2Ib/KO56zP5vHS8VMYGL6JCVl/YHWP+0hLG8eUKcX6CrGIiIhIA9yRLQkJToyCHB4a9C9O//Rdgvysr7v/UnA0czJu4vOcFMAgdnMJKSNLAQ0MFRGRlmcMO6HljmXzqymcV1rDRcMj2mcnemh47XXv/HZpU8ozEJEOyz1w9Jb7Qvj4mLl8uOcMAv2qmD3sQd6+6jH69ilj2rRIVq3S54kiIiIibt4DQ9PTg+kZvIvi5//O2OUTmdTnTYL8KvkxbygTvp/LBV+/zDnTBjN3bgFgfRtQA0NFROSI4RkuWjM7rar9FdEN72GiZaW+W0gnp8qRiHRY7oGj27bZ+ec/ozF4nD8kvcCdSS9wfMEivpy3nQ9+eRQI9XSvi4iIiHRG3rEt7u7zox3budb2LA+d/jF2m1UQ/yb3OPJGXEXC2EFcutHOl2kGQ4ZUeQrnyclV6j4XEZEjR1Aw7CuC8pritNP6phX29lNEr6OizNcr6LTUiS4iHZb7Ddytt+5j7tx8TGy4Uq/ilp8fx2kL4rTY73gv5VouTtlQp+NKREREpLPxHhr67ft5PDFkOmd8cR0Dcz/Ebqtm2d4TueSbf3L5d//kq70nMGSok6Qkp+fxGhgqIiJHpKAQ69Ld4V1V829bO+pEr0Od6D6japGIdHgOh4uUlAqmTCkmKamSD/ecybKTn6IkyEFC6HaGfTiZje/8wuzZ4axd207/oRQRERFpQfs3EOTmGhwVsp2wt57krqIJXN7rffxt1WwJOZ7xX7/EurMf5ZqHEgArsgVQbIuIiBz5QqwiuukuTjvb4WBRbyqi+4yK6CLSKbi7o775xso7u/a+40n5YD7f5B6HvbqUE3/8C7cnvkz64kB1pYuIiEiH5+48X748kPXLsrHNe4ovTruE3js/xoaLpTknc+HX/+K0Rf/gp4JhZGb6e5oSkpOtAoO6z0VE5Ijn7kQvL8V0uaC6nXaiR8ZYlwn9fbuOTkyZ6CLSqUycWAJYHVTr1vlz9cPP8fYVj3BM4Xv8aeAzbDTW8O2XdzJ7djjDh1ficFT4eMUiIiIiLcM79xwgIXQrzhdeIqHHEvrZrEL459mnMGfjTfxSMITRo8uZe34+aWnRpKaWK+tcREQ6HCM4BBOgrKS2Cx3A3r5KprZpj2J+kY4x5kJfL6XTUpuliHQqgwc7mTmzkFGjKsjM9Mdp+nP+a3/h3lV/osrlR7/8zznqzal0C9pDenqQutJFRETkiOb9u4x7YOhvH2UR8sbf+Py0S7m4Zzp+hovMkJM4b/nL5Fz+ENfP6AnApEklB3Sfi4iIdCjB7kz0srpFdP/2FedixHXDdvkNGNFdfL2UTktVIRHptFJTranWc+fmk3DtaK76/jlK/SIZErmO91OuZUTcbyxfHqisdBERETlieQ8M/eH9LOYM+zNnfHkjfbI+w89w8WnWqYxb/gqjFj3Lb4WDGTKkyjMwtEsXlyJbRESkY/MU0UugqqaIbhjg5+e7NUm7pCK6iHRayclOpkwpJiXF6kr/Lm84Z306jzVFScQF5nLO2ikse/xLANLTg3y8WhEREZFDq29gaFJYJhFvPs6dRZMY32MJNsNkU+gpjFv+KptTH2TmG3HMnZvvOYYGhoqISKfhlYnu6UT3t2MYhu/WJO1S+wr4ERFpQ965nqmpZSxYEMofZwbz3e4n2fLhbFK7fc7fhs5gUHgGroTrWbo0gPT0YCZOLGHwYKePVy8iIiJyIHfneUKCk8Exmwic9yafnPo5tt0mAB/tOZ05G29iVdFAAIZklnDrrSV1CufKPhcRkU4jOBQAs6wUw92Jbtc30eVA6kQXEaFuV/qGreHc9stjzNpwCwDXJ7zOwI//zB2T/FmwIJRXXw318WpFREREau3ffd4/bCN+/3qchPm3caLtM2yGyZI9ozjnq/nc9PMsup3Ux9N5nppaDqDYFhER6ZyCg63LslJwVlrX/VVElwOpiC4iQt03jqmpZZjY6Df5Er4a/CAlzmBGdv2eb86/hv5hm0hNLdfAUREREfGp+gaGrliyi/DXHuXT065gXLdPsRkmG0JPZeyyBRRe+Wdu/asD0MBQERERN6OmE52yUqiq+ca5iuhSD1V/RET2492Vbg4bwYXf/JuS4HhCy3bz31OugxXfaeCoiIiI+JT3wNCf39vJP46byu++upleOTXzXHb/jjHLXuOsN59kTfEADQwVERGpj3cmelVNJ7o9wHfrkXZLRXQRkf14v6lMTw9mfXE/TnlvPsv3Hk+YfykpKx5gw1NvYeDirbeC1ZEuIiIibcK7+zw312BQ+Hqi3niYycU3kBr/BQDrw05n9LLX2TnuPp56M0oDQ0VERBoSXFNEL/MeLKoRknIgvSpERBowcWIJAKmp1axd+1cy3n6RSX3eZOqAf3B05HpWRE1l9uw4EhKcpKRUqJtLREREWkxWlo3580OZMKEEh8PliW05JmYdkV/9hyWnLoMscJkGi3efxZyNN7BhXz8AMjUwVERE5NDqLaLrG+dyILVOiog0YPBgJzNnFjJqVAWbNgfxlzV/ZNqKP1NRbSc1/gvGZ/yeo0J2kJYWzT/+EaaudBEREWkx3pEtAL++t50Xh09h1Ne3caxtGS7T4N1dYxiz7HXu+PVRjjq5pwaGioiINIW7iF5ZgVlh/dupOBepjyo9IiKNlJpaBsDgW0/nraOeJKu8KwPCM/kg5Rpm3/gZvXs7lZMuIiIizVLf8PLsHzMpeOSvpBXfxBjHl5gYrA37HaOXvUH2eX8k7dEYQANDRUREmsydiQ6Y/3zCumLXe3o5kOJcREQayT1wdNs2O//85wgcgfP4x3HTGB69kvE77+Gxz34PXEN6ehCjRlX4erkiIiJyBHJHtiQkOAnJXs+/j/8ro77+CoBq08a7u85m7sYb2FTSB7BiW1JSSoG6A0NFRETk0Iz68s8V5yL1UBFdRKSR3G9Ks7JsDBlSRVpaLEsG/Y0N3z/Hlb3e5b7kpxkcuY7cPpNZujSA9PRgJk4sYfBgp6+XLiIiIu2Yd/Z5enowwyJXEfbKC5wZtxziaovnT2+8gcySPjzxRAFBQfmkpUWTmlqugaEiIiItSZ3oUg8V0UVEmsjhcHm+Kr1lSzDPr/wzKwuTmT7oCS7o/jGrlm7h5tl/Y0dZVwBmziz08YpFRESkvfEunLu7z4+LWsHt1fPplfIDAC5svL3jHFxnX8rgyQ7uzPAnLQ2GDKnyFM6Tk6vUfS4iItIMxgVXY767oPa2OtGlHspEFxE5DO43qxdfXAoYnDT1TL4c/jdyKmIYHLmBL8ZM4JQuP5CaWl5vtqmIiIh0bt5DQ1e9t4lXT0jjtG8n06voB5wuP97cMY5RSxcxZcV0ftmVwJAhVSQl1X67TQNDRUREWoZt3OVwzEm1G9SJLvVQRUdEpBncOekpKRUEDEpm3PJXKYhIIrCqiPkn/J7Q795l+VcBGjgqIiLSye3/oXpursHx0b/SdcF93FZ8B6Niv8GFjVURYznjy0UUXHAndz0eDkBqajmAYltERERaiRFcO2BUmehSH8W5iIg0g/fXp2fNCmZ3eSgnLPw3jw1+hIt7pnPcxufIXLqVQNs9pKcHkZxc5fnqtjrHREREOg9353lCgpOhob8Ss/AN3j75R8gFp8uPRTvP5dlN17O1tCdgDQwdP77YE9kCKLZFRESktQSH1l5XEV3qoSK6iEgLmTixBLC6xdatncKD85P5y6AnuaTnYpLCNrO65/0sX96V2bPDGT68EoejwscrFhERkdbknXsOcGL0z3Sd9wIJXX8AG1S5/Fi04zye2XQd28t6MHp0OXefXzswVEVzERHfyM7O5q233mLVqlUUFBQQExPDqaeeykUXXYS/f20pbe/evbz44ousXr2agIAAUlJSmDhxYp195Ajh3YluD/DdOqTd0v/VIiItZPBgp2eIaHp6JAu2XMn64r48e+w9DItaQ/cf7+DWf84EoklPD2LUKBXRRUREOpr6BoYeH/ETSRvms+jkXwFwGX6sCh/Lre/ewuSHQpgWZJKWBpMmlZCcXFWn+1xERNrerl27ME2Tm2++mfj4eLZv387zzz9PeXk5EydOBMDlcvHoo48SERHBQw89RHFxMc8++ywA119/vS+XL4dDnehyCMpEFxFpBampZQBc8WASHx/3LKuL+hMbmMfCk29hQu9FJCZUsXRpANOmRbJqlT7PFBER6Si8B4aufXcdb5x0MyO/vxtHwa9UuvyZv+0iUj77L+Nen86Osu51BoZ26eLSwFARkXbgmGOO4fbbb2fYsGE4HA6OP/54zjvvPL7//nvPPr/99hs7duwgLS2NhIQEhg4dysSJE/nss88oLS314erlsNTJRNd7dDmQiugiIq3Ae+Dobzt7cdE3L/HertH4Uc0jgx8j9L/Pct01ESxYEMqrr4Ye+oAiIiLSbnkPDc3dC6d0+YG4edO4ed8fOLnLz1Tjz6+R53Pa0v9SNv4OXvqvP3Pn5nser4GhIiLtX2lpKWFhYZ7bGzZsoHfv3sTExHi2DRs2jKqqKjIzMw96nKqqKkpLSz3/lZWVee4zDKPB/xqzz5HwX7s8j5Da9+VGQOCRex4d6e+khc+jufTRiohIK/DOME1NLWPBgq6Y10/ltw19GLLpRa7q/Q5jh65nzFuzOflkg1mzwjVsVERE5AjhHdnicLhqYlvCOCH8exzfLeD1k1ZAPlRU23l9x4U8t+ladpfHA9bA0FtvLalTOFf2uYhI+7Znzx4+/PBDT5QLQEFBAZGRkXX2CwsLw9/fn4KCgoMe65133mHRokWe2wkJCTz++OPExsY2ai3x8fFNW3w71d7Oo6xHL/bWXI/o0oXwbt0a9bj2dh7N0VHOpbXOQ0V0EZFW5ulKH1nJ2i4Xc+3rQ3jplHuJKVjD4pQJfLZiOrP/eRIJCU5SUipUSBcREWnn3JEtY8aUExdXzYZ3V/HWiHmc8MNvYLOK569tv5DnMiexp9zB6NHl3Os1MBRQ4VxExAcWLlxYp4Bdn0cffZS+fft6bufl5fHII49w8sknc+aZZ9bZt77uVtM0G+x6HT9+POPGjTvgGDk5OTidzoM+zjAM4uPj2bNnD6ZpNngO7Vl7PQ+zrNxzvaiklH27dze4f3s9j8PRUc7lUOfh7+/f6A+r6qMiuohIK/N+kzxrVjD/23sKZ346jxeH38WA8Ewu3voHfu75J9LSLuDmm/cRFmaqK11ERKSd8e4+t5gUfP0r+xa+yg371kIMOA07KyPGccs7N3LT1CDui3NpYKiISDsyduxYUlJSGtzHu8iWl5fH9OnT6d+/PzfffHOd/aKioti4cWOdbfv27aO6uvqADnVvdrsdu73+wZWNKWCapnlEFzrd2tt5mF6Z6Kbd3ui1tbfzaI6Oci6tdR4qoouItKGJE6033iefHMJH6+eSufxvnBP/BX8bOoOrT13Jqp63ct9fujJ8eCUOR4WPVysiIiJuVmRLOAl9qoja9RPvnPwfhv+4EoDy6gD+s+0i/p55LVkVVvElM7OElBRrsJz3wFAREfGdiIgIIiIiGrWvu4CekJDA7bffjs1Wd6xg//79efvtt8nPzyc6OhqAFStWYLfbSUxMbPG1SyvzHizqV/+HHNK5abCoiEgbGjzYycyZhWRmBvC3uQ5u/flxnlh/KwDHFv6XpMX30iUgj/T0oDpDykRERKTtef9bnL44iNO6fkPP1+7i9BX3MDx6JeXVgby0+UpOXfouD669m7sftnsGhqamlmtgqIjIESovL48HH3yQLl26MHHiRIqKiigoKKiTdT5s2DB69uzJM888w+bNm1m5ciXz5s3jzDPPJCQk5OAHl/YpuHawKC79uy0HUie6iIgPTJhQQkKCk7S0aMrOuJzr3+vP30/8MyO6/MwHKdfwveNBli/vx+zZ4epKFxERaSMHGxh6Ytg3/KFqHo4T1wJQZQTwSubFBF0wnpPvDKdrhj9paTBkSJWncJ6cXKXucxGRI9SKFSvYs2cPe/bs4dZbb61z38KFCwGw2Wzcc889vPjii9x///0EBAQwcuRIrrnmGl8sWZorILD2+v+zd99xVdbvH8df92HIHsp0kOBEcaUNxZIsyy/ZsKwsR1a2NLLMrF+2t/bVhu1pjoaalhlZWek3bZg2zJELFVMRFEE2HM79++PECXKhjHMOvJ+PBw8459zj+nhu4XCdi+s6Rm96abyURBcRcYLISBuJiSWMH5/Hjh0eLM08m4HfzuTNnuNpE5DOf9bfwT0fTAKSSU31ISlJSXQREZG69u+BoVs/WcvHvWdy6up1ABSXN2FW+uW8um0kWaVhDDu1gGu75FY5hhLnIiLuLykpiaSkpONuFxYWxr333lv3AUmdqzIMtqzUeYGIy3LLHgFlZWXcfffdXHnllezYscPZ4YiInJSKX7Ivv9zeL/WOp4P5ru90vs7si49HCc93f5D7Oz5Lm9gSli3zZuLEYNat03ufIiIitWnvXvjvfwMqtU8zyf3+V/IfmMh1+RM5NXQdZYY3q0OGkPjtJzDkBh6c6gHYW7YAatsiIiLSgBgtWzs7BHFBbpmNmT17Nk2bNmXnzp3ODkVEpMbi462MH59HYmIJU6eG8NDqaYxv9xrj2r3FTXFzWPHlFsZMfpKcMnuPtilTco9zRBEREamutWupNDB0NR/3fs9ReV5U3oRZO4fwWtoIskrDAPvA0MGD8xwtW0DV5yIiIg2B5dGXYd9ujLbxzg5FXJDbVaL/+uuvrF27Vj2mRKTBqPjFOzLSRnJyESYWWt8+lJWdH6TA6kvfsFX8cPFw4gM3k5xcrIGjIiIiNVT5Z+mCj0z6hX1Pq/fH02/tfZwauo6i8ia8njaMvt9+wuN/3snEJzyrDAyt/LNbREREGgYjuiVG9zOcHYa4KLfKwOTk5PDaa69x22234e3t7exwRERqXeWqdFv3Plzy/TsU+EbjX5TBwt7X4/Hbd6xc2YRp0wLZuNHL2eGKiIi4jcqJ84qBoZsX/s6tedcx6/Tb/27bYk+ef9RjNn2fG+5o29KlS5ljlklF9bmIiIiINB5u087FNE1efvllBgwYQJs2bcjMzKzWfmVlZZSV/fNC1zAMfH19HV+7s4r43X0d4jy6hlxPVJTJhAn5AEyd6svm/DDOXDSbF7tPol/4j/RZ/zgvLfoLC7eSmupDp05WZs3yY8SIQqdUw+kakprQ9SM1pWtIToRjaOiAosMGhv67bcuwXQWM6nqoyv6Vf0aDrjnR9yCpOV1DIiLuw+lJ9Llz5zJ//vxjbvPUU0+xadMmioqKGDx48Akdf+HChVWOHxsby+TJkwkPDz+peF1RVFSUs0MQN6dryDVNmAD+/nDZZcGsW/s8r7z1Ere2mcnYNjPoFLiZg50fZ/36SKZNg/PPD6R7d+fFqmtIakLXj9SUriE5kr174bXX4OabIToa1v5ukhS+kpbvvU6n/PUQClajCRvCh3DdeyOY+EQYz0bD8OEwYoQ/0dH2WSQPPQRdu4YTHe3kBYnL0vcgqSldQyIirs8wTdN0ZgCHDh0iL+/YQ3jCw8N57rnnWLNmTZV3aG02GxaLhb59+3Lbbbcdcd+jVaJnZWVhtVprZxFOYhgGUVFRZGRk4OSnUdyUriH3cffdQcyZ489F0V/w366P4utRwvaCVty45r9szm/DsGEFPPPMoeMfqJbpGpKa0PUjNaVrSI5l7VpPBg4MZ/oL2fTw/hHrx+8TZ9kI2CvPZ+68gtfSRrC/tBkAw4YVMGFCvlP/wkvci74HSU01pGvI09OzQRUrOkNWVlaV/NW/GYZBdHQ0e/fudevrRetwPQ1lLcdbh5eXV42+Tzm9Ej0oKIigoKDjbnf99dczdOhQx+2DBw/yxBNPcMcdd9CuXbuj7ufl5YWX15H7BrvzhVGZaZoNZi3iHLqGXF9ychFz5vhz/n2nk7rjBU5f8zCx/rtI7TeKMasfIy6uB99+60Vqqi8jRxaQkFC/bxLqGpKa0PUjNaVrSCrs22dh9mx/hg8vANNeeR7zwevEhKwHy+HJ8wEDirn2Wnv1eXJyMRER5dx1l73AR5eUVJe+B0lN6RoSEXF9bjNYNCwsjJiYGMdH9N9/TxkVFUWzZs2cHJ2ISN2qPHB0dUZHBq2cxcr9vfA2i3iz5wQKPviA4cOaMmeOPzNn+js7XBERkXpzpIGhWz7+ncgZ45l52jh6hKzHamnC6pArSfx2ESE3jOKhqfZfg0aNKqB/fzQwVERERESOyemV6CIicnyRkTZHZZy9Kj2MA8MeY/P6N2j/1wLuaPcGVyWu49zZT9G7dwlTpwYyfHiB/hRdREQavKoDQ3/nkz4z6bF6PXDkti1dumQ59m3WzEZ0NEyYkK8qUBERcSpPz+ql6Kq7navTOlxPQ1nL0dZR0/W57b9OREQEc+fOdXYYIiL1rqIqvc9Z5WwMu4lXJ3blmR5PEJ35A5/0GcV36x9l2iudiI21kphYokS6iIg0OJXbthzYD0nhK4me+QrX5f8JIVBmNOH34Eu4af4N3HqPJ7MTS9my5SApKaEARESUM358nn5GioiIywgNDa3Wdg2l97zW4Xoaylrqah1u085FRETsKqrSIyNtpKb6Mn/3IC757k32FkXQLmAHQ7beSv/wFaSkhPLqqwGOP3EXERFxV5VbtgD/tG1Z+BstZtvbtoTm/klReRNeSxvOGV8t4rL3JrK/tBlpaZ506VJGYmIJ48fnERFRXuVnqYiIiDsoKirinnvuoaioyNmh1IjW4Xoaylrqeh1uW4kuIiIwcmQBAL17R/HxxlfoueYxTm/6G2/3upOVYdezvdVQ7n8glJ49S4mMLHFytCIiIifH0bLlfPvwz22f/M6iPu/Sfc0Gx8DQd3deyetpwx0DQy++2F55npxcDFRtjSYiIuJuTNNk+/btbt9+TOtwPQ1lLXW9DpUmioi4sYQEK1Om5JKW5s1TL53C1T+9wsydQ7AYJmcdeItmC57Gz6OQ1FSfw6r4REREXNnhP7dMcleuoeCBuxmVfw/dQzZQZjTh55CrSPx2ER5XVB0YWlF5roGhIiIiIlJTqkQXEWkAhg8vIDbWSkpKKDt6j+WeLzrwZJfJXBj9NW0CdvBbi4dZuTKKadMCVZUuIiJuwd6yJZDY1mWE7vmZRX3m2CvPObzyHCAtrYDExELAPjBUleciIiIiUluURBcRaQAiI22OirsdOzxYsGswm/PieO3UiXQM3EbUL2MZ+/aTwJmkpvqQlKQkuoiIuJ7KA0NTP/PhnPAVnPLB63QP2QAhhyfPn3kmBx+ff9q2VAwMjYgod/ZSREREapWXlxdDhgzBy8vL2aHUiNbhehrKWup6HYbp7g1vTlJWVhZlZe79p52GYRAdHc3evXvdvm+ROIeuoYZp2TJvhg0LY/r0g+T/lU38/x7j1NB12LDw5MYUIoddRMd4K6mpvowcWUBCgvWkz6VrSGpC14/UlK4h91c5aR4Zafv7Z1gzPnzgC9psnEVE4SYAyowmvLXtSvwvvYSeSf5s2eJJSkooS5ZkERFRXuUYJ0LXkNSErh+pqYZ0DXl5eREeHu7sMERE6owa44qINDDx8VbGj88jMbGEdX9FceVPr/PBrouxYOP++OcJ+/S/3DAigDlz/Jk509/Z4YqISCNWMTA0M9MD0zT/Hhh6Lb3X3E9E4SYKrT68um0Ep3/1KU/+OY4Nu8Lp0qWMdu3+eQO4om3LiSbQRURERESqS0l0EZEGpnIyITm5iFKbN7433saadimU2TwY3GIJq64cRQufvSQnF2vgqIiI1KsjDQw9tHINBfdPqDQw1IefQ68icdkiPK4cxcNTDQCSk4sB1LZFREREROqVeqKLiDRgjqr0vqVsbHYh18xKYPbZ9xByaCuLE0fw+/r7WZndTQNHRUSk3lQZGLp7FZ/2eY9ufw8MLbT6MHPnFby2fQQHSpsC9oGhgwfnMX58HvHx9naMGhoqIiIiIvVJSXQRkQascpJh6lRffsruSb8ls3mj5wS6BP/J2b/cw6Mb7wSuIjXVh/j4spPuKysiInI0/x4Y2j98Ba0/eJ1ufw8M/Xfy/N8DQ5U0FxGRxuyLL75g0aJF5OTk0LJlS0aNGkV8fLyzwzqquXPnMn/+/Cr3BQcH88YbbwBgmibz5s3j66+/Jj8/n3bt2nHDDTfQqlUrZ4RbxYYNG1i0aBHbt2/n4MGDTJgwgdNPP93xeHViLysrY9asWaxcuZLS0lISEhIYPXo0zZo1c5l1vPTSSyxfvrzKPu3ateOJJ55wqXUsXLiQVatWsXv3bry9vWnfvj3Dhw+nefPmjm3q6zlREl1EpJEYObIAgORkL37eMI0ti6dzWYvPebTzf0kI3kR+6zGsXNlEVekiIlIrKifO7dXnAZzpv5LxpbMIP61iYKgPb229Av/Bl3D2eH+itxikpECXLmWOli0V1eciIiKN0ffff8+MGTMYPXo0HTp0YOnSpTz55JM8++yzhIWFOTu8o2rVqhUPPPCA47bF8k/70E8++YTPPvuMMWPGEB0dzYIFC3j88cd57rnn8PX1dUa4DiUlJbRu3ZpzzjmHqVOnHvZ4dWKfMWMGa9asYdy4cQQGBjJz5kyefvppJk+eXOXfwZnrAOjevTtjxoxx3Pb0rJomdoV1bNiwgQsuuIA2bdpQXl7OBx98wOOPP860adPw8fEB6u85UQNcEZFGIiHBypQpuSQllbBlhz93/P4oj2y4k3LTwpUtP+XUb+/iibtLAfjoI1/1SRcRkRpxDA3dZ2HbJ7/xaZ9rOXPN/YRXGRi6iCc3aWCoiIjI0SxevJj+/ftz7rnnOqrQw8LC+PLLL50d2jFZLBZCQkIcH0FBQYC9ajg1NZXBgwdzxhlnEBMTw9ixYykpKWHFihVOjhp69OjB0KFDOeOMMw57rDqxFxYW8s033zBy5Ei6du1KbGwsKSkppKens3btWpdYRwVPT88qz1FAQIDjMVdZx6RJk0hKSqJVq1a0bt2aMWPGsH//ftLS0oD6fU6UHRERaYSSk4sAg+53JbOk/dMcLA2me8gGvh0wnF6hv9G0qY1p0wJZubKJEukiIlIt/x4YemA/9A9fQfTMOxiVfy/d/h4Yuip0qAaGioiIVIPVaiUtLY1u3bpVub9r165s2rTJSVFVT0ZGBjfffDNjx47lueeeY9++fQBkZmaSk5NTZU1eXl506tTJ5ddUndjT0tIoLy+na9eujm2aNm1KTEwMmzdvrveYj2XDhg2MHj2acePG8eqrr5Kbm+t4zFXXUVhYCOBI+Nfnc6LMiIhII+QYOJpYwor9ZzBo5Uw2HGqHf/lBPjjjFoq++AKAlJRQZs/2d3K0IiLiDioqz1eu8Gb7ol9oOftOZpx2B6G5mym0+vDKtpGc9tWnDJkzgQOlTUlL8yQxseSIA0NVfS4iIgKHDh3CZrMRHBxc5f7g4GBycnKcE1Q1tGvXjrFjxzJp0iRuvvlmcnJyuP/++8nLy3PEfaQ1VU7iuqLqxJ6Tk4Onp2eVqu6KbVzpOevRowe33347Dz74ICNGjGDbtm08+uijlJXZX5O54jpM0+Tdd9+lY8eOxMTEAPX7nKgnuohII1R5QFtychFz5rTgtwFT8Vg/jQ75y3iqy1MkBP9JZv9biYszmTgxmJEjC0hIsB7nyCIi0phU7nuOaXJuxHfEfvg6McEbwWIfGPruzit5bfsIsktDGTCgmIsv1sBQERGRE2EYRrXucxU9evRwfB0TE0P79u1JSUlh+fLltGvXDjg8ftM06zXGmjiZ2F1tfX369HF8HRMTQ5s2bRgzZgy//PLLMVvAOHMdb731Funp6Tz66KOHPVYfz4kq0UVEGrmKqvS03UEMmPsMT/15GzbTYFjMQs5aNYFH7zKZM8efmTNVkS4iIlXbtlQMDN268FeiZtzBO73upGvwRqwe9rYtfZZ9StPRI3nk73lWo0YVHFZ9LiIiIkcWFBSExWI5rFo2Nzf3sMpbV+bj40NMTAx79+4lJCQE4LA1HTp0yOXXVJ3YQ0JCsFqt5OfnH7ZNxf6uKDQ0lPDwcPbu3Qu43jrefvtt1qxZw0MPPUSzZs0c99fnc6IkuohII1dRBXjLLflMn57DK2mjWNjiKXLLAujVdC3fJQ+jW/A6kpOLD+t3KyIijU/lgaFpH//K4sSRnLnmAZrm/dO2pdcX9rYt2aWhVQaGNmtmU8sWERGRavL09CQuLu6w4Ydr166lQ4cOTorqxJWVlbF7925CQ0OJiIggJCSkypqsVisbNmxw+TVVJ/a4uDg8PDyqbHPw4EHS09Np3759vcdcXXl5eRw4cIDQ0FDAddZhmiZvvfUWP/30Ew8++CARERFVHq/P50TtXEREBLAn0yuqA73ienDRezP57MI7CCxIZ/6ZN/L7mnGszL6AadMC6dmzlMjIEmeHLCIi9aRy25YD++HciO9o/u7LXFuwBYKhzPDh15BLuWneDYy9x8J7iaVs2WJv2wIaGCoiInKyBg0axPTp04mLi6N9+/YsXbqU/fv3M2DAAGeHdlQzZ86kV69ehIWFkZuby0cffURRURH9+vXDMAySk5NZuHAh0dHRREVFsXDhQpo0aULfvn2dHTrFxcVkZGQ4bmdmZrJjxw4CAgIICws7bux+fn7079+fWbNmERgYSEBAALNmzSImJqbKYEtnriMgIIC5c+dy5plnEhISQlZWFu+//z6BgYGcfvrpLrWOt956ixUrVjBx4kR8fX0dFed+fn54e3tX63qqrbUYpqs15aknWVlZjmb57sowDKKjo9m7d6/L9VYS96BrSI5m4sRg5szxx9+jgGe7PcTAqGUAvLPjKh7beCdXXVPCXXflMXu2PxMmBAK6huTE6XuQ1JSuobpTOWkeGWlj2TJvhg1rxtwHlhD182xaWzYBUGD15d2dV/L69uFkl9oT5sOGFTBlSu5hx3BFuoakJnT9SE01pGvIy8uL8PBwZ4fRYH3xxRcsWrSIgwcP0qpVK6699lo6derk7LCO6rnnnmPjxo0cOnSIoKAg2rVrx9ChQ2nZsiVgry6eN28eS5cupaCggLZt23LDDTc4hkU60/r163nkkUcOu79fv36MHTu2WrGXlpYye/ZsVqxYQWlpKQkJCYwePZqwsDCXWMeNN97IM888w/bt2ykoKCA0NJTOnTtz1VVXVYnRFdZx5ZVXHvH+MWPGkJSUBFTveqqNtSiJ7sYa0g9ccQ5dQ3I069Z5MnOmP8nJxfy50cKhD+ZzV/vXAPjhwKlsPWcSQS2CSEkJZckS6NpV15CcOH0PkprSNVR3/vjDi4EDw1myJIuEhFLeuXM9PfbMomvwRuDw5Ll9YGgRKSmhzJlzgKQk9/hrJV1DUhO6fqSmGtI1pCS6iDR0amorIiKHSUiwMmVKLklJJaRt9+b5rTdyw+qp5JX507vZL5zz01hem7QPgAULnBysiIjUisPnXpgcWvEzBZPu4tqC++gavJFSw4dVoVeTuGwRXldqYKiIiIiINA5KoouIyDElJxcBcPEDXVnSbTppBTG09M3gk7Ou59Lmn9OuHSxb5s3EicGsW6dRGyIi7mrjRk+mTQtk5QpvDny7ms8SR3DmLw/im7WVAqsvL2+7ltO/+pQhc+4iuzSUtDRPDQwVERERkUZBSXQRETmm+Hgr48fnkZhYwi9723Dxynf5OjMRL7OUF7o/QM5bzzFimL2H+syZ/s4OV0RETkDl6vPUz3w4L+J/xH14O2f98QBdgv90JM8Tly3i6U0p/N8TBtOnHwQgOblYA0NFREREpFFQEl1ERI6pcmVhcnIRh6yB5I98gPWnXAPAzXGz+Wn4GEK8ckhOLj5COwAREXEllb9P26vPA9i64BfGl97I273G0yX4T0oNH17aNoqPes4h6fmhjrYtXbqUVWnboupzEREREWkMlOEQEZFqc1Sl97WS3Xckt/zyNOWevkQc+IXFiddSsHknK1c2Ydq0QDZu9HJ2uCIicgSZmR5MmxZI5j4LaR//4mjbEl64hQKrLy9tG8VpXy5m8qbb2JjejC5dyhxtWwAlzkVERESk0VESXUREqq1y4iQ11ZfUjPMY+O07pBe2IMZvN2f/cDufP7EGgNRUH1Wli4i4gH9/Lz6wHwZELKf5u+O4tuA+R+X5T6HX0OfbT/G+cgSPTjMBe8sWQG1bRERERKRR0wQ4ERE5KSNHFgAwYkRbli1/idZLn+Ls8J949dR7mb71Onxjr3ZUpffsWUpkZImTIxYRaZwqKs9jW5fRw3MlMZ++z1u9NsMhKLD6MmPnVbyeNpyDZSEApKUVMHhwnqNlC/zzJqqIiIiISGOk0kARETkpCQlWnnnmEBdcABvTQ7l29fO8mjYCgJS27xC75BEm3Wl/r/ajj3xVkS4iUo+qVJ+bJgMilhP3YQoxix/hFGOzo21Ln28/ZfKm2+iV5FNlYKhatoiIiIiI/EPZDBERqbELLyym3PQkeuxIvom9j+LyJpwbsZL/XTiCtv7badrUxrRpgaxc2USJdBGROnKkgaHbFqwh+p3beavXXXQJ3oTV45+2LWGjhzvatowaVVBlYKiIiIiIiPxDmQwREakxx8DRxBK+yrmAy354i7+Komha9hef9BnFzkWrAUhJCWX2bH8nRysi0jBVHhi6/eNf+CxxOGf88hCh+VvJt/rx4tbr6LlkMVfMGc/BspAqA0ObNbOp+lxERERE5CiURBcRkRqrnHhJTi5i3aGOrDx7Oum+3Qn0KuCtXhO4o+3rjLs9l7i4UiZODGbdOo3lEBGpiaMPDL2dkQX30SV4E6WGLz+FXkPit4toctVw3v+0zNG2BTQwVERERESkOpTBEBGRWlVRlb5lbzj/t+BV7u/4HNfHfsD49q/zxYpN3PnyI+Rb7dXoU6bkOjlaERH3VWVgqMcKYhZ/4BgYmm/1Y8aOq3hj+7AqA0NvuaWgSuJcA0NFRERERI5PSXQREalVFQmZffssdOlSRkrKBJqfeQpJe57lgqjl/NRmJINSnyU5OYB9+yzMnu3P8OEFah8gIlINlb9v2geGLiPuwzeICd4ExuHJ8wEDirn44oOkpISSnFwMoMS5iIiIiMgJUjsXERGpE5GRNseQutKe/bnix9cpahJGYEE6i/pci/nHalaubMK0aYFs3Ojl7HBFRFzWsQeGTvh7YOg/bVvCbxymgaEiIiIiIrVISXQREakzFdWOP/zgw++5CfT9bDars7sS7JVP39/vZ+OznwAmqak+h/X2FRERu6oDQ9ccNjB0+tbrOHXJpxoYKiIiIiJSR5SpEBGROjdyZAHDhhXw3DsGv587hdnpl2ExTO7t+CIv9/g/2p+Sp6p0EZFKKr+xaB8YuuzvgaGTHANDfwwdRp9vF+Fz1XA+0MBQEREREZE6o57oIiJS5xISrI4hoqmpwcxZdx/rczvwSOdnGBS9lI3/28GNa/4LhJKa6kNSUolzAxYRqWf/nhFR0balt9//OGXNbN7qtcUxMPSdv3ue52hgqIiIiIhIvVAluoiI1Kvk5CIAzpzYnyXxU8ksaUZ80Fa+OnckfZv9RFyclWXLvJk4MZh16/Rer4g0Do6WLZkemKbJ9o/XkJo4jDN+eYgYY4ujbUufbxfxzOaxnJbk46g8//fAULVtERERERGpXcpOiIhIvYqPtzJ+fB6JiSVM/bE7j62Yxes976ZHyHpmnZ7CE7Nv57HtwwADwFHBLiLS0FSuPrczyVvxEwXvzWRkQRoEQ6nhyy8hl3HT3OtIudfgsQgbKSn2gaHx8WUaGCoiItJAHDx4EKvVesxtwsPDycrKqqeI6o7W4Voayzo8PT0JDQ096eMriS4iIvWqcouB5OQi5syJ4K8rpxCy9gViM77gwfjnuO7cP+j/9iMkJxcf1uJARKShsLdsCSS2dRnN/vqB1MQ5JPyyGTh625bExEKg6sBQERERcX9Wq5WysqO/MW4YhmM70zTrK6xap3W4Fq2j+tTORUREnKaiKr332SZ/9b+DB9bfjc2w0GrP1yzoPZqctP0aOCoiDUrlgaGpn/lwfuQy2nx4G33XPURC8GbyrX68sPV6R9uWSU9SpW2LBoaKiIiIiNQ/VaKLiIjTVK6inDo1kDk7r2JTXhte6XEvXYL/pPmysdz669NALz76yJc1a7xVkS4ibqfyX9T8MzB0OXeVzCas51bA3rbl1S1XE3L5IM4b78spW0xSUqBLlzJH4jw+vkzV5yIiIiIiTqAkuoiIuISRI+09gZOTY/ny95dJWPkIXYI38cGZY3h0w51YQgfZ2x7EWklMLFEiXUTcRsXQ0PMHFLHj49WkJs6s0rbl7R1DeXP7NeSUhTAsvYDrulSdBaHEuYiIiIiIc6mdi4iIuISEBCtTpuSSlFTC2t0tuOyHt1iw+z9YsPFwp6kkrJ5CE0sxKSmhvPpqgKMdgoiIq6ncsgXgwH44P3IZzWekMKLgfhKCN1Ni8ePH0OH0+XYRvlcN47Fp9t6NycnFAGrbIiIiIiLiQlSJLiIiLsc+cDSM/CF38s3WNpy97xUua/E57QLS+KHbw/g0D+f++0Po2bOUyMgSZ4crIlJFReV5bOsyenis4JTF7/Nmzy2QB3ll/ryz8ypH5TnYB4YOHpznaNkCqj4XERFxFxs2bGDRokVs376dgwcPMmHCBE4//XRnhyUitUwlfCIi4nIqBo6m7/Jm1LujuGbVSxwoCaFL8CaGbL6F1Ge3AJCa6uPkSEVE7KpUn5sm54SvIPbDccR89igxxhbyyvx5Yev1JC77hP9uHsNpST5VBoZWJM3VqkpERMS9lJSU0Lp1a66//npnh3LCzLRN2L76BDNtk7NDEXF5qkQXERGXU5FM2rfPQpcuZaSk9GJWq1fpv+URugZv5L0zxvL4xtuJjh3EsmXepKb6MnJkAQkJVmeHLiKNyJEGhp4e+BPtN73Lu6dtBMDq4cPqoMu5ae51THoSHvOxDwwdNaqA+PiyKtXnIiIi4n569OhBjx49nB3GCbN9+gHmovcAMAFj4OVYLr/WuUGJuDAl0UVExGVFRtpITCxh/Pg8duxozuU/vMFTCU8xpOVnPBj/HAs//ZMbnryfYpu9In3KlNzjHFFEpPY4BoaeX8zGT/5k3pnvcsbPvwJQVN6Ed3dcyavbR5JdGgpAly5Zjn2bNbOpZYuIiEgjVFZWRlnZP2+gG4aBr6+v4+ujqXjsWNtUl+33VY4EOq3iYFca5pKPMGPisJx+do2Pfyy1uQ5n0jpcS32sQ0l0ERFxaRVJpmXLvFmwIAyv0eP4ZVtrum56lcEtlnBOxy1cuGgayck+VapC1RJBRGrbv7/HHDhg0Cv0N8LnvMhN+b9BU7AaXvwefDE3zb+RW+7x4r3EUrZsOUhKij2RroGhIiIijdvChQuZP3++43ZsbCyTJ08mPDy8WvtHRUXV6PymaZI55SNKgYCLhxJ68wRy3plO3vx3Md+dTrNuPfFu3bZG56iOmq7DVWgdrqUu16EkuoiIuIWKPumJfUvZ2Owirp7Vldln30NI3jYWJ47k93X3sTL7VKZNC9TAURGpNZUT546BobFWugSuJ+SD91jQexUcgFKbJ+/vGsyLW69jX0kEYB8YesstBVUS56o+FxERadwGDx7MoEGDHLcrKmezsrKwWo/entIwDKKiosjIyMA0zZM+v7llA+WbN4CnF0VJF1K8dy/mgMEY63/D3Pg7+x65E4/7p2H4BZz0OY6lttbhbFqHa6nOOjw9Pav9ZtWRaLCoiIi4hcpD91JTffkpuydnL5nNbzmdCPXO5azf/o8/pi0GTFJTfaoO+RMROUkVifPMTA8AEoL+xH/Go8TNvYMullWU2Tx4L30wZy/7mAfW30PXs4OqDAwFNDRUREREHLy8vPDz83N8VLRyAXuV+LE+qrPN8T5sq5YDYJx+NgQG249rsWDceDc0DYfMvZS/OQ1beXmNz1WX63CFD63DtT6Ot46aUmZBRETczsiRBQwbVsB/3/Lil3OmMvevi/AwbNwf/zzTu0+i/Sl5rFzZhGnTAtm40cvZ4YqIm6n8JtyBA/bqsH1r0gl67wlS+w7nvMjvMLGwLnAg5yz/CI9rx/J/zzQB7ANDK2Y5aGCoiIiIuBpzvX1+i9HjjCr3G4FBWMb8H3h6wdqfMee9UyuJR5GGQu1cRETE7SQkWB1DRFNTg5mz9kF+z+nEw53+yyXNv2TD/7Zz05pngFBSU32Ijy9Tr3QRqbaNGz0dbVt+XpTBS92ncs7KrwCwmQYf7xnI81tHs73gFEADQ0VERBqz4uJiMjIyHLczMzPZsWMHAQEBhIWFOTGyw5mZeyFzL3h4QIeuhz1unNIWY+RtmG8/i7n0E8wD+7D85wpo3dbtB0+K1JSS6CIi4taSk4uYM8ef0+8+jyXbojjzj8foFLSFr84dwegfnyIuLt5Rla5e6SJyNJV7n6em+tLaL53yN9/g0eZLsDS3V2F9umcAz229kda9m/PK5DwNDBURERG2bdvGI4884rg9c+ZMAPr168fYsWOdFdYRmRt+s3/RpiOGr98Rt7H0PgdbWSnmnFfg1x+x/fojhIZh9DgT47yLMcIbxgBKkROlJLqIiLg1x8DRxBKm/ngqj62cxWunTqRHyHpmnnY7k+eM5bG0kQCkpvqQlKQkuohUTZpHRtoc1eedI3cxyjKdx85eiqfFnhD/POMcCs+5Gs//xLIlJZSHRx2gS5cyDQwVEREROnfuzNy5c50dRvWkbwPAaNvpmJtZzr4AM64D5mdzMf9YDQf3Y36zGPOHb7GMnYTRIaE+ohVxKeqJLiIibq3ywL7k5CIyiiP568opbGo2EA/Dxn0dp/PVlXfj61FEXJyVZcu8mTgxmHXr9D6ySGP274GhKxcf4umEJ0j69jo6HPgCT0s5S/edRfKK2dz8yzOszuhAu3ZWwN6yBTQwVERERNyLuXeX/YvmMcfd1mjZGsvNE7E8OxvLbQ9Am45QVIBt1kuY5frLO2l8lEQXEZEGo6IqvffZJjPK7+W+dfdSZvOgQ/4yPu59HTOn5jFsWBhz5vgzc6a/s8MVkXpWeWBohV1/5JD1wuvcfegarolZiJelnO1+p3HxyhlsT36Ym5+IBCA5uVgtW0RERMRtmaYJe9IBMKqRRK9geHljdDsNyx0PQ0Ag7NuN+eOyuglSxIUpiS4iIg1Glar0C4uZnT6EH3v/lyLvUOKDtvL1ecP58MEvAejdu/iwZJqINGwVLVtWrmzCltV5PBQ/lX5Lr6XpH4vxMK2s3H8al//wJv3mv8JvuQmkpXmSmFjC+PF5xMeXqfJcRERE3FduNhQWgGGBqBYnvLvh44dxwWUAmN9+VtvRibg8ZQ5ERKRBqqhKj7+oHWsvnM6ag13wtuZz5upJjG3zDls2ezmSaUqkizRclavPU1N9aep9kL0vzuT870ZwQ+z7+HiUsiq7O1f++CpXr3qFK+9rzfTpBwF79bkS5yIiItIg/F2FTkQ0hpf3SR3CSBwAHp6wcyvmXztqLzYRN6CsgYiINEiVE18fL2vFVT+9xvvpl2Jgck+Hl+j43RP4eRSSkhLKq68GqCpdpAGpnDivqD7/aZmVK5q8wcqki7mlzSx8PUr45WACqe0mE/DQkwx7pA0AXbqUVak+FxEREWkIzIokevNWJ30MIzAIup1mP94P39RGWCJuQ1PVRESkwRs5sgDwx7/3rXy5Oo6kjBe4MPpr2gZsZ0XCI3i1iOb++0Po2bOUyMgSZ4crIjVUMTT0/POL+eozg1vi3iUx9V1CvA+BJ6zNjWfq5pv5NiuRYXGFXNQ1FwzDsX/Fm3AiIiIiDcYe+1DRE+mHfiSW087C9ssPmOt/hStqIzAR96CSOxERafASEqxMmZJLWpo3o2dcw1U/vkZmcTM6BKYxZOutfPP8OgBSU32cHKmInIx/Dww9cMDAyyijbGkq9+ZfzX0dpxPifYgD3qdw05op/HTOdC57sDNgkJxcDKChoSIiItKg/VOJXrMkOh262j/v3ol56GDNjiXiRpREFxGRRmP48AKmTz/ImpxuzD7lVVYf7EqwVz4zTruDO9u9RlxsKcuWeTNxYjDr1umPtUTcxb59FseMgz9+t7Dp3RV8228I3TZMx8+aTXphc+78/WF6fjyXJfv6k7bd67CWLep9LiIiIg2VaZqOnug1rUQ3AoOgZaz9uJvW1Tg2EXehJLqIiDQakZE2R+IsPTeSoT+9yrs77X+DeGe7N2iz5CHGjPJizhx/Zs70d3K0InIs+/ZZ+O9/A9i7t+Iek8WP/4bnU7cz2vNxYvx2k1ncjEnr7uGc5R9xqNN5PD/9EKCBoSIiItLIHDwARYVgsUBkixofzuj4dzX6n3/U+Fgi7kJJdBERaVQqEmeXX15Iqc2bkFtu4qf4iRSXN6F/xPf8ePEwOgVuIjm5+LAWESLiXEcaGPrN1yaZy9fyaZ9reaPn3bQPTKPIEshTf97G/85/l9PvPo8y04tRowo0MFREREQap732fuhERGN4edX8eHEdADB3pdX8WCJuQlkBERFplOLjrYwfn0diYgmlp/bn0u/fpsA3Cv+iDD7ucz3ev3zNypVNmDYtkI0ba+GFpojUWMXA0MxMD1JTfTk1ZC2eL95C0u/30C1kAwVWX57fcgOnLVnEK2mj6NTdg3btrAA0a2ZT9bmIiIg0SrXWD/1vRou/j7NnF6ZNr6ukcVASXUREGqXKybTUVF825HXgzEVz+CazDz4eJZyxcQo5r76Ol1FGaqqPqtJFnKTy/70DBwwAMn7ZxS22e/m4z/X0abYGq+HFm9uvZsGpsxgwfQhPPGt17K+BoSIiItLo1VI/dIeI5uDpCSVFcCCzdo4p4uI0NU1ERBq9kSMLAEhOtvLnxkf4/cO53NnuDa49ZR4JQX/yZ8tJrFzZjGnTAunZs5TIyBInRyzScO3bZ2H2bH+GDy8gMtLmaNsSG2tl5aIcnu36AknffY7FMCk3Lcz96yKe33Ije4qjGHZqAaO65FZJnFe8YSYiIiLSWNV6JbqnJ0S1hL922BP04VG1clwRV6ZyOhERafQSEqxMmZJLUlIJadu9eXbLzYz6+TlyywLpGfoH568ew5yHtgGoKl2kjlVu2QKQmupLqFcOWS+/zWOWa7i8ZSoWw2Tx3vM4939zWdH6Af7vmSaAfWAooLYtIiIiIn8zTdPRE73WKtEBo/kp9uPv3llrxxRxZfrtX0REpJLk5CIABj/Ymc97vMyGQ+0Ib5LNB2eO4cbY2cTFlqlXukgtO9IbU1u2eLLul3Iu953BiqRLGB37Pk08yli5/zQWdnyZ8uvvIa2gNWPHQt++pRoYKiIiInIkB/dDUSF4eEBk89o7bkt7Eh0l0aWRUBJdRESkksoDR3/fHcOl37/Dgt3/wYKNB+KfI2rxZO65w171mprq4+RoRRqGipYtK1c24Y8/vPA0rPz0zNc0e240vfa8Q6BXAX/kdmDYqhe5etXLrNrX2TEwNDxcleciIiIiR1XRyiWiOYZn7RUBqRJdGhsl0UVERCqpnIxLTi6i2OaDxw13srJVCmU2Dy5q/hUrLhpBG/8dxMVZWbbMm4kTg1m3TmNGRE5E5erz1FRfAG5PCeZ/01bx9dlX8GTC00Q0OcDOghaM/fUJNlwynSsf6gAYJCcXO/qeR0c7dx0iIiIiruyffuitavfAFZXoGbsxrdZjbyvSACiJLiIichSOqvS+pSzOH8KVP77OvuIwwkp3sjhxBL+/+QPDhoUxZ44/M2f6OztcEZf275YtlavP4+Ks9G32Ez8NHs5LPe4j1n8XhZ4h7O03ht8ve4NP915Al67lJCaWONq2REbamDAhX0l0ERERkWNJTwPAaNm6do/bNBx8fKHcCvv21O6xRVyQkugiIiJH8e+q9DU53fg1+WX2hXTH37OIF3vcz/JbHsHbUkrv3sUaNipyDEcaGArw2qR9dFhyH++dMZaoks3kW/2YuvlmJge8T8vhA2nbwXAcQ21bRERERE6MuXMrAMYpbWv1uIZhQIu/W7rsUUsXafj0m76IiEg1VFSl9+rvx+b/PMELW68HIDb9Uz46czT7NhxwVNUqkS5id7SBoX/84UW3FulM734fqX2Hc3b4T5TaPFkXMZjvzp/B81tv5LwL7ftUtG2JiCh31jJERERE3JJZXPhPlfgpbWr9+EbzGPsXfymJLg2fGriKiIhUQ0UFLMDUqcHM2TyG1Qe78Xy3B+kWsoHWW27mh4hHSEk5m5tuyicgwGT48AJVzEqjVtGyJTbWSnGxvaL8gfEGKW1nce0pc/FubsVmGny8ZyDTNt/MWZeFclf/PEfLFqj6f09ERERETkB6GpgmhIZhBIXW/vH/bhFj7kqr/WOLuBgl0UVERE7QyJEFAPTu3ZF5G16j16+Pc2roOt7uNZ5VoUPZ1Oo6Jj3QjJ49S4mMLHFytCL1a98+C7Nn+zN8eIGjZUtKSihNLCXcHDuT29q+Q7CXPSn+3f7TKRx4HR7hbUlPCSU5+YCS5iIiIiK1xNxhb+VSF1XoYG8RYwLs3IppmvYWLyINlP7eXERE5AQlJFiZMiWXtDRvHn+5LVf8+AZvbb8agNMPfkD7z+4lskkWqak+To5UpH5Ubtvy74GhBjZeuW4BqwddxqT4Fwj2yqO4WWu+7/Ukw1a9TKs+rasMDBURERGR2mH+uRYAo03HujlBq1iwWOBQDhzcXzfnEHERSqKLiIicpOHDC5g+/SBlphe7E2/i1l+epsTixxlNfyW17zD6hq1i2TJvJk4MZt06/fGXNFyVh4ZWrj7/+uXNLE4cyYX7niTYuo+9RRHM87sXvyefJaRPD8f+GhgqIiIiUrtMaxlsXgeA0anHcbY+OYZ3E2huHy5KRdW7SAOlJLqIiMhJioy0OSpos7M9+CzjPM7/dhYbDrUjvEk2Azffw48Pfsx7c3yZOdPf2eGK1Jp/Dww9cMD+p7tbtngSF2elfcA2lg0Zywdn3EqX4D8ptfixof119Fu+gKjB52BYPDQwVERERKQGzMJ8bF9+jG3Bu5i70w/fYNsmKCmGwGBH7/K6YMS2s8ezY0udnUPEFagsTkREpAYqKmiXLfNmwQI/xj8dxIaC51g75zWGtlrE3R1epVfoWnz638G+fX6OXtGquBV3VlF5HhtrpV07KzNmBADw+AQr49u/yhdnfYpHoY0ymwez0y9nd7dh3DLSgzGWMg0MFREREakhM/8QtqkPwF/b7be/+gRjxFgsfc79Z5u1qwAw4rthWOqwhjbG3m/d3LW97s4h4gKURBcREakF8fFWxo/PIzGxhI0bPRn2x4O0T25P1/XTOSfiewoXb2HNX/cxbdpZGjgqbqnywNAKKSmhAPh7FDC+3avcFDsbP89iANbY+nEwaRQP3duFOZMOEBlZoqS5iIiISC0wP3zTnkD3C4DwKPtgzxkvYLPZsPQdgFlejvnjMgCM0/rWaSxGi1Psw0X3HKEaXqQBURJdRESkFlSuqp061d4T+tLJQ+kQ2IvXTp1IHOn0+fEuxrW9kc8/u4r4+DJVpYvLq5w4rxgYGhtrpbjY3r7lztsP0t/7U9pumoV/+UEAskM6Mfrz8dz5Yiu6x5cxPlMDQ0VERKRh++KLL1i0aBE5OTm0bNmSUaNGER8fXyfnMndsdSTILXc8Aq3bYr7/Oua3n2G+Ox3boRzw87cP+wwMhoRedRKHQ/NW9s/ZWZjFhRg+fnV7PhEnURJdRESklo0caa/UTU4u5s8/w7nwyVnMH/I4nfO+4q72r7HX+gNrlt7DtGlRqkoXl1bRtuX884urDAwFkwERy7jot+m0DdgJwPaCVnheMZK8Nomsfi+CZs2y1LJFREREGrzvv/+eGTNmMHr0aDp06MDSpUt58sknefbZZwkLC6vVc9kKCyh/878AGGf0c/Qj5+qbwGLB/PpTzIWzHNsbfc/D8Kzb1J/hHwjBoZB7EPbsgrgOdXo+EWfRYFEREZFalpBgZcqUXJKSSkhL86Sg3J//fPgUd/z2CPlWP6Lz13LGl7dyQeS3pKb6HDakUcSZKl+P/x4YCvDUzT/x/WU38FavCbQN2InVJ4i1ncZy7v/mkde2LxGRNg0MFRERkUZj8eLF9O/fn3PPPddRhR4WFsaXX35Zq+cxbTaypz0MGbshNAzjqtGOxwzDwLhqNMawWyEoBDw8MPoNxLjomlqN4aiax9hjVEsXacBUiS4iIlKHkpOLmDPHn+nTD5KZ2Zf/TO3KvAvuJYpNvNHzbjZ4XswP/7uJadMCVZUuTlG5ZUtkpK1K25ZFi/6pPo/x/YuXuj/NRbu+AqC4vAk/+A/h3MmDaJ4XyO22IiIiylV9LiIiInXup59+Oqn9unTpgp9f7bUbsVqtpKWlcemll1a5v2vXrmzatOmI+5SVlVFW9k+rO8Mw8PX1dXx9JOULZmKmzqMIwMMTj1vuwQgKqbKNYRhwTjKck4xptdZ5BXqVczePwdz4O+zZddQ1OLb9+/GjbWduWY/tm88w2idgnH0BhodHrcdbG463DnehdVSfkugiIiJ1qPLA0alTA9lZ2IrEj2dwd/uXuaXNLDplLcLjo3W0D3iS1NRokpKURJf6VbllS2Sk7V9tWyDEK4fb277FyFPm4W2xYjMN/mo5gCGzxjH1LU8MvxIi/ZQ4FxERkfozbdq0k9rvqaeeIi4urtbiOHToEDabjeDg4Cr3BwcHk5OTc8R9Fi5cyPz58x23Y2NjmTx5MuHh4Uc9T27TZhwCDO8mhNw6kYC+59RG+LUmv0sPDn79KV47txAZHV2tfaKiog67L2/RB+S8Zm9XY/78HX67t9Ps7sdrNdbadqR1uCOt4/iURBcREalDlatyK6rSp72QT2bmKIa9cgav936ADoFpLE68lhVetzLx7ktJvrCY+HirBo5KnalcfV5hyxb7y8KKti3jUw5was5HdMt4j2CvfACWZ51J4LUjiekTwzWBfsTHFxx+cBEREZF6cMMNN9CyZctqbVteXs7jj9ddMvZI1a9Hq4gdPHgwgwYNOmy7rKwsrFbrEfcxe/bFs9uZRLXrwL4DB8jbu7cWoq49Zkv7GxOlWzawZ9PGw6rkKzMMg6ioKDIyMjBN03G/7dcfsf2dQKd5DOzdReGyJRTH98DSs09dhn9SjrYOd9OY1uHp6XnMN6uOR0l0ERGRevLvqvTv9p/JWV98wLRuD5MU/gPnZT5HacbvjJl3PzekNFFlr9SZyi1biovtv7hVVJ4b2BjcPJUh616mpW8GeMFejzaUDrqOETcPZMljWURGlun6FBEREaeKi4ujbdu21drWZqub4pSgoCAsFsthVee5ubmHVadX8PLywsvL64iPHTWJGRAEhoHh5YVpmq6X7AxuCjFxkJ6G7Y81WPr0P+4ulddh5h3CNvNFAIxzLsS4+ibMj2djps7D9tlcjFN712n4NeGSz8dJ0DqOTxPMRERE6klFVXpkpI3k5CIAHppqYd8Vj/DYxjsox5PkqG9ZddFQLk1YpWGjUqsqDwyt3LLl7rtDHNskNlvF4sQRPN/9QVr6ZlDkE8743x9m65XT8T+tuwaGioiIiEuYPHkyMTEx1d7eYrEwefJkWrVqVatxeHp6EhcXx9q1a6vcv3btWjp06FCr53J1RpdeAJhrVp7wvuZHMyAvF5rHYFxxvX1Q6nkXg8UC6dswM/fUcrQiJ06/mYuIiDhBRVV6+/Zl+PgavLF9OO+3epHtBa3wLc7ilPn/h/npe2xcrx/VcvIqJ84rqs9XrmziaNkyblwe48bl0T5gKyuGjuH9M8bQJXgTeWX+7Os9ioJ7XiXmqn7Ed7ZVeRNIRERExJlat26Nt7f3Ce9ztArwmhg0aBBff/0133zzDX/99RczZsxg//79DBgwoNbP5cqMM5PsX/yxGnNf9ZPe5rY/MVcuBcAy8jaMv58jIzAYOna1b/PzilqNVeRk6DdzERERJ6hISH7xha+jjcZ9r/UiecVs5v91IQY27mz3Bq3n3sX+P3arKl1OSsXQ0MxMjyrV5489Zv/z4g9eLaLFN8/yxVnXEHNoFXh4cKDbxZy1/GMOnHYVkS29lDgXEREROYY+ffowatQoPvroIyZOnMjGjRv5v//7vxr1XnZHRlRL6NILTBPzsw+rtY9pK8c25xX7/onnYbTpWPWYPRPt261bU7vBipwE9UQXERFxouHDC+jZs5TUVB/Cw8t57rkgdp4zgc8OdaPvXy/Qio2Uv3g7+evHsLHHBUpmyjFVHhgaGWnjwAF7v/MtWzyrVJ972QoxlyxgbPvZeJolAGTFnEXkTcMwacmoEk8iIkqctg4RERGRY3n55Zerva1hGNx66611GA1ccMEFXHDBBXV6DndgSb4C27o1mD98i61TDywV1elHYX76IezaDn7+GJdfe9jjRvvOmAA7t2FayzA8a/8vCUSqS0l0ERERJ4qMtBEZWUJSUgkTJ9qrg59/PhC4jCifRKZ0eZyk8B+4P/55dsz9mqzIFGYuae9IkopUVlF5HhtrpV07KzNmBAD/DA31NKxkL1zCne1eJ6zdQTChLCaeBcZYzr2xNUakjUhsGhoqIiIiLm39+vVVbhcWFlJYWIjFYiEwMJC8vDxsNht+fn74+/s7KcrGx2gbjzHwMszPP8J8+zlsWRkY51+K0cSnynamzYZt8YeYiz+w73fVjfb2Lf8W2QL8AqAwH3btgNh29bAKkSNTEl1ERMRFJCcXMWeOP9OnHyQz08Jjj0WypvcTlB5KpffuV2jNOqwv3E7OutvYeOp5SqILULX6vEJF0vwfJudHLufeDtNpG7ATgLSCGIoHXkvCiF5cYxiAricRERFxDy+99JLj661btzJ16lRuuOEG+vTpg8ViwWaz8f333zN79mzuuOMO5wXaCBmXDIf8PMzvvsRc9B7mFwuhTQeMVnEQHAq52ezbuhHbtj/t2ydfgaVP/yMfyzAgrgOsW4OZtglDSXRxIiXRRUREXETFsNHExBKmTg0E4PkXgoChtPDpxzNdH6Nv2Coe7jSV7XO/wuw8FiMi2rlBi1NUTpxXDAyNjbVSXGxv3zJuXB5t21rZutWT/727gzf/M5Xw3HUAlDYJpnTA1SzecjnXXFCCYSh5LiIiIu5r1qxZXHTRRfTt29dxn8VioW/fvuTk5PDuu+/y2GOPOTHCxsXw8IARY6FDF8xF70HmXtjwG+aG3xzblAH4+GJceQOWs84/9vHadLD3RE/bBOcOqtPYRY5FSXQREREXUTFsFI5UlR7NT2c+TVHup/TZ+yqxrKXswdtZ7H0r7W88j4QuSoQ2JhVtW84/v7jKwNAKzz8fyCl+f3FPhxe5q89SyAWbhzcvbRrGgGcupHMvb+6kyFnhi4iIiNSatLQ0hgwZcsTHYmJi+PDD6g25lNpjGAbGGf0wTz8b0rdh7twKf+2A/DwIDiW4XTx5bTrZK9OPd6xT2mIC5u4ddR22yDEpiS4iIuKCjl6VPoxWvkk80/VR+jRbwyVFz7Ht5eWYj43BCIt0btBSZ6o7MBRgziulzLzmVTrv/xTDZsVmGuR2Pg/zwmGUf3oKYa0KUOsWERERaSh8fX35448/6NKly2GP/fHHH/j6+johKoG/27Gc0hbjlLZV7guMjiZ/715M0zz+QZrH2D9n7Ma0WjE8lcoU59CVJyIi4oKOVpVeXGxw990t2HX5U6zN/IS2a9+iDb9ifeh2vg29hW639ScyqhovRsWtHG9gKMCMl23cEjeLFUkf4JdZDEBpu57MLbuVgddEVbmmRERERBqKs88+m0WLFlFeXk7fvn0JCQkhJyeH7777jtTUVAYNUgsQt9Y0HJr4QkkRZO75J6kuUs+URBcREXFxlavSN260/+j28TXYGDmYsSvOY8ElDxCeu45z9z3LwZeWYd4xFqNZhJOjlpqq3sBQ8Pco4IbY9xnTbhZ+hn3bQ806EDJyGL6dunMtoMpzERERaaiuvvpqcnNzWbx4MYsXL67y2FlnncXVV1/tpMikNhiGAc1bwfbNsCddSXRxGiXRRUREXFzlCuKpU//d/zqEXu+/zfWtP+CeDi8RmvEr5Q+M5fvg4XQYeyGRLfWj3p2cyMDQV6d7MW/sTOLTP6BJ2SEArJGtSfUcTZ9bumHoLxJERESkEfDw8GDs2LEMHjyYdevWkZ+fT0BAAJ07d6ZFixbODk9qgdE8BnP7Zsw96RjODkYaLf1mLSIi4kZGjrRXGicnF/Pnn5489lgwt48rAC7igjcT+eDCh4nO/4PE/W9RNDUVc9QN0PU0ewWHuLzqDAz1Msq4OmYhK5LeJnLbfgC25cfQZMjVxAzuzWCLBVACXURERBqX5s2b07x5c2eHIXXh7+pzc0+6kwORxkxJdBERETeSkGBlypRcAFJTfQB7YtUukDPmvs0lzb9gUsfniWIvthcfh4RTsVx1I0aUKnFcUeXq82MNDH3xBV9m3PIRvbPfxTsvE4DSwAhKzruaxRsuYljfYgyL2raIiIhI43Xo0CFKS0sPuz8sLMwJ0UhtMaJb2UtEMnY7OxRpxJREFxERcVOVB45mZlp47LFgxo3LBxJJevFsZg59mVMPzsdz3S+Ub0zBct7FGIOuxPDxc3bojVrlpHlkpK1K25ZFiw6vPn/heX8GRX/F0rNeo81Oe/WNLSCUZf4j6HrrOUS28GB8cqFT1iIiIiLiCj766CM+//xz8vKOPET9ww8/rOeIpFZVFAPt24NpK8eweDg3HmmUlEQXERFxU5UHjk6daq9G/6cqHYbMmUBrvyt5qNNUzo1YifnFAswfl2EMGYVxRj+1eHGSyi1bIiNtR2zbAmBg4/zI5Tx46qu0MrYBUNYkCO+LLsczKZkBTZrUe+wiIiIiruabb77h448/5tJLL2Xu3LkMHjwYgP/97394e3tzySWXODlCqbFm4eDpBdYyOJAF4VHOjkgaIYuzAxAREZGTUzFwNDLSRnJyEQDTpx/kmWdyAHsbkB2FMeRf+zC7LnqIHK/mkJuN+dY0bFPuxUzf5sToG5d9+yxMnRrIvn3/vPTassWTP/7wqtK2Zdy4PHwsxbx3y2zWX3EZb/S8m1bGNmxN/PghbBSH7n4TywWDMZRAFxEREQHgiy++YPDgwY7k+emnn87QoUN57rnn8PX1PWp1urgPw+IBkX/3u1dLF3ESVaKLiIg0ABVV6e3bl7F5s1eVx4qLDX7x6ctdn17AV/e8QezG92DrRmyP34Vx9vkYlw7HCAhyUuSNQ+WWLcXF9r8A+Hfl+exXyrj2lHn82H8uTdPtfe9zywIo630hEcMvpq9/4GHHFREREWnsMjIyaN++veOvLK1We4GCt7c3gwYN4sMPP+Tiiy92ZohSGyJbwO6dmPv+wujS09nRSCOkJLqIiEgDUFGVPnVqINOmVW3tcvfdIY7tXk8fxd3j+pH16kw65H2DuXwJ5s8r7In0sy/A8FB/wdpSuff50Vq2ALTx38GNsXO4qvViPGxlABT7R2LtdzGzt1zKVZeaGP4aGCoiIiJyJB5/v341DANfX1+ys7MdjwUGBla5Le7LiGqp4aLiVEqii4iINCDDhxfQs2cpqak+hIeX89xzQYwbZ/8T1uefDyQuzsp361qQ8uEUFk/7lq4bX7RXdLz3KuZXH2OcPxgj8VwML28nr8Q9VU6cV64+r9yyBeD55wN4+Y7/0a/0QwJ3rLLvbIOylu350jaUM27uSWRzg9spd9ZSRERERNxCdHQ0+/fvB6BNmzZ8/fXX9OrVC4vFwtKlSwkPD3dyhFIr/h4uaiqJLk6iJLqIiEgDEhlpIzKyhKSkEiZODAaqDht97LFgx9fvrzmd5ne8wNqXvyYpbwaWrAzMOa9gfvo+xnkXY/T7D4aff72vwZ1VHhp6pOrzl17w5cLopXyWOJsum/8EwMTgi4x+dLjtQtqc356LNfBVREREpNq6d+/Oxo0bSUpKYvDgwTzxxBNcd911WCwWiouLufXWW50dotQCI6qFKtHFqZREFxERaaCSk4uYM8ef6dMPkplp4bHHgg+rSl/5ox8p74zk/XfPpa/lM8wvP4YDmZgLZmKmzrMn0s+7GCOkqXMX46IqV55HRto4cMCeAN+yxbNK9bl3eT45n33NnV3fI6AsE4ByjyZ4ntWf7O6X8ueS9vTqXoBhqG2LiIiIyIm44oorHF8nJCTw2GOP8f333wNw6qmnkpCQ4KzQpDZF2ivRyc3GLCrE8PVzbjzS6CiJLiIi0kBVDBtNTCxh6tSqfdKhalX64i9DOHvKIMyzB2Ku/g5zyQJ7m5cvFmB+vQijz7kYFwzGiGhe7+twZRWV57GxVtq1szJjRgBgrz73MsroH76C2GVfcH7kcgLiC6EMbP4h/Og7mA43nkdEXCDhwF2d85y7EBERERE3VFpayv/+9z86duxIy5YtAWjbti1t27Z1cmRS2ww/fwgOhdyD9mr02HbODkkaGSXRRUREGqiKYaNQvar0Zcu8SU0NZuTIAXR+KAn+WI3t849g6wbM/32B+d1XGD37YAy8HOOUNk5cmXNVrj6vUNGyxUI5ic1WcXH0l/wn6htCvA85ttmSF4t53qV0vDaRs9RzXkRERKTGvL29eeedd5g0aZKzQ5H6ENkCcg9i7vsLQ0l0qWdKoouIiDQCJ1KVDjBlSi50PQ2PrqdhbtmAbclHsPZnzNUrMFevgE49sAy8DDp2xWgEPbyPNjC0uNjAwMbTN/3EGR5fE/nXcvzLDzr2yyxuRlm3s/Dvl8hny3sy/KJCDC+1bBERERGpLREREeTk5Dg7DKkHRlQLzM3r1BddnEJJdBERkUbgaFXpxcUGd98dwjPP5ODjY5KSEkpycnHVXt/tOuHRrhPmXzvs7V1W/Q82/Iptw6/Quh3GWedjdOmFEdrMyausO4cPDDV5ddI+Lo7+kpXnfEnLvzIc2+aUBmH26ENu+34k3dif1InZxHQp467T8p23ABEREZEGKjk5mY8//pju3bvj56c+2Q1alL1lj5Lo4gxKoouIiDQylavSN260vxTw8TEpLrZXlO/Z40F2toVp0wLp2bOUyMgSAIyWrTFuGI95yTDMLz/GXPkV7NiCuWMLJkDLWIyuvTC69ITYDhgeHk5aYc0dbWDo3l/3MMRnGaPPXk6bgHTH9qUWXwrb9WZjQH+GP34un07IISKinDvGFxIRUe6sZYiIiIg0eLt27SIvL4+xY8eSkJBAaGholccNw+C6665zUnRSm4yoFpiAmfGXs0ORRkhJdBERkUamclX61Km+wD89vQHuvjvE8fVHH/myZo23I5kMYIRFYlxzM+ZFQ+290tf+DNs3w1/bMf/ajpk6D/wCMDr3gK69MDqfihFYtV2Mq8vM9ODF55pwaugfWL024LVsG//rt5HW3/39gj0Aisub8HVmXxbtPZ+I/j14ckIx7fZZSCkoJiKivMq/s4iIiIjUjS+++MLx9apVq464jZLoDURkC/vnzL2YNhuGxeLceKRRURJdRESkERs50j4cMzm5mD//9Dxs4GjTpjZH/+/ExBJHIh3ACAzGuPBKuPBKzLxDmOt/gT9WY677BQrzMX/+Dn7+DtMw7G1fuvTC6NoLWsW53Ate0zTZvyGDVR/upN8pfxC7fTPrB6TR5IcyAKIsgD+U2Tz43/7eLNpzPtbOZ3D+9RY+TwllzoUHAJQ4FxEREalnH374obNDkPoSFgGenlBWCtlZEBbp7IikEVESXUREpBFLSLDah4gCqak+QNWBo2++GQDYK9XHj887aoLYCAzCODMJzkzCLC+H7Zsx/1iN+cdq2LXdfnv7ZsxF70FQCEZCT4z4bpR06IRZbmIGhWB4N6nbxVZi5h+C7VvI/2Mzmau2EWPbSNOiPAYC7P17Iw8osgSR26wj28o78cqSnlw2vhUegf4sTAllzjMHiI8vYfz4POLjy+otdhERERGRxsiweEBEc9iTDhl/KYku9UpJdBEREQH+GTj6+OMHycry5PnnAxkypJD58/0YNy6PuLhSJk4MZuTIAhISrEc9juHhAW3jMdrGw+ARmAcPYK5bY0+ob/gdDuVgfv815vdfk1l5R/9ACGkKwU0xQppCSDMIqfj679tBIVV6rZumCSXFUFQIhQVQlA+FBZgVtwvz7Y8VFfx9fwFkZUCmPVPuB7T++1hWvFh7sAO/5STwa24Cv+UksLOwBWA4znffqVmAfe3NmtlUeS4iIiLSiC1YsIBffvmFHTt24OnpyYwZM5wdUsMX1QL2pGNm7MZI6OnsaKQRURJdREREgH8Gjqane/H66/YK9Pnz/YCq1emAo3q9OozQZhhnnQ9nnY9pLYMtG+xV6ju24pmfi3V/pv1PMgvy7B+7d9oHlf7NrHIwA4JCwLuJIzGOzcbJKG/WnP2BHXnxs56cN/oUtha35ZEnwhg3Lo/WwCfPB/LAA7kkJpayZYuno298REQ548fnaWCoiIiIiJNMmDCB22+/nZiYmGptb7PZmDhxInfccQctW7astTisVitnnnkm7du355tvvqm148rRGZH24aLs2+3sUKSRURJdREREgH/6ee/bZ6FLlzJSUkIZNy6P558P5JlncvDxMUlJCSU5uZh9+yzMnu1fZeBodRieXhDfDSO+G4ZhEB0dzZ49ezAL8+FgNuQewMzJhpxsyKn0dW425B6E8nL753/z8ABff/Dzr/LZ8PWjkAB+3RRK1zO8CIzwY+3OcK75vzN5fJqNRYt8+WqnD+8+8M+hKr9hkJbmyS23FFRJnKv6XERERMS5du3aRWlpaZ3vczxXXnklAMuWLavV48oxRLcCwNy13cmBSGOjJLqIiIhUERlpIzHR3us7Ls7+i4aPj0lxsb2tyZ49HmRnW5g2LZCePUuJjCyp0fkMwwC/APtHi5hKzVOqMm02yM+1J9vLSu2Jcj9/8A0Ab2/7cY5g+x9eDJ0UzpJrsujSpYz3Pg4mt8yflJQjn2fAgGIuvrjI8YZBxb+JEuciIiIiruOZZ57By8vL2WFIPTPaxtsr0XdswSwpxmji4+yQpJFQEl1EREQOU5E0njgxGMDRygTg7rtDHF+npvoQH192UlXpJ8qwWCAo1P5xHJUr5Sts2WJ/2RMXZ+9pPm6cPSn+/N9tWyIibKSkhDJqVAHx8WUaGCoiIiLiovr163dS+wUFBdVyJCeurKyMsrJ/XmMahoGvr6/j66OpeOxY27iDGq8jPAqahkH2ftj2J0bnHrUYXfXp+XAt9bEOJdFFRETkqEaOtCehk5OL+fNPTx57LLhK8jkuzsrKlU1qrSq9tmzc6Mm0aYHExlodFfSV3wiAw9u2JCYWAhoYKiIiIuLqxowZU2fHnjt3LvPnzz/mNk899RRt2rQ5qeMvXLiwyvFjY2OZPHky4eHh1do/KirqpM7ramqyjgPdT6fwm1T8d28n5LzkWozqxOn5cC11uQ4l0UVEROSoEhKsjiGiqan2P5WsnHx+7LFgx9f1WZV+JJWrz1NT7dU8/06cV/bvPu8aGCoiIiIiAwcOJDEx8ZjbVDfhfSSDBw9m0KBBjtsVlbNZWVlYrdaj7mcYBlFRUWRkZGCa5kmf39lqYx22mHYA5K34msIBg51SRa3nw7VUZx2enp41+r+rJLqIiIhUS3JyEXPm+DN9+kEyMy0uUZVeOXFeufr8aC1bEhNL2bLFk5SUULp0KXMkzuPjy1R9LiIiIiIEBQXVadsXLy+vo/Zyr04S0zRNt052VqjROnqcAe95w550zG1/QpuOtRvcCdDz4Vrqch1KoouIiEi1xMdbGT8+j8TEEqZOtVejH6sqPSmp7pPomZkeTJsWyPnnFx+x+vzfLVtuuaWgyv5KnIuIiIjIydq/fz/5+fns378fm83Gjh07AHtLCR8fDbysK4ZfAEavszC//xrbVx/j0ebe4+5jWq2Yv/4Ie3ZCZAuMnn0wvLzrIVppKJREFxERkWqpnHCuTlX6smXepKb6MnJkAQkJR//T1BNRufI8MtLGgQP2P93cssXzuANDk5OLAdS2RURERERqxYcffsjy5csdtydOnAjAQw89ROfOnZ0VVqNgnDsI84dvYc332H5egeW0vkfd1tz4O7YP3oA96f/ct3wJlrsex/BUalSqR1eKiIiInLATqUoHHH3Va6qi8jw21kq7dlZmzAgAjl19PnhwnqNlC6j6XERERERqx9ixYxk7dqyzw2iUjJg2GAMHY37+Eeab/8WW8RfG2RdgBNt/LzBLS2DjWmzfL4VffrDvFBCIkdATc/VK2LoB89MPMAYPd+IqxJ0oiS4iIiIn7GhV6cXFBnffHXLY0M5/V5CfiMr7VjjWwNABA4q5+OIix7mVNBcRERERaXiMi4fBwQOYPy7DXPQe5qL3wD8QTBsUFdk/AxgWjKT/YFwyDMM/AFtCT8w3p2KuXIp56TCnDCYV96MkuoiIiNRI5ar0jRvtLy18fEyKi+0vRvfs8SA723JCA0ePNjC04pjjxuXRtq2VrVs9ef75wCpJ+1GjCoiPL6tSfS4iIiIiDduePXvIzs6mtLSUoKAgmjdvjp+fn7PDkjpkeHrC9XdCQk/Mrz6B9G1QUKl4pmkYRrfTMc4eiNGy9T/7ndoHs8lLkJsNu7ZDTFz9By9uR0l0ERERqZHKld5Tpx4+3PPuu0McX3/0kS9r1ngzfHgBUVFHn5p+IgNDAbp0+SdZ3qyZTdXnIiIiIo3A5s2b+eqrr/jtt984dOhQlccsFgutW7fmrLPOIikpSQn1BsowDIwz+sEZ/TCLC+FAFlg8wM8fgkKOWGVueHlBx67w+yrM9b9gKIku1aAkuoiIiNSakSPtLVeSk4v580/PwwaONm1qc1SV9+1bSnT0P/tWrj6vzsDQxMRStmzxdCTXNTBUREREpHHYsWMHM2bMYOPGjbRo0YIzzjiDuLg4goKC8Pb2Jj8/n3379rFlyxbef/99PvzwQwYPHsygQYPw1CDJBsvw8YMWp1Rv286nYv6+CnP9r/CfIXUcmTQEbved45dffmH+/Pns3LkTHx8f4uPjmTBhgrPDEhERESAhweoYIpqa6gNUrRp/881/BoEOH17Arl0waZInnTuXVWnbsmjRsavP09I8ueWWgiqJc1Wfi4iIiDQO9913H3379mXkyJHExR27iri4uJjvv/+eTz75hPLyci6//PJ6ilJcmdEuHhMgfRumzYZhsTg7JHFxbpVE//HHH3nttde4+uqrSUhIACA9Pd3JUYmIiMiRVAwcffzxg2Rl2XuXDxlSyPz5fowbl0dZGSxfDgMGeNG5c9kR27ZU9u+BoYAS5yIiIiKN0NSpU4mu/CeNx+Dj40P//v1JSkpi//79dRyZuI2oVuDpBUWFkJUBkc2dHZG4OLdJopeXlzNjxgxGjBhB//79Hfc3b66LXERExBVVDBxNT/fi9dftFejz59t7UVauKk9N9aVXr7Kjtm2JiLBpYKiIiIiIOFQ3gV6ZxWIhIiKiDqIRd2R4ekKrWNi+GTN9G4aS6HIcbpNE3759O9nZ2RiGwcSJE8nJyaF169aMGDGCVq1aHXW/srIyysr++UXbMAx8fX0dX7uzivjdfR3iPLqGpKZ0DcmxREWZTJiQz759Frp0KSMlJZRrringvff8ufrqArKyLCxd6sv33zdh4MBwx37/btuSmFgI2AeGVhzTTtddY6fvQVJTuoakJnT9SE3pGqodt912GxMmTKB169aHPZaens6UKVN48cUX6z8wcXnGKW0wt2+GnVvhtLOcHY64OLdJou/btw+AefPmMXLkSCIiIvj00095+OGHef755wkICDjifgsXLmT+/PmO27GxsUyePJnw8PAjbu+OoqKinB2CuDldQ1JTuobkWKKjITIS9u+HBQv8AXj/ff+jbv/GG+DrC8OHw4gR/nTt6s9DD0HXruGcRNGRNAL6HiQ1pWtIakLXj9SUrqGaycrKwmq1HvGxsrIysrKy6jkicRsxbQAw09OcHIi4A6cn0efOnVslyX0kTz31FKZpAnDZZZdx5plnAjBmzBhuueUWfvjhBwYMGHDEfSumL1eoeIf3WN9k3YVhGERFRZGRkeH49xE5EbqGpKZ0DcmJuPlmiIjwYezYUCZOPMT27Z7Mm+fHFVcUcvbZJeza5cGUKUG0apVFZKSN8eP9iIwsBGzcfLP9GHv3OnUJ4mL0PUhqSteQ1ISuH6mphnQNeXp6umSx4r59+xzdCET+zYhuZR8uum+3s0MRN+D0JPrAgQNJTEw85jbh4eEUFRUB0LJlS8f9Xl5eREZGHnMwhJeXF15eXkd8zN1/SFUwTbPBrEWcQ9eQ1JSuIamu3r1LGD8+j6FDC1m5sgnz5vlx9tklXHZZEX/84cWUKfbtIiLKHQNDdWnJ8eh7kNSUriGpCV0/UlO6hk7csmXLWL58ueP2m2++eViyvLS0lJ07d9KpU6f6Dk/cRUUf9Oz9mKUlGN5NnBuPuDSnJ9GDgoIICgo67nZxcXF4eXmxZ88eOnbsCIDVaiUrK8sl3+0UERGRw0VG2hzJ8X+LiChn/Pg8IiLK6zkqEREREXEnpaWlHDp0yHG7oKCgyjw8sBdV9unThyuvvLK+wxN3ERAEvv5QVABZ+6BFjLMjEhfm9CR6dfn5+TFgwADmzp1Ls2bNCA8PZ9GiRQCO9i4iIiLiPjp0sNKvn/0zHDvBLiIiIiJS4fzzz+f8888HYOzYsdx1111HHCwqciyGYUBEtH2waOYeJdHlmNwmiQ4wfPhwLBYLL774IqWlpbRt25YHH3zwqENFRURExHUlJFhZtgz27rWqZYuIiIiInJSXXnrJ2SGIGzMiojF3bsXM3IPh7GDEpblVEt3T05ORI0cycuRIZ4ciIiIiIiIiIiJOsH//fsLCwk54v+zsbJo2bVoHEYnbquiLnrnXuXGIy7M4OwAREREREREREZHqGjduHO+88w4ZGRnH3dZqtfLDDz9w9913880339RDdOJWwqMBMPftcXIg4urcqhJdREREREREREQat/vvv593332XJUuW0LZtWzp37kxsbCzBwcF4eXmRn5/Pvn372Lx5M7///jvFxcUkJyczaNAgZ4cuLsYIi8QEyM5ydiji4pREFxERERERERERtxEfH8/TTz/Nr7/+yldffcXnn39OaWnpYdtFRERwwQUXMGDAAEJDQ50Qqbi8ZhH2z9n7MW02DIuadsiRKYkuIiIiIiIiIiJup0ePHvTo0QOr1cqOHTs4ePAgpaWlBAYG0rJlS/U/l+MLaQoWC5Rb4dBBCGnm7IjERSmJLiIiIiIiIiIibsvT05O2bds6OwxxQ4aHhz1xnp0FB7KURJej0t8oiIiIiIiIiIiISOPUNBwAU33R5RhUiS4iIiIiIiIiIm5r7969fPXVV+zevfuw3uiGYfDggw86KTJxB0azcMytwIFMZ4ciLkxJdBERERERERERcUvp6elMmjSJpk2bkpGRwSmnnEJeXh7Z2dk0a9aMyMhIZ4cors4xXFSV6HJ0auciIiIiIiIiIiJu6f3336dbt25MmzYNgFtuuYVXXnmFe+65h7KyMoYOHerkCMXlVbRzOaAkuhydkugiIiIiIiIiIuKWtm/fTlJSEoZhAGCaJgCnnnoqF110Ee+9954zwxM3YDSzJ9HVzkWORUl0ERERERERERFxSwUFBQQEBGCxWPDw8KCgoMDxWFxcHNu3b3didOIW/q5EJ3u/c+MQl6YkuoiIiIiIiIiIuKWmTZty6NAhAKKiotiwYYPjsfT0dHx8fJwVmriLip7oRQWYhQXH3lYaLQ0WFRERERERERERt9ShQwc2b97M6aefTt++fZk3bx45OTl4enqybNkyzjrrrDo5b2ZmJh999BHr1q0jJyeHpk2bctZZZ3HZZZfh6al0mzsxmvhAQCDk59mHi/r5OzskcUH6Xy0iIiIiIiIiIm7psssu4+DBgwBceuml5OTksGLFCgzDoHfv3owYMaJOzrtnzx5M0+Smm24iKiqKXbt28dprr1FcXMzIkSPr5JxSh5qG25PoB7KgZWtnRyMuSEl0ERERERERERFxS1FRUURFRQFgsVi4/vrruf766+v8vN27d6d79+6O25GRkezZs4cvv/xSSXR31DQC0tMws7MwnB2LuCQl0UVERERERERExC29/PLLDBkyhIiIiMMey8rKYt68eYwZM6ZeYiksLCQgIOCY25SVlVFWVua4bRgGvr6+jq+PpuKxY23jDlx1HUazcEyA7Kxqxeaq6zhRWkf1KYkuIiIiIiIiIiJuafny5Zx//vlHTKLn5eWxfPnyekmiZ2Rk8Pnnnx+3Cn3hwoXMnz/fcTs2NpbJkycTHh5erfNUVN27O1dbR15sG3IAn8JDhEVHV3s/V1vHydI6jk9JdBERERERERERaXDy8/Px8vI6oX3mzp1bJcl9JE899RRt2rRx3M7OzubJJ5+kd+/enHvuucfcd/DgwQwaNMhxu6JyNisrC6vVetT9DMMgKiqKjIwMTNOszlJckquuw+bpA0DR7l3s3bv3uNu76jpOVGNah6enZ7XfrDri/ie9p4iIiIiIiIiISD3bsGEDGzZscNz++uuv+e2336psU1pays8//0zLli1P6NgDBw4kMTHxmNtUTsRlZ2fzyCOP0L59e2666abjHt/Ly+uoif3qJDFN03TrZGcFl1tHSFP755zsE4rL5dZxkrSO41MSXURERERERERE3Mb69eurVIt/8803R9wuLCyMG2644YSOHRQURFBQULW2rUigx8bGMmbMGCwWywmdS1xIRRI9155Ed/ce4VL7lEQXERERERERERG3cckllzBw4EBM0+TGG29k0qRJxMbGVtnGy8sLHx+fOoshOzubhx9+mLCwMEaOHMmhQ4ccj4WEhNTZeaWOBIXaP1utUJgP/oHOjUdcjpLoIiIiIiIiIiLiNry9vfH29gbgxRdfJDQ0FE/P+k1xrV27loyMDDIyMrjllluqPDZ37tx6jUVqzvDygoBAyM+DnGwl0eUwSqKLiIiIiIiIiIhbquhPvnv3bjZs2EBeXh79+/cnJCSE7OxsAgICHAn32pSUlERSUlKtH1ecKLjpP0n0Fqc4OxpxMUqii4iIiIiIiIiIW7LZbLz22mssW7bMcV/37t0JCQnh9ddfJzY2lquuusp5AYr7CG4Ku3di5majjujyb5p4ICIiIiIiIiIibmnBggWsWLGCESNGMHXq1CqP9ejRg99++805gYnbMSqGi+ZkOzcQcUmqRBcREREREREREbe0bNkyLr/8cgYNGoTNZqvyWEREBJmZmU6KTNxORRI996Bz4xCXpEp0ERERERERERFxS9nZ2bRv3/6Ij3l5eVFcXFzPEYnbCg4FwFQluhyBkugiIiIiIiIiIuKWgoODj1ptvmfPHpo2bVrPEYm7MkKa2b84uN+5gYhLUhJdRERERERERETcUo8ePViwYAHZ2f9UDxuGQWFhIZ9//jk9e/Z0YnTiVsKj7J+z9jo3DnFJ6okuIiIiIiIiIiJu6corr+TXX3/lzjvvpHPnzgC8//777Nq1Cw8PD4YMGeLkCMVtRETbP+fnYRbkY/gHODcecSmqRBcREREREREREbcUEhLCU089RWJiItu3b8disbBz5066d+/O448/TkCAEqFSPUYTHwj+u/1PpqrRpSpVoouIiIiIiIiIiNsKCQnhpptucnYY0hBERkNuNmbmHozYds6ORlyIKtFFRERERERERESk0TPC/27psm+PcwMRl6NKdBERERERERERcVt//vknK1asICsri9LS0iqPGYbBgw8+6KTIxO1ENrd/1nBR+Rcl0UVERERERERExC19++23vPrqqwQEBBAdHY2Xl1eVx03TdFJk4o6MyOaYgPnXTmeHIi5GSXQREREREREREXFLixYtonfv3owdO/awBLrICWsTb/+8ewdm/iGMgCDnxiMuQz3RRURERERERETELWVlZdG/f38l0KVWGMGhEN0KTBM2r3N2OOJClEQXERERERERERG31KJFC3Jzc50dhjQgRnw3AMyNa50cibgSJdFFRERERERERMQtXX311Xz88cdkZ2c7OxRpIBxJ9F++xywrPc7W0lioJ7qIiIiIiIiIiLiNyZMnV7ldWFjIuHHjaN26NQEBAVUeMwyDiRMn1md44u4SekLTMMjej/njMoyzzq+zU5m2cti4FnPNSigpgbYdMXr3x/DxrbNzyslREl1ERERERERERNxGenp6ldsWi4WgoCCys7NVkS41Znh6Ypx7Mea8tzEXzsLs2BUjPOqEj2OaJpg2MLF/ttnAVg4Hs2HfX5h//IL5+0+Qe/CfnVYtx1y+BMs9kzF8/WpvUVJjSqKLiIiIiIiIiIjbeOmll5wdgjRwRr//YP60DNLTsD0+HuOsARDc1J4ML8iH3INklRRizcyAwgIoLoKSYii32oeSmmb1T+YfiNErEUKaYn7zGezeiTn7ZYwbJ9TZ+uTEKYkuIiIiIiIiIiJuacOGDcTFxeHj43PYY8XFxaSlpdGpUycnRCbuzGjSBEvKA9imPwbpaZhfLDxsm+KTPXgTXwiPxIjriNHjDOjQFcPLCwAzvju2pydirl6BOfRGjMDgk1+E1Col0UVERERERERExC098sgjPPHEE7Rt2/awx/bs2cMjjzzChx9+6ITIxN0ZIc2w3DcV8+fvYPM6e89yA/ALwAhpSnBMa3JNA/wCoIkP+PiCpydggMUAw/LP1xhgsdg/vJtgGMaRz9mmI8S0gfRtmL/8gNFvYD2uWI5FSXQREREREREREWlwrFYrFovF2WGIGzM8PDDOTIIzk6rebxgEREeTt3evvfd5bZ7ztL6Y6dswV68AJdFdhpLoIiIiIiIiIiLiNgoLCyksLHTczsnJYf/+/VW2KS0tZfny5YSEhNRzdCI1Y/TojfnRu7BlA2ZJCUaTJs4OSVASXURERERERERE3Mhnn33G/PnzHbefeeaZo247ePDg+ghJpPZEREPTMMjeD9s2QKcezo5IUBJdRERERERERETcSLdu3fDx8cE0TebMmcPAgQMJCwurso2XlxcxMTEaKipuxzAMjA5dMH/4FvPPtRhKorsEJdFFRERERERERMRttG/fnvbt2wNQUlLCueeeS9OmTZ0clUgt6tgVfvgW888/nB2J/E1JdBERERERERERcUtXXHGFs0MQqXVG206YALvSMK1WDE+lcJ1Nz4CIiIiIiIiIiMgJmjx5Mjt27ODQoUP4+/vTpUsXhg0bpqp4qbmwSPD1g6JCyNgFLWOdHVGjZ3F2ACIiIiIiIiIiIu6mc+fO3HnnnTz33HPcdddd7Nu3j2nTpjk7LGkADIsFWsUBYKanOTkaASXRRURERERERERETtigQYNo37494eHhdOjQgUsvvZQtW7ZgtVqdHZo0AEaMPYmOkuguQe1cREREREREREREaiA/P5/vvvuO9u3b43mM/tVlZWWUlZU5bhuGga+vr+Pro6l47FjbuAOt4wTOcUobTMBM31Zn59HzUX1KoouIiIiIiIiIiJyE2bNn88UXX1BSUkK7du249957j7n9woULmT9/vuN2bGwskydPJjw8vFrni4qKqlG8rkLrOL7SHqezDzD27CIqKqpOE8R6Po5PSXQRERERERERERFg7ty5VZLcR/LUU0/Rpk0bAC6++GL69+/P/v37mTdvHi+++CL33nvvUROegwcPZtCgQY7bFdtlZWUdsw2MYRhERUWRkZGBaZonuiyXoXVUn+nhDYYFsyCPvX9uwAip/YG1jen58PT0rPabVUfc/6T3FBERERERERERaUAGDhxIYmLiMbepnIgLCgoiKCiI5s2b06JFC2699Va2bNlC+/btj7ivl5cXXl5eR3ysOklM0zTdOtlZQeuoBk8vCI+CzD2Ye9IhOLRuzoOej+pQEl1ERERERERERIR/kuInoyJ5V7nnuUiNNG9lT6Lv3YUR383Z0TRqSqKLiIiIiIiIiIicgK1bt7J161Y6duyIv78/+/btY+7cuURGRh61Cl3kRBnRLTF/+wn27nJ2KI2ekugiIiIiIiIiIiInwNvbm59++om5c+dSUlJCSEgI3bt354477jhquxaRExYdA4C59y8nByJKoouIiIiIiIiIiJyAmJgYHnroIWeHIQ2c0bwVJsCedGeH0uhZnB2AiIiIiIiIiIiIiPxLVEv757xczPxDzo2lkVMSXURERERERERERMTFGE18oFmE/YZaujiVkugiIiIiIiIiIiIirii6FQDmXrV0cSb1RBcRERERERERERFxQUZ0S8x1a2DPLqfGYZaWQEkxmCZgYm/WXkuMmh/AjIqqjUiOSkl0EREREREREREREVfkqESv/3YuZkkJ5pKPMFd/Bxm76/38J+Tj7+v08Eqii4iIiIiIiIiIiLggI7qVveg7o36T6Gb+IWzP3Ad7jtJGxqhx+bhbURJdRERERERERERExBVFRNs/H9yPWVaG4eVV56c0bTZsrz9jT6AHh2IMGYXR+VQICMJwweS5YRgYXt51eg4l0UVERERERERERERcUWAwNPGx9yM/sA+iWtb9OX/9ETb+Dk18sNz5KEaLU+r+nC7O4uwARERERERERERERORwhmFA+N9DM7P21fn5TNPEtuQj+7nPu1gJ9L8piS4iIiIiIiIiIiLiqv5OoptZe+v+XDu22D+8vDH6D6r787kJJdFFREREREREREREXJThqETPqPNzmT8us5+zR2+MoJA6P5+7UBJdRERERERERERExFU5KtHrNolulpdj/vwdAMaZ/er0XO5GSXQRERERERERERERF2WER9u/yKzjdi4bf4O8XAgIgvjudXsuN6MkuoiIiIiIiIiIiIiratXa/jnjL8zC/Do7jfnTcgCM087C8PSss/O4IyXRRURERERERERERFyUERRqb+limpC2qU7OYZYUY/76o/18Z6iVy78piS4iIiIiIiIiIiLiwoy28QCYWzbWyfHN336CkmJ7sj6uQ52cw50piS4iIiIiIiIiIiLiytp2AsDcuqFODu9o5XJGPwzDqJNzuDMl0UVERERERERERERcmNGxi/2LrRsw83Jr9djmoRzY8Kv9PGrlckRKoouIiIiIiIiIiIi4MCOiOZzSFmw2zJ+/q9Vjmyu+gvJyiG2PEdWyVo/dUCiJLiIiIiIiIiIiIuLijDOTADC/+wrTZquVY5rlVmzLUu3HT0qulWM2REqii4iIiIiIiIiIiLg444x+4OMLf23H/OGbWjlm4fIvIHs/BARhnNa3Vo7ZECmJLiIiIiIiIiIiIuLijMBgjEFDATA/eANz++YaHc8sK+PQ+2/Zj33+pRhe3jWOsaHydHYAIiIiIiIiIiIiInJ8xrmDMP9YDZv+wDblXoxzLsTofCpERIOfP2CAYQAmmCY08cXwPDwFbJaVYb49DXNPur0K/ZwL630t7kRJdBERERERERERERE3YHh6YbltErbX/wt/rMb86hPMrz45xg4GBAZDSDNoGoYRGgamDXPDb5C5Fzw9sdx0N4aPb72twR0piS4iIiIiIiIiIiLiJgwfPywpD8DanzF/XIa5eydk7QWr9fCNTRMO5dg/0rdhVn4sIJCwu58gp0Uspmkevq84KIkuIiIiIiIiIiIi4kYMw4Bup2N0Ox0A02YDmw17GxfsFeiGAQV5kHMADh7APLgfsrPA8IDoFli69MK3XQdy9u516lrcgZLoIiIiIiIiIiIiJ6msrIz77ruPnTt3MmXKFFq3bu3skKQRMiwWsFgOfyAoxP4R0wbj3/sY/75HjuYI/7IiIiIiIiIiIiJSHbNnz6Zp06bODkNE6pCS6CIiIiIiIiIiIifh119/Ze3atYwYMcLZoYhIHVISXURERERERERE5ATl5OTw2muvcdttt+Ht7e3scESkDqknuoiIiIiIiIiIyAkwTZOXX36ZAQMG0KZNGzIzM6u1X1lZGWVlZY7bhmHg6+vr+PpoKh5z9x7WWodr0TqqT0l0ERERERERERERYO7cucyfP/+Y2zz11FNs2rSJoqIiBg8efELHX7hwYZXjx8bGMnnyZMLDw6u1f1RU1Amdz1VpHa5F6zg+JdFFRERERERERESAgQMHkpiYeMxtwsPD+eijj9i8eTPXXHNNlcfuvfde+vbty2233XbEfQcPHsygQYMctysqZ7OysrBarUc9p2EYREVFkZGRgWma1V2Oy9E6XEtjWoenp2e136w64v4nvaeb8/RsOEtvSGsR59A1JDWla0hqQteP1JSuIakpXUNSE7p+pKYawjXUENZQISgoiKCgoONud/311zN06FDH7YMHD/LEE09wxx130K5du6Pu5+XlhZeX12H3V/ff0MPDo1rbuTqtw7U0hnXU9PuUYbrz2wwiIiIiIiIiIiJOlpmZyW233caUKVNo3bq1s8MRkVpmcXYAcvKKioq45557KCoqcnYo4qZ0DUlN6RqSmtD1IzWla0hqSteQ1ISuH6kpXUNyIhrK9aJ1uBato/oazt/bNEKmabJ9+3a37lkkzqVrSGpK15DUhK4fqSldQ1JTuoakJnT9SE3pGmpYIiIimDt3bp0dv6FcL1qHa9E6qk+V6CIiIiIiIiIiIiIiR6EkuoiIiIiIiIiIiIjIUSiJ7sa8vLwYMmTIEac6i1SHriGpKV1DUhO6fqSmdA1JTekakprQ9SM1pWtITkRDuV60DteidVSfYbp70xsRERERERERERERkTqiSnQRERERERERERERkaNQEl1ERERERERERERE5CiURBcREREREREREREROQpPZwcgJ++LL75g0aJF5OTk0LJlS0aNGkV8fLyzwxI3sHDhQlatWsXu3bvx9vamffv2DB8+nObNmzs7NHFDCxcu5P333yc5OZlRo0Y5OxxxE9nZ2cyePZvffvuN0tJSoqOjufXWW4mLi3N2aOLiysvLmTdvHt999x05OTmEhoaSlJTEZZddhsWi+hA53IYNG1i0aBHbt2/n4MGDTJgwgdNPP93xuGmazJs3j6+//pr8/HzatWvHDTfcQKtWrZwYtbiSY11DVquVDz74gF9//ZXMzEz8/Pzo0qUL11xzDU2bNnVy5OIqjvd9qLLXX3+dpUuXcu2113LhhRfWc6Tiqtwt/zN37lzmz59f5b7g4GDeeOMNwHV/9tbGa4aysjJmzZrFypUrKS0tJSEhgdGjR9OsWTOXWcdLL73E8uXLq+zTrl07nnjiCZdaR3VyV/X5nOg3DTf1/fffM2PGDC677DImT55MfHw8Tz75JPv373d2aOIGNmzYwAUXXMATTzzB/fffj81m4/HHH6e4uNjZoYmb2bp1K0uXLuWUU05xdijiRvLz83nggQfw9PTkvvvuY9q0aYwcORI/Pz9nhyZu4JNPPuGrr77ihhtu4Nlnn2X48OEsWrSIJUuWODs0cVElJSW0bt2a66+//oiPf/LJJ3z22Wdcf/31PPXUU4SEhPD4449TVFRUz5GKqzrWNVRaWsr27du5/PLLmTx5MnfddRd79+5lypQpTohUXNXxvg9VWLVqFVu2bCE0NLSeIhN34K75n1atWvH66687PqZOnep4zFV/9tbGa4YZM2awatUqxo0bx6OPPkpxcTFPP/00NputvpZRre853bt3r/L8/N///V+Vx11hHdXJXdXnc6IkuptavHgx/fv359xzz3W8CxkWFsaXX37p7NDEDUyaNImkpCRatWpF69atGTNmDPv37yctLc3ZoYkbKS4uZvr06dx88834+/s7OxxxI5988gnNmjVjzJgxtG3bloiICLp06UJUVJSzQxM3sHnzZnr16sWpp55KREQEZ555Jl27dmXbtm3ODk1cVI8ePRg6dChnnHHGYY+ZpklqaiqDBw/mjDPOICYmhrFjx1JSUsKKFSucEK24omNdQ35+fjzwwAP06dOH5s2b0759e6677jrS0tJcPsEl9edY11CF7Oxs3n77bW6//XY8PdU0QP7hrvkfi8VCSEiI4yMoKAhw7Z+9NX3NUFhYyDfffMPIkSPp2rUrsbGxpKSkkJ6eztq1a11iHRU8PT2rPD8BAQGOx1xlHcfLXdX3c6IkuhuyWq2kpaXRrVu3Kvd37dqVTZs2OSkqcWeFhYUAVb5pihzPm2++SY8ePejatauzQxE3s3r1auLi4pg2bRqjR49m4sSJLF261NlhiZvo2LEj69atY8+ePQDs2LGDTZs20aNHDydHJu4oMzOTnJycKq+rvby86NSpk15Xy0krLCzEMAz9hZVUm81mY/r06Vx88cVOb2chrsWd8z8ZGRncfPPNjB07lueee459+/YB7vuztzpxp6WlUV5eXuV35KZNmxITE8PmzZvrPeZj2bBhA6NHj2bcuHG8+uqr5ObmOh5z1XX8O3dV38+J3t50Q4cOHcJmsxEcHFzl/uDgYHJycpwTlLgt0zR599136dixIzExMc4OR9zEypUr2b59O0899ZSzQxE3lJmZyVdffcWFF17I4MGD2bp1K++88w5eXl7069fP2eGJi7vkkksoLCzkzjvvxGKxYLPZGDp0KH379nV2aOKGKl47H+l1taqI5WSUlpby3nvvkZiYqCS6VNsnn3yCh4cH//nPf5wdirgYd83/tGvXjrFjx9K8eXNycnJYsGAB999/P9OmTXPbn73ViTsnJwdPT8/DChRd7fnq0aMHvXv3JiwsjMzMTD788EMeffRRnn76aby8vFxyHUfKXdX3c6IkuhszDKNa94kcy1tvvUV6ejqPPvqos0MRN7F//35mzJjBpEmT8Pb2dnY44oZsNhtt2rThmmuuASA2NpZdu3bx5ZdfKokux/X999/z3Xffcfvtt9OqVSt27NjBjBkzHANGRU7Gv19Dm6bppEjEnVmtVp577jlM02T06NHODkfcRFpaGqmpqUyePFm/z8tRuVv+p/JfCMbExNC+fXtSUlJYvnw57dq1A9z3Z+/JxO1qa+vTp4/j65iYGNq0acOYMWP45ZdfjtkCxpnrOFbuqr6eEyXR3VBQUBAWi+Wwd0xyc3MPe/dF5Fjefvtt1qxZwyOPPFKvE5bFvaWlpZGbm8u9997ruM9ms7Fx40aWLFnCe++9h8WibmFydKGhobRs2bLKfS1btuSnn35yUkTiTmbPns0ll1xCYmIiYH/hn5WVxccff6wkupywkJAQwF6lVHmQ36FDh/S6Wk6I1Wrl2WefJSsriwcffFBV6FJtGzdu5NChQ4wZM8Zxn81mY+bMmaSmpvLSSy85MTpxtoaS//Hx8SEmJoa9e/dy2mmnAe73s7c6rxlCQkKwWq3k5+dXqXw+dOgQHTp0qNd4T0RoaCjh4eHs3bsXcL11HC13Vd/PibIcbsjT05O4uLjDGuCvXbvWpf9TiuswTZO33nqLn376iQcffJCIiAhnhyRupEuXLvz3v4ZML4sAAAXvSURBVP9lypQpjo82bdrQt29fpkyZogS6HFeHDh0c/awr7Nmzh/DwcCdFJO6kpKTksO8zFovF5Sp8xD1EREQQEhJS5XW11Wplw4YNel0t1VaRQM/IyOCBBx4gMDDQ2SGJGzn77LN55plnqry2Dg0N5eKLL2bSpEnODk+crKHkf8rKyti9ezehoaFu+7O3OnHHxcXh4eFRZZuDBw+Snp5O+/bt6z3m6srLy+PAgQOORLSrrON4uav6fk5Uie6mBg0axPTp04mLi6N9+/YsXbqU/fv3M2DAAGeHJm7grbfeYsWKFUycOBFfX1/Hu9p+fn5qzyHH5evre1j//CZNmhAYGKi++lItF154IQ888AALFiygT58+bN26la+//pqbbrrJ2aGJG+jZsycLFiwgLCyMli1bsmPHDhYvXsw555zj7NDERRUXF5ORkeG4nZmZyY4dOwgICCAsLIzk5GQWLlxIdHQ0UVFRLFy4kCZNmqjPvjgc6xoKDQ1l2rRpbN++nXvuuQebzeZ4bR0QEICnp37lluN/H/r3Gy+enp6EhITQvHnz+g5VXJA75n9mzpxJr169CAsLIzc3l48++oiioiL69euHYRgu+7O3pq8Z/Pz86N+/P7NmzSIwMJCAgABmzZpFTExMlcGWzlxHQEAAc+fO5cwzzyQkJISsrCzef/99AgMDOf30011qHcfLXVXnWqrNtRimynbc1hdffMGiRYs4ePAgrVq14tprr6VTp07ODkvcwJVXXnnE+8eMGaM/hZeT8vDDD9O6dWtGjRrl7FDETaxZs4b33nuPjIwMIiIiuPDCCznvvPOcHZa4gaKiIj788ENWrVpFbm4uTZs2JTExkSFDhihZJUe0fv16HnnkkcPu79evH2PHjsU0TebNm8fSpUspKCigbdu23HDDDXpjWByOdQ1dccUV3HbbbUfc76GHHqJz5851HZ64geN9H/q3sWPHkpyczIUXXlgf4YkbcLf8z3PPPedoVRQUFES7du0YOnSoo6Wjq/7srY3XDKWlpcyePZsVK1ZQWlpKQkICo0ePJiwszCXWceONN/LMM8+wfft2CgoKCA0NpXPnzlx11VVVYnSFdVQnd1Wfz4mS6CIiIiIiIiIiIiIiR6HGtSIiIiIiIiIiIiIiR6EkuoiIiIiIiIiIiIjIUSiJLiIiIiIiIiIiIiJyFEqii4iIiIiIiIiIiIgchZLoIiIiIiIiIiIiIiJHoSS6iIiIiIiIiIiIiMhRKIkuIiIiIiIiIiIiInIUSqKLiIiIiIiIiIiIiByFkugiIiIiIiIiIiIiIkehJLqIiIiIiIiIiIiIyFEoiS4iIiIiIiIiIiIichRKoouIiIi4iNLSUiZOnEhKSgqFhYWO+3Nycrjxxht5+OGHsdlsToxQRERERESk8VESXURERMRFeHt7c+edd3Lo0CFefvllAGw2Gy+88AIA48aNw2LRyzcREREREZH6pN/CRERERFxIdHQ0N998M6tWrSI1NZX58+ezfv16UlJSCA0NdXZ4IiIiIiIijY6nswMQERERkar69OnDhg0bmDVrFjabjcGDB9O1a1dnhyUiIiIiItIoqRJdRERExAWdc845lJeX4+HhQXJysrPDERERERERabSURBcRERFxMcXFxbz44otER0fj7e3Nq6++6uyQREREREREGi0l0UVERERczBtvvMH+/fuZMGECt9xyC6tXr2bx4sXODktERERERKRRUhJdRERExIV8/fXXfPfdd9xwww20atWKM888k4EDBzJnzhz+v107NIIgBKIoyEZCKJAIMRECiaHIAc25c6PZqu2Wo75+NXPO2/MAAAA+R0QHAHiJtVYaY6RSSqq1/u+ttZRzTr33tPe+NxAAAOCDnnPOuT0CAAAAAADeyCc6AAAAAAAERHQAAAAAAAiI6AAAAAAAEBDRAQAAAAAgIKIDAAAAAEBARAcAAAAAgICIDgAAAAAAAREdAAAAAAACIjoAAAAAAAREdAAAAAAACIjoAAAAAAAQENEBAAAAACDwAwZwJA3SSWwlAAAAAElFTkSuQmCC"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot trajectory\n",
    "grid = plt.GridSpec(4, 5)\n",
    "\n",
    "plt.figure(figsize=(15, 10))\n",
    "\n",
    "plt.subplot(grid[0:4, 0:4])\n",
    "plt.plot(track[0, :], track[1, :], \"b+\")\n",
    "plt.plot(x_sim[0, :], x_sim[1, :])\n",
    "plt.axis(\"equal\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.xlabel(\"x\")\n",
    "\n",
    "plt.subplot(grid[0, 4])\n",
    "plt.plot(u_sim[0, :])\n",
    "plt.ylabel(\"a(t) [m/ss]\")\n",
    "\n",
    "plt.subplot(grid[1, 4])\n",
    "plt.plot(x_sim[2, :])\n",
    "plt.ylabel(\"v(t) [m/s]\")\n",
    "\n",
    "plt.subplot(grid[2, 4])\n",
    "plt.plot(np.degrees(u_sim[1, :]))\n",
    "plt.ylabel(\"delta(t) [rad]\")\n",
    "\n",
    "plt.subplot(grid[3, 4])\n",
    "plt.plot(x_sim[3, :])\n",
    "plt.ylabel(\"theta(t) [rad]\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}