Puzzles/SlitherLink.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slither Link (数回)\n",
    "\n",
    "Slither Link (also known as Fences and Loop the Loop) is a logic puzzle with simple rules and challenging solutions.\n",
    "\n",
    "The rules are simple. \n",
    "\n",
    "1. Draw a single closed loop along the grid lines that does not visit any grid point more than once.\n",
    "2. A number in a cell indicates how many of the four grid lines surrounding that cell are used by the loop.\n",
    "3. For a cell without a number the loop can use any number of surrounding grid lines.\n",
    "\n",
    "----------\n",
    "\n",
    "游戏规则很简单。 \n",
    "\n",
    "1. 游戏目标是画线连接棋盘上的点形成一条唯一的回路，每个节点被访问不超过1次。\n",
    "2. 围成每个格子的4条边中，被连接成回路的边的数量必须等于格中数字。\n",
    "3. 对于没有数字的单元格，回路可以使用任意数量的周围网格线。\n",
    "\n",
    "\n",
    "\n",
    "- [Puzzle Wiki](https://www.puzzles.wiki/wiki/Slitherlink);\n",
    "\n",
    "- [Janko's Site](https://www.janko.at/Raetsel/Slitherlink/index.htm);\n",
    "\n",
    "> Puzzles and Games: A Mathematical Modeling Approach. Tony Hürlimann, 2015 \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "-----\n",
    "\n",
    "## 棋盘表示\n",
    "\n",
    "以 `assets/data/Slitherlink/problems/122_10x18.txt` 文件为例，表示棋盘：\n",
    "\n",
    "![](https://cdn.jsdelivr.net/gh/SmilingWayne/picsrepo/202409280914553.png)\n",
    "\n",
    "第一行是两个数字 $m, n$，以空格分开，分别表示棋盘的行数和列数。\n",
    "\n",
    "后面紧接着 m 行，每一行有 n 个符号，用空格分开，表示该行每个该行该列中网格里的数字。注意，数字仅能取 $0，1，2，3$，如果网格中没有数字，则取 \"-\" 。\n",
    "\n",
    "> 注意：problems文件夹外的一些数据文档，网格中无数字时的符号为 \".\"。该问题会在后续统一。\n",
    "\n",
    "\n",
    "```txt\n",
    "10 18\n",
    "0 - - 3 - 3 - 1 1 - 3 - - - - 3 - 1\n",
    "- - - - 2 - 3 - - 0 - 1 - 3 3 - 3 -\n",
    "3 - 3 2 - - - 1 - 2 - - 1 - - - - 1\n",
    "- 1 - - 2 - 0 - 2 - - - - 0 - - 1 -\n",
    "0 - - - - 3 - - 3 - 3 3 - - 1 3 - -\n",
    "- - 1 0 - - 1 3 - 1 - - 2 - - - - 1\n",
    "- 3 - - 3 - - - - 1 - 2 - 1 - - 3 -\n",
    "1 - - - - 2 - - 0 - 3 - - - 3 2 - 0\n",
    "- 1 - 0 3 - 3 - 1 - - 3 - 2 - - - -\n",
    "3 - 3 - - - - 1 - 2 0 - 0 - 3 - - 3\n",
    "```\n",
    "\n",
    "----\n",
    "\n",
    "## 问题建模\n",
    "\n",
    "对于一个 $m \\times n$ 的网格，我们现在专注于每一个格子的四条边。每一个格子都有4个**顶点**，这些顶点之间的互相连接，构成了棋盘的最终解。网格会和相邻网格的顶点重合。以上述表格第一行为例，\n",
    "\n",
    "`0 - - 3 - 3 - 1 1 - 3 - - - - 3 - 1`\n",
    "\n",
    "我们按照从上到下，从左到右对18个格子的顶点从0开始进行编号。第一行18个格子的上顶点有19个，下顶点也有19个，其中有一些是共享节点。如图示。\n",
    "\n",
    "![](https://cdn.jsdelivr.net/gh/SmilingWayne/picsrepo/202409280940808.png)\n",
    "\n",
    "我们可以发现，对于一个$m \\times n$ 的网格，有 $(m + 1) \\times (n + 1)$ 个非重复的顶点。记顶点集合为 $V$。由于每个顶点至多和4个其他顶点相连（有一些顶点仅和两个顶点相连），整个网格共有 $2 mn + m + n$ 条边。记边的集合为 $E$.\n",
    "\n",
    "我们的任务实际就是选择这些边中的一些边连接起来，满足方格中数字约束与环路约束。\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们用两个节点编号来描述“边”，比如，(0,1) 表示0-1的边，以此类推。上图中，(3, 4), (3, 22), (4, 23), (20,21)， (21, 22) 等边是被连接的，其他的没有连接。\n",
    "\n",
    "我们用 0-1 决策变量 $x_{ij}$ 表示边 $(i, j)$ 是否被连接。记原始的 $m \\times n$ 棋盘为 $G$, $G_{a,b}$ 表示原来棋盘第 $a$ 行第 $b$ 列的数字，$S_{a,b}$ 表示棋盘第 $a$ 行第 $b$ 列方格周围的边的集合。\n",
    "\n",
    "所以我们可以把方格数字约束写成：\n",
    "\n",
    "$$\\sum_{(i, j) \\in S_{a,b}} x_{ij} = G_{a,b}, \\quad a = 1, 2, \\cdots, m; b = 1, 2, \\cdots, n$$\n",
    "\n",
    "仿照路径规划的流平衡，对于每个顶点流入流出是相等的；同时每一个顶点至多流出一条边。所以可以写成：\n",
    "\n",
    "$$\\sum_{j \\in V} x_{ij} = \\sum_{j \\in V} x_{ji} \\leq 1, \\quad i \\in V$$\n",
    "\n",
    "这里因为我们用 $(i, j)$ 对边进行表示，在终盘里 $(i, j)$ 和 $(j, i)$ 实际上是同一个边，所以可以加一个约束，限制这两条边至多只能选一个。\n",
    "\n",
    "$$x_{ij} + x_{ji} \\leq 1, \\forall (i, j) \\in E \\quad \\text{and} \\quad i \\leq j$$\n",
    "\n",
    "上述两个约束保证了可以生成一些环路，但是不保证整个图都可以连成一个完整的环，而是存在子环(Subtour).比如下图红圈内的情况：\n",
    "\n",
    "![](https://cdn.jsdelivr.net/gh/SmilingWayne/picsrepo/202409281039368.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时我们每次求解后，动态地添加去子环约束。比如如果我们发现某个解中出现了子环路，也就是说我们发现了一个边集合 $T$，这个集合里的边首尾相连。那么我们只需要仿照旅行商问题中的DFJ formulation，加入如下约束：\n",
    "\n",
    "$$\\sum_{(i, j) \\in T} x_{ij} \\leq |T| - 1 \\quad \\forall |T| \\geq 2$$\n",
    "\n",
    "约束的本质是限制围城这个子环路的所有边在终盘里不会全部被选中。即假设这个子环路由 $|T|$ 条边组成，约束这 $| T |$ 个边至多同时被选中 $|T| - 1$ 个。\n",
    "\n",
    "我们用Gurobi求解上述模型，即可得到最终盘。每一个整数规划求解器都可以用来编程求解。上述终盘也就是:\n",
    "\n",
    "\n",
    "![](https://cdn.jsdelivr.net/gh/SmilingWayne/picsrepo/202409281047352.png)\n",
    "\n",
    "----------\n",
    "\n",
    "## 一些有意思的试验\n",
    "\n",
    "现在有很多很多的棋盘，我能找到的最大的是 $60 \\times 60$ 的谜题，来自[这个SudokuFans链接](http://www.sudokufans.org.cn/main.index.php?type=loop60)（需要注册）。虽然没法直接从网页端解析这个棋盘，最后我是截图切片识别数字，解析了这个棋盘并求解。\n",
    "\n",
    "Gurobi能在24s内找到终盘。连接了3556条边，总共加入了162条去子环约束。可视化如下。\n",
    "\n",
    "![](https://cdn.jsdelivr.net/gh/SmilingWayne/picsrepo/202409281058239.png)\n",
    "\n",
    "除了这种超大规模数据外，Janko网站有非常多非常多的谜题数据，[参考链接。](https://www.janko.at/Raetsel/Slitherlink/index-2.htm)\n",
    "\n",
    "我目前爬了一部分数据和终盘的答案，大概100+个题目，放在我的[这个Github仓库](https://github.com/SmilingWayne/PuzzleSolver/tree/main/assets/data/slitherlinkdata) 里了，仓库里还有许多别的谜题和数据。\n",
    "\n",
    "Janko网站里的谜题数据格式比较统一，而且终盘的表示是比较特殊的，因为我们的终盘要求边连成一个唯一回路，所以这个回路一定会把某些格子围起来。Janko网站里每个终盘就是用“某格是否在终盘里被围起来”进行表示的。用 `x` 表示该格子被围起，否则`-`表示没有被围。以上述 $10 \\times 18$ 棋盘为例，终盘的表示为：\n",
    "\n",
    "```txt\n",
    "10 18\n",
    "- - - x - x x x x x - x - - - x - - \n",
    "- x x x - - - x x x x x - x - x - x \n",
    "x x - x x x x x - x x x x x x x x x \n",
    "- - - - - x x x - - x x x x x x x x \n",
    "- - - x - - x x x - x - x x x - - x \n",
    "- x x x x x x - - - - - - x x x - - \n",
    "- - x x - x x x x x x x - x x x x - \n",
    "- x x x - - x x x x - x - x - - - - \n",
    "- x x x x - x - x x - x - x x x x - \n",
    "x x - x - - - - x - - - - - x - x x\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## HERE is the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import gurobipy as grb\n",
    "import numpy as np\n",
    "import os\n",
    "from matplotlib.pyplot import MultipleLocator\n",
    "from matplotlib.patches import Rectangle\n",
    "import warnings \n",
    "warnings.filterwarnings(\"ignore\")\n",
    "import sys\n",
    "sys.path.append(\"..\")\n",
    "from Utils.grid_utils import vertex_to_arcs\n",
    "\n",
    "# ======== Visualization ===========\n",
    "\n",
    "def coordinatesParser(m, n, idx):\n",
    "    \"\"\"_summary_\n",
    "        Coordinate Parser for visualization \n",
    "    Args:\n",
    "        m (_type_): _description_\n",
    "        n (_type_): _description_\n",
    "        idx (_type_): _description_\n",
    "\n",
    "    Returns:\n",
    "        _type_: _description_\n",
    "    \"\"\"\n",
    "    ori_x , ori_y = idx // n, idx % n \n",
    "    return (0.5 + ori_y, 0.5 + ( m - ori_x - 1) )\n",
    "\n",
    "def coordinatesParserNodes(m, n, idx):\n",
    "    ori_x, ori_y = idx // (n + 1), idx % (n + 1)\n",
    "    return (ori_y, m - ori_x )\n",
    "\n",
    "\n",
    "def Vis(m, n, grid, result):\n",
    "    \"\"\"_summary_\n",
    "\n",
    "    Args:\n",
    "        m (int): Height of the grid\n",
    "        n (int): Width of the grid\n",
    "        grid (List[List[int]]): The Grid\n",
    "        result (Dict[\"arcs\": List[[int, int]]]): The result.\n",
    "        \n",
    "        The vertex is defined in [ 0 ~ (m + 1) * (n + 1) ]. As:\n",
    "        \n",
    "        0 ______ 1 ______ 2 ______ .... ___ n\n",
    "        |         |         |              |\n",
    "        |         |         |              |\n",
    "       n+1 _____ n+2 _____ n+3 ......___   2*n\n",
    "        |\n",
    "        ..\n",
    "        ..\n",
    "      m*(n+1)....................      (m+1)*(n+1)\n",
    "      \n",
    "        The arc is defined by the vertex index, always from the smaller one to larger one. \n",
    "        \n",
    "        For example:\n",
    "        \n",
    "        (0,1), (1,n+2), (0,n+1), ...  etc.\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(n,m))\n",
    "\n",
    "    ax = plt.gca()\n",
    "    x_major_locator = MultipleLocator(1)\n",
    "    y_major_locator = MultipleLocator(1)\n",
    "    ax.xaxis.set_major_locator(x_major_locator)\n",
    "    # set main axis as 1 \n",
    "    ax.yaxis.set_major_locator(y_major_locator)\n",
    "\n",
    "    plt.xlim(0,n)\n",
    "    plt.ylim(0,m)\n",
    "\n",
    "    plt.grid(linestyle = \"--\")\n",
    "\n",
    "    # Draw squares that unvisited\n",
    "    for i in range(m):\n",
    "        for j in range(n):\n",
    "            if grids[i][j] != -1:    \n",
    "                new_coor = coordinatesParser(m, n, i * n + j)\n",
    "                ax.text(new_coor[0], new_coor[1], str(grids[i][j]), \n",
    "                        horizontalalignment = \"center\", \n",
    "                        verticalalignment = 'center',\n",
    "                        fontsize = 24)\n",
    "\n",
    "    # draw result lines\n",
    "    for line in result[\"arcs\"]:\n",
    "        dot1 = coordinatesParserNodes(m, n, line[0])\n",
    "        dot2 = coordinatesParserNodes(m, n, line[1])\n",
    "        plt.plot([dot1[0], dot2[0]], [dot1[1], dot2[1]], linestyle=\"-\", linewidth = 4, color = \"blue\") \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "READING FILE ../assets/data/Slitherlink/problems/655_17x17.txt\n",
      "[-1, -1, -1, 2, 3, 2, 3, -1, -1, 2, -1, -1, -1, 2, 2, -1, -1]\n",
      "[-1, -1, 1, -1, -1, -1, 1, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1]\n",
      "[2, -1, 3, 2, 1, 3, -1, 3, -1, -1, 2, -1, 2, 2, 2, 2, -1]\n",
      "[3, -1, -1, -1, 2, -1, 0, 3, -1, 3, 1, -1, 2, -1, 1, 1, 2]\n",
      "[-1, -1, -1, -1, -1, -1, -1, -1, 1, 3, -1, -1, -1, 3, 3, 2, -1]\n",
      "[-1, 1, 3, -1, 3, 1, -1, -1, 3, -1, -1, -1, -1, 1, 2, -1, 2]\n",
      "[-1, -1, 2, 1, -1, 1, 2, -1, 2, 2, -1, -1, -1, -1, -1, 2, 0]\n",
      "[3, 2, -1, 2, 2, 2, 2, 3, 2, -1, -1, 1, -1, -1, -1, -1, -1]\n",
      "[-1, 1, 3, 2, 2, -1, 2, -1, -1, 2, 3, 1, -1, -1, -1, 2, -1]\n",
      "[-1, 1, -1, -1, -1, -1, 2, 1, -1, 2, -1, 1, 2, -1, -1, -1, -1]\n",
      "[-1, -1, -1, -1, 2, -1, 3, 2, 2, 2, 3, -1, 2, 2, -1, 0, 2]\n",
      "[-1, 2, 1, -1, 2, 3, 1, 1, -1, 2, -1, 2, -1, 3, -1, -1, -1]\n",
      "[-1, -1, 1, 1, -1, 2, 1, 1, 2, 3, -1, -1, -1, -1, 2, 2, 2]\n",
      "[-1, 3, 3, 3, 2, -1, 2, 3, -1, 2, 1, 3, -1, -1, 3, 2, 2]\n",
      "[-1, 2, 0, 2, 1, 3, 2, 1, -1, 1, -1, 2, -1, 1, 2, -1, -1]\n",
      "[-1, -1, 2, 3, 2, 2, -1, 2, -1, 2, -1, 3, -1, 2, -1, 2, 2]\n",
      "[-1, 2, 3, 2, -1, -1, 2, 2, -1, -1, -1, -1, -1, 2, 3, -1, -1]\n"
     ]
    }
   ],
   "source": [
    "def readInstance(path):\n",
    "    # file_name = f\"../assets/data/slitherlinkdata/{path}{np.random.randint(1)+1}.txt\"\n",
    "    file_name = f\"../assets/data/Slitherlink/problems/{path}\"\n",
    "\n",
    "    m = 0\n",
    "    n = 0\n",
    "    grids = None\n",
    "    print( f\"READING FILE {file_name}\" )\n",
    "    if not os.path.isfile(file_name):\n",
    "        print('File does not exist')\n",
    "    else:\n",
    "        \n",
    "        with open(file_name) as file:\n",
    "            firstline = file.readline().strip().split(\" \")\n",
    "            m = int(firstline[0])\n",
    "            n = int(firstline[1])\n",
    "            grids = [[-1 for _ in range(n)] for _ in range(m)]\n",
    "            for idx in range(m):\n",
    "                line = file.readline().strip().split(\" \")\n",
    "                \n",
    "                for j in range(n):\n",
    "                    if line[j] not in ['.', '-']:\n",
    "                        grids[idx][j] = int(line[j])\n",
    "    return m, n, grids\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # data = \"30x25normal1\"\n",
    "    # data = \"15x15medium1\"\n",
    "    data = \"655_17x17.txt\"\n",
    "    m, n, grids = readInstance(data)\n",
    "    # print(grids)\n",
    "    for row in grids:\n",
    "        print(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "READING FILE ../assets/data/Slitherlink/problems/655_17x17.txt\n",
      "Model Status: optimal\n",
      "Total arcs: 316.0\n",
      "Running time: 0.079 seconds\n"
     ]
    }
   ],
   "source": [
    "from pyscipopt import Model, quicksum\n",
    "import time\n",
    "import networkx\n",
    "    \n",
    "def cell2Arcs(m, n, i, j):\n",
    "    upperLeft = (n + 1) * i + j\n",
    "    return [\n",
    "        (upperLeft, upperLeft + 1),\n",
    "        (upperLeft, upperLeft + n + 1),\n",
    "        (upperLeft + 1, upperLeft + n + 2),\n",
    "        (upperLeft + n + 1, upperLeft + n + 2)\n",
    "    ]\n",
    "    # New Constraints\n",
    "    \n",
    "def SlitherlinkWithSCIP(m, n, grids):\n",
    "    starttime = time.time()\n",
    "    model = Model(\"Slitherlink\")\n",
    "    x = {}\n",
    "    node2Arc = {}\n",
    "    all_arcs = []\n",
    "    \n",
    "    for i in range(m + 1):\n",
    "        for j in range(n + 1):\n",
    "            if i != m and j != n:\n",
    "                x[i * (n + 1) + j, i * (n + 1) + j + 1] = model.addVar(\n",
    "                    vtype = \"B\", \n",
    "                    name = f\"x[{i * (n + 1) + j}, {i * (n + 1) + j + 1}]\"\n",
    "                )\n",
    "                x[i * (n + 1) + j, (i + 1) * (n + 1) + j] = model.addVar(\n",
    "                    vtype = \"B\", \n",
    "                    name = f\"x[{i * (n + 1) + j}, {(i + 1) * (n + 1) + j}]\"\n",
    "                )\n",
    "                all_arcs.append((i * (n + 1) + j, i * (n + 1) + j + 1))\n",
    "                all_arcs.append((i * (n + 1) + j, (i + 1) * (n + 1) + j))\n",
    "            elif i == m and j != n:\n",
    "                x[i * (n + 1) + j, i * (n + 1) + j + 1] = model.addVar(\n",
    "                    vtype = \"B\", \n",
    "                    name = f\"x[{i * (n + 1) + j}, {i * (n + 1) + j + 1}]\"\n",
    "                )\n",
    "                all_arcs.append((i * (n + 1) + j, i * (n + 1) + j + 1))\n",
    "            elif i != m and j == n:\n",
    "                x[i * (n + 1) + j, (i + 1) * (n + 1) + j] = model.addVar(\n",
    "                    vtype = \"B\", \n",
    "                    name = f\"x[{i * (n + 1) + j}, {(i + 1) * (n + 1) + j}]\"\n",
    "                )\n",
    "                all_arcs.append((i * (n + 1) + j, (i + 1) * (n + 1) + j))\n",
    "            node2Arc[i, j] = vertex_to_arcs(m, n, i, j)\n",
    "            x[i, j, 0] = model.addVar(\n",
    "                    vtype = \"B\", \n",
    "                    name = f\"x[{i}, {j}, 0]\"\n",
    "                )\n",
    "\n",
    "    for i in range(m + 1):\n",
    "        for j in range(n + 1):\n",
    "            model.addCons(quicksum(x[a, b] for (a, b) in node2Arc[i, j]) == 2 * x[i, j, 0], name = f\"Balance_{i}_{j}\")\n",
    "    \n",
    "    for i in range(m):\n",
    "        for j in range(n):\n",
    "            if grids[i][j] >= 0 and grids[i][j] < 4:\n",
    "                model.addCons(quicksum(x[a, b] for (a, b) in cell2Arcs(m, n, i, j)) == grids[i][j], name = f\"#ofnode_{i}_{j}\")\n",
    "                \n",
    "    # print(grids)\n",
    "    model.setObjective(quicksum(x[a, b] for (a, b) in all_arcs), \"minimize\")\n",
    "    model.hideOutput()\n",
    "    def addCut(edges):\n",
    "        G = networkx.Graph()\n",
    "        G.add_edges_from(edges)\n",
    "        components = list( list(c) for c in networkx.connected_components(G))\n",
    "        # print(f\"Totally: {len(components)} subtours!\")\n",
    "        if len(components) == 1:\n",
    "            return False\n",
    "        else:\n",
    "            # cutting_edges = []\n",
    "            for component in components:\n",
    "                prev = -1\n",
    "                curr = component[0]\n",
    "                cntt = len(component)\n",
    "                nodeSet = set(component)\n",
    "                temp = list()\n",
    "                while cntt > 0:\n",
    "                    for direct in [- n - 1, n + 1, -1, 1]:\n",
    "                        target = direct + curr \n",
    "                        curredge = (curr, target) if curr < target else (target, curr)\n",
    "                        if target in nodeSet and target != prev and curredge in edges:\n",
    "                            temp.append(curredge)\n",
    "                            prev = curr \n",
    "                            curr = target \n",
    "                            break \n",
    "                    cntt -= 1\n",
    "                model.freeTransform()\n",
    "                model.addCons(quicksum(x[a, b] for (a, b) in temp) <= len(temp) - 1)\n",
    "                # print(\"Add Cut!\")\n",
    "            return True\n",
    "                \n",
    "    arcs = []\n",
    "    while True:\n",
    "        model.optimize()\n",
    "        edges = []\n",
    "        for cur_key in x.keys():\n",
    "            if len(cur_key) < 3:\n",
    "                a, b = cur_key[0], cur_key[1]\n",
    "                if model.getVal( x[a, b]) > 1e-1:\n",
    "                    edges.append((a, b))\n",
    "        if not addCut(edges):\n",
    "            print(f\"Model Status: {model.getStatus()}\")\n",
    "            print(f\"Total arcs: {model.getObjVal()}\")\n",
    "            sol = model.getBestSol()\n",
    "            for (a, b) in all_arcs:\n",
    "                if sol[x[a, b]] > 1e-1:\n",
    "                    arcs.append([a, b])\n",
    "            break\n",
    "    endtime = time.time()\n",
    "    print(f\"Running time: {(round(endtime - starttime, 3)) } seconds\")\n",
    "    return arcs\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # data = \"60x60_1\"\n",
    "    # m, n, grids = readInstance(data)\n",
    "    # result = SlitherlinkWithSCIP(m, n, grids)\n",
    "    # Vis(m, n, grids, {'arcs': result})\n",
    "    \n",
    "    txt_files = []\n",
    "    datasetRouter = \"../assets/data/Slitherlink/problems/\"\n",
    "    for root, dirs, files in os.walk(datasetRouter):\n",
    "        txt_files.extend([f for f in files if f.endswith('.txt')])\n",
    "# txt_files[539:]\n",
    "    for f in [\"655_17x17.txt\"]:\n",
    "        try:\n",
    "            m, n, grids = readInstance(f)\n",
    "            result = SlitherlinkWithSCIP(m, n, grids)\n",
    "        except Exception:\n",
    "            print(f\"Wrong! File {f} failed to process!\")\n",
    "\n",
    "# hardcase: 1165_10x10.txt, 709_20x36.txt\n",
    "# 539 + 108?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABV0AAAVOCAYAAABhXJkTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzde3TV9Z3v/9e+xJSYgEEuAhoULZeWKkwPHoLTcrU6wbAsdGYJ1mt7OvZmp646bX9dbXHOnOHMnHad6Tp2VZ01R8Dj6PS0VWeGVCkFigiCqVBuyuEiRA1yvyQEY/bl9wfNhkh2yOeT796fz/e7n4+1XM3+5tL3fuX9/ny/fNh8dyybzWYFAAAAAAAAAAhE3HUBAAAAAAAAABAlbLoCAAAAAAAAQIDYdAUAAAAAAACAALHpCgAAAAAAAAABYtMVAAAAAAAAAALEpisAAAAAAAAABIhNVwAAAAAAAAAIEJuuAAAAAAAAABAgNl0BAAAAAAAAIEBsugIAAAAAAABAgIw3XdesWaP6+noNHz5csVhMzz//fJfPx2Kxbv/7H//jfwRVMwAAAAAAAAB4y3jT9fTp07rhhhv005/+tNvPHzhwoMt///t//2/FYjHNmzevz8UCAAAAAAAAgO9i2Ww2a/3NsZiee+453X777Xm/5vbbb1dLS4t++9vf2v7fAAAAAAAAAEBoJAv5ww8ePKhly5ZpyZIleb+mvb1d7e3tuceZTEbHjh3T5ZdfrlgsVsjyAAAAAAAAAECSlM1m1dLSouHDhyse79tbYRV003XJkiWqqqrS3Llz837NokWL9MgjjxSyDAAAAAAAAADolbfffltXXnlln35GQW8vMHbsWN188836X//rf+X9GR9+pevJkydVU1Mj6W1J/W1LA1AEl14q7d/f0eVYMnn273JSqVSvjpeVlSmTySidTueOxWIxJZPJvMfT6bQymUzueDweVyKRyHs8lUrp/KUukUgoHo/nPd7REcxzuvLKmE6f5hX7Qbj00qz27z+bc9C/pyj03siRSXoNAAA4demlWb39dsaLa6NOPl3vcb0GhMUpSVfpxIkTGjBgQJ9+UsFe6fryyy9r586d+td//dcev668vFzl5eXdfKa/Kiv7a/z4wtQXFXv3Sm1tkpRVNivFYlJFRUyjRrmuzF9kZmfbNqm1teuxSy+VLr/cTT1hcOml0unTXY9VVop17SLoNXP0mh3OB+bIzA65mSMzO+Rmjszs5Lteq652U08YcL1mhxk1R2Z2PryuBXHL04Jtuv7zP/+zPvnJT+qGG26w/hnjx0vr1wdYVIRls2f/Vi+ZTIpb4fYOmZmprZVefbXrMRbtno0aJR061PUY69rF0Wvm6LW+4XxgjszskJs5MrNDbubIzAzXa+a4XusbZtQcmZnpbl3rK+M7wra2tmrz5s3avHmzJOmtt97S5s2b1dTUlPuaU6dO6f/+3/+rL37xi4EVip6lUik1NDRc8M8pkB+ZAQAkzgc2yMwOuZkjMzvkZo7MAL8xo+bIzD3jV7o2NjZq+vTpuccPPfSQJOmee+7R4sWLJUnPPvusstms5s+fH0yVAAAAAAAAABASxpuu06ZN08Xee+tLX/qSvvSlL1kXBQAAAAAAAABhZXx7AQAAAAAAAABAfmy6RkQymVRdXZ2SyYK9N1rkkBkAQOJ8YIPM7JCbOTKzQ27myAzwGzNqjszcY9M1Qs6cOeO6hNAhMwCAxPnABpnZITdzZGaH3MyRGeA3ZtQcmbnFpmtEpFIprVq1inelM0BmAACJ84ENMrNDbubIzA65mSMzwG/MqDkyc49NVwAAAAAAAAAIEJuuAAAAAAAAABAgNl0jhJsjmyMzAIDE+cAGmdkhN3NkZofczJEZ4Ddm1ByZuUX6EVFWVqbZs2e7LiNUyAwAIHE+sEFmdsjNHJnZITdzZAb4jRk1R2bu8UrXiMhkMjp06JAymYzrUkKDzAAAEucDG2Rmh9zMkZkdcjNHZoDfmFFzZOYem64RkU6ntX79eqXTadelhAaZAQAkzgc2yMwOuZkjMzvkZo7MAL8xo+bIzD02XQEAAAAAAAAgQGy6AgAAAAAAAECA2HSNiFgspqqqKsViMdelhAaZAQAkzgc2yMwOuZkjMzvkZo7MAL8xo+bIzL2k6wIQjGQyqRkzZrguI1TIDAAgcT6wQWZ2yM0cmdkhN3NkBviNGTVHZu7xSteIyGQy2r9/P+9KZ4DMAAAS5wMbZGaH3MyRmR1yM0dmgN+YUXNk5h6brhGRTqe1efNm3pXOAJkBACTOBzbIzA65mSMzO+RmjswAvzGj5sjMPTZdAQAAAAAAACBA3NMVQCjt27dPv/nNb/S73/1OW7duVVNTk1pbW1VVVaUrr7xStbW1WrBggaZOneq6VC8cOXJEr7zyijZu3KitW7dqz549am5uVmtrq8rKylRdXa3x48dr2rRpuvvuuzVixAjXJXuDXjNDrwH+Y10DEDWsa+bIDCiCrGdOnjyZlZSVTmYnT3ZdTXh0dHRkX3nllWxHR4frUkKDzMxMnpzNSl3/czGjr7/+evbGG2/84zpx8f+mTZuW3b9/f/ELzfqTWTabzc6ePbvXmZWXl2cXLlyYTafTTmr1JTd6zU6Yeq0T5wNzZGbHdW5hWtc6uc4srMjNHJmZ8eXaI0zrGpn1DTNqjszMnJvRs/uSJ0+e7PPP5JWuEZFMJjVlyhTXZYQKmYXTzp07tXHjxi7HRo8erfHjx2vQoEE6ceKE1q1bp3feeUeStHr1atXW1urll1/WqFGjXJTsnUGDBmncuHEaOXKkKisr1dbWpt27d2vjxo1KpVJqb2/XwoULtXfvXi1ZssR1uc7Qa30Xll7jfGCOzOy4zi2M65rrzMKK3MyRWTiFcV1zLayZMaPmyMw9Nl0jIp1Oa9euXfroRz+qRCLhupxQILNwu+666/TFL35Rn//85y/458mZTEaLFy/W17/+dbW1tam5uVl33nmn1q1bp1gs5qhit6ZNm6b6+nrNnDlT1113Xbdfc/DgQX3zm9/UM888I0launSp6uvr9bnPfa6YpXqHXjMTxl7jfGCOzOz4kluY1jVfMgsbcjNHZuEWpnXNF2HLjBk1R2bu8UZaEZHJZLRz505lMhnXpYQGmYXTsGHD9OSTT+rNN9/Ut7/97W7vBxmPx3X//ffr//yf/5M79uqrr2r58uXFLNUr3/rWt/SXf/mXeTfBJGno0KF6+umnNWPGjNyxxx9/vBjleYlesxPGXuN8YI7M7LjOLYzrmuvMworczJFZOIVxXXMtrJkxo+bIzD02XQGEytSpU3Xvvff26m/qPvvZz+rGG2/MPV62bFkhS4uEWCym++67L/d406ZNDqtxi14rLHoNKD7WNQBRw7pmjsyA4mHTFUCk3XTTTbmP9+3b566QEBk8eHDu45aWFoeVhAu9Zo5eA/zGugYgaljXzJEZYI9N14iIx+OqqalRPM6vtLfIrDScf8+hdDrtsJLw2LFjR+7jq6++2l0hIUOvmfOl1zgfmCMzO2HLzYd1LWyZ+YLczJFZafBhXQsbXzJjRs2RmXu8kVZEJBIJTZw40XUZoUJmpWHr1q25j6+66iqHlYRDc3OzfvSjH+Uel/qbaJmg18z41GucD8yRmZ2w5ebDuha2zHxBbubIrDT4sK6FjS+ZMaPmyMw9trsjIp1Oa9OmTfxtnQEyi76mpiatXLky93jWrFkOq/FXW1ubduzYoR//+MeaOHGimpubJUnjxo3Td77zHcfVhQO91ju+9hrnA3NkZidMufmyroUpM5+Qmzkyiz5f1rUw8SkzZtQcmbnHpmtEZDIZNTU18a50Bsgs+h566KHcCaampkb19fWOK/LD2rVrFYvFcv9deuml+vjHP65vfetbOnTokCSprq5O69atU1VVleNqw4Fe615Yeo3zgTkysxOm3HxZ18KUmU/IzRyZRZ8v61qY+JQZM2qOzNxj0xVAJC1ZskS//OUvc48XLVqk8vJyhxWFQ3V1tZ555hktW7ZMl112metyQoFes0OvAf5iXQMQNaxr5sgM6Dvu6QogchobG/XAAw/kHs+fP18LFixwWJFfhg8frq9+9auSpGw2q5aWFu3cuVOvv/66jh8/rvnz5+uJJ57QY489ptGjRzuu1m/0Ws/oNSB8WNcARA3rmjkyA4LBpmtExONxjRkzhnelM0Bm0fTWW2+pvr5e77//viTp+uuv12OPPea4Kr+MGjVKjz766AXHm5ub9b3vfU+LFy/WqlWrNHnyZK1evVrXX3+9gyr9R69dXFh6jfOBOTKz43tuPq5rvmfmK3IzR2bR5OO65jtfM2NGzZGZeyQfEYlEQmPHjlUikXBdSmiQWfQcOHBAN998s9577z1JZzd8XnzxRfXv399xZeEwfPhwPfnkk3rwwQclScePH9cdd9zBjde7Qa/1jW+9xvnAHJnZ8Tk3X9c1nzPzGbmZI7Po8XVd85nPmTGj5sjMPTZdIyKVSmndunVKpVKuSwkNMouWo0eP6uabb9aePXskScOGDdOKFSs0bNgwx5WFz6JFi3IXVm+88YZ+/etfO67IL/RacHzpNc4H5sjMjq+5+byu+ZqZ78jNHJlFi8/rmq98z4wZNUdm7rHpGhHZbFaHDx9WNpt1XUpokFl0nDp1Srfccou2b98uSRo0aJBWrFiha665xnFl4VRRUaEpU6bkHr/yyisOq/ELvRYsX3qN84E5MrPjY26+r2s+ZhYG5GaOzKLD93XNR2HIjBk1R2busekKINROnz6turo6/f73v5ckDRgwQC+++KI+9rGPOa4s3Kqrq3MfHz161GEl/qDXCoNeA9xhXQMQNaxr5sgMKBw2XQGE1vvvv685c+bkXh1XUVGhZcuW6ZOf/KTjysLvwIEDuY8HDhzosBI/0GuFQ68BbrCuAYga1jVzZAYUFpuuEZFIJDRhwgRukGyAzMKto6ND8+bN08qVKyVJ5eXleuGFF3TTTTc5riz8jh49qvXr1+cejxs3zmE17tFrheNLr3E+MEdmdnzJLUzrmi+ZhQ25mSOzcAvTuuaLsGXGjJojM/fYdI2IeDyukSNHKh7nV9pbZBZe6XRaCxYsUENDgyQpmUzq5z//uWbNmuW4Mj8dO3as11+byWT0ta99Te3t7ZLOXnzddttthSrNe/SambD2GucDc2Rmx4fcwrau+ZBZGJGbOTILr7Ctaz4IY2bMqDkyc4/kIyKVSmnlypW8K50BMgunbDarL3zhC/rFL34h6eyJ5KmnntKcOXMcV+avpUuXatKkSVq6dKlOnTqV9+u2bNmiuro6Pfvss7ljDz/8sC6//PJilOkdes1cWHuN84E5MrPjOrcwrmuuMwsrcjNHZuEUxnXNtbBmxoyaIzP3kq4LQDCy2axaWlp4VzoDZBZOP/vZz7RkyZLc42uvvVZr167V2rVre/X9jz76aKFK81pjY6PuueceJZNJjR07VmPGjFF1dbVisZiOHj2qLVu2aPfu3V2+Z968efrhD3/oqGL36DU7Yew1zgfmyMyO69zCuK65ziysyM0cmYVTGNc118KaGTNqjszcY9MVQKgcOnSoy+Ndu3Zp165dvf7+UrywKi8vz32cSqW0bds2bdu2Le/XV1VVaeHChfrGN75R0vf/odfM0WuA31jXAEQN65o5MgOKh01XAIi4L3/5y5o5c6ZWrFihDRs2aPv27WpqatKJEyckSf3799ewYcM0YcIEzZo1S/PmzVNlZaXbohFK9BoAAAAAnBXLevY641OnTmnAgAGSTmry5P46702N0YNMJqMjR45o0KBB3CS5l8jMTG2t9OqrXY9NnixmtAdkZofczJFZ33A+MEdmdsjNHJnZITdzZGaGaw9zZNY3zKg5MjNzbkZPSRqgkydPqn///n36mbzSNSLi8biGDBniuoxQITMAgMT5wAaZ2SE3c2Rmh9zMkRngN2bUHJm5x1Z3RHR0dGjZsmXq6OhwXUpokBkAQOJ8YIPM7JCbOTKzQ27myAzwGzNqjszcY9M1QlKplOsSQofMAAAS5wMbZGaH3MyRmR1yM0dmgN+YUXNk5habrgAAAAAAAAAQIDZdAQAAAAAAACBAbLpGRDKZ1PTp05VM8t5ovUVmAACJ84ENMrNDbubIzA65mSMzwG/MqDkyc49N1wjp16+f6xJCh8wAABLnAxtkZofczJGZHXIzR2aA35hRc2TmFpuuEZFKpdTQ0MBNkg2QGQBA4nxgg8zskJs5MrNDbubIDPAbM2qOzNxj0xUAAAAAAAAAAsSmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64RkUwmVVdXx7vSGSAzAIDE+cAGmdkhN3NkZofczJEZ4Ddm1ByZucema4ScOXPGdQmhQ2YAAInzgQ0ys0Nu5sjMDrmZIzPAb8yoOTJzi03XiEilUlq1ahXvSmeAzAAAEucDG2Rmh9zMkZkdcjNHZoDfmFFzZOYem64AAAAAAAAAECA2XQEAAAAAAAAgQGy6Rgg3RzZHZgAAifOBDTKzQ27myMwOuZkjM8BvzKg5MnOL9COirKxMs2fPdl1GqJAZAEDifGCDzOyQmzkys0Nu5sgM8Bszao7M3OOVrhGRyWR06NAhZTIZ16WEBpkBACTOBzbIzA65mSMzO+RmjswAvzGj5sjMPTZdIyKdTmv9+vVKp9OuSwkNMgMASJwPbJCZHXIzR2Z2yM0cmQF+Y0bNkZl7bLoCAAAAAAAAQIDYdAUAAAAAAACAALHpGhGxWExVVVWKxWKuSwkNMgMASJwPbJCZHXIzR2Z2yM0cmQF+Y0bNkZl7xpuua9asUX19vYYPH65YLKbnn3/+gq954403NGfOHA0YMECXXnqpJk2apKampiDqRR7JZFIzZsxQMpl0XUpokBkAQOJ8YIPM7JCbOTKzQ27myAzwGzNqjszcM07+9OnTuuGGG3T//fdr7ty5F3x+z549+tM//VN94Qtf0COPPKL+/ftr+/bt+shHPmJc3N69xt9ScsaOld59V5KyymSyisdjqqiIadQo15X5a+9eqa1NIjMz27ZdeIwZ7Vl3+ZDZxZGbue7y2bZNqq0tfi1hwvnAXHeZjRgR05tvuq7Mb1yvmWM+7TCj5phPO/zZwBzXuHaYUXOcC+wUYh5j2Ww2a/3NsZiee+453X777bljd9xxh8rKyvTUU09Z/cxTp05pwIABkk6qsrK/WlpsqysNVVVSa6vrKlCqKivFjPagu/kks4sjN3OcC+AS83lxzChcYkZ7xnwGh17rGde4dpjRYNBrF3eu105JGqCTJ0+qf//+ffqZgb7GOJPJaNmyZfrrv/5r3XLLLdq0aZOuueYaffe73+2yMXu+9vZ2tbe35x6fOnXqvM9m1dGRUjweVyKRUDqdViaTyX2283gqldL5e8eJRELxeDzv8Y6Oji41dL7UOpVK9ep4WVmZMpmM0ul07lgsFlMymcx7PF/tfX1OZ3+F3J8D7kRpnoJeI87O5ofn8+y6FtbnVJzfU3fr2rncwvmc1KX24H9PnAvgUlZSLELzdFaQa0RnRoAb586hUZin4NcIzqHBySqdzkR2LS/Mn92z6vySMD6nYvyeOIcGJ0rzVJjeC/58EOim66FDh9Ta2qr//t//u/72b/9Wf//3f68XX3xRc+fO1apVqzR16tQLvmfRokV65JFHuv15qVRaDQ0Nqqmp0cSJE7Vly5Yu94YdM2aMxo4dq40bN+rw4cO54xMmTNDIkSO1Zs0atZy3lV9bW6shQ4Zo+fLlXYKePn26+vXrp4aGhi7//3V1dTpz5oxWrVqVO5ZMJjV79mwdOXJE69evzx2vqqrSjBkz9Pbbb2vz5s2544MHD9aUKVO0a9cu7dy5M3c8qOeUzdaLBQguRWmegl4jUqmB+vAym8lku/ycsD2nYvyeUqnZF+TWeT4I63PqVKjfU3eZAcWSSp29SI3KPEnBrxHpdEZSoneBAgE7/xwahXkKeo3gHBqcVCqtLVu2RnYtL8Sf3VOptFpa2kL7nIrxe8pk2HQNSpTmqRC9V4jzQaC3F2hubtaIESM0f/58/cu//Evu6+bMmaNLL71UzzzzzAU/o7tXul511VU6e3uBKh07xitde3pOAwcm1drKAgQ3KiulY8eiM09BrxEDBsQumM/KyqyOHeOVrj09p+7WtfNzC+Nz6lSo3xPnArhUWZlVSwuvdO3pOVVVZZlROHP+OTQK8xT0GsE5NDiVlVmdOMErXU3+7F5ZmVXnP/YN43Mqxu+Jc2gw+LP7xZ/TuRn19PYCgwYNUjKZ1Mc+9rEux8eNG6e1a9d2+z3l5eUqLy/v9nMVFTGVlZXlHicSiT/+E62u8r0TW77j5/9M2+PxeFzxeLzXx/PV3tfnVFHR/X1hxo/v9tuh828qfU5FhbgR90V0l9uIEdGap55qND0ej8e7nc8Pr2udwvKcivF76m1uYXpOvT1u+5xGjOh8g4FzWNcujvOBuW3bup9PKTrzdL6gnlNFRYzrNUPMp518M/rh/g7zPAW9RvDnKTvd/9kglvvdRHEtL8Sf3SsqYorF8tee77gvz6mnGk2P56udc6i57s8F0Zqnnmo0Pd5Ze3cz2leBbrpecsklmjRpUpeXDkvS//t//08jR440/nlcVF3cqFHSoUNdj40fL533am/kkU6ntWvXLn30ox/tdtjRPXLrve7mk3Xt4sjNXOc7kTKfdsit92prpVdf7XqM+bw4rtfsMZ9mmFFzzGffMKO9xzWuHWbUHOcCO931Wl9duA19Ea2trdq8eXPuXg1vvfWWNm/enLsXw8MPP6x//dd/1T/90z9p9+7devTRR/Xv//7v+spXvhJo4UBfZTIZ7dy5s8tL2nFx5Ab4i/m0Q26Av5hPwG/MKADkZ/xK18bGRk2fPj33+KGHHpIk3XPPPVq8eLE++9nP6rHHHtOiRYv04IMPasyYMfrlL3+pP/3TPw2uagAAAAAAAADwlPGm67Rp03Sx9966//77df/991sXBQAAAAAAAABhZXx7ASAq4vG4ampqur3ZM/IjN8BfzKcdcgP8xXwCfmNGASC/QN9ICwiTRCKhiRMnui4jdMgN8BfzaYfcAH8xn4DfmFEAyI+/jkLJSqfT2rRpk9LptOtSQoXcAH8xn3bIDfAX8wn4jRkFgPzYdEXJymQyampq4p02DZEb4C/m0w65Af5iPgG/MaMAkB+brgAAAAAAAAAQIDZdAQAAAAAAACBAbLqiZMXjcY0ZM4Z32jREboC/mE875Ab4i/kE/MaMAkB+SdcFAK4kEgmNHTvWdRmhQ26Av5hPO+QG+Iv5BPzGjAJAfvx1FEpWKpXSunXrlEqlXJcSKuQG+Iv5tENugL+YT8BvzCgA5MemK0pWNpvV4cOHlc1mXZcSKuQG+Iv5tENugL+YT8BvzCgA5MemKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64oWYlEQhMmTFAikXBdSqiQG+Av5tMOuQH+Yj4BvzGjAJBf0nUBgCvxeFwjR450XUbokBvgL+bTDrkB/mI+Ab8xowCQH690RclKpVJauXIl77RpiNwAfzGfdsgN8BfzCfiNGQWA/Nh0RcnKZrNqaWnhnTYNkRvgL+bTDrkB/mI+Ab8xowCQH7cXABxLp9Pavn27XnvtNTU2Nuq1117Tli1b1NHRIUmaOnWqVq9e7bZIADDAumbuyJEjeuWVV7Rx40Zt3bpVe/bsUXNzs1pbW1VWVqbq6mqNHz9e06ZN0913360RI0a4LhkAAABAD9h0BRx6/vnndeedd6qtrc11KQAQCNY1O/fee6+WLVvW7edSqZTOnDmj5uZmLV++XI888oi++93v6vvf/77icf7REgAAAOAjNl1RshKJhGpra52+0+aJEydCtzHhQ24AuufDfLKu9d2gQYM0btw4jRw5UpWVlWpra9Pu3bu1ceNGpVIptbe3a+HChdq7d6+WLFniulygoHybTwBdMaMAkB+brihZ8XhcQ4YMcV2GJGno0KGaNGlS7r+XXnpJP/nJT1yX1S2fcgPQlU/zybpmZtq0aaqvr9fMmTN13XXXdfs1Bw8e1De/+U0988wzkqSlS5eqvr5en/vc54pZKlBUPswngPyYUQDIj01XlKyOjg4tX75cn/nMZ1RWVuakhltvvVX79+9XTU1Nl+MbNmxwUk9v+JAbgO75MJ+sa3a+9a1vXfRrhg4dqqeffloHDx7UypUrJUmPP/44m66INB/mE0B+zCgA5MeNwFDSUqmU0///K6644oKNiTBwnRuA/FzPJ+taYcViMd133325x5s2bXJYDVAcYZlPoFQxowDQPTZdAQAAQmTw4MG5j1taWhxWAgAAACAfNl0BAABCZMeOHbmPr776aneFAAAAAMiLTVeUrGQyqenTpyuZ5NbGJsgN8BfzaSdMuTU3N+tHP/pR7jH3c0XUhWk+gVLEjAJAfmy6oqT169fPdQmhRG6Av5hPOz7n1tbWph07dujHP/6xJk6cqObmZknSuHHj9J3vfMdxdUDh+TyfAJhRAMiHTVeUrFQqpYaGBm78bojcAH8xn3Z8y23t2rWKxWK5/y699FJ9/OMf17e+9S0dOnRIklRXV6d169apqqrKcbVAYfk2nwC6YkYBID82XQEAAEKiurpazzzzjJYtW6bLLrvMdTkAAAAA8uDGKwAAAB4ZPny4vvrVr0qSstmsWlpatHPnTr3++us6fvy45s+fryeeeEKPPfaYRo8e7bhaAAAAAN1h0xUAAMAjo0aN0qOPPnrB8ebmZn3ve9/T4sWLtWrVKk2ePFmrV6/W9ddf76BKAAAAAD3h9gIoWclkUnV1dbzTpiFyA/zFfNoJS27Dhw/Xk08+qQcffFCSdPz4cd1xxx1Kp9OOKwMKJyzzCZQqZhQA8mPTFSXtzJkzrksIJXID/MV82glTbosWLVL//v0lSW+88YZ+/etfO64IKKwwzSdQiphRAOgem64oWalUSqtWreKdNg2RG+Av5tNO2HKrqKjQlClTco9feeUVh9UAhRW2+QRKDTMKAPmx6QoAABAy1dXVuY+PHj3qsBIAAAAA3WHTFQAAIGQOHDiQ+3jgwIEOKwEAAADQHTZdUdK44bsdcgP8xXzaCVNuR48e1fr163OPx40b57AaoPDCNJ9AKWJGAaB7rI4oWWVlZZo9e7brMkKH3AB/MZ92XOd27NixXr9aNZPJ6Gtf+5ra29slSeXl5brtttsKWR7glOv5BNAzZhQA8uOVrihZmUxGhw4dUiaTcV1KqJAb4C/m047r3JYuXapJkyZp6dKlOnXqVN6v27Jli+rq6vTss8/mjj388MO6/PLLi1Em4ITr+QTQM2YUAPLjla4oWel0WuvXr1ddXZ3icXd//1BXV6fm5uYux957773cx42NjZowYcIF39fQ0KDhw4cXurwL+JIbgAv5Mp+sa+YaGxt1zz33KJlMauzYsRozZoyqq6sVi8V09OhRbdmyRbt37+7yPfPmzdMPf/hDJ/UCxeLDfALIjxkFgPzYdAUc27Fjh/bv35/386dPn9Yf/vCHC45/8MEHhSwLAKyxrpkpLy/PfZxKpbRt2zZt27Yt79dXVVVp4cKF+sY3vqFEIlGMEgEAAAAYYtMVAADAoS9/+cuaOXOmVqxYoQ0bNmj79u1qamrSiRMnJEn9+/fXsGHDNGHCBM2aNUvz5s1TZWWl26IBAAAA9IhNV5SsWCymqqoqxWIxp3Xs27fP6f+/KV9yA3AhX+aTdc3c6NGjNXr0aH3lK19xVgPgIx/mE0B+zCgA5MemK0pWMpnUjBkzXJcROuQG+Iv5tENugL+YT8BvzCgA5MedrlGyMpmM9u/fzzttGiI3wF/Mpx1yA/zFfAJ+Y0YBID82XVGy0um0Nm/erHQ67bqUUCE3wF/Mpx1yA/zFfAJ+Y0YBID82XQEAAAAAAAAgQGy6AgAAAAAAAECA2HRFyYrFYho8eDDvtGmI3AB/MZ92yA3wF/MJ+I0ZBYD8kq4LAFxJJpOaMmWK6zJCh9wAfzGfdsgN8BfzCfiNGQWA/HilK0pWOp3Wm2++yU3fDZEb4C/m0w65Af5iPgG/MaMAkB+brihZmUxGO3fuVCaTcV1KqJAb4C/m0w65Af5iPgG/MaMAkB+brgAAAAAAAAAQIDZdAQAAAAAAACBAbLqiZMXjcdXU1CgeZwxMkBvgL+bTDrkB/mI+Ab8xowCQX9J1AYAriURCEydOdF1G6JAb4C/m0w65Af5iPgG/MaMAkB9/HYWSlU6ntWnTJt5p0xC5Af5iPu2QG+Av5hPwGzMKAPmx6YqSlclk1NTUxDttGiI3wF/Mpx1yA/zFfAJ+Y0YBID82XQEAAAAAAAAgQGy6AgAAAAAAAECA2HRFyYrH4xozZgzvtGmI3AB/MZ92yA3wF/MJ+I0ZBYD8kq4LAFxJJBIaO3as6zJCh9wAfzGfdsgN8BfzCfiNGQWA/PjrKJSsVCqldevWKZVKuS4lVMgN8BfzaYfcAH8xn4DfmFEAyI9NV5SsbDarw4cPK5vNui4lVMgN8BfzaYfcAH8xn4DfmFEAyI9NVwAAAAAAAAAIEJuuAAAAAAAAABAgNl1RshKJhCZMmKBEIuG6lFAhN8BfzKcdcgP8xXwCfmNGASA/403XNWvWqL6+XsOHD1csFtPzzz/f5fP33nuvYrFYl/9uvfXWoOoFAhOPxzVy5EjF4/zdgwlyA/zFfNohN8BfzCfgN2YUAPJLmn7D6dOndcMNN+j+++/X3Llzu/2aW2+9VU8++WTucXl5uVVxe/dafVtJ6S6jbduk2tri1xIWe/dKbW2SlFU6nVYikdCIETG9+abryvw2dqz07rvS+blVVMQ0apTryvy1bduFx1jXLo51zRzrmh3WNXOsa3ZY18yxrtnprteY0Z4xn3a6m1HOoT3jHGqHdc0cmdkpREbGm65/9md/pj/7sz/r8WvKy8t1xRVXWBfV6ewijp50l1Frq/Tqq8WvJXxi6hyBs3/oRk/effdsb52fW2urdOiQy6rCh3Xt4ljX+oJ1zQTrWjBY1y6Oda0vWNdMdNdrzGjPmM++4hzaF8znxbGumSMzO4XIyHjTtTdWr16tIUOGqLq6WjNmzNDf/u3f6vLLL+/2a9vb29Xe3p57fOrUqfM+m1VHR0rxeFyJRELpdFqZTCb32c7jqVRK2Ww2dzyRSCgej+c93tHR0aWGZPJsDKlUqlfHy8rKlMlklE6nc8disZiSyWTe4/lq7+tzOvsrjAl9lZUUK9jvKQq915kR+ursutap0GtEOHuPdS0YZ3vN1fkpDL1HrwXl7PnBl2sjH3uPc2hQup5DJb+uy/3ove7WtXO5hfM5qUvtwf+eOBfApaw62zMa89Rz7TbPKd85NMzPydWf3cP8nIrzewr+fBD4puutt96quXPn6pprrtGePXv0//1//5/+7M/+TOvXr+/25tqLFi3SI4880u3PSqXSamhoUE1NjSZOnKgtW7aoqakp9/kxY8Zo7Nix2rhxow4fPpw7PmHCBI0cOVJr1qxRS0tL7nhtba2GDBmi5cuXdwl6+vTp6tevnxoaGrr8/9fV1enMmTNatWpV7lgymdTs2bN15MgRrV+/Pne8qqpKM2bM0Ntvv63Nmzfnjg8ePFhTpkzRrl27tHPnztzxoJ5TNlsvLhL6Lp3OSEoU7PcUhd47twihLzKZbJffd6HXiDD2Xio1W/Ra33WeQ12dn8LQe5kM59AgpFJnzw++XBv52Hud1xnom2xWXX5/rq+NfOy97s6hneeDsD6nToX6PXHdAZdSqbRaWtoiM0+dglwjMpnuNxDD/Jxc/dk9zM+pGL+nQpwPYtmuL5s0++ZYTM8995xuv/32vF+zd+9eXXvttVqxYoVmzpx5wee7e6XrVVddJemkKiurdOwYr3Tt6TkNHJhUayt/YOyrysqsWlp4pWtPz6mqKkuvBaCyMqtjx3ila0/PiXUtGJ29Fq2/fe5ae1+fE70WjM5zqC/XRj72HufQYHz4HCr5dV3uQ+91t66dn1sYn1OnQv2eOBfApcrKrDr/sW8U5ulitds8p+7OoZWV0okT4X1OLv7sXlkpHTsW3udUjN/TufPBKUkDdPLkSfXv3199UfC/0hs1apQGDRqk3bt3d7vpWl5enveNtioqYiorK8s9TiQS3b5atjO83h4//2faHo/H492+Q2O+4/lq7+tzGjHiwvtbVVSIG5j3YNu2znv4nVNRcXZBKtTvqVOYe6+iInZBbpWV0vjx3X45dP4bDJwzYkSs298rvXeudtY1c/nWtfN/j8U+P3XyufcqKi7MjXWtZ/nWNcmfa6NOPvXeiBEx1jVDvVnXOtF752rvbl3rLrcwPafeHrd9Tlx32OnufEBuPct3Do39cW8sCvPUl+P5au/uz6EVFeF+Ti7+7F5REe7nVIzfU3fn0L4q+KbrO++8o6NHj2rYsGHG38uCfXGd7+Da0dGh5cuX6zOf+Uze5sJZtbUX3hifXru4UaMuvDH++PHSef+yAHkwn2ZY18yxrtlhXbPHfJphXTPHumanu3WN3HrGfPYNuZkjMzOsa+bIzE53ufWV8aZra2urdu/enXv81ltvafPmzRo4cKAGDhyoRx55RPPmzdMVV1yhPXv26K//+q913XXX6ZZbbgm0cFzowy+TBuAP5tMOuQH+Yj7tkBvgL+bTDrmZIzOgNBhvujY2Nmr69Om5xw899JAk6Z577tHPfvYzbdmyRUuWLNGJEyc0fPhwfeYzn9F//a//Ne8tBAAAAAAAAAAgSow3XadNm6ae3nvrpZde6lNBAAAAAAAAABBmF97lFqGUTCY1ffr0vDcXBuAO82mH3AB/MZ92yA3wF/Nph9zMkRlQOth0jZB+/fq5LgFAHsynHXID/MV82iE3wF/Mpx1yM0dmQGlg0zUiUqmUGhoauCE34CHm0w65Af5iPu2QG+Av5tMOuZkjM6B0sOkKAAAAAAAAAAFi0xUAAAAAAAAAAsSmKwAAAAAAAAAEiE3XiEgmk6qrq+MdEAEPMZ92yA3wF/Nph9wAfzGfdsjNHJkBpYNN1wg5c+aM6xIA5MF82iE3wF/Mpx1yA/zFfNohN3NkBpQGNl0jIpVKadWqVbwDIuAh5tMOuQH+Yj7tkBvgL+bTDrmZIzOgdLDpCgAAAAAAAAABYtMVAAAAAAAAAALEpmuEcCNuwF/Mpx1yA/zFfNohN8BfzKcdcjNHZkBpYNIjoqysTLNnz3ZdBoBuMJ92yA3wF/Nph9wAfzGfdsjNHJkBpYNXukZEJpPRoUOHlMlkXJcC4EOYTzvkBviL+bRDboC/mE875GaOzIDSwaZrRKTTaa1fv17pdNp1KQA+hPm0Q26Av5hPO+QG+Iv5tENu5sgMKB1sugIAAAAAAABAgNh0BQAAAAAAAIAA8UZaeezbt0+/+c1v9Lvf/U5bt25VU1OTWltbVVVVpSuvvFK1tbVasGCBpk6d6rpUSVIsFlNVVZVisZjrUmDgyJEjeuWVV7Rx40Zt3bpVe/bsUXNzs1pbW1VWVqbq6mqNHz9e06ZN0913360RI0a4LtkbYZpRX+YznU5r+/bteu2119TY2KjXXntNW7ZsUUdHhyRp6tSpWr16tdMaz+dDbswoiiVsvebDfIYRuYVXmK47YMeX+Qxbr5GbOTILN3KDkaxnTp48mZWUlU5mJ08u/v//66+/nr3xxhv/WMPF/5s2bVp2//79xS8U1iZPzmalrv+56LVsNpudPXt2r3utvLw8u3Dhwmw6nXZSqy+5MaN2nnvuuWxFRUWPWU2dOtV1md4Jy4z6Mp9h41NuYek1oFh8mc+wXXf4khvMha3XfEFu5sKWmS/rWphy8yWzsDmX29l9yZMnT/b5Z/JK1w/ZuXOnNm7c2OXY6NGjNX78eA0aNEgnTpzQunXr9M4770iSVq9erdraWr388ssaNWqUi5IlnX0HxLfffltXXXWV4nHuGhFGgwYN0rhx4zRy5EhVVlaqra1Nu3fv1saNG5VKpdTe3q6FCxdq7969WrJkietynQnjjPownydOnFBbW5uT/29bPuR2PmYUxRKGXvNtPsOC3MInjNcdsON6PsPaa+RmjszCidxgg03XPK677jp98Ytf1Oc///kL/glfJpPR4sWL9fWvf11tbW1qbm7WnXfeqXXr1jn7JwLpdFqbN2/W8OHDuYgPkWnTpqm+vl4zZ87Udddd1+3XHDx4UN/85jf1zDPPSJKWLl2q+vp6fe5znytmqd4J04z6NJ9Dhw7VpEmTcv+99NJL+slPfuK0pnx8yI0ZRbGErdd8mM8wIrfwCtN1B+z4Mp9h6zVyM0dm4UZuMMGm64cMGzZMTz75pO666y4lEoluvyYej+v+++9XdXW15s6dK0l69dVXtXz5ct1yyy3FLBch961vfeuiXzN06FA9/fTTOnjwoFauXClJevzxx0t2Q4cZtXPrrbdq//79qqmp6XJ8w4YNjioKB2YUxUKvAX7iugPFQq/ZITdzZGaH3GCDv2L/kKlTp+ree+/NO0Tn++xnP6sbb7wx93jZsmWFLA0lLBaL6b777ss93rRpk8Nq3GJG7VxxxRUXbLgiOMwoioVeA4qL6w4UC71mh9zMkZkdcoMNNl376Kabbsp9vG/fPmd1xGIxDR48mJesR9jgwYNzH7e0tDisJFx8mFHm007YcmNGUSw+9FrY5tMX5BZ9Plx3wE7Y5tOXXiM3c2RWGsgNErcX6LPzF8p0Ou2sjmQyqSlTpjj7/0fh7dixI/fx1Vdf7a6QkPFhRplPO2HLjRlFsfjQa2GbT1+QW/T5cN0BO2GbT196jdzMkVlpIDdIvNK1z7Zu3Zr7+KqrrnJWRzqd1ptvvskwR1Rzc7N+9KMf5R5z/77e82FGmU87YcqNGUWx+NJrYZpPn5Bb9Plw3QE7YZtPX3qN3MyRWWkgN0hsuvZJU1NT7o0sJGnWrFnOaslkMtq5c6cymYyzGhCstrY27dixQz/+8Y81ceJENTc3S5LGjRun73znO46rCwdfZpT5tON7bswoisXHXvN9Pn1FbtHmy3UH7IRpPn3qNXIzR2bRR27oxO0F+uChhx7K/e1UTU2N6uvrHVeEMFu7dq0+9alP9fg1dXV1evrpp1VVVVWkqsKNGUWQmFEUC70GhBPXHSgWes0OuZkjMzvkhk680tXSkiVL9Mtf/jL3eNGiRSovL3dYEaKsurpazzzzjJYtW6bLLrvMdTmhwIyimJhRFAu9BviJ6w4UC71mh9zMkZkdcsP5eKWrhcbGRj3wwAO5x/Pnz9eCBQscViTF43HV1NQoHmcfPayGDx+ur371q5KkbDarlpYW7dy5U6+//rqOHz+u+fPn64knntBjjz2m0aNHO67Wb77NKPNpx7fcmFEUSxh6zbf5DAtyiybfrjtgJwzz6WOvkZs5MosucsMFsp45efJkVlJWOpmdPNl1NRfau3dv9oorrvhjjcpef/312ZMnT7ouCwYmT85mpa7/+dhrnd59993svffem+u56urq7B/+8Iei1xGW3JhRMz/84Q9zWU2dOtV1OaHkw4yGZT59E7bcfOg1oFjCMp++XXeEJTeY863XwoLczPmWWVjWNZ9yC0tmvjmX29l9ySB+f/7+1YqHDhw4oJtvvlnvvfeeJGnUqFF68cUX1b9/f8eVnX0HxE2bNoXmHRDRe8OHD9eTTz6pBx98UJJ0/Phx3XHHHfyuu+HrjDKfdsKSGzOKYvGp18Iyn74ht2jx9boDdnyeT597jdzMkVn0kBvyYdO1l44ePaqbb75Ze/bskSQNGzZMK1as0LBhwxxXdlYmk1FTU1Mo3gERdhYtWpRbtN944w39+te/dlyRX3yeUebTTthyY0ZRLD70Wtjm0xfkFh0+X3fAjq/z6XuvkZs5MosWckNP2HTthVOnTumWW27R9u3bJUmDBg3SihUrdM011ziuDKWkoqJCU6ZMyT1+5ZVXHFbjF2YUPmBGUSz0GuAW1x0oFnrNDrmZIzM75IaLYdP1Ik6fPq26ujr9/ve/lyQNGDBAL774oj72sY85rgylqLq6Ovfx0aNHHVbiD2YUPmFGUSz0GuAG1x0oFnrNDrmZIzM75IbeYNO1B++//77mzJmTewVJRUWFli1bpk9+8pOOK7tQPB7XmDFjvH4HRPTdgQMHch8PHDjQYSV+CMuMMp92wpgbM4picd1rYZxPH5BbuIXlugN2fJrPMPUauZkjs/AjN/RW0nUBvuro6NC8efO0cuVKSVJ5ebleeOEF3XTTTY4r614ikdDYsWNdl4ECOnr0qNavX597PG7cOIfVuBemGWU+7YQtN2YUxeJDr4VtPn1BbuEVpusO2PFlPsPWa+RmjszCjdxgwv1frXgonU5rwYIFamhokCQlk0n9/Oc/16xZsxxXll8qldK6deuUSqVcl4JeOnbsWK+/NpPJ6Gtf+5ra29slnV3Yb7vttkKV5r2wzSjzacd1bswoiiWMveZ6PsOK3MIpbNcdsOPDfIax18jNHJmFF7nBFJuuH5LNZvWFL3xBv/jFLySdfen/U089pTlz5jiurGfZbFaHDx9WNpt1XQp6aenSpZo0aZKWLl2qU6dO5f26LVu2qK6uTs8++2zu2MMPP6zLL7+8GGV6J4wzynzacZ0bM4piCWOvuZ7PsCK38AnjdQfsuJ7PsPYauZkjs3AiN9jg9gIf8rOf/UxLlizJPb722mu1du1arV27tlff/+ijjxaqNERQY2Oj7rnnHiWTSY0dO1ZjxoxRdXW1YrGYjh49qi1btmj37t1dvmfevHn64Q9/6Khi95hRe3V1dWpubu5y7L333st93NjYqAkTJlzwfQ0NDRo+fHihy/MSM4piodcAP3HdgWKh1+yQmzkys0NusMGm64ccOnSoy+Ndu3Zp165dvf5+Bgm9VV5envs4lUpp27Zt2rZtW96vr6qq0sKFC/WNb3xDiUSiGCV6iRm1t2PHDu3fvz/v50+fPq0//OEPFxz/4IMPClmWt5hRFAu9BviL6w4UC71mh9zMkZkdcoMNNl0jIpFIaMKECfzhK0S+/OUva+bMmVqxYoU2bNig7du3q6mpSSdOnJAk9e/fX8OGDdOECRM0a9YszZs3T5WVlW6LhhXm047r3JhRFEsYe831fIYVuQH+Yj7tkJs5MgNKRyzr2U2lTp06pQEDBkg6qcmT++u8N+cFAlFbK736atdjkyeLXrsIcgP8xXzaITfAX8ynHXIDEDWsa+bIzM653E5JGqCTJ0+qf//+ffqZvJFWRKRSKa1cuZJ3wwU8xHzaITfAX8ynHXID/MV82iE3c2QGlA42XSMim82qpaWFd8MFPMR82iE3wF/Mpx1yA/zFfNohN3NkBpQONl0BAAAAAAAAIEBsugIAAAAAAABAgNh0jYhEIqHa2lreARHwEPNph9wAfzGfdsgN8BfzaYfczJEZUDqSrgtAMOLxuIYMGeK6DADdYD7tkBvgL+bTDrkB/mI+7ZCbOTIDSgevdI2Ijo4OLVu2TB0dHa5LAfAhzKcdcgP8xXzaITfAX8ynHXIzR2ZA6WDTNUJSqZTrEgDkwXzaITfAX8ynHXID/MV82iE3c2QGlAY2XQEAAAAAAAAgQGy6AgAAAAAAAECA2HSNiGQyqenTpyuZ5L3RAN8wn3bIDfAX82mH3AB/MZ92yM0cmQGlg03XCOnXr5/rEgDkwXzaITfAX8ynHXID/MV82iE3c2QGlAY2XSMilUqpoaGBG3IDHmI+7ZAb4C/m0w65Af5iPu2QmzkyA0oHm64AAAAAAAAAECA2XQEAAAAAAAAgQGy6AgAAAAAAAECA2HSNiGQyqbq6Ot4BEfAQ82mH3AB/MZ92yA3wF/Nph9zMkRlQOth0jZAzZ864LgFAHsynHXID/MV82iE3wF/Mpx1yM0dmQGlg0zUiUqmUVq1axTsgAh5iPu2QG+Av5tMOuQH+Yj7tkJs5MgNKB5uuAAAAAAAAABAgNl0BAAAAAAAAIEBsukYIN+IG/MV82iE3wF/Mpx1yA/zFfNohN3NkBpQGJj0iysrKNHv2bNdlAOgG82mH3AB/MZ92yA3wF/Nph9zMkRlQOoxf6bpmzRrV19dr+PDhisViev755/N+7QMPPKBYLKZ//Md/7EOJ6I1MJqNDhw4pk8m4LgXAhzCfdsgN8BfzaYfcAH8xn3bIzRyZAaXD+JWup0+f1g033KD7779fc+fOzft1zz33nF599VUNHz7curht26TaWutvLwl790ptbZIUUyo1UMlkTCNGSG++6boyf+3de+Exeu3itm278Fh3WeKcsWOld9+Vzp/Pigpp1CjXlfmtu3WN3HrGfNrhfGCO6w47nA/Msa7Z6S4jcusZ82mH6zVzZGaH84E5rnHtdNdrfRXLZrNZ62+OxfTcc8/p9ttv73L83Xff1X/+z/9ZL730kmbPnq2/+qu/0l/91V/16meeOnVKAwYMkHRSUn/b0kpaZaXU0uK6Cn9VVUmtra6riAZ6rWf0GlxiPi+OGQ0GvXZx9Fow6LWL667XyK1nzCcQPqxrPWNd66tTkgbo5MmT6t+/b/uSgd/TNZPJ6K677tLDDz+sj3/84xf9+vb2drW3t+cenzp1KuiSSlBWnVvpqVSqy2c6b9j94eNlZWXKZDJKp9O5Y7FYTMlkMu/xdDrd5Z9ExONxJRKJvMdTqZTO3+NPJBKKx+N5j3d0dPSqdtPnxK2Mg1Wo31MUek+K/fE/wIWsOjpSkZmnQqwRZ88HzGjfZSXFIruWB/GcOjNCX51d184X5esIu+fU3bp2LrdwPid1qT343xPnAiCMor2W9+05cd3hj8B3n/7+7/9eyWRSDz74YK++ftGiRXrkkUeCLqOkpVJptbS0qV+/fmpoaOjyubq6Op05c0arVq3KHUsmk5o9e7aOHDmi9evX545XVVVpxowZevvtt7V58+bc8cGDB2vKlCnatWuXdu7cmTteU1OjiRMnasuWLWpqasodHzNmjMaOHauNGzfq8OHDueMTJkzQyJEjtWbNGrWc99dUtbW1GjJkiJYvX95l4Zo+fXogz0ma0ZsY0UuF+j1FofdSqYFikx+upFJpNTQ0RGaeCrFGZDL14oK071KptKRkZNfyIJ5TOp2RlOhdoMgrm1WX31/UryNsnlMqNVsfvvboPB+E9Tl1KtTvqbvMAPgvymt5X5/T2Q1d1jUfBHp7gd///veaPXu2Xn/99dy9XK+++uoeby/Q3Stdr7rqKnF7AXuVlVl1vmA4DH8LU+y/WaquTvJS+4BUVkrHjoX3bwAL3XsDBsTU2sqGDtyorMzq2DFe6drTcxo4MMmMBqCyMquWFl7p2tNzqqrK0msB6FzXzhfl6wib59TdunZ+bmF8Tp0K9XviXACET2WldOJEdNfyvj4nrjv6KrjbCwS66fqP//iPeuihh/74cuaz0um04vG4rrrqKu3bt++iP7Pznq6XXnpCl146gJtKX8S2bRfeq2PIEOngQTf1hMG5m+VnlclkFY/HVFERo9cu4tyN38/lNmJEjDdP6cHQodKhQ12PVVZK48e7qScsuus1ZrRnzKcdzgfmuO6ww/nAHOuane56jRntGfNph+s1c2Rmh/OBOa5x7XT2WjZ7UqdPX+bfPV3vuusuzZo1q8uxW265RXfddZfuu+8+o5+1f39Kl18eZHXRVFsrvfpq12MMUs86F+eOjpQaGhpUV1ensrIyt0WFCLn13qhRF17Ejx8vnfcvTNADes0cmZnhfGCO6w47nA/sMZ9muus1ZrRnzGffMKPmyMwOufUe17h9c/RoSoMGBfOzjDddW1tbtXv37tzjt956S5s3b9bAgQNVU1Ojyz+0U1pWVqYrrrhCY8aM6Xu1AAAAAAAAAOA5403XxsZGTZ8+Pff4oYcekiTdc889Wrx4cWCFAQAAAAAAAEAYGW+6Tps2TSa3ge3NfVy7E4tx018UViwW0+DBg+k1Q+SGYqHXzJGZHXID/MV8An5jRs2RmR1yM0dmdoLMK9B7ugap8x3ggEJJJpOaMmWK6zJCh9xQLPSaOTKzQ26Av5hPwG/MqDkys0Nu5sjMTpD7kfHAflLA0um06xIQcel0Wm+++Sa9ZojcUCz0mjkys0NugL+YT8BvzKg5MrNDbubIzE6QeXm76ZrJZFyXgIjLZDLauXMnvWaI3FAs9Jo5MrNDboC/mE/Ab8yoOTKzQ27myMxOkHl5u+kKAAAAAAAAAGHEpisAAAAAAAAABMjbTdd43NvSEBHxeFw1NTX0miFyQ7HQa+bIzA65Af5iPgG/MaPmyMwOuZkjMztB5hXcW3IFLJFIuC4BEZdIJDRx4kTXZYQOuaFY6DVzZGaH3AB/MZ+A35hRc2Rmh9zMkZmdIPcjvd3u5t3VUGjpdFqbNm2i1wyRG4qFXjNHZnbIDfAX8wn4jRk1R2Z2yM0cmdkJMi9vN115dzUUWiaTUVNTE71miNxQLPSaOTKzQ26Av5hPwG/MqDkys0Nu5sjMTpB5ebvpCgAAAAAAAABhxKYrAAAAAAAAAATI201X3l0NhRaPxzVmzBh6zRC5oVjoNXNkZofcAH8xn4DfmFFzZGaH3MyRmZ0g80oG9pMCFuS7hQHdSSQSGjt2rOsyQofcUCz0mjkys0NugL+YT8BvzKg5MrNDbubIzE6Q+5HebnenUinXJSDiUqmU1q1bR68ZIjcUC71mjszskBvgL+YT8Bszao7M7JCbOTKzE2Re3m66ZrNZ1yUg4rLZrA4fPkyvGSI3FAu9Zo7M7JAb4C/mE/AbM2qOzOyQmzkysxNkXt5uugIAAAAAAABAGHl7T1eXjhw5oldeeUUbN27U1q1btWfPHjU3N6u1tVVlZWWqrq7W+PHjNW3aNN19990aMWKE65IB4KL27dun3/zmN/rd736nrVu3qqmpSa2traqqqtKVV16p2tpaLViwQFOnTnVdKiLigw8+0L/+67/qmWee0fbt23Xw4EFVV1frmmuu0dy5c3Xvvfdq0KBBrsv0AtceKBZ6zU46ndb27dv12muvqbGxUa+99pq2bNmijo4OSdLUqVO1evVqt0UiErheQ7GwrtkhN3Mlva5lPXPy5MmspOzx48ed1TB79uyspF79V15enl24cGE2nU47qXXy5GxW6vrf5MlOSgmddDqd3bdvn7PfXViRW+/5Mp+vv/569sYbb+z1ujZt2rTs/v37i1/oh9Br5nzK7I033shOmDChx14bMmRIdtmyZa5L9SK3sFx7+LKuhY1PuYWl1zr5MJ/PPfdctqKiosespk6d6qy+8/nUa2HhS2Zcr5UOHzIL07rWidzMuc4srOva8ePHs5KyJ0+e7PPP8vaVrvG4H3c+GDRokMaNG6eRI0eqsrJSbW1t2r17tzZu3KhUKqX29nYtXLhQe/fu1ZIlS1yXCwPxeFwjR450XUbokFv47Ny5Uxs3buxybPTo0Ro/frwGDRqkEydOaN26dXrnnXckSatXr1Ztba1efvlljRo1ykXJkug1G75k9s4772jmzJlqbm6WJMViMX3605/Wtddeq8OHD2vFihU6c+aMDh06pNtvv10vvviiZsyY4axeX3LrxLUHiiUMvebDfJ44cUJtbW1Oa0D0cb1WOnzILIzrGrmZc51ZmNe1oHi76ery3dWmTZum+vp6zZw5U9ddd123X3Pw4EF985vf1DPPPCNJWrp0qerr6/W5z32umKWiD1KplNasWaNPf/rTSia9HQXvkFt4XXfddfriF7+oz3/+8xf8c9FMJqPFixfr61//utra2tTc3Kw777xT69atUywWc1IvvWbOl8wWLFiQ23AdOXKkXnjhBd1www25zx85ckR33HGHfvvb36qjo0N//ud/rj179uiyyy5zUq8PuXHtgWIJW6/5MJ+dhg4dqkmTJuX+e+mll/STn/zEaU2IHq7Xos+nzMK0rpGbOV8yC+O6FhRvV8Wsw3dX+9a3vnXRrxk6dKiefvppHTx4UCtXrpQkPf744/zBJ0Sy2axaWlp4Jz9D5BY+w4YN05NPPqm77rpLiUSi26+Jx+O6//77VV1drblz50qSXn31VS1fvly33HJLMcvNodfM+ZBZQ0ODXn75ZUnSJZdcon//93/XJz7xiS5fM2jQIL3wwgu6/vrrtXfvXh07dkz/8A//oL/7u79zUbIXuXHtgWIJW6/5MJ+33nqr9u/fr5qami7HN2zY4KgiRBHXa6XDh8zCuK6RmznXmYV5XQuKH/+GP6RisZjuu+++3ONNmzY5rAYAujd16lTde++9eU905/vsZz+rG2+8Mfd42bJlhSwNEfTTn/409/E999xzwYZrp0svvVR/8zd/k3v8+OOPO/1XLmHBtQeKhV4754orrrjgD9hA0LheQzGxrtkhNzOsa2y69tngwYNzH7e0tDisBACCcdNNN+U+3rdvn7tCEDqtra367W9/m3t8/oZNd+bNm6fKykpJ0rFjx7RmzZqC1hcVXHugWOg1wF9crwGImiiua95uuvZmJ9wHO3bsyH189dVXuysExhKJhGpra0PTa74gt+g7/9456XTaWR30mjnXma1bt07t7e2Szr6SddKkST1+/Uc+8hHV1tbmHnf+M+Zic52bKa49UCw+9FrY5hMoFq7XwovM7JCbubBl5tO6FhRvN12DfLewQmlubtaPfvSj3GPuqRYu8XhcQ4YMCUWv+YTcom/r1q25j6+66ipnddBr5lxn9sYbb+Q+/sQnPtGrG/b/yZ/8SbffX0yuczPBtQeKxZdeC9N8AsXE9Vp4kZkdcjMXtsx8WtcC+1mB/aSAdXR0uC6hW21tbdqxY4d+/OMfa+LEibl3Zx43bpy+853vOK4OJjo6OrRs2TJve81X5BZtTU1NXV5tOGvWLGe10GvmXGe2c+fO3McjR47s1fecf1+sN998M/CaesN1bhfDtQeKxcde830+ARe4Xgs3MrNDbubClJlv61pQLv4SlBK3du1afepTn+rxa+rq6vT000+rqqqqSFUhKLxpix1yi66HHnoo9085ampqVF9f77Qees2cy8yOHj2a+3jo0KG9+p4rrrgi9/GxY8cCr6m3fOo1rj1QLGHpNZ/mE/AB12vhR2Z2yM1cWDLzbV0LirevdA2D6upqPfPMM1q2bJkuu+wy1+UAQJ8sWbJEv/zlL3OPFy1apPLycocVIWxaW1tzH/fr169X33P+153//ege1x4oFnoN8BPXawCiJsrrGq90vYjhw4frq1/9qiQpm82qpaVFO3fu1Ouvv67jx49r/vz5euKJJ/TYY49p9OjRjqsFADuNjY164IEHco/nz5+vBQsWOKwIYfT+++/nPr7kkkt69T3nX1CdOXMm8JrCiGsPFAu9BoQL12sAoibq65q3m669efONYhg1apQeffTRC443Nzfre9/7nhYvXqxVq1Zp8uTJWr16ta6//noHVcJGMpnU9OnTvem1sCC36HnrrbdUX1+f2zC7/vrr9dhjjzmuil6z4Tqzj3zkI7mPP/jgg159T3t7e+7j3r46Nmiuc/swrj1QLGHoNd/mE3CF67XoIDM75GbO98x8XteCwu0FLA0fPlxPPvmkHnzwQUnS8ePHdccdd+TuQYFwcPUH/LAjt+g4cOCAbr75Zr333nuSzv4B/MUXX1T//v0dV3YWvWbOZWaVlZW5j3v7qtXzv+787y+2MPQa1x4oFt96LQzzCRQS12vRQ2Z2yM2cr5n5vq4FxdtN17Dc7HfRokW5pnjjjTf061//2nFF6K1UKqWGhobQ9JovyC06jh49qptvvll79uyRJA0bNkwrVqzQsGHDHFd2Fr1mznVml19+ee7jgwcP9up7Oi+0JGngwIGB19QbrnMzxbUHisWHXgvbfAJB43otesjMDrmZ8zWzMKxrQfF20zUsKioqNGXKlNzjV155xWE1ANA7p06d0i233KLt27dLkgYNGqQVK1bommuucVwZwmzMmDG5j/fv39+r72lqasp9PHbs2MBriiKuPVAs9BrgFtdrAKKm1NY1Nl0DUF1dnfv46NGjDisBgIs7ffq06urq9Pvf/16SNGDAAL344ov62Mc+5rgyhN24ceNyH2/durVXf0v8+uuvd/v96BnXHigWeg1wg+s1AFFTiusam64BOHDgQO5jV/80EgB64/3339ecOXNyr1aqqKjQsmXL9MlPftJxZYiCKVOmqLy8XNLZi6rGxsYev769vV2vvvpq7vGMGTMKWl+UcO2BYqHXgOLjeg1A1JTquubtpquv7672YUePHtX69etzj3mVTngkk0nV1dWFptd8QW7h1dHRoXnz5mnlypWSpPLycr3wwgu66aabHFfWPXrNnOvMKisrNXPmzNzjxYsX9/j1v/rVr9TS0iLp7GbOpz/96UKWl5fr3Exx7YFi8aHXwjafQF9xvRZ9ZGaH3Mz5klkY17WgeLvp6sqxY8d6/bWZTEZf+9rX1N7eLuls49x2222FKg0F0Nt310ZX5BY+6XRaCxYsUENDg6SzJ5Kf//znmjVrluPKekavmXOd2Ve+8pXcx4sXL87dr+nD2tra9IMf/CD3+Etf+pLTC0KXuXHtgWIJa6+5XteAYuF6rXSQmR1yM+c6s7Cua0HxdtPV1burLV26VJMmTdLSpUt16tSpvF+3ZcsW1dXV6dlnn80de/jhh7u8czP8lkqltGrVKu/eyc935BY+2WxWX/jCF/SLX/xCkhSPx/XUU09pzpw5jivrGb1mzofMZs+erU996lOSzt4+4LbbbtOWLVu6fM3Ro0d1++23a/fu3ZLOvsr129/+dtFr7eQ6N649UCxh7DXX8wkUC9drpYPM7JCbOdeZhXldCwqvy+5GY2Oj7rnnHiWTSY0dO1ZjxoxRdXW1YrGYjh49qi1btuT+oNhp3rx5+uEPf+ioYgDI72c/+5mWLFmSe3zttddq7dq1Wrt2ba++/9FHHy1UaYiof/mXf9GNN96oAwcOaN++fZowYYKmTp2qa6+9VocPH9aKFSvU1tYm6dzfdl922WVui3aMaw8UC71mp66uTs3NzV2Ovffee7mPGxsbNWHChAu+r6GhQcOHDy90eYgArtdQbKxrdsit91jX2HS9QOcbgEhnd7e3bdumbdu25f36qqoqLVy4UN/4xjeUSCSKUSIAGDl06FCXx7t27dKuXbt6/f1RONmhuK688kqtXLlS8+fP1+bNm5XNZrV69WqtXr26y9cNHjxYTz75ZJf7wJYirj1QLPSavR07dmj//v15P3/69Gn94Q9/uOD4Bx98UMiyECFcr6HYWNfskFvvsa6x6XqBL3/5y5o5c6ZWrFihDRs2aPv27WpqatKJEyckSf3799ewYcM0YcIEzZo1S/PmzVNlZaXbomHN9Q2lw4rcUCz0mjlfMhs7dqw2bNigZ599Vs8884y2b9+ugwcP6rLLLtOoUaM0d+5c3XfffRo0aJDrUiW5zY1rDxRLWHvNl3UNQPeYUXNkZofczJGZW7FsNpt1XcT5Tp06pQEDBujkyZPq37+/63K8V1srvfpq12OTJ0vnvdEsAEeYTwBRw7pmh9xQLPSaOTIDAJwvyH1Jb99IK5PJuC4BEZfJZHTo0CF6zRC5oVjoNXNkZofcAH8xn4DfmFFzZGaH3MyRmZ0g8/J20zWdTrsuARGXTqe1fv16es0QuaFY6DVzZGaH3AB/MZ+A35hRc2Rmh9zMkZmdIPPydtMVAAAAAAAAAMKITVcAAAAAAAAACJC3m66xWMx1CYi4WCymqqoqes0QuaFY6DVzZGaH3AB/MZ+A35hRc2Rmh9zMkZmdIPNKBvaTApZMelsaIiKZTGrGjBmuywgdckOx0GvmyMwOuQH+Yj4BvzGj5sjMDrmZIzM7Qe5HevtKV95dDYWWyWS0f/9+es0QuaFY6DVzZGaH3AB/MZ+A35hRc2Rmh9zMkZmdIPPydtOVd1dDoaXTaW3evJleM0RuKBZ6zRyZ2SE3wF/MJ+A3ZtQcmdkhN3NkZifIvLzddAUAAAAAAACAMGLTFQAAAAAAAAAC5O2mK++uhkKLxWIaPHgwvWaI3FAs9Jo5MrNDboC/mE/Ab8yoOTKzQ27myMxOkHkF95ZcAQvy3cKA7iSTSU2ZMsV1GaFDbigWes0cmdkhN8BfzCfgN2bUHJnZITdzZGYnyP1Ib1/pyo1+UWjpdFpvvvkmvWaI3FAs9Jo5MrNDboC/mE/Ab8yoOTKzQ27myMxOSbyRViaTcV0CIi6TyWjnzp30miFyQ7HQa+bIzA65Af5iPgG/MaPmyMwOuZkjMztB5uXtpisAAAAAAAAAhBGbrgAAAAAAAAAQIG83XeNxb0tDRMTjcdXU1NBrhsgNxUKvmSMzO+QG+Iv5BPzGjJojMzvkZo7M7ASZV3BvyRWwRCLhugREXCKR0MSJE12XETrkhmKh18yRmR1yA/zFfAJ+Y0bNkZkdcjNHZnaC3I/0drubd1dDoaXTaW3atIleM0RuKBZ6zRyZ2SE3wF/MJ+A3ZtQcmdkhN3NkZifIvLzddOXd1VBomUxGTU1N9JohckOx0GvmyMwOuQH+Yj4BvzGj5sjMDrmZIzM7Qebl7aYrAAAAAAAAAIQRm64AAAAAAAAAECBvN115dzUUWjwe15gxY+g1Q+SGYqHXzJGZHXID/MV8An5jRs2RmR1yM0dmdoLMKxnYTwpYkO8WBnQnkUho7NixrssIHXJDsdBr5sjMDrkB/mI+Ab8xo+bIzA65mSMzO0HuRxpv365Zs0b19fUaPny4YrGYnn/++S6fX7hwocaOHatLL71U1dXVmjVrljZs2GBcWCqVMv4ewEQqldK6devoNUPkhmKh18yRmR1yA/zFfAJ+Y0bNkZkdcjNHZnaCzMv4la6nT5/WDTfcoPvvv19z58694POjR4/Wo48+qlGjRunMmTP6n//zf+ozn/mMdu/ercGDB/f6/6emJqFLL5VGjTKtsLRs23bhsb17i19HmIwdK737riQllErdqGQyoYoKeu1i9u6V2tokcus95tMOM2quu/kcMUJ6803XlfmNXjPHumanu4y2bZNqa4tfS1iwrtnprteY0Z6RmR3OoeZY1+zQa+b4s7udztyy2eBe6RrLZrNZ62+OxfTcc8/p9ttvz/s1p06d0oABA7RixQrNnDnzoj+z8+ulk5L625ZW0iorpZYW11X4q6pKam11XQVKFfN5ccxoMOi1i6PXgkGvXRy9Fgx67eK66zVy6xmZ2WFdCwa9dnH0GorvlKQBOnnypPr379u+ZEHv6frBBx/oiSee0IABA3TDDTd0+zXt7e1qb2/PPT516lQhSyoRWXVupX/4ZdHJZLLb42VlZcpkMkqn07ljsVhMyWQy7/F0Oq1MJpM7Ho/HlUgk8h5PpVI6f48/kUgoHo/nPd7R0dGr2k2fk8e3MkZJyKqj41yvhn2eCrNGJCXF8keIXjrba1Fdy4N4TvRaULKSYiVzHWHznDozQl91PYdKpXUN27vn1N26di63cD4ndak9+N9Tz5mF8zmpx9qDeE6cQ4PCn90v9pw4hyLMCrL79B//8R+644471NbWpmHDhuk3v/mNBg0a1O3XLlq0SI888kghyihZqVRaLS1t6tevnxoaGrp8rq6uTmfOnNGqVatyx5LJpGbPnq0jR45o/fr1ueNVVVWaMWOG3n77bW3evDl3fPDgwZoyZYp27dqlnTt35o7X1NRo4sSJ2rJli5qamnLHx4wZo7Fjx2rjxo06fPhw7viECRM0cuRIrVmzRi3n/fVebW2thgwZouXLl3dZjKdPnx7Ic5Jm9CZGoCAymWyXHg77PBVijUilZou/HOm7VCqthoaGyK7lQTynTKZeXMT3XSqVlpQsmesIm+eUTmck8SaxfZXNqsvvr9SuYXvznLo7h3aeD8L6nDoV6vd0sczC+Jw6FfL3lE7fJta1vuPP7hd/TpkMm64Ir4LcXuD06dM6cOCAjhw5on/6p3/SypUrtWHDBg0ZMuSCn9HdK12vuuoqcXsBe5WVWXW+YJi/Lbuw9urqJP88Ac5UVmZ17BivdO3pOQ0cmFRrKxdWfdXZa1Fdy4N4TvRaMCors2pp4ZWuPT2nqqosvRaAD59DpdK6hu3Nc+puXTs/tzA+p06F+j1dLLMwPqdOhfw9cQ4NBn92v/hz4hyK4gvu9gIFv6erJH30ox/V/fffr+9+97sX/Znn39O1srK/xo+3ra40nLtBclbpdFqJREIjRsS4GXcPhg6VDh3qeqyyUvTaRXTXaxUVMW7G3QPm0w4zam7btgvvdTVkiHTwoJt6woJeM8e6Zufcm4BwDu0t1jU73a1r5NYzMrPDOdQc65odes0cf3a3c25GQ3JP106ZTKbLq1l7a/x46bxXl6MHHR0pNTQ0qK6uTmVlZa7L8dqoURcu2vRa79Fr5sjMDDNqrrZWevXVrse4qLo4es0e65qZzk1pcus91jU73a1r5NYzMrPDOdQc65odes0e1x1mupvRvjLedG1tbdXu3btzj9966y1t3rxZAwcO1OWXX67/9t/+m+bMmaNhw4bpyJEj+ulPf6p3331Xf/7nfx5o4QAAAAAAAADgI+NN18bGRk2fPj33+KGHHpIk3XPPPXrsscf05ptvasmSJTpy5Iguv/xyTZo0SS+//LI+/vGPB1c1AAAAAAAAAHjKeNN12rRp6uk2sL/61a/6VBDsJBIJ1dbWKpHgHSRRWPSaOTIDEDWsa3bIDQAAFAvXHe4V5Z6uKLx4PK4hQ4a4LgMlgF4zR2YAooZ1zQ65AQCAYuG6w7246wIQjI6ODi1btkwdHR2uS0HE0WvmyAxA1LCu2SE3AABQLFx3uMema4SkUinXJaBE0GvmyAxA1LCu2SE3AABQLFx3uMWmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64RkUwmNX36dCWTvDcaCoteM0dmAKKGdc0OuQEAgGLhusM9Nl0jpF+/fq5LQImg18yRGYCoYV2zQ24AAKBYuO5wi03XiEilUmpoaOAmySg4es0cmQGIGtY1O+QGAACKhesO99h0BQAAAAAAAIAAsekKAAAAAAAAAAFi0xUAAAAAAAAAAsSma0Qkk0nV1dXxrnQoOHrNHJkBiBrWNTvkBgAAioXrDvfYdI2QM2fOuC4BJYJeM0dmAKKGdc0OuQEAgGLhusMtNl0jIpVKadWqVbwrHQqOXjNHZgCihnXNDrkBAIBi4brDPTZdAQAAAAAAACBAbLoCAAAAAAAAQIDYdI0Qbo6MYqHXzJEZgKhhXbNDbgAAoFi47nCL9COirKxMs2fPdl0GSgC9Zo7MAESNL+taOp3W9u3b9dprr6mxsVGvvfaatmzZoo6ODknS1KlTtXr1ardFnseH3I4cOaJXXnlFGzdu1NatW7Vnzx41NzertbVVZWVlqq6u1vjx4zVt2jTdfffdGjFihNN6AeBiWNfMkZm9ffv26Te/+Y1+97vfaevWrWpqalJra6uqqqp05ZVXqra2VgsWLNDUqVNdl+rFdUepY9M1IjKZjI4cOaJBgwYpHucFzCgces0cmQGIGh/Wteeff1533nmn2tranPz/2/Aht3vvvVfLli3r9nOpVEpnzpxRc3Ozli9frkceeUTf/e539f3vf5/zFwBvsa6ZIzNzmzZt0gMPPKCNGzd2+/njx4/r+PHj2rp1q5544glNmzZNS5YsUU1NTZErPceH645Sx6ZrRKTTaa1fv151dXUMEwqKXjNHZgCixod17cSJE6HacJX8yO18gwYN0rhx4zRy5EhVVlaqra1Nu3fv1saNG5VKpdTe3q6FCxdq7969WrJkietyAeCiWNfMkVnv7Ny584IN19GjR2v8+PEaNGiQTpw4oXXr1umdd96RJK1evVq1tbV6+eWXNWrUKBcle3fdUYrYdAUAAEBoDR06VJMmTcr999JLL+knP/mJ67K8NW3aNNXX12vmzJm67rrruv2agwcP6pvf/KaeeeYZSdLSpUtVX1+vz33uc8UsFQB6hXXNHJnZu+666/TFL35Rn//85y+47UImk9HixYv19a9/XW1tbWpubtadd96pdevWKRaLOaoYLrHpCgAAgNC59dZbtX///gv+2d6GDRscVRQO3/rWty76NUOHDtXTTz+tgwcPauXKlZKkxx9/vOT/oA3AT6xr5sjM3LBhw/Tkk0/qrrvuUiKR6PZr4vG47r//flVXV2vu3LmSpFdffVXLly/XLbfcUsxy4QleXxwRsVhMVVVV/O0JCo5eM0dmAKLGh3XtiiuucHqfNBs+5NZbsVhM9913X+7xpk2bHFYDAH3HumaOzM6ZOnWq7r333rwbruf77Gc/qxtvvDH3ON/9cwstTNcdUcWma0Qkk0nNmDFDySQvXkZh0WvmyAxA1LCu2QlbboMHD8593NLS4rASAAgG65o5MrNz00035T7et2+fkxrCdt0RRWy6RkQmk9H+/fuVyWRcl4KIo9fMkRmAqGFdsxO23Hbs2JH7+Oqrr3ZXCAAEhHXNHJnZOf/Vpel02kkNYbvuiCI2XSMinU5r8+bNzoYZpYNeM0dmAKKGdc1OmHJrbm7Wj370o9zjUr2HH4DoYF0zR2b2tm7dmvv4qquuclJDmK47oopNVwAAAABqa2vTjh079OMf/1gTJ05Uc3OzJGncuHH6zne+47g6ADDHumaOzPquqakp9+ZjkjRr1iyH1cAlbuwAAAAAlKC1a9fqU5/6VI9fU1dXp6efflpVVVVFqgoA7LGumSOz4D300EO5V5fW1NSovr7ecUVwhVe6RkQsFtPgwYN5VzoUHL1mjswARA3rmp0w5VZdXa1nnnlGy5Yt02WXXea6HADoM9Y1c2RmbsmSJfrlL3+Ze7xo0SKVl5c7qSVM1x1RxStdIyKZTGrKlCmuy0AJoNfMkRmAqGFds+NbbsOHD9dXv/pVSVI2m1VLS4t27typ119/XcePH9f8+fP1xBNP6LHHHtPo0aMdVwsAF8e6Zo7MgtPY2KgHHngg93j+/PlasGCBs3p8u+4oRWy6RkQ6ndauXbv00Y9+VIlEwnU5iDB6zRyZAYga1jU7vuU2atQoPfrooxccb25u1ve+9z0tXrxYq1at0uTJk7V69Wpdf/31DqoEgN5jXTNHZsF46623VF9fr/fff1+SdP311+uxxx5zWpNv1x2liNsLREQmk9HOnTuVyWRcl4KIo9fMkRmAqGFdsxOW3IYPH64nn3xSDz74oCTp+PHjuuOOO3j3YwChxbpmjsx678CBA7r55pv13nvvSTq7kf3iiy+qf//+TusKy3VHlLHpCgAAAOACixYtyv2B8Y033tCvf/1rxxUBQN+wrpkjs54dPXpUN998s/bs2SNJGjZsmFasWKFhw4Y5rgw+YNMVAAAAwAUqKiq63AvulVdecVgNAPQd65o5Msvv1KlTuuWWW7R9+3ZJ0qBBg7RixQpdc801jiuDL9h0jYh4PK6amhrF4/xKUVj0mjkyAxA1rGt2wphbdXV17uOjR486rAQAgsG6Zo7MLnT69GnV1dXp97//vSRpwIABevHFF/Wxj33McWXnhPG6I2p4I62ISCQSmjhxousyUALoNXNkBiBqWNfshDG3AwcO5D4eOHCgw0oAIBisa+bIrKv3339fc+bMyb3qt6KiQsuWLdMnP/lJx5V1Fcbrjqhhuzsi0um0Nm3axE2tUXD0mjkyAxA1rGt2wpbb0aNHtX79+tzjcePGOawGAPqOdc0cmXXV0dGhefPmaeXKlZKk8vJyvfDCC7rpppscV3ahsF13RBGbrhGRyWTU1NTEu9Kh4Og1c2QGIGpY1+y4zu3YsWO9/tpMJqOvfe1ram9vl3T2D5W33XZboUoDACusa+bIzF46ndaCBQvU0NAgSUomk/r5z3+uWbNmOa6se66vO8CmKwAAAFASli5dqkmTJmnp0qU6depU3q/bsmWL6urq9Oyzz+aOPfzww7r88suLUSYA9Brrmjkys5PNZvWFL3xBv/jFLySdvV/qU089pTlz5jiuDD7jnq4AAAAIpbq6OjU3N3c59t577+U+bmxs1IQJEy74voaGBg0fPrzQ5XmpsbFR99xzj5LJpMaOHasxY8aourpasVhMR48e1ZYtW7R79+4u3zNv3jz98Ic/dFQxAPSMdc0cmZn72c9+piVLluQeX3vttVq7dq3Wrl3bq+9/9NFHC1UaPMama0TE43GNGTOGd6VDwdFr5sgMQNT4sq7t2LFD+/fvz/v506dP6w9/+MMFxz/44INClpWX69zKy8tzH6dSKW3btk3btm3L+/VVVVVauHChvvGNbyiRSBSjRAAwwrpmjszsHDp0qMvjXbt2adeuXb3+fhebrq6vO8Cma2QkEgmNHTvWdRkoAfSaOTIDEDWsa3Zc5/blL39ZM2fO1IoVK7RhwwZt375dTU1NOnHihCSpf//+GjZsmCZMmKBZs2Zp3rx5qqysdFYvAFwM65o5Misdrq87wKZrZKRSKW3cuFE33nijkkl+rSgces0cmQGIGl/WtX379jn7/7bhQ26jR4/W6NGj9ZWvfMXJ/z8ABI11zRyZmVu4cKEWLlzougwjPlx3lDpeYxwR2WxWhw8fVjabdV0KIo5eM0dmAKKGdc0OuQEAgGLhusM9Nl0BAAAAAAAAIEBsugIAAAAAAABAgNh0jYhEIqEJEyaU9LsJojjoNXNkBiBqWNfskBsAACgWrjvc4066ERGPxzVy5EjXZaAE0GvmyAxA1LCu2SE3AABQLFx3uMcrXSMilUpp5cqVSqVSrktBxNFr5sgMQNSwrtkhNwAAUCxcd7jHpmtEZLNZtbS08K50KDh6zRyZAYga1jU75AYAAIqF6w732HQFAAAAAAAAgACx6QoAAAAAAAAAAWLTNSISiYRqa2t5VzoUHL1mjswARA3rmh1yAwAAxcJ1h3tJ1wUgGPF4XEOGDHFdBkoAvWaOzABEDeuaHXIDAADFwnWHe7zSNSI6Ojq0bNkydXR0uC4FEUevmSMzAFHDumaH3AAAQLFw3eEem64RkkqlXJeAEkGvmSMzAFHDumaH3AAAQLFw3eEWm64AAAAAAAAAECA2XQEAAAAAAAAgQGy6RkQymdT06dOVTPLeaCgses0cmQGIGtY1O+QGAACKhesO99h0jZB+/fq5LgElgl4zR2YAooZ1zQ65AQCAYuG6wy02XSMilUqpoaGBmySj4Og1c2QGIGpY1+yQGwAAKBauO9xj0xUAAAAAAAAAAsSmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64RkUwmVVdXx7vSoeDoNXNkBiBqWNfskBsAACgWrjvcY9M1Qs6cOeO6BJQIes0cmQGIGtY1O+QGAACKhesOt4w3XdesWaP6+noNHz5csVhMzz//fO5zHR0d+va3v61PfOITuvTSSzV8+HDdfffdam5uDrJmdCOVSmnVqlW8Kx0Kjl4zR2YAooZ1zQ65AQCAYuG6wz3j1xifPn1aN9xwg+6//37NnTu3y+fa2tr0+uuv6/vf/75uuOEGHT9+XN/4xjc0Z84cNTY2Ghe3bZtUW2v8bSVl716prU2SkkqlZiuZTGjECOnNN11X5q+9ey88Rq9dHL1mbuxY6d13pfMzq6iQRo1yXZnftm278Fh3c4tzusuHzC6O3Myxrtnp7hxKbj3jXGCHdc0cmdkhN3P8OdQO5wNzXK/Z6a7X+iqWzWaz1t8ci+m5557T7bffnvdrXnvtNd14443av3+/ampqLvozT506pQEDBkg6Kam/bWklrbJSamlxXYW/qqqk1lbXVUQDvdYzei049FrPuus1Mrs4cjPHugaXmM+LY10zR2Z2yM0c59Dg0Gs9o9f66pSkATp58qT69+/bvmTB76Z78uRJxWIxXXbZZd1+vr29Xe3t7bnHp06dKnRJJSCrzq30D7+MvPMGyh8+XlZWpkwmo3Q6nTsWi8WUTCbzHk+n08pkMrnj8XhciUQi7/FUKqXz9/gTiYTi8Xje4x0dHb2q3fQ5FaHtS0qhfk9R6D0p9sf/0HdZdXSczbnQa0Q4ey+pC3vtbGbhfU5nFfL3lC+3TCYb2udU6N9T95kBxXLuXNApzPNUmDUi//kgvM9JXWoP/vfUc2bhfE7qsfYgnlO+3NLpTGifU6F/T5xDgxWleQq696Ss6DU/FHT36f3339e3v/1tzZ8/P+/u8KJFi/TII48UsoySk0ql1dLSpn79+qmhoaHL5+rq6nTmzBmtWrUqdyyZTGr27Nk6cuSI1q9fnzteVVWlGTNm6O2339bmzZtzxwcPHqwpU6Zo165d2rlzZ+54TU2NJk6cqC1btqipqSl3fMyYMRo7dqw2btyow4cP545PmDBBI0eO1Jo1a9Ry3l9T1dbWasiQIVq+fHmXhWv69OmBPCdpRm9iRC8V6vcUhd5LpQaKTf5gpFLpXP6FXiPC2Hup1Gx9uNc6Mwvrc5IK/3vKZOr14QvSVCqtt99+N7TPqdC/J2mOAFeyWXXpybDPUyHWiJ7OB2F9Tp0K9Xu6WGZhfE6dCvl7Sqdvk5S4ILctW7aG9jkV+veUzV543QF7UZqnoHvv7IYufw71QcFuL9DR0aF58+bpnXfe0erVq/Nuunb3SterrrpK3F7AXmVlVp0vGA7D38IU+2+WqquTvNQ+IJWV0rFj4f0bwEL33oABMbW2cmEVhMrKrI4d45Wu+Y4PHJi8oNc6Mwvrc+pUyN9TvtxOnuSVrvlq7y4zoFjOPxd0CvM8FWKN6Ol8ENbn1KlQv6eLZRbG59SpkL+nfLmdOMErXfM9J86hwamslE6ciM48Bd17VVVZeq1PPL+9QEdHh/7iL/5C+/fv18qVK3sssry8XOXl5Rccv/TSrC69lBv9Xsy2bRfeq6OiIqbYH+errKys2+/r7ng8Hv/jS9F7dzyRSCiRSPT6eOdi1NvjJrXnO95d7SNGdN5UOqtUKv3Hm0rH6LWL6L7XCvd76ul4WHqvoqL7e12NH9/tj8EfnXvDmXMzOmJE7IKc6b1zx7vrtYqKrpmF7Tmdr1C/p3y5xeNnT6JhfE6dCvV7Yl2z0926xrVHz3p7LpDCO089Hbd9Tr05H/RUu4/PqbfHbZ9TbzML03Pqy/HePqd8uXU+jzA+p06F+j3x51A7+c4HUZqnTkE9p4qKGNdrFjp7LZvN6vTpYH5m4JuunRuuu3bt0qpVq3T55Zdb/Zz9+1Oy/NaSUlsrvfpq12Ms2j17882z/9vRkVJDQ4Pq6uryLpw4h14zN2qUdOhQ12Pjx0vn/QsT9IAZ7b3ueo35vDhyM8e61jesa+bIzAzrmjkys0Nu5vhzaN+QW+9xvdY3R4+mNGhQMD/LeNO1tbVVu3fvzj1+6623tHnzZg0cOFDDhg3T5z73Ob3++uv6j//4D6XTab333nuSpIEDB+qSSy4JpmoAAAAAAAAA8JTxpmtjY6OmT5+ee/zQQw9Jku655x4tXLhQ//Zv/ybp7A18z7dq1SpNmzat1/8/sRj3n0BhxWIxVVVV0WuAp5hRAFHDumaOzABEDeuaHXJDsQTZY8abrtOmTVNP773Vh/fl6iLfvSmAoCSTSc2YMcN1GQDyYEYBRA3rmjkyAxA1rGt2yA3FEuR+5IV37vXE+e/MBhRCJpPR/v376TXAU8wogKhhXTNHZgCihnXNDrmhWILsMW83XdPptOsSEHHpdFqbN2+m1wBPMaMAooZ1zRyZAYga1jU75IZiCbLHvN10BQAAAAAAAIAwYtMVAAAAAAAAAALk7aYr70iHQovFYho8eDC9BniKGQUQNaxr5sgMQNSwrtkhNxRLkD0W3FtyBSzIdwsDupNMJjVlyhTXZQDIgxkFEDWsa+bIDEDUsK7ZITcUS5D7kd6+0pWbI6PQ0um03nzzTXoN8BQzCiBqWNfMkRmAqGFds0NuKJaSeCOtTCbjugREXCaT0c6dO+k1wFPMKICoYV0zR2YAooZ1zQ65oViC7DFvN10BAAAAAAAAIIzYdAUAAAAAAACAAHm76RqPe1saIiIej6umpoZeAzzFjAKIGtY1c2QGIGpY1+yQG4olyB4L7i25ApZIJFyXgIhLJBKaOHGi6zIA5MGMAoga1jVzZAYgaljX7JAbiiXI/Uhv/4qAd6RDoaXTaW3atIleAzzFjAKIGtY1c2QGIGpY1+yQG4olyB7zdtOVd6RDoWUyGTU1NdFrgKeYUQBRw7pmjswARA3rmh1yQ7EE2WPebroCAAAAAAAAQBix6QoAAAAAAAAAAfL2jbR4R7pwSqfT2r59u1577TU1Njbqtdde05YtW9TR0SFJmjp1qlavXu22yD+Kx+MaM2aM0147cuSIXnnlFW3cuFFbt27Vnj171NzcrNbWVpWVlam6ulrjx4/XtGnTdPfdd2vEiBHOakW4hbHXfJhRKVzrGlBKWNdKA5kB6I0wXa/5sq7t27dPv/nNb/S73/1OW7duVVNTk1pbW1VVVaUrr7xStbW1WrBggaZOneq0zk6+5AZzYey1oHi76Rrku4WhOJ5//nndeeedamtrc11KryQSCY0dO9ZpDffee6+WLVvW7edSqZTOnDmj5uZmLV++XI888oi++93v6vvf/z4nGhgLY6/5MKNhW9eAUsK6VhrIDMDFhO16zfW6tmnTJj3wwAPauHFjt58/fvy4jh8/rq1bt+qJJ57QtGnTtGTJEtXU1BS50q5c5wZzYe61oHi76ZpKpVyXAEMnTpwIzYlOOttjGzdu1I033qhk0v0oDBo0SOPGjdPIkSNVWVmptrY27d69Wxs3blQqlVJ7e7sWLlyovXv3asmSJa7LRYiFpdd8mNGwrWtAqWJdiy4yA3AxYbtec72u7dy584JNsNGjR2v8+PEaNGiQTpw4oXXr1umdd96RJK1evVq1tbV6+eWXNWrUqKLX28l1bjAX5l4Liredms1mXZcAS0OHDtWkSZNy/7300kv6yU9+4rqsC2SzWR0+fNhpr02bNk319fWaOXOmrrvuum6/5uDBg/rmN7+pZ555RpK0dOlS1dfX63Of+1wxS0XIhbHXfJjRTmFZ14BSwrpWGsgMQG+F5XrNl3Xtuuuu0xe/+EV9/vOfv+AWPJlMRosXL9bXv/51tbW1qbm5WXfeeafWrVunWCzmpF5fcoO5MPZaULzddEX43Hrrrdq/f/8FLwXfsGGDo4r8961vfeuiXzN06FA9/fTTOnjwoFauXClJevzxx9l0hRF6zQ7rGuAv1jUAgMT1mqlhw4bpySef1F133ZX3n1HH43Hdf//9qq6u1ty5cyVJr776qpYvX65bbrmlmOUixOg1iRtDIjBXXHGF83tvRFUsFtN9992Xe7xp0yaH1SDK6LWuWNeA8GNdA4Bo43rNzNSpU3Xvvff26r6Vn/3sZ3XjjTfmHue7lzrQHXrN401X3kgLhZZIJDRhwoTQ9NrgwYNzH7e0tDisBFHnS6+FbUYB+It1LbzIDEDUhG1du+mmm3If79u3z1kdYcsN5nzqtaB4e3sB3p0dhRaPxzVy5EjXZfTajh07ch9fffXV7gpB5PnSa2GbUQD+Yl0LLzIDEDVhW9fOv69mOp12VkfYcoM5n3otsJ8V2E8KWJDvFgZ0J5VKaeXKlaHotebmZv3oRz/KPeZedCgUn3otTDMKwF+sa+FGZgCiJmzr2tatW3MfX3XVVc7qCFtuMOdTrwXF201X3pEOhZbNZtXS0uJtr7W1tWnHjh368Y9/rIkTJ6q5uVmSNG7cOH3nO99xXB2ixNde831GAfiLdS06yAxA1IRpXWtqasq9EaUkzZo1y1ktYcoN5nzrtaB4e3sBoNSsXbtWn/rUp3r8mrq6Oj399NOqqqoqUlWIInoNQNSwrgEAELyHHnoo98+8a2pqVF9f77giRFVUe83bV7oCOKe6ulrPPPOMli1bpssuu8x1OYgweg1A1LCuAQBgbsmSJfrlL3+Ze7xo0SKVl5c7rAhRFeVe8/aVrrwjHQotkUiotrbWm14bPny4vvrVr0o6908ndu7cqddff13Hjx/X/Pnz9cQTT+ixxx7T6NGjHVeLMAtLr/k2owD8xboWXWQGIGrCsK41NjbqgQceyD2eP3++FixY4LCicOQGc772WlC83XQN8t3CgO7E43ENGTLEdRk5o0aN0qOPPnrB8ebmZn3ve9/T4sWLtWrVKk2ePFmrV6/W9ddf76BKREFYes23GQXgL9a16CIzAFHj+7r21ltvqb6+Xu+//74k6frrr9djjz3muCr/c4M5n3stsJ8V2E8KWEdHh+sSEHEdHR1atmyZ9702fPhwPfnkk3rwwQclScePH9cdd9yRu98JEBTfei0sMwrAX6xr4UdmAKLG53XtwIEDuvnmm/Xee+9JOvuXmi+++KL69+/vuDK/c4M533stKN5uugLFkEqlXJfQa4sWLcotQG+88YZ+/etfO64IUeVTr4VpRgH4i3Ut3MgMQNT4uK4dPXpUN998s/bs2SNJGjZsmFasWKFhw4Y5ruwcH3ODuTD0WlDYdAVCoqKiQlOmTMk9fuWVVxxWgyij1wBEDesaAAD5nTp1Srfccou2b98uSRo0aJBWrFiha665xnFliJpS6zU2XYEQqa6uzn189OhRh5Ug6ug1AFHDugYAwIVOnz6turo6/f73v5ckDRgwQC+++KI+9rGPOa4MUVOKvebtpmsy6e17fCEiksmkpk+fHqpeO3DgQO7jgQMHOqwEUedDr4VxRgH4i3UtnMgMQNT4tK69//77mjNnTu5fgFRUVGjZsmX65Cc/6biyC/mUG8yFrdeC4u2mK1AM/fr1c11Crx09elTr16/PPR43bpzDahBlPvVamGYUgL9Y18KNzABEjQ/rWkdHh+bNm6eVK1dKksrLy/XCCy/opptuclxZfj7kBnNh7LWgeLvpyg2SUWipVEoNDQ3Oeu3YsWO9/tpMJqOvfe1ram9vl3R2kbrtttsKVRoiJqy95npGAfiLda10kBmAqPFhXUun01qwYIEaGhoknX1l389//nPNmjXLWU0X40NuMBfWXguKt5uuQNQtXbpUkyZN0tKlS3Xq1Km8X7dlyxbV1dXp2WefzR17+OGHdfnllxejTEQAvQYgaljXAACwk81m9YUvfEG/+MUvJEnxeFxPPfWU5syZ47gyRA29JnEzDASqrq5Ozc3NXY699957uY8bGxs1YcKEC76voaFBw4cPL3R53mlsbNQ999yjZDKpsWPHasyYMaqurlYsFtPRo0e1ZcsW7d69u8v3zJs3Tz/84Q8dVYywotfssa4BfmJdAwB04nqt9372s59pyZIlucfXXnut1q5dq7Vr1/bq+x999NFClYaIodfYdEXAduzYof379+f9/OnTp/WHP/zhguMffPBBIcvyUnl5ee7jVCqlbdu2adu2bXm/vqqqSgsXLtQ3vvENJRKJYpSIiKDX+oZ1DfAP6xoA4Hxcr/XeoUOHujzetWuXdu3a1evvj8JGGIqDXvN405V3pEOhJZNJ1dXVOeu1L3/5y5o5c6ZWrFihDRs2aPv27WpqatKJEyckSf3799ewYcM0YcIEzZo1S/PmzVNlZaWTWhFuYe011zMKwF+sa6WDzABEDeuaHXJDsQTZY3QrArVv3z7XJRg5c+aMqqqqnP3/jx49WqNHj9ZXvvIVZzWgNIS111zPqBS+dQ0oFaxrpYPMAFxM2K7XXK5rCxcu1MKFC538f/cV54NwCXOvBcXbN9LiHelQaKlUSqtWraLXAE8xowCihnXNHJkBiBrWNTvkhmIJsse83XQFAAAAAAAAgDBi0xUAAAAAAAAAAsSmK0oaN+EG/MaMAoga1jVzZAYgaljX7JAbwsbbji0rK3NdAiKurKxMs2fPdl0GgDyYUQBRw7pmjswARA3rmh1yQ7EEuR/p7StdM5mM6xIQcZlMRocOHaLXAE8xowCihnXNHJkBiBrWNTvkhmIJsse83XRNp9OuS0DEpdNprV+/nl4DPMWMAoga1jVzZAYgaljX7JAbiiXIHvN20xUAAAAAAAAAwohNVwAAAAAAAAAIkLebrrFYzHUJiLhYLKaqqip6DfAUMwogaljXzJEZgKhhXbNDbiiWIHssGdhPClgy6W1piIhkMqkZM2a4LgNAHswogKhhXTNHZgCihnXNDrmhWILcj/T2la68Ix0KLZPJaP/+/fQa4ClmFEDUsK6ZIzMAUcO6ZofcUCxB9pi3m668Ix0KLZ1Oa/PmzfQa4ClmFEDUsK6ZIzMAUcO6ZofcUCxB9pi3m64AAAAAAAAAEEZsugIAAAAAAABAgLzddOUd6VBosVhMgwcPptcATzGjAKKGdc0cmQGIGtY1O+SGYgmyx4J7S66ABfluYUB3ksmkpkyZ4roMAHkwowCihnXNHJkBiBrWNTvkhmIJcj/S21e6cnNkFFo6ndabb75JrwGeYkYBRA3rmjkyAxA1rGt2yA3FUhJvpJXJZFyXgIjLZDLauXMnvQZ4ihkFEDWsa+bIDEDUsK7ZITcUS5A95u2mKwAAAAAAAACEEZuuAAAAAAAAABAgbzdd43FvS0NExONx1dTU0GuAp5hRAFHDumaOzABEDeuaHXJDsQTZY8G9JVfAEomE6xIQcYlEQhMnTnRdBoA8mFEAUcO6Zo7MAEQN65odckOxBLkf6e1fEfCOdCi0dDqtTZs20WuAp5hRAFHDumaOzABEDeuaHXJDsQTZY8abrmvWrFF9fb2GDx+uWCym559/vsvnf/WrX+kzn/mMLr/8csViMW3evNmqMN6RDoWWyWTU1NRErwGeYkYBRA3rmjkyAxA1rGt2yA3FEmSPGd9e4PTp07rhhht0//33a+7cud1+/k//9E/1F3/xF/ov/+W/WBc2cmRSl14qjRpl/SNKwrZtFx7bu7f4dYTJ2LHSu+9KUlKp1GwlkwlVVNBrF0Ovmesun23bpNra4tcSJnv3Sm1t0vkzOmKE9OabrivzF71mh3XNHL1mh3XNHNdrdljXzLGu2aHXzLGu2enuHEpuPWM+/RHLZrNZ62+OxfTcc8/p9ttvv+Bz+/bt0zXXXKNNmzZpwoQJvf6Zp06d0oABAySdlNTftrSSVlkptbS4rsJfVVVSa6vrKqKBXusZvRYceq1n9Fpw6LWe0WvBodd6Rq8Fh17rGb0WHHqtZ/QaXGI+e+/o0aMaNGiQTp48qf79+7Yv6fyNtNrb29Xe3p57fOrUKYfVREVWnVvpqVSqy2eSyWS3x8vKypTJZLrcuyIWiymZTOY9nk6nu7zsOh6PK5FI5D2eSqV0/h5/IpFQPB7Pe7yjo6NXtZs+Jw/aPlIK9XuKQu9JsT/+h77LqqPjbM6FXiPC2XtJ0WtBySqTyTo5P4Wh9+i1YPlybeRj7/2xCiEI586hrq+N/Ow91rXgZJVOZzy5NjrLp96j1+BalOapkGuE09sLBG3RokV65JFHXJcRKalUWi0tberXr58aGhq6fK6urk5nzpzRqlWrcseSyaRmz56tI0eOaP369bnjVVVVmjFjht5+++0u9+YdPHiwpkyZol27dmnnzp254zU1NZo4caK2bNmipqam3PExY8Zo7Nix2rhxow4fPpw7PmHCBI0cOVJr1qxRy3l/5VJbW6shQ4Zo+fLlXQZi+vTpgTwnaUZvYkQvFer3FIXeS6UGyoNlNhJSqXQu/0KvEWHsvVRqtui1YKRSab399rtOzk9h6D1pTi9SRG/5cm3kY++lUvxFeVDOP4e6vjbysfc4hwYnlUpry5atXlwbSf71XjZbLzZd4VKU5qmQa0Q8bvz2V3k5v71Ad690veqqq8TtBexVVmbV+YJh/sbiwtqrq5P8s46AVFZKx47xt2X5ntOAATG1tnJhFYTKyqyOHeOVrvmODxyYpNcCUlmZ1cmTvNI1X+30WnAqK6Xjx/24NvKx9/r3F70WkPPPoa6vjXzsPda14FRWZnXiBK90zfec6DW4xJ/de/+cjh8/rqFDh0bj9gLl5eUqLy/v9nOVldL48UUuKGTO3VQ6q1Qq/cc3Zogp9se1vKysrNvv6+54PB7vdkc/3/FEIqFEItHr413/udjFj5vUnu94d7VXVFx4Lx167eLy9Vqhfk89HQ9L740Y0Xmz/HOZVVTEuOn7RWzbduGMVlRc2Gv03rnj9JqdfOtaPH72JFrs81NPx33pPXrNTvfrmj/XRj0dd9V7XK/Z6e31Gr3HObSv8vVa5+/G9bXR+XzpPdY1O931GjPaM/7s3rfn1F1dtpxvuvZk/HjpvFf4ogcdHSk1NDSorq4ub3PhrFGjpEOHuh6j13qPXuu9znelJjMztbXSq692PcZFVc/otb4ht96j1+ywrpnjeq1vmNHeY13rG3LrPda1vqHXzJGZe8abrq2trdq9e3fu8VtvvaXNmzdr4MCBqqmp0bFjx9TU1KTm5mZJyt274YorrtAVV1wRUNkAAAAAAAAA4Cfju8M2NjZq4sSJmjhxoiTpoYce0sSJE/WDH/xAkvRv//ZvmjhxombPni1JuuOOOzRx4kQ99thjAZaND0skEpowYUKgL4MGukOvmSMzFAu9ZofczJEZ4Ddm1ByZ2SE3FAu9Zo7M7Di9vcC0adPU03tv3Xvvvbr33nv7UhMsxONxjRw50nUZKAH0mjkyQ7HQa3bIzRyZAX5jRs2RmR1yQ7HQa+bIzE5396a1/lmB/SQ4lUqltHLlygveiQ0IGr1mjsxQLPSaHXIzR2aA35hRc2Rmh9xQLPSaOTKzE2RebLpGRDabVUtLS4+vQgaCQK+ZIzMUC71mh9zMkRngN2bUHJnZITcUC71mjszsBJkXm64AAAAAAAAAECA2XQEAAAAAAAAgQGy6RkQikVBtbS3vSoeCo9fMkRmKhV6zQ27myAzwGzNqjszskBuKhV4zR2Z2gswrGdhPglPxeFxDhgxxXQZKAL1mjsxQLPSaHXIzR2aA35hRc2Rmh9xQLPSaOTKzE48H9/pUXukaER0dHVq2bJk6Ojpcl4KIo9fMkRmKhV6zQ27myAzwGzNqjszskBuKhV4zR2Z2gsyLTdcISaVSrktAiaDXzJEZioVes0Nu5sgM8Bszao7M7JAbioVeM0dmbrHpCgAAAAAAAAABYtMVAAAAAAAAAALEpmtEJJNJTZ8+Xckk742GwqLXzJEZioVes0Nu5sgM8Bszao7M7JAbioVeM0dmdoLMi03XCOnXr5/rElAi6DVzZIZiodfskJs5MgP8xoyaIzM75IZiodfMkZlbbLpGRCqVUkNDAzdJRsHRa+bIDMVCr9khN3NkBviNGTVHZnbIDcVCr5kjMztB5sWmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64AAAAAAAAAECA2XSMimUyqrq6Od6VDwdFr5sgMxUKv2SE3c2QG+I0ZNUdmdsgNxUKvmSMzO0HmxaZrhJw5c8Z1CbCwb98+/dM//ZM+//nP64YbblB1dbXKyso0cOBAXX/99frLv/xL/e53v3NdZhc+9Fo6ndaWLVv0z//8z/ryl7+s//Sf/pMuueQSxWIxxWIxTZs2zXWJXfiQGezQa+ZY10qDD5mFsdd8QG6lwYcZDRsys0NuKBYfei1s51AfMuv0wQcf6KmnnlJdXZ1Gjhypj3zkIxo2bJimTJmiH/3oRzpy5IjrEoOX9czJkyezkrLSyezkya6rCY8PPvgg+/zzz2c/+OAD16V4b/LkbFbq+p+LXnv99dezN9544x/7/eL/TZs2Lbt///7iF/ohPvTac889l62oqOgxr6lTpzqr78N8yCxMfJnRbJZeM8W6VjpcZxa2XvNlXQtTbr5kFlauZzSMyMwOufUe61rfuO61MJ1DO7nO7HxvvPFGdsKECT1mNmTIkOyyZctcl5o9cuRIVlL25MmTff5ZvMYYcGTnzp3auHFjl2OjR4/W+PHjNWjQIJ04cULr1q3TO++8I0lavXq1amtr9fLLL2vUqFEuSvbGiRMn1NbW5roMlAB6zQzrGoqFXrNDbgAA2OEcau+dd97RzJkz1dzcLEmKxWL69Kc/rWuvvVaHDx/WihUrdObMGR06dEi33367XnzxRc2YMcNx1cFg0xVw7LrrrtMXv/hFff7zn9eIESO6fC6TyWjx4sX6+te/rra2NjU3N+vOO+/UunXrFIvFHFXsj6FDh2rSpEm5/1566SX95Cc/cV0WIoheM8O6hmKh1+yQGwAAdjiHmluwYEFuw3XkyJF64YUXdMMNN+Q+f+TIEd1xxx367W9/q46ODv35n/+59uzZo8suu8xRxcFh0zVCuDlyuAwbNkxPPvmk7rrrLiUSiW6/Jh6P6/7771d1dbXmzp0rSXr11Ve1fPly3XLLLcUstwvXvXbrrbdq//79qqmp6XJ8w4YNjiq6ONeZwQ69ZoZ1rbTQa+FDbqWFdc0cmdkhNxQL1x7mXM9nQ0ODXn75ZUnSJZdcon//93/XJz7xiS5fM2jQIL3wwgu6/vrrtXfvXh07dkz/8A//oL/7u79zUXKgeCOtiCgrK9Ps2bNVVlbmuhT00tSpU3XvvffmXbDP99nPflY33nhj7vGyZcsKWVqPfOi1K6644oJNMJ/5kBns0GtmWNdKh+vMwtprrpFb6XA9o2FEZnbIDcXiutfCeA51nZkk/fSnP819fM8991yw4drp0ksv1d/8zd/kHj/++ONKpVIFr687QebFpmtEZDIZHTp0SJlMxnUpKJCbbrop9/G+ffuc1UGvmSMzFEvYeo11LbzClpkvvRY25BZeYZtRH5CZHXJDsYSt13w4h7rOrLW1Vb/97W9zj++7774ev37evHmqrKyUJB07dkxr1qwpaH35BJkXm64RkU6ntX79eqXTadeloEDOvweMy98zvWaOzFAsYes11rXwCltmvvRa2JBbeIVtRn1AZnbIDcUStl7z4RzqOrN169apvb1d0tlXsk6aNKnHr//IRz6i2tra3OOVK1cWtL58gsyLTVcgJLZu3Zr7+KqrrnJYCQAEg3UNxUKv2SE3AADscA6V3njjjdzHn/jEJ3p1f9k/+ZM/6fb7w4pNVyAEmpqauvwtz6xZsxxWAwB9x7qGYqHX7JAbAAB2OIeetXPnztzHI0eO7NX3nP9+Gm+++WbgNRUbm64REYvFVFVV1eUl7IiOhx56KPcS95qaGtXX1zurhV4zR2YoljD1GutauIUpM596LUzILdzCNKO+IDM75IZiCVOv+XIOdZ3Z0aNHcx8PHTq0V99zxRVX5D4+duxY4DX1RpB5Xfy1vQiFZDKpGTNmuC4DBbBkyRL98pe/zD1etGiRysvLndVDr5kjMxRLWHqNdS38wpKZb70WFuQWfmGZUZ+QmR1yQ7GEpdd8Ooe6zqy1tTX3cb9+/Xr1Ped/3fnfX0y9uQ1Cb/FK14jIZDLav39/aN7JD73T2NioBx54IPd4/vz5WrBggcOK6DUbZIZiCUOvsa5FQxgy87HXwoDcoiEMM+obMrNDbiiWMPSab+dQ15m9//77uY8vueSSXn3P+RvUZ86cCbym3ggyLzZdIyKdTmvz5s2heSc/XNxbb72l+vr63EJ1/fXX67HHHnNcFb1mg8xQLL73GutadPiema+95jtyiw7fZ9RHZGaH3FAsvveaj+dQ15l95CMfyX38wQcf9Op72tvbcx/39tWxQQsyLzZdAQ8dOHBAN998s9577z1J0qhRo/Tiiy+qf//+jisDADusaygWes0OuQEAYIdzaPcqKytzH/f2Vavnf9353x9WbLoCnjl69Khuvvlm7dmzR5I0bNgwrVixQsOGDXNcGQDYYV1DsdBrdsgNAAA7nEPzu/zyy3MfHzx4sFff07lxLUkDBw4MvKZiY9M1ImKxmAYPHhyKd/JDfqdOndItt9yi7du3S5IGDRqkFStW6JprrnFc2Tn0mjkyQ7H42Gusa9HkY2Zh6DUfkVs0+TijviMzO+SGYvGx13w/h7rObMyYMbmP9+/f36vvaWpqyn08duzYwGvqjSDzCu4tueBUMpnUlClTXJeBPjh9+rTq6ur0+9//XpI0YMAAvfjii/rYxz7muLKu6DVzZIZi8a3XWNeiy7fMwtJrviG36PJtRsOAzOyQG4rFt14LwznUdWbjxo3Lfbx161alUiklkz1vQ77++uvdfn8xXaxGE7zSNSLS6bTefPNNb28qjZ69//77mjNnjl555RVJUkVFhZYtW6ZPfvKTjiu7EL1mjsxQLD71GutatPmUWZh6zSfkFm0+zWhYkJkdckOx+NRrYTmHus5sypQpKi8vl3R2k7qxsbHHr29vb9err76aezxjxoyC1pcPb6SFC2QyGe3cuVOZTMZ1KTDU0dGhefPmaeXKlZKk8vJyvfDCC7rpppscV9Y9es0cmaFYfOk11rXo8yWzsPWaL8gt+nyZ0TAhMzvkhmLxpdfCdA51nVllZaVmzpyZe7x48eIev/5Xv/qVWlpaJJ29n+unP/3pQpaXV5B5sekKOJROp7VgwQI1NDRIOvsy9p///OeaNWuW48oAwA7rGoqFXrNDbgAA2OEcau4rX/lK7uPFixfn7n/7YW1tbfrBD36Qe/ylL30p0H/m7wqbroAj2WxWX/jCF/SLX/xCkhSPx/XUU09pzpw5jisDADusaygWes0OuQEAYIdzqJ3Zs2frU5/6lKSztw+47bbbtGXLli5fc/ToUd1+++3avXu3pLOvcv32t79d9FoLIfzbxpB0duBramoUj7OPHhY/+9nPtGTJktzja6+9VmvXrtXatWt79f2PPvpooUrrkS+9VldXp+bm5i7H3nvvvdzHjY2NmjBhwgXf19DQoOHDhxe6vC58yQx26LXeY10rHa4zC2uvuUZupcP1jIYRmdkhNxSL614L4znUdWad/uVf/kU33nijDhw4oH379mnChAmaOnWqrr32Wh0+fFgrVqxQW1ubpHOvHr7sssuc1RtkXmy6RkQikdDEiRNdlwEDhw4d6vJ4165d2rVrV6+/39UffHzptR07dmj//v15P3/69Gn94Q9/uOD4Bx98UMiyuuVLZrBDr/Ue61rpcJ1ZWHvNNXIrHa5nNIzIzA65oVhc91oYz6GuM+t05ZVXauXKlZo/f742b96sbDar1atXa/Xq1V2+bvDgwXryySe73AfWhUQiEdjP4q+jIiKdTmvTpk1evJMfoo1eM0dmKBZ6zQ65mSMzwG/MqDkys0NuKBZ6zZxPmY0dO1YbNmzQkiVLdOutt+qqq67SJZdcoiFDhmjy5Mn6h3/4B+3YsUOzZ892XWqgebHpGhGZTEZNTU3O38kPvbdw4UJls1nr/1zxpdf27dtnldvVV19d9Fp9yQx26LXeY10rHa4zC2uvuUZupcP1jIYRmdkhNxSL614L4znUdWYfdskll+juu+/Wr3/9azU1Nam9vV0HDx7U+vXr9fDDD2vQoEGuS5SkQPNi0xUAAAAAAAAAAsSmKwAAAAAAAAAEiE3XiIjH4xozZozzd6VD9NFr5sgMxUKv2SE3c2QG+I0ZNUdmdsgNxUKvmSMzO0HmlQzsJ8GpRCKhsWPHui4DJYBeM0dmKBZ6zQ65mSMzwG/MqDkys0NuKBZ6zRyZ2UkkEoH9LLa7IyKVSmndunVKpVKuS0HE0WvmyAzFQq/ZITdzZAb4jRk1R2Z2yA3FQq+ZIzM7QebFpmtEZLNZHT58mHeWRcHRa+bIDMVCr9khN3NkBviNGTVHZnbIDcVCr5kjMztB5sWmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64RkUgkNGHChEBv+At0h14zR2YoFnrNDrmZIzPAb8yoOTKzQ24oFnrNHJnZCTKvZGA/CU7F43GNHDnSdRkoAfSaOTJDsdBrdsjNHJkBfmNGzZGZHXJDsdBr5sjMTjwe3OtTeaVrRKRSKa1cuZJ3pUPB0WvmyAzFQq/ZITdzZAb4jRk1R2Z2yA3FQq+ZIzM7QebFpmtEZLNZtbS08K50KDh6zRyZoVjoNTvkZo7MAL8xo+bIzA65oVjoNXNkZifIvNh0BQAAAAAAAIAAsekKAAAAAAAAAAFi0zUiEomEamtreVc6FBy9Zo7MUCz0mh1yM0dmgN+YUXNkZofcUCz0mjkysxNkXsnAfhKcisfjGjJkiOsyUALoNXNkhmKh1+yQmzkyA/zGjJojMzvkhmKh18yRmZ14PLjXp/JK14jo6OjQsmXL1NHR4boURBy9Zo7MUCz0mh1yM0dmgN+YUXNkZofcUCz0mjkysxNkXmy6RkgqlXJdAkoEvWaOzFAs9JodcjNHZoDfmFFzZGaH3FAs9Jo5MnOLTVcAAAAAAAAACBCbrgAAAAAAAAAQIDZdIyKZTGr69OlKJnlvNBQWvWaOzFAs9JodcjNHZoDfmFFzZGaH3FAs9Jo5MrMTZF5sukZIv379XJeAEkGvmSMzFAu9ZofczJEZ4Ddm1ByZ2SE3FAu9Zo7M3GLTNSJSqZQaGhq4STIKjl4zR2YoFnrNDrmZIzPAb8yoOTKzQ24oFnrNHJnZCTIv403XNWvWqL6+XsOHD1csFtPzzz/f5fPZbFY/+MEPNGzYMPXr10+zZs3Srl27gqoXAID/n737j66qvvP9/zo/IiUmYJAfAiUoWggtw4RxdAzcDogw9gbhjqUzt2Bbte2d8UdrW297r71d/YrTzqVzp+2arussrbO6EDodnU7b0XsvkSoDaBEUqdDwQxmEQtSAID+DQcg5Z3//oDkS84N8dvbZn89nn+djLdbK2TlJ3vt13p/P3vnksDcAAAAAAE5LBUEQmHzBU089peeff15XX321Pv7xj+tf//Vf9ad/+qfFz//N3/yNli5dquXLl+uKK67QN7/5TW3btk07d+7UBz7wgQt+/5MnT2ro0KGSTqiqaoimTDHdpfKyd6/U3i5JgXK5vLLZjMaOTenVV21X5q5Ro6RDh7puGzlSeustO/X4oq5OevNN6fxeq6xMacIE25W5q6fxSWYXtn27dOpU122M0b4xPsNhjJrjvCMczj3M9ZRZVZX43eACmNfMkVk4HA/MMa+Fwxg1x/gcmCNHjmj48OE6ceKEhgwZMqDvZbzo2uWLU6kui65BEGjMmDH6r//1v+qrX/2qJOnEiRMaNWqUHn30UX3yk5+84Pc8f9FVGtjOlauqKqmtzXYV7qqu7r6gQ2YX1lNuQFwYo31jfMImxueFce5hjnkN8A/zWt+Y12AT47P/olx0jfQWZr/97W918OBBzZkzp7ht6NCh+qM/+iNt3Lixx0XXM2fO6MyZM8XHJ0+ejLKkMhWocyn9/dei6LwL2/u3V1RUqFAoKJ/PF7elUills9let+fzeRUKheL2dDqtTCbT6/ZcLqfz1/gzmYzS6XSv2zs6OvpVu+k+9dz2gaSUt/sUx+vUmRFgR6COjnPjIQnjKfo5IivGJ+w5d3xIzng6J8o5ordjqM/7VOrX6XdVCIBPAuXzhcTO5QPdJ87XYFuSxlMp54goRbroevDgQUnSqFGjumwfNWpU8XPvt3TpUj3wwANRllH2crm82traNXjwYDU1NXX5XGNjo06fPq21a9cWt2WzWc2bN09vv/22Nm7cWNxeXV2t2bNn6/XXX9fWrVuL20eMGKHp06dr9+7d2rVrV3F7bW2tpk2bpubmZrW0tBS3T5o0SXV1ddq0aZMOHz5c3F5fX6/x48frueeeU9t5f3JpaGjQyJEj9fTTT3cZENdff30k+yTN7pZZPl+QlPF2n+J4nc5NQpFOGUC/5XL54jhJwniKeo7I5eaJ8Qlbcrlzx4ekjCcp+jmi8zzj/Xzep1K/Trlcb38oB+CqXC6v5uZtiZ3LB7pPQTBfLLrCpiSNp1LOEefedBaNSC8vsGHDBs2YMUOtra0aPXp08Xl//ud/rlQqpX/+53/u9j16eqfruHHjxOUFwquqCtT5hmH+YtG99pqabA//xS9QWxvvdO1rn6qrA506xUkC7KiqCnT0KO907W37sGFZxies6TyGJmU8dYpyjujpGFpVJR075u8+lfp1GjJEzGuAZ6qqAh0/zjtde9snztdgU1WVdPRocsZTKeeIo0eP6rLLLnPv8gKXXXaZJOmtt97qsuj61ltvqb6+vsevGTRokAYNGtRt+8UXB7r4YnFx5Avo6YYzlZUppX43l1dUVPT4dT1tT6fTPa7o97Y9k8n87r/M9W971/8uduHtJrX3tr2n2isre85M8nef+toe1T5VVqZ6vB4dF37vHRd9D6e3C7+/fzz4PJ6iniN6mtcYnxfGGDXX23mHlJzxdL6o9qmnY2hlpd/7VOrXaexYbhAYBvOaOTILp7fjQee8kMS5fKD7xLwWDmPUXM/jM1njqa8aTbe/v/beflYYkS66XnHFFbrsssv0b//2b8VF1pMnT+rFF1/UnXfeafS99u/P6dJLo6wumRoapBde6LqNyadvEyZ0v2skmV1YT7lNmSKd9y589KKjI6empiY1Njb2OvmjO3LrP8bnwNBr/cd5Rzice5jrvMMy4zMccjNHZmY4HphjXhsYcus/xqc7jBddT506pddee634+Le//a22bt2qYcOGqba2Vl/+8pf17W9/Wx/60Id0xRVX6Jvf/KbGjBlTvAQBAJSjKP9aVk7IDXGh1wB3MT7DITdzZIa40GvhkBt8Y9yxmzdv1vXXX198fO+990qSbr31Vj366KP6b//tv+mdd97RX/zFX+j48eP6D//hP2jVqlX6wAc+YPRz+MsFgKSoqKjQvHnzbJfhHXJDXOg1wF2Mz3DIzRyZIS70WjjkhrhEuR5pfEuuWbNmKQiCbv8effRRSeculvtXf/VXOnjwoN59912tXr1aEydONC7s/AvqAoDPCoWCDh06xLxmiNwQF3oNcBfjMxxyM0dmiAu9Fg65IS5R9pjxomtczr9zGAD4LJ/Pa+PGjcxrhsgNcaHXAHcxPsMhN3NkhrjQa+GQG+ISZY85u+gKAAAAAAAAAD5i0RUAAAAAAAAAIuTsomsqlbJdAgBEIpVKqbq6mnnNELkhLvQa4C7GZzjkZo7MEBd6LRxyQ1yi7LFsZN8pYtmss6UBgJFsNqvZs2fbLsM75Ia40GuAuxif4ZCbOTJDXOi1cMgNcYlyPdLZd7pyRzoASVEoFLR//37mNUPkhrjQa4C7GJ/hkJs5MkNc6LVwyA1xibLHnF105Y50AJIin89r69atzGuGyA1xodcAdzE+wyE3c2SGuNBr4ZAb4hJljzm76AoAAAAAAAAAPmLRFQAAAAAAAAAi5OyiK3ekA5AUqVRKI0aMYF4zRG6IC70GuIvxGQ65mSMzxIVeC4fcEJcoeyy6W3JFLMq7hQGATdlsVtOnT7ddhnfIDXGh1wB3MT7DITdzZIa40GvhkBviEuV6pLPvdOXiyACSIp/P69VXX2VeM0RuiAu9BriL8RkOuZkjM8SFXguH3BCXsriRVqFQsF0CAESiUCho165dzGuGyA1xodcAdzE+wyE3c2SGuNBr4ZAb4hJljzm76AoAAAAAAAAAPmLRFQAAAAAAAAAi5OyiazrtbGkAYCSdTqu2tpZ5zRC5IS70GuAuxmc45GaOzBAXei0cckNcouyx6G7JFbFMJmPtZ7/99tt6/vnntWnTJm3btk179uxRa2urTp06pYqKCtXU1GjKlCmaNWuWPvOZz2js2LHWanXNvn379Mwzz+jZZ5/Vtm3b1NLSolOnTqm6ulof/OAH1dDQoMWLF2vmzJm2S4XnfOq1TCajadOm2S7Dq8wkcvOZb5m50Guce4TjW6/BnAvj00eu5JbP57Vjxw699NJL2rx5s1566SU1Nzero6NDkjRz5kytW7fObpG/40pmSD56LRxyQ1wiXY8MHHPixIlAUnD06FFrNcybNy+Q1K9/gwYNCpYsWRLk83krtV53XRBIXf9dd138dbz88svBtdde2+/cZs2aFezfvz/+QgN3MvONK7n51Gudcrlc8PLLLwe5XM7Kz/cxsyAgNxOMz4Gx3WtB4M+5B70Wjiu5+ciF8ekjF3L713/916CysrLPsTlz5kxr9b2fC5n5hHktPHotHHLrP8bnwBw9ejSQFJw4cWLA38vZd7q6cke64cOHa/LkyRo/fryqqqrU3t6u1157TZs2bVIul9OZM2e0ZMkS7d27V8uXL7ddrjW7du3Spk2bumybOHGipkyZouHDh+v48ePasGGD3njjDUnSunXr1NDQoF/96leaMGGCjZLhKR97rVAoqKWlRVOmTLHyLn4fM5PIzUe+Zma7196Pc48L87XXYM618ekLF3I7fvy42tvbrfzsMFzIDOWBXguH3BCXKNcjnV10tWnWrFmaP3++brjhBl111VU9Puett97SV77yFT322GOSpBUrVmj+/Pn6xCc+EWepzrnqqqv0+c9/Xp/61Ke6/dfHQqGgRx99VF/84hfV3t6u1tZW3XLLLdqwYYNSqZSliuEres0cmYVDbubIzBznHuHQa4D7Ro0apWuuuab475e//KV+8IMf2C4LAICSY9G1B1/96lcv+JxRo0bpJz/5id566y2tWbNGkvTDH/6wbH/xGT16tJYtW6ZPf/rTvf7VKZ1O67Of/axqamr08Y9/XJL0wgsv6Omnn9aNN94YZ7nwGL1mjszCITdzZBYe5x5m6DXAfR/72Me0f/9+1dbWdtn+4osvWqoIAIB4OXvbNx/uSJdKpXT77bcXH2/ZssViNXbNnDlTt912W7/e5n/zzTfr2muvLT5euXJlKUtDwvjYa+l0WpMmTbI2r/mYmURuPvI1M9u9ZoJzj3N87TWY82l8usSF3C677LJuC64ucyEzlAd6LRxyQ1yi7DFnu9WXa3SMGDGi+HFbW5vFSvwyY8aM4sf79u2zVwgSz4Vey2Qyqqur82ZecyEzidzKgSuZ+dZrnHuYc6XXYM638ekKcjNHZogLvRYOuSEuUfaYs4uuuVzOdgn9snPnzuLHl19+ub1CPHP+tdTy+bzFSpB0LvRaLpfThg0bvJnXXMhMIrdy4EpmvvUa5x7mXOk1mPNtfLqC3MyRGeJCr4VDbohLlD3m7KJrEAS2S7ig1tZWffe73y0+LsdrqoW1bdu24sfjxo2zWAmSzoVeC4JAhw8f9mJek9zITCK3cuBKZj71Guce4bjSazDn0/h0CbmZIzPEhV4Lh9wQlyh7zNlFV1e1t7dr586d+t73vqdp06aptbVVkjR58mTdd999lqvzQ0tLS/EGIJI0Z84ci9Ugyeg1c2QWDrmZI7P+49xjYOg1AAAA2JC1XYDr1q9fr49+9KN9PqexsVE/+clPVF1dHVNVfrv33nuL/7WvtrZW8+fPt1wRkopeM0dm4ZCbOTLrHece0aLXAAAAYIOz73T14eLINTU1euyxx7Ry5UpdcskltsvxwvLly/Xzn/+8+Hjp0qUaNGiQxYqQVC71WiaTUX19vfPzmkuZSeSWZK5l5kuvSZx7mHKt12DOp/HpEnIzR2aIC70WDrkhLlH2mLPvdE2n3VgPHjNmjO6++25J567r0NbWpl27dunll1/WsWPHtGjRIj3yyCN6+OGHNXHiRMvVum3z5s264447io8XLVqkxYsXW6wISeVar6XTaY0fP97az+8P1zKTyC2pXMzMtV7j3CMaLvYazLk2Pn1BbubIDHGh18IhN8QlyvVIN1Y2e+DKHekmTJigBx98UA8++KD+/u//XitWrNCLL76o/fv367bbbpMkrV27Vtddd52am5vtFuuw3/72t5o/f77effddSdLUqVP18MMPW64KSeRir+VyOa1Zs8aZee39XMxMIrckcjUz13qNc4+Bc7XXYM618ekLcjNHZogLvRYOuSEuUfaYs4uurt+RbsyYMVq2bJnuueceSdKxY8f0yU9+snjNMLznwIEDmjt3rg4ePCjp3C+Tq1at0pAhQyxXhqRxtdc636nm4rzmamYSuSWNy5m53Gvn49yjf1zuNZjzZXy6htzMkRniQq+FQ26IS5Q95uyiqy+WLl1aPIl/5ZVX9NRTT1muyC1HjhzR3LlztWfPHknS6NGjtXr1ao0ePdpyZUgaes0cmYVDbubILFqce/SOXgMAAIArWHQdoMrKSk2fPr34+Pnnn7dYjVtOnjypG2+8UTt27JAkDR8+XKtXr9YVV1xhuTIkDb1mjszCITdzZBY9zj16Rq8BAADAJc4uuvp0R7qamprix0eOHLFYiTveeecdNTY26te//rUkaejQoVq1apU+/OEPW64MSeNDr2UyGTU0NDgzr/mQmURuSeBLZq71Wn9w7tGVL70Gcz6OTxeQmzkyQ1zotXDIDXGJsseykX2niEV5t7BSO3DgQPHjYcOGWazEDe+++64WLFhQfOdNZWWlVq5cqauvvtpyZUgaX3otnU5r5MiRtsuQ5E9mErn5zqfMXOq1/uLc4z0+9RrM+Tg+XUBu5sgMcaHXwiE3xCXK9UhnVzY7Ojpsl9AvR44c0caNG4uPJ0+ebLEa+zo6OrRw4UKtWbNGkjRo0CA9+eSTmjFjhuXKkDQ+9VpHR4dWrlxpfV7zKTOJ3HzmW2au9Fp/ce7xHt96DeZ8G5+uIDdzZIa40GvhkBviEmWPObvoasvRo0f7/dxCoaAvfOELOnPmjKRzJ/o33XRTqUpzXj6f1+LFi9XU1CRJymaz+ulPf6o5c+ZYrgxJ42Ov5XI5qz/fx8wkcvORr5nZ7DXOPcLxtddgzvaxwFfkZo7MEBd6LRxyg29YdH2fFStW6JprrtGKFSt08uTJXp/X3NysxsZGPf7448VtX/va13TppZfGUaZzgiDQ5z73Of3sZz+TdO7t2D/+8Y+1YMECy5Uhaeg1c2QWDrmZI7NwOPcwR68BAADAdc5e09WmzZs369Zbb1U2m1VdXZ0mTZqkmpoapVIpHTlyRM3NzXrttde6fM3ChQt1//33W6rYvoceekjLly8vPr7yyiu1fv16rV+/vl9f/+CDD5aqNCQMvWaOzMIhN3NkFh7nHmboNcAPjY2Nam1t7bLt4MGDxY83b96s+vr6bl/X1NSkMWPGlLo8AABKytlF12zWTmmDBg0qfpzL5bR9+3Zt37691+dXV1dryZIl+tKXvlTWd9E7dOhQl8e7d+/W7t27+/31/PKD/vKx17LZrK6//npr85qPmUnk5iNfM7Pda5x7mPO112DO9vj0lSu57dy5U/v37+/18++8845+85vfdNt+9uzZUpbVI1cyQ/LRa+GQG+ISZY/Rre9z55136oYbbtDq1av14osvaseOHWppadHx48clSUOGDNHo0aNVX1+vOXPmaOHChaqqqrJbNADnDR482HYJXiI3xMVmr3HuAfSNY0E45GaOzBAXei0ccoNvUkEQBLaLON/Jkyc1dOhQvf3222V5jTJTDQ3SCy903XbdddJ5NzXG+5BZOOQWXkdHh5qamtTY2KiKigrb5XiD3PqP8Tkw9Fr/0WvhkFt4jM9wyM0cmZlhXguPXguH3PqP8TkwR44c0fDhw3XixAkNGTJkQN+LG2kBAAAAAAAAQIRYdAUAAAAAAACACLHoCgAAAAAAAAARcnbRlTvSAUiKbDarxsZG5jVD5Ia40GuAuxif4ZCbOTJDXOi1cMgNcYmyx5xddAWAJDl9+rTtErxEbogLvQa4i/EZDrmZIzPEhV4Lh9zgG2cXXXO5nO0SACASuVxOa9euZV4zRG6IC70GuIvxGQ65mSMzxIVeC4fcEJcoe8zZRVcAAAAAAAAA8BGLrgAAAAAAAAAQIRZdASAGXPA9HHJDXOg1wF2Mz3DIzRyZIS70WjjkBt8427EVFRW2SwCASFRUVGjevHm2y/AOuSEu9BrgLsZnOORmjswQF3otHHJDXKJcj3T2na6FQsF2CQAQiUKhoEOHDjGvGSI3xIVeA9zF+AyH3MyRGeJCr4VDbohLlD3m7KJrPp+3XQIARCKfz2vjxo3Ma4bIDXGh1wB3MT7DITdzZIa40GvhkBviEmWPObvoCgAAAAAAAAA+YtEVAAAAAAAAACLk7KJrKpWyXQIARCKVSqm6upp5zRC5IS70GuAuxmc45GaOzBAXei0cckNcouyxbGTfKWLZrLOlAYCRbDar2bNn2y7DO+SGuNBrgLsYn+GQmzkyQ1zotXDIDXGJcj3S2Xe6ckc6AElRKBS0f/9+5jVD5Ia40GuAuxif4ZCbOTJDXOi1cMgNcYmyx5xddOWOdACSIp/Pa+vWrcxrhsgNcaHXAHcxPsMhN3NkhrjQa+GQG+ISZY85u+gKAAAAAAAAAD5i0RUAAAAAAAAAIuTsoit3pAOQFKlUSiNGjGBeM0RuiAu9BriL8RkOuZkjM8SFXguH3BCXKHssultyRSzKu4UBgE3ZbFbTp0+3XYZ3yA1xodcAdzE+wyE3c2SGuNBr4ZAb4hLleqSz73Tl4sgAkiKfz+vVV19lXjNEbogLvQa4i/EZDrmZIzPEhV4Lh9wQl7K4kVahULBdAgBEolAoaNeuXcxrhsgNcaHXAHcxPsMhN3NkhrjQa+GQG+ISZY+VZNG1ra1NX/7ylzV+/HgNHjxY06dP10svvVSKHwUAAAAAAAAATinJhVM///nPa/v27frxj3+sMWPG6B//8R81Z84c7dy5U2PHju3X9xg/PquLL5YmTChFhcmxfXv3bXv3xl+HT3rKh8wujNzM1dVJb74pSVnlcvOUzWZUWcm8diF790rt7RK59R/HgnAYo+botXB6ymj7dqmhIf5afMGxIJyechs7Vnr1VduVIWn43cAc5x3hMK+Z47wjnM5eC4LolkpTQRAEkX03SadPn1Z1dbWefPJJzZs3r7j96quv1n/8j/9R3/72t/v8+pMnT2ro0KGSTkgaEmVpZaOqSmprs12Fu6qrpVOnum4jswsjN3M9ZQbEhfF5YYzRaNBrF0avwSbGaP/k83k1Nzdr6tSpymQytstxHr8bmONYEB16rW/02kCdlDRUJ06c0JAhA1uXjPydrrlcTvl8Xh/4wAe6bB88eLDWr1/f7flnzpzRmTNnio9PnjwZdUllKFDnUnoul+vymc67sL1/e0VFhQqFQpcLBqdSKWWz2V635/P5Lte6SKfTymQyvW7P5XI6f40/k8konU73ur2jo6NftZvuU89tH0hKebtPcbxOnRm9n8/7VOrX6Vxe3TMD4hGooyOXmPFUijni3PGAMTpw544PSZ3Lo9in3o6hQDzOHQ+kZIynUs4R9fX1yuVyXb6/7/vUU+1R7FPPx9BA+XzB230q9evEeUe0kjSe4vrdHfGLfNG1urpaDQ0N+ta3vqXJkydr1KhReuyxx7Rx40ZdddVV3Z6/dOlSPfDAA1GXUdZyubza2to1ePBgNTU1dflcY2OjTp8+rbVr1xa3ZbNZzZs3T2+//bY2btxY3F5dXa3Zs2fr9ddf19atW4vbR4wYoenTp2v37t3atWtXcXttba2mTZum5uZmtbS0FLdPmjRJdXV12rRpkw4fPlzcXl9fr/Hjx+u5555T23l/pmpoaNDIkSP19NNPd5m4rr/++kj2SZrdLbN8viAp4+0+xfE6nTsodJ8yfN6nUr9OudywHjMD4pDL5dXU1JSY8VSKOaJQmC9OSAculzt3fEjqXB7FPnWeZwA2dB4PpGSMp1LNETNnztSePXv0xhtvJGafSvk65fM36f3zWi6XV3PzNm/3qdSvUxBw3hGlJI2nuH53R/wiv7yAJO3Zs0ef/exn9dxzzymTyegP/uAPNHHiRP3617/WK6+80uW5Pb3Tddy4ceLyAuFVVQXqfMOwD3+FifsvSzU12R7+K0ygtjbe6drXPlVXBzp1qutJQlWVdPSov/tU6tdp6NBUt8yAuFRVBTp6lHe69rVPw4ZlGaMR6DyGJnUuj2KfejqGAnHpPB5IyRhPpZojgiDQU089pblz56qioiIR+1TK16mnY2hVVaDjx3mna2/7xHlHdKqqpOPHkzOe4vjdHSaiu7xASRZdO73zzjs6efKkRo8erf/8n/+zTp06pZUrV/b5Nedf07WqaoimTClVdcnw3kWlA+Vy+d9dVDrFRaX7MGqUdOhQ120jR0pvvWWnHl+Qm7meMquqEvPaBfQ0r1VWprjJQB84FoTDGDVHr4Xz3s1TmNf6i2NBONu3d7+OH+dr/dPR0aGmpiY1NjZ2WXRFz/jdwBznHeEwr5njvCOc93rN4Wu6nu/iiy/WxRdfrGPHjumXv/yl/tf/+l9GXz9linTeO7HRh46OHCcJ/TRhQveDHZPPhZGbuZ4yY17rP+Y1c2RmhjEaHr1mpnNRmtzMkZmZhgbphRe6buN8DaXA7wbmOO8Ih3nNHOcd4fTUawNVkkXXX/7ylwqCQJMmTdJrr72mr33ta6qrq9Ptt99eih8HnXt7+aRJk3530WQA8B/zmjkyQ1zotXDIzRyZIS70GoCkYV6zrySLridOnNDXv/51vfHGGxo2bJgWLlyov/7rv2ZlvYQymYzq6upslwEAkWFeM0dmiAu9Fg65mSMzxIVeA5A0zGv2lWS5+8///M+1Z88enTlzRgcOHNCDDz74u+u0olRyuZw2bNjQ7eLNAOAr5jVzZIa40GvhkJs5MkNc6DUAScO8Zh/vMU6IIAh0+PBhlfC+aAAQK+Y1c2SGuNBr4ZCbOTJDXOg1AEnDvGYfi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6JkQmk1F9fb0ymYztUgAgEsxr5sgMcaHXwiE3c2SGuNBrAJKGec2+rO0CEI10Oq3x48fbLgMAIsO8Zo7MEBd6LRxyM0dmiAu9BiBpmNfs452uCZHL5bRmzRruSgcgMZjXzJEZ4kKvhUNu5sgMcaHXACQN85p9LLomRBAEamtr4650ABKDec0cmSEu9Fo45GaOzBAXeg1A0jCv2ceiKwAAAAAAAABEiEVXAAAAAAAAAIgQi64Jkclk1NDQwF3pACQG85o5MkNc6LVwyM0cmSEu9BqApGFesy9ruwBEI51Oa+TIkbbLAIDIMK+ZIzPEhV4Lh9zMkRniQq8BSBrmNft4p2tCdHR0aOXKlero6LBdCgBEgnnNHJkhLvRaOORmjswQF3oNQNIwr9nHomuC5HI52yUAQKSY18yRGeJCr4VDbubIDHGh1wAkDfOaXSy6AgAAAAAAAECEWHQFAAAAAAAAgAix6JoQ2WxW119/vbJZ7o0GIBmY18yRGeJCr4VDbubIDHGh1wAkDfOafSy6JsjgwYNtlwAAkWJeM0dmiAu9Fg65mSMzxIVeA5A0zGt2seiaELlcTk1NTdYvkpzP59Xc3Kwf/ehHuvPOO/WHf/iHuuiii5RKpZRKpTRr1iyr9bnm7bff1pNPPqlvfOMbWrBggT7ykY+opqZGFRUVqqys1NixY3XjjTdq6dKlevPNN22X65R9+/bpH/7hH/SpT31Kv//7v1/MbdiwYZo6dar+8i//Us8++6ztMp3iW2auzGs+cSUz33oN5lzpNd+4kptPY9SFzDhfC8+n3w1c6DUA7uMYChO8xxiReeKJJ3TLLbeovb3ddineuO2227Ry5coeP5fL5XT69Gm1trbq6aef1gMPPKCvf/3r+uY3v6l0unz/XrJlyxbdcccd2rRpU4+fP3bsmI4dO6Zt27bpkUce0axZs7R8+XLV1tbGXKk7yAxxodcAtzFGw+F8LRx+NwCQJBxDEQaLrojM8ePHOakagOHDh2vy5MkaP368qqqq1N7ertdee02bNm1SLpfTmTNntGTJEu3du1fLly+3Xa41u3bt6nagmzhxoqZMmaLhw4fr+PHj2rBhg9544w1J0rp169TQ0KBf/epXmjBhgo2SrSMzxIVeA9zGGB04ztf6j98NACQJx1CEwaIrIjdq1Chdc801xX+//OUv9YMf/MB2WU6aNWuW5s+frxtuuEFXXXVVj89566239JWvfEWPPfaYJGnFihWaP3++PvGJT8RZqnOuuuoqff7zn9enPvUpjR07tsvnCoWCHn30UX3xi19Ue3u7Wltbdcstt2jDhg1KpVKWKraPzBAXeg1wG2PUDOdrA8PvBgCShGMojASOOXHiRCApkE4E111nuxp/FAqF4OzZs0GhULBWw4EDB4L9+/d3237//ff/7jVVMHPmzPgLe5/rrgsCqes/13utUCgEs2fPLuY4Z86c2GtwJbd169YFy5YtC3K53AWf+4tf/KKYmaRg1apVMVT4HjIbGBfmNd/Yzsy3XnNljPrIdq/5ynZuvo3RILCfmQnO17ry5XeDTj71mgtc6jVfkFk4ruTGMTT53uu1c+uSJ06cGPD3LO8LDSXM6dOnrf78yy67jOuVlEgqldLtt99efLxlyxaL1dg1c+ZM3XbbbcpkMhd87s0336xrr722+Li367Elnc+Z2Z7XfGQzM597DeYYn+EwRs350mucr3Xl4+8GvvQagPhxDEUYLLomRC6X09q1a7krXYKNGDGi+HFbW5vFSvwyY8aM4sf79u2zV4hHXMmMec2cb5m50msw51uvucK33FwYo75lxvmav3zrNQBu4xgKiUVXwBs7d+4sfnz55ZfbK8Qz5187J5/PW6zEH2SGuNBrgNsYo+Y4XwMASBxDcQ6LroAHWltb9d3vfrf4mJsy9N+2bduKH48bN85iJf4gM8SFXgPcxhg1w/kaAKATx1BILLomSjabtV0CItTe3q6dO3fqe9/7nqZNm6bW1lZJ0uTJk3XfffdZrs4PLS0tWrNmTfHxnDlzLFbjB9cyY14z50tmrvUazPnSa67xJTeXxqjLmXG+liwu9xoAf3AMRSfST4iKigrNmzfPdhkYgPXr1+ujH/1on89pbGzUT37yE1VXV8dUld/uvffe4n/lqK2t1fz58y1X5D6XMmNeM+dTZi71Gsz51Gsu8Sk3V8aoa5lxvpZcrvUaAH9xDEUn3umaEIVCQYcOHVKhULBdCkqgpqZGjz32mFauXKlLLrnEdjleWL58uX7+858XHy9dulSDBg2yWJH7XMuMec2cL5m51msw50uvucaX3Fwao75kJnG+5jufeg2AuziG4nwsuiZEPp/Xxo0buUCzx8aMGaO7775bd999t+666y59+tOf1rXXXqtsNqtjx45p0aJFmj17tv793//ddqnO27x5s+64447i40WLFmnx4sUWK3Kfi5kxr5nzITMXew3mfOg1F/mQm2tj1LXMOF9LLtd6DYB/OIbi/bi8AOCICRMm6MEHH+y2vbW1Vd/4xjf06KOPau3atbruuuu0bt06TZ061UKV7vvtb3+r+fPn691335UkTZ06VQ8//LDlqtxGZogLvQa4jTF6YZyvAQB6wjEUPeGdroDjxowZo2XLlumee+6RJB07dkyf/OQn+WtVDw4cOKC5c+fq4MGDks79YrRq1SoNGTLEcmXuIjPEhV4D3MYYHRjO1wCgfHEMRW9YdE2IVCql6upqpVIp26WgRJYuXVqctF955RU99dRTlityy5EjRzR37lzt2bNHkjR69GitXr1ao0ePtlyZu1zPjHnNnKuZud5rMOdqr7nO1dxcHqOuZtYbztf85VuvAXADx1D0hUXXhMhms5o9e7ayWa4YkVSVlZWaPn168fHzzz9vsRq3nDx5UjfeeKN27NghSRo+fLhWr16tK664wnJl7vIhM+Y1cy5m5kOvwZyLveYDF3NzfYy6mFlfOF/zl2+9BsA+jqG4EBZdE6JQKGj//v3clS7hampqih8fOXLEYiXueOedd9TY2Khf//rXkqShQ4dq1apV+vCHP2y5Mnf5khnzmjnXMvOl12DOtV7zhWu5+TBGXcusPzhf85OPvQbAHo6h6A8WXRMin89r69atXDcq4Q4cOFD8eNiwYRYrccO7776rBQsWFN9FUllZqZUrV+rqq6+2XJm7fMqMec2cS5n51Gsw51Kv+cSl3HwZoy5l1l+cr/nJx14DYAfHUPQXi66AJ44cOaKNGzcWH0+ePNliNfZ1dHRo4cKFWrNmjSRp0KBBevLJJzVjxgzLlbmLzBAXeg1wG2O0dDhfA4Bk4xgKEyy6ApYcPXq0388tFAr6whe+oDNnzkg6N7HfdNNNpSrNefl8XosXL1ZTU5Okc9eq+elPf6o5c+ZYrsxdZIa40GuA2xijZjhfAwB04hgKUyy6JkQqldKIESO4K51HVqxYoWuuuUYrVqzQyZMne31ec3OzGhsb9fjjjxe3fe1rX9Oll14aR5nOCYJAn/vc5/Szn/1MkpROp/XjH/9YCxYssFyZu3zNjHnNnO3MfO01mLPda76ynZuPY9R2ZpyvlQ/bvQbAbRxDEQa3MEuIbDbb5U6ptjQ2Nqq1tbXLtoMHDxY/3rx5s+rr67t9XVNTk8aMGVPq8pyzefNm3Xrrrcpms6qrq9OkSZNUU1OjVCqlI0eOqLm5Wa+99lqXr1m4cKHuv/9+SxXb99BDD2n58uXFx1deeaXWr1+v9evX9+vrH3zwwVKV5ixfM3NlXvOJ7cx87TWYs91rvrKdm49j1HZmEudrA+HT7wYu9BoAd3EMRRgsuiZEPp/X7t279aEPfUiZTMZaHTt37tT+/ft7/fw777yj3/zmN922nz17tpRlOWnQoEHFj3O5nLZv367t27f3+vzq6motWbJEX/rSl6y+xrYdOnSoy+Pdu3dr9+7d/f76clzU8TUzV+Y1n9jOzNdegznbveYr27n5OEZtZ8b52sD49LuB7V4D4DaOoQiDRdeEKBQK2rVrl6688koGkyfuvPNO3XDDDVq9erVefPFF7dixQy0tLTp+/LgkaciQIRo9erTq6+s1Z84cLVy4UFVVVXaLBmLEvGaOzBAXei0ccjNnOzPO18qH7V4DgKgxr9nHoisitW/fPtsleGXixImaOHGi7rrrLtuleGPJkiVasmSJ7TK8QmaIC70GuI0xGg7na+HxuwGApOAYijC4kRYAAAAAAAAARIhF14RIp9Oqra1VOs1LCiAZmNfMkRniQq+FQ27myAxxodcAJA3zmn1cXiAhMpmMpk2bZrsMAIgM85o5MkNc6LVwyM0cmSEu9BqApGFes4/l7oTI5/PasmWL8vm87VIAIBLMa+bIDHGh18IhN3NkhrjQawCShnnNPhZdE6JQKKilpUWFQsF2KQAQCeY1c2SGuNBr4ZCbOTJDXOg1AEnDvGYfi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6JkQ6ndakSZO4Kx2AxGBeM0dmiAu9Fg65mSMzxIVeA5A0zGv2ZW0XgGhkMhnV1dXZLgMAIsO8Zo7MEBd6LRxyM0dmiAu9BiBpmNfsY7k7IXK5nDZs2KBcLme7FACIBPOaOTJDXOi1cMjNHJkhLvQagKRhXrOPRdeECIJAhw8fVhAEtksBgEgwr5kjM8SFXguH3MyRGeJCrwFIGuY1+1h0BQAAAAAAAIAIsegKAAAAAAAAABFi0TUhMpmM6uvrlclkbJcCAJFgXjNHZogLvRYOuZkjM8SFXgOQNMxr9mVtF4BopNNpjR8/3nYZABAZ5jVzZIa40GvhkJs5MkNc6DUAScO8Zh/vdE2IXC6nNWvWcFc6AInBvGaOzBAXei0ccjNHZogLvQYgaZjX7GPRNSGCIFBbWxt3pQOQGMxr5sgMcaHXwiE3c2SGuNBrAJKGec0+Fl0BAAAAAAAAIEIsugIAAAAAAABAhFh0TYhMJqOGhgbuSgcgMZjXzJEZ4kKvhUNu5sgMcaHXACQN85p9WdsFIBrpdFojR460XQYARIZ5zRyZIS70WjjkZo7MEBd6DUDSMK/ZxztdE6Kjo0MrV65UR0eH7VIAIBLMa+bIDHGh18IhN3NkhrjQawCShnnNPhZdEySXy9kuAQAixbxmjswQF3otHHIzR2aIC70GIGmY1+yKfNE1n8/rm9/8pq644goNHjxYV155pb71rW8pCIKofxQAAAAAAAAAOCfya7r+zd/8jR566CEtX75cH/nIR7R582bdfvvtGjp0qO655x6j77V9u9TQEHWFybJ3r9TeLklZ5XLzlM1mNHas9Oqrtitz19693bfRaxe2fXv3bT1liff0lA+ZXVhdnfTmm9L581plpTRhgu3K3NXTsYDMLox5zRzjMxzGqDkyC4d5zRzzWjj0mjl+NwiH39/NsU4UTinGYyqI+C2oN910k0aNGqUf/ehHxW0LFy7U4MGD9Y//+I8X/PqTJ09q6NChkk5IGhJlaWWjqkpqa7Ndhbuqq6VTp2xXkQz0Wt966jUyuzDGKGxijPaN8Qn4h3mtb8xr0aHX+sbvBuEwRqNBr13Ye712UtJQnThxQkOGDGxdMvJ3uk6fPl2PPPKI/v3f/10TJ07Ub37zG61fv17f//73e3z+mTNndObMmeLjkydPRl1SGQrUuZT+/ut3ZLPZHrdXVFSoUCgon88Xt6VSKWWz2V635/N5FQqF4vZ0Oq1MJtPr9lwu1+UyE5lMRul0utft77/Yc2+1m+5TCdq+rJXqdUpC70mp3/07X6COjvee79s+xfM6ZXvIDYhLoEIhSNB46lr7QPeJ8Qn46L1zj/I4jzDdJ+a16ATK5wtlfA7b9z713Gv87n6hfZICMUajkaTxVJrei/54EPnq03333aeTJ0+qrq6uGORf//Vf65Zbbunx+UuXLtUDDzwQdRllLZfLq62tXYMHD1ZTU1OXzzU2Nur06dNau3ZtcVs2m9W8efP09ttva+PGjcXt1dXVmj17tl5//XVt3bq1uH3EiBGaPn26du/erV27dhW319bWatq0aWpublZLS0tx+6RJk1RXV6dNmzbp8OHDxe319fUaP368nnvuObWd9yeXhoYGjRw5Uk8//XSXAXH99ddHsk/S7P7EiH4q1euUhN7L5Ybp/dNsoRB0+T6+7VMcr1MuN69bbkBccrm8Xn/9zcSMp05RzRHSgn6kCMAluVy+OJbL4TzCdJ8474hOLpdXc/O2sj2HvdA+BcF8vX9Bh9/dL7xPhQKLrlFJ0ngqRe+V4ngQ+eUFHn/8cX3ta1/T3/7t3+ojH/mItm7dqi9/+cv6/ve/r1tvvbXb83t6p+u4cePE5QXCq6oK1PmGYf5i0b32mpos/z0hIlVV0tGj/LWst30aOjSlU6e6niBUVQU6epR3uva1T8OGZbvlBsSlqirQiRO807W32hmfgH/OP/coh/MI031iXotOVVWg48d5p2tv+9RTr/G7+4X3qbo6YIxGgN/dL7xP743R6C4vEPmi67hx43Tffffp7rvvLm779re/rX/8x3/Uq/24am/nNV0vvvi4Lr54KBcwv4Dt27tf32TkSOmtt+zU44P3LpYfKJfL/+5i+Sl67QLeuxj3e7mNHZviYtx9GDVKOnSo6zbG54X1lFtVlTRlip16fNDT+GReuzDmNXOMz3AYo+bILBzmNXPMa+HQa+b43SAcfn83xzpROO+NUYev6dre3q50Ot1lWyaT6bKC3R/79+d06aVRVpZMDQ3SCy903cbk07fOE4GOjpyamprU2NioiooKu0V5hNz6b8KE7idWjM8L6ym3KVOk8/4XC3rB+AyH3PqP8Tkw9Jo5MguH3PqPeW1g6LX+43eDcPj93RzrROH0NEYHKvJF1/nz5+uv//qvVVtbq4985CPasmWLvv/97+uzn/2sWWFZrquD0spms2psbKTXDJEb4C7GZzjkhrjQa+bILBxyQ1zoNcSFXoOP0hd+ipn//b//tz7xiU/orrvu0uTJk/XVr35Vf/mXf6lvfetbUf8oYMBOnz5tuwQvkRvgLsZnOOSGuNBr5sgsHHJDXOg1xIVeg28iX3Strq7W3/3d32n//v06ffq09uzZo29/+9u66KKLjL7P+y9uC0Qtl8tp7dq19JohcgPcxfgMh9wQF3rNHJmFQ26IC72GuNBr8FHki64AAAAAAAAAUM5YdAUAAAAAAACACLHoirLGRbjDITfAXYzPcMgNcaHXzJFZOOSGuNBriAu9Bt8427EVFRW2S0DCVVRUaN68ebbL8A65Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4yNl3uhYKBdslIOEKhYIOHTpErxkiN8BdjM9wyA1xodfMkVk45Ia40GuIC70GHzm76JrP522XgITL5/PauHEjvWaI3AB3MT7DITfEhV4zR2bhkBviQq8hLvQafOTsoisAAAAAAAAA+IhFVwAAAAAAAACIkLOLrqlUynYJSLhUKqXq6mp6zRC5Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4KGu7gN5ks86WhoTIZrOaPXu27TK8Q26Auxif4ZAb4kKvmSOzcMgNcaHXEBd6DT5y9p2u3JEOpVYoFLR//356zRC5Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4yNlFV+5Ih1LL5/PaunUrvWaI3AB3MT7DITfEhV4zR2bhkBviQq8hLvQafOTsoisAAAAAAAAA+IhFVwAAAAAAAACIkLOLrtyRDqWWSqU0YsQIes0QuQHuYnyGQ26IC71mjszCITfEhV5DXOg1+Chru4DeZLPOloaEyGazmj59uu0yvENugLsYn+GQG+JCr5kjs3DIDXGh1xAXeg0+cvadrlwc2U/5fF7Nzc360Y9+pDvvvFN/+Id/qIsuukipVEqpVEqzZs2yXWJRPp/Xq6++Sq8ZIjfAXa6Mz3379ukf/uEf9KlPfUq///u/r5qaGlVUVGjYsGGaOnWq/vIv/1LPPvus1RrP50puPh1DEY4rvebTGHUlM9+4khvzmjmfxqfkTq8h+eg1+MjZt5MWCgXbJcDQE088oVtuuUXt7e22S+mXQqGgXbt26corr1Qmk7FdjjfIDXCX7fG5ZcsW3XHHHdq0aVOPnz927JiOHTumbdu26ZFHHtGsWbO0fPly1dbWxlxpV7Zzk/w7hiIc273m4xi1nZmvXMiNec2Mj+NTcqPXUB7oNfjI2UVX+Of48eOcVAFAGdu1a1e3XxYnTpyoKVOmaPjw4Tp+/Lg2bNigN954Q5K0bt06NTQ06Fe/+pUmTJhgo2RncAxFHBijiBPzmhnGJwAkD4uuiNyoUaN0zTXXFP/98pe/1A9+8APbZQEAYnLVVVfp85//vD71qU9p7NixXT5XKBT06KOP6otf/KLa29vV2tqqW265RRs2bODGCOIYingwRhEn5jUzjE8ASA5nF13TaWcvN4tefOxjH9P+/fu7/ReXF1980VJFfUun06qtraXXDJEb4C7b43P06NFatmyZPv3pT/f6377S6bQ++9nPqqamRh//+MclSS+88IKefvpp3XjjjXGW26Um2/Oab8dQhGO713wco7Yz85ULuTGvmfFxfHbWZLvXUB7oNfjI2W7lGh3+ueyyy6xfU8hEJpPRtGnT6DVD5Aa4y/b4nDlzpm677bZ+/fybb75Z1157bfHxypUrS1lan2znJvl3DEU4tnvNxzFqOzNfuZAb85oZH8en5EavoTzQa/CRs4uu3JEOpZbP57VlyxZ6zRC5Ae7ybXzOmDGj+PG+ffus1eFbbvCXb73mwhj1LTNXkFvyuTA+JXoN8aHX4CNnF10LhYLtEpBwhUJBLS0t9JohcgPc5dv4PP/6czZPoH3LDf7yrddcGKO+ZeYKcks+F8anRK8hPvQafOTsoisAAEi2bdu2FT8eN26cxUoA9IQxCriL8QkA7mPRFQAAxK6lpUVr1qwpPp4zZ47FagC8H2MUcBfjEwD84OyiK3ekQ6ml02lNmjSJXjNEboC7fBqf9957b/G/Q9bW1mr+/PnWavEpN/jNp15zZYz6lJlLyC3ZXBmfEr2G+NBr8FHWdgG94Y50KLVMJqO6ujrbZXiH3AB3+TI+ly9frp///OfFx0uXLtWgQYOs1eNLbvCfL73m0hj1JTPXkFtyuTQ+JXoN8aHX4CNn/0SQy+Vsl4CEy+Vy2rBhA71miNwAd/kwPjdv3qw77rij+HjRokVavHixxYr8yA3J4EOvuTZGfcjMReSWTK6NT4leQ3zoNfjI2UXXIAhsl4CEC4JAhw8fptcMkRvgLtfH529/+1vNnz9f7777riRp6tSpevjhhy1X5X5uSA7Xe83FMep6Zq4it+RxcXxK9BriQ6/BR84uugIAgOQ4cOCA5s6dq4MHD0qSJkyYoFWrVmnIkCGWKwMgMUYBlzE+AcBPLLoCAICSOnLkiObOnas9e/ZIkkaPHq3Vq1dr9OjRlisDIDFGAZcxPgHAX84uunIjLZRaJpNRfX09vWaI3AB3uTg+T548qRtvvFE7duyQJA0fPlyrV6/WFVdcYbmy97iYG5LJxV5zfYy6mJkPyC0ZXB+fEr2G+NBr8FHWdgG9SaedXQ9GQqTTaY0fP952Gd4hN8Bdro3Pd955R42Njfr1r38tSRo6dKhWrVqlD3/4w5Yr68q13JBcrvWaD2PUtcx8QW7+82F8SvQa4kOvwUfOrmxyRzqUWi6X05o1a+g1Q+QGuMul8fnuu+9qwYIFev755yVJlZWVWrlypa6++mrLlXXnUm5INpd6zZcx6lJmPiE3v/kyPiV6DfGh1+AjZxdduSMdSi0IArW1tdFrhsgNcJcr47Ojo0MLFy7UmjVrJEmDBg3Sk08+qRkzZlitqzeu5Ibkc6XXfBqjrmTmG3Lzl0/jU6LXEB96DT5ydtEVAAD4J5/Pa/HixWpqapIkZbNZ/fSnP9WcOXMsVwZAYowCLmN8AkCysOgKAAAiEQSBPve5z+lnP/uZpHPX3vrxj3+sBQsWWK4MgMQYBVzG+ASA5HH2Rlrckc5PjY2Nam1t7bLt4MGDxY83b96s+vr6bl/X1NSkMWPGlLq8LjKZjBoaGug1Q+QGuMv2+HzooYe0fPny4uMrr7xS69ev1/r16/v19Q8++GCpSuuT7dw6+XQMRTi2e83HMWo7M1+5khvzWv/5OD4ld3oNyUevwUfOLrqm07wJ10c7d+7U/v37e/38O++8o9/85jfdtp89e7aUZfUonU5r5MiRsf9c35Eb4C7b4/PQoUNdHu/evVu7d+/u99fb+oXRdm6dfDqGIhzbvebjGLWdma9cyY15rf98HJ+SO72G5KPX4CNnVzY7Ojpsl4CE6+jo0MqVK+k1Q+QGuIvxGQ65IS70mjkyC4fcEBd6DXGh1+AjZxdd4ad9+/YpCALjf5dffrmVenO5nJWf6ztyA9xlc3wuWbIk1DGg859NLsxrvh1DEQ5j1JwL49NHLuTGvNZ/vo5PyY1eQ3mg1+AbFl0BAAAAAAAAIEIsugIAAAAAAABAhJxddM1mnb3HFxIim83q+uuvp9cMkRvgLsZnOOSGuNBr5sgsHHJDXOg1xIVeg4+cXXQF4jB48GDbJXiJ3AB3MT7DITfEhV4zR2bhkBviQq8hLvQafOPsoisXSEap5XI5NTU10WuGyA1wF+MzHHJDXOg1c2QWDrkhLvQa4kKvwUfOLroCAAAAAAAAgI9YdAUAAAAAAACACLHoCgAAAAAAAAARcnbRlTvSodSy2awaGxvpNUPkBriL8RkOuSEu9Jo5MguH3BAXeg1xodfgI2cXXYE4nD592nYJXiI3wF2Mz3DIDXGh18yRWTjkhrjQa4gLvQbfOLvoyh3pUGq5XE5r166l1wyRG+Auxmc45Ia40GvmyCwcckNc6DXEhV6Dj5xddAUAAAAAAAAAH7HoCgAAAAAAAAARYtEVZY2LcIdDboC7GJ/hkBviQq+ZI7NwyA1xodcQF3oNvnG2YysqKmyXgISrqKjQvHnzbJfhHXID3MX4DIfcEBd6zRyZhUNuiAu9hrjQa/CRs+90LRQKtktAwhUKBR06dIheM0RugLsYn+GQG+JCr5kjs3DIDXGh1xAXeg0+cnbRNZ/P2y4BCZfP57Vx40Z6zRC5Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4yNlFVwAAAAAAAADwEYuuAAAAAAAAABAhZxddU6mU7RKQcKlUStXV1fSaIXID3MX4DIfcEBd6zRyZhUNuiAu9hrjQa/BR1nYBvclmnS0NCZHNZjV79mzbZXiH3AB3MT7DITfEhV4zR2bhkBviQq8hLvQafOTsO125Ix1KrVAoaP/+/fSaIXID3MX4DIfcEBd6zRyZhUNuiAu9hrjQa/CRs4uu3JEOpZbP57V161Z6zRC5Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4yNlFVwAAAAAAAADwUeSLrpdffrlSqVS3f3fffXfUPwoAAAAAAAAAnBP53apeeumlLm/33r59u+bOnas/+7M/M/o+48dndfHF0oQJUVeYLNu3d9+2d2/8dfikrk56801Jyiqfv0mZTFqVlfTahezdK7W3S+fnNnas9OqrtitzV09jkfF5YeRmjnktHOY1cz2Nxe3bpYaG+GvxSU+9xhjtG5mFw7xmjvOOcDj3MMfv7gOTSqU0YsQIpVIp26U4j/O1cHoaowOVCoIgiP7bvufLX/6y/t//+3/avXt3vwbHyZMnNXToUEknJA0pZWmJVVUltbXZrsJd1dXSqVO2q0gGeq1vPfUamV0YuZljXosOvdY3eg3wD/Na3zjvCIfjQTToNZQC43OgTkoaqhMnTmjIkIGtS0b+TtfznT17Vv/4j/+oe++9t9cF1zNnzujMmTPFxydPnixlSWUiUOdSei6X6/KZbDbb4/aKigoVCoUu71JOpVLKZrO9bs/n813uHJhOp5XJZHrdnsvldP4afyaTUTqd7nV7R0dHv2o33acSt33ZKdXrlITek1K/+3e+QB0d7z3ft32K53XK9pmbn/ukLrVH/zr1lBnCCVQoBAkaT11rH+g+0WuAj947hpbHeYTpPvV93uHnPqnP2qPYJ44HUeF39/7uUz6f1549e3TVVVdp0KBBidin92+Pap+kQIxPN5R09emJJ57Q8ePHddttt/X6nKVLl+qBBx4oZRllJ5fLq62tXYMHD1ZTU1OXzzU2Nur06dNau3ZtcVs2m9W8efP09ttva+PGjcXt1dXVmj17tl5//XVt3bq1uH3EiBGaPn26du/erV27dhW319bWatq0aWpublZLS0tx+6RJk1RXV6dNmzbp8OHDxe319fUaP368nnvuObWd9+e9hoYGjRw5Uk8//XSXiev666+PZJ+k2f2JEf1UqtcpCb2Xyw3T+6fZQiHo8n1826c4Xqdcbl633HK5fLFWH/epU6lep54yQzi5XF6vv/5mYsZTp6h6T1rQjxQBuOT8Y2g5nEeY7tOFzjt83KdOpXyd8vmbJGWEgeF3d/N9On78uGbMmJGofYr6dTq3oMvvBi4o6eUFbrzxRl100UX6v//3//b6nJ7e6Tpu3DhxeYHwqqoCdb5h2Ie/wsT9l6WamixvtY9IVZV09Ki/fwEsde8NHZrSqVNd/8JYVRXo6FHe6drXPg0blu0zNx/3qVOpXqeeMkM4VVWBTpzgna691U6vAf45/xhaDucRpvt0ofMOH/epUylfJ44H0eB39/7vU0dHh5555hn9yZ/8iQYPHpyIfXr/9qj2qbo6YHwOiAeXF9i/f79Wr16tX/ziF30+b9CgQRo0aFCPn6uqkqZMKUV1yfHexfID5XJ5ZbMZjR2bUufVHCoqKnr8up62p9Pp370VvX/bM5mMMpnuf93sbXvnZNTf7Sa197a9p9orK3u+bhO91rft27vnVllZutepr+2+9F5PvVZZmerx+b7sUxyvU39z82mf+rs97D4xr4XT87yWUjp97iCahPHU3+39rX3s2M4bp7x33lFZmeLGKRfQ0/kaufWNzMLpbV57/1hO8nlEf7f3dQzt73mHq/s0kO393SfOPczxu3vf2/u7T501JGmfOkW1T2PHpjhfC6FzjAZBoHfeieZ7lmzRddmyZRo5cqTmzZsX+ntMmSKd905s9CGfL6i5eZumTp3a42DEeyZMkA4d6rqNXruwhgbphRe6bmPS7ltPvUZmF0Zu5pjXwmFeM9d5B3TOO8IhN3NkZoZ5zRznHeFw7hEe81o46XRatbW1PS5WoivO1wbm2LGChg2L5nuVZNG1UCho2bJluvXWW3tdeUe0MpmMpk2bZrsMAABQBjjvCIfczJEZgKRhXguH3MyRWThRLlCX5E8Eq1evVktLiz772c+W4tujB/l8Xlu2bHnfHSUBAACix3lHOORmjswAJA3zWjjkZo7Mwokyr5Isuv7Jn/yJgiDQxIkTS/Ht0YNCoaCWlpYuF1cGAAAoBc47wiE3c2QGIGmY18IhN3NkFk6UeXExDAAAAAAAAACIEIuuAAAAAAAAABAhFl0TIp1Oa9KkSdzJDwAAlBznHeGQmzkyA5A0zGvhkJs5MgsnyryykX0nWJXJZFRXV2e7DAAAUAY47wiH3MyRGYCkYV4Lh9zMkVk4mUwmsu/FcndC5HI5bdiwQblcznYpAAAg4TjvCIfczJEZgKRhXguH3MyRWThR5sWia0IEQaDDhw8rCALbpQAAgITjvCMccjNHZgCShnktHHIzR2bhRJkXi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6JkQmk1F9fX2kF/wFAADoCecd4ZCbOTIDkDTMa+GQmzkyCyfKvLKRfSdYlU6nNX78eNtlAACAMsB5RzjkZo7MACQN81o45GaOzMJJp6N7fyrvdE2IXC6nNWvWcFc6AABQcpx3hENu5sgMQNIwr4VDbubILJwo82LRNSGCIFBbWxt3pQMAACXHeUc45GaOzAAkDfNaOORmjszCiTIvFl0BAAAAAAAAIEIsugIAAAAAAABAhFh0TYhMJqOGhgbuSgcAAEqO845wyM0cmQFIGua1cMjNHJmFE2Ve2ci+E6xKp9MaOXKk7TIAAEAZ4LwjHHIzR2YAkoZ5LRxyM0dm4aTT0b0/lXe6JkRHR4dWrlypjo4O26UAAICE47wjHHIzR2YAkoZ5LRxyM0dm4USZF+90TZBcLme7BAAO27dvn5555hk9++yz2rZtm1paWnTq1ClVV1frgx/8oBoaGrR48WLNnDnTdqnw2Ntvv63nn39emzZt0rZt27Rnzx61trbq1KlTqqioUE1NjaZMmaJZs2bpM5/5jMaOHWu7ZGf4NkZdOO/wLTOJ3MKwnRnzGuLk2/h0hW+52Z7XfOVKbmfPntU///M/67HHHtOOHTv01ltvqaamRldccYU+/vGP67bbbtPw4cNtlynJjcx8G5+RChxz4sSJQFIgnQiuu852Nf44e/Zs8MQTTwRnz561XYrzrrsuCKSu/+i1CyM3c65k9vLLLwfXXnvt7+bWC/+bNWtWsH///vgL/R1XcvOJS5nNmzev3702aNCgYMmSJUE+n7dSqyu5+TZGg8D+eYePmQUBuYVhO7MgYF5LOlcy8218klt4LsxrPnIlt1deeSWor6/vs89GjhwZrFy50mqdQWA/Mx/HZxAEwdtvvx1ICk6cODHg78U7XQEg4Xbt2qVNmzZ12TZx4kRNmTJFw4cP1/Hjx7Vhwwa98cYbkqR169apoaFBv/rVrzRhwgQbJSMhhg8frsmTJ2v8+PGqqqpSe3u7XnvtNW3atEm5XE5nzpzRkiVLtHfvXi1fvtx2udYwRs2RWTjkNnDMaygVxmc45IY4vfHGG7rhhhvU2toqSUqlUvrjP/5jXXnllTp8+LBWr16t06dP69ChQ/rTP/1TrVq1SrNnz7ZctT2MT4l3uiZEoVAITpw4ERQKBdulOM+Vv8r6htzMuZLZY489FkgKrrrqquA73/lO8MYbb3R7Tj6fD370ox8FlZWVxb80XnfddVbmFFdy84lLmf3t3/5t8PDDDwe7d+/u9TkHDx4MFi1a1OUv2//yL/8SY5XnuJKbb2M0COyfd/iYWRCQWxi2MwsC5rWkcyUz38YnuYXnwrzmIxdy++hHP1rsofHjxwdbt27t8vnDhw8HN9xwQ/E5w4YNC44dO2an2MB+Zj6OzyAIguPHj0f2TlcWXROiUCgEZ8+eZeLuB1dOEHxDbuZcyWzdunXBsmXLglwud8Hn/uIXv+jyC+OqVatiqLArV3LziY+ZFQqFYPbs2cVemzNnTuw1uJKbb2M0COyfd/iYWRCQWxi2MzPBvOYnVzLzbXySW3g+zWsusZ3bypUri71z0UUXBc3NzT0+79SpU8GECROKz/36178ec6XvsZ2Zj+MzCKJddE0P/L2ycEEul1NTU5MTF0kG4JaZM2fqtttuUyaTueBzb775Zl177bXFxytXrixlaShjqVRKt99+e/Hxli1bLFZjl49j1PZ5h4+ZSeQWhu3MTDCvYSB8HJ8u8DE3n+Y1l9jO7e///u+LH9966636vd/7vR6fd/HFF+uv/uqvio9/+MMfWqvZdmY+jk8p2puPsegKAOhixowZxY/37dtnrxAk3ogRI4oft7W1WazEL4xRc2QWDrmZY15DXBif4ZAbwjh16pT+7d/+rfj4/D+w9WThwoWqqqqSJB09elTPPfdcSetLiiSOTxZdAQBdpFKp4sf5fN5iJUi6nTt3Fj++/PLL7RXiGcaoOTILh9zMMa8hLozPcMgNYWzYsEFnzpyRdO6drNdcc02fz//ABz6ghoaG4uM1a9aUtL6kSOL4ZNEVANDFtm3bih+PGzfOYiVIstbWVn33u98tPv7EJz5hsRq/MEbNkVk45GaGeQ1xYnyGQ24I45VXXil+/Hu/93vKZrMX/Jo/+IM/6PHr0bskjk8WXRMim82qsbGxX4MfAHrT0tLS5S+xc+bMsVgNkqa9vV07d+7U9773PU2bNk2tra2SpMmTJ+u+++6zXJ0fXBmjPp13uJKZRG5huJ4Z8xpscGV8+saV3Fyf11xlM7ddu3YVPx4/fny/vqa2trb48auvvhp5Tf3hU6+5Mj4lRZqX+8mj306fPq3q6mrbZQDw2L333lv8rxy1tbWaP3++5Yrgs/Xr1+ujH/1on89pbGzUT37yE45f/eTSGPXlvMOlzCRyC8OlzJjX4AKXxqdPXMrNpXnNJ7ZyO3LkSPHjUaNG9etrLrvssuLHR48ejbym/vKl11wan1Hina4JkcvltHbtWu6ACCC05cuX6+c//3nx8dKlSzVo0CCLFSHJampq9Nhjj2nlypW65JJLbJfjBZfGqC/nHS5lJpFbGL5kJjGvIR4ujU+fuJSbT/OaS2zmdurUqeLHgwcP7tfXnP+8878+Tr70mkvjU1KkefFOVwCANm/erDvuuKP4eNGiRVq8eLHFipAEY8aM0d133y1JCoJAbW1t2rVrl15++WUdO3ZMixYt0iOPPKKHH35YEydOtFyt2xij5sgsHHLrG/MabGJ8hkNuGKh33323+PFFF13Ur685f9Hw9OnTkdeUFEkfnyy6AkCZ++1vf6v58+cXTyamTp2qhx9+2HJVSIIJEybowQcf7La9tbVV3/jGN/Too49q7dq1uu6667Ru3TpNnTrVQpXuY4yaI7NwyO3CmNdgC+MzHHJDFD7wgQ8UPz579my/vubMmTPFj/v77thyUw7jk8sLJIgPF0cG4JYDBw5o7ty5OnjwoKRzv0yuWrVKQ4YMsVwZkmzMmDFatmyZ7rnnHknSsWPH9MlPfrJ4HSe8x+Ux6up5h8uZSeQWhquZnY95DaXk8vh0mcu5+TCvuchWblVVVcWP+/uu1fOfd/7Xx83VXnN5fEaJRdeEqKio0Lx581RRUWG7FACeOHLkiObOnas9e/ZIkkaPHq3Vq1dr9OjRlitDuVi6dGnxxOqVV17RU089Zbkit7g8Rl0973A5M4ncwnA1s94wryFqLo9Pl7mcm2/zmits5nbppZcWP37rrbf69TWdi4mSNGzYsMhr6g9Xe83l8Skp0rxYdE2IQqGgQ4cOqVAo2C4FgAdOnjypG2+8UTt27JAkDR8+XKtXr9YVV1xhuTKUk8rKSk2fPr34+Pnnn7dYjVtcH6Munne4nplEbmG4mFlfmNcQJdfHp6tcz823ec0VNnObNGlS8eP9+/f362taWlqKH9fV1UVeU3+42Guuj09JkebFomtC5PN5bdy4kf/CBOCC3nnnHTU2NurXv/61JGno0KFatWqVPvzhD1uuDOWopqam+PGRI0csVuIOH8aoa+cdPmQmkVsYrmXWH8xriIIP49NFPuTm47zmApu5TZ48ufjxtm3b+nV3+5dffrnHr4+Ta73mw/iUFGleLLoCQBl59913tWDBguI7byorK7Vy5UpdffXVlitDuTpw4EDxY1v/9coljFFzZBYOuZUO8xoGivEZDrmhVKZPn65BgwZJOrdwuHnz5j6ff+bMGb3wwgvFx7Nnzy5pfT4o1/HJoisAlImOjg4tXLhQa9askSQNGjRITz75pGbMmGG5MpSrI0eOaOPGjcXHtt4F4ArGqDkyC4fcSod5DQPF+AyH3FBKVVVVuuGGG4qPH3300T6f/4tf/EJtbW2Szv3x7Y//+I9LWZ7zynl8suiaEKlUStXV1UqlUrZLAeCgfD6vxYsXq6mpSdK5u1j+9Kc/1Zw5cyxXhiQ5evRov59bKBT0hS98QWfOnJF07uTrpptuKlVpzvNtjLpw3uFbZhK5hWE7M+Y1xMm38ekK33KzPa/5ynZud911V/HjRx99tHhN0vdrb2/X//f//X/Fx3/xF3+hbDZb8vp6Yjszyb/xKSnSvFh0TYhsNqvZs2dbG8wA3BUEgT73uc/pZz/7mSQpnU7rxz/+sRYsWGC5MiTNihUrdM0112jFihU6efJkr89rbm5WY2OjHn/88eK2r33ta13uDFtOfByjts87fMxMIrcwbGfGvIa4+Dg+XeBjbrbnNV/Zzm3evHn66Ec/Kunc5QNuuukmNTc3d3nOkSNH9Kd/+qd67bXXJJ17l+t//+//PfZaO9nOzMfxKSnSvBjlCVEoFPT6669r3LhxSqdZSwfwnoceekjLly8vPr7yyiu1fv16rV+/vl9f/+CDD5aqNCTQ5s2bdeuttyqbzaqurk6TJk1STU2NUqmUjhw5oubm5uKJaKeFCxfq/vvvt1SxfT6OUdvnHT5mJpFbGLYzk5jXEA8fx6cLfMzNhXnNRy7k9k//9E+69tprdeDAAe3bt0/19fWaOXOmrrzySh0+fFirV69We3u7pPfe0XnJJZdYqVWyn5mP41M6l1tUWHRNiHw+r61bt2rMmDFM3AC6OHToUJfHu3fv1u7du/v99eV6Eg9znTcYkKRcLqft27dr+/btvT6/urpaS5Ys0Ze+9CVlMpk4SnSSj2PU9nmHj5lJ5BaG7cyY1xAXH8enC3zMzfa85isXcvvgBz+oNWvWaNGiRdq6dauCINC6deu0bt26Ls8bMWKEli1b1uU6sDbYzszH8Smdyy0qLLoCAIBI3Hnnnbrhhhu0evVqvfjii9qxY4daWlp0/PhxSdKQIUM0evRo1dfXa86cOVq4cKGqqqrsFg0AfWBeAwCcr66uTi+++KIef/xxPfbYY9qxY4feeustXXLJJZowYYI+/vGP6/bbb9fw4cNtlwoHsOgKAAm3ZMkSLVmyxHYZKBMTJ07UxIkTu9xsAH1jjJojs3DILRzmNcSB8RkOucGGiy66SJ/5zGf0mc98xnYpTmN8ciOtxEilUhoxYgR3QAQAACXHeUc45GaOzAAkDfNaOORmjszCiTIv3umaENlsVtOnT7ddBgAAKAOcd4RDbubIDEDSMK+FQ27myCycbDa6pVLe6ZoQ+Xxer776aqQX/AUAAOgJ5x3hkJs5MgOQNMxr4ZCbOTILJ8q8WHRNiEKhoF27dqlQKNguBQAAJBznHeGQmzkyA5A0zGvhkJs5MgsnyrxYdAUAAAAAAACACLHoCgAAAAAAAAARYtE1IdLptGpra5VO85ICAIDS4rwjHHIzR2YAkoZ5LRxyM0dm4USZV3S35IJVmUxG06ZNs10GAAAoA5x3hENu5sgMQNIwr4VDbubILJxMJhPZ92K5OyHy+by2bNnCXekAAEDJcd4RDrmZIzMAScO8Fg65mSOzcKLMi0XXhCgUCmppaeGudAAAoOQ47wiH3MyRGYCkYV4Lh9zMkVk4UebFoisAAAAAAAAARIhFVwAAAAAAAACIEIuuCZFOpzVp0iTuSgcAAEqO845wyM0cmQFIGua1cMjNHJmFE2Ve2ci+E6zKZDKqq6uzXQYAACgDnHeEQ27myAxA0jCvhUNu5sgsnEwmE9n3Yrk7IXK5nDZs2KBcLme7FAAAkHCcd4RDbubIDEDSMK+FQ27myCycKPNi0TUhgiDQ4cOHFQSB7VIAAEDCcd4RDrmZIzMAScO8Fg65mSOzcKLMi0VXAAAAAAAAAIgQi64AAAAAAAAAECEWXRMik8movr4+0gv+AgAA9ITzjnDIzRyZAUga5rVwyM0cmYUTZV7ZyL4TrEqn0xo/frztMgAAQBngvCMccjNHZgCShnktHHIzR2bhpNPRvT+Vd7omRC6X05o1a7grHQAAKDnOO8IhN3NkBiBpmNfCITdzZBZOlHmx6JoQQRCora2Nu9IBAICS47wjHHIzR2YAkoZ5LRxyM0dm4USZF4uuAAAAAAAAABChkiy6vvnmm/rUpz6lSy+9VIMHD9bv/d7vafPmzaX4UQAAAAAAAADglMhvpHXs2DHNmDFD119/vZ566imNGDFCu3fvVk1NjfH32rs36uqSp65OevNNScoqCOYrlUqpslKaMMF2Ze7avr37NnrtwnrKiNz6RmbhkJs5Mgunp4y2b5caGuKvxRd790rt7RLnHWbIzRyZhcN5rjmOoeGQmzl+dw+np+PB2LHSq6/arsxd9Fo4nb0WBNEtlaaCiC/ucN999+n555/Xr371q1Bff/LkSQ0dOlTSCVVVDVFbW5TVJU91tXTqlO0q/FdVJXrtAnrqNXLrG5mFQ27myCwcjqEAygHHg75xDA2H3Mxx3hEdeq1v9NpAnZQ0VCdOnNCQIUMG9J0if6fr//k//0c33nij/uzP/kzPPvusxo4dq7vuukv/5b/8lx6ff+bMGZ05c6b4+OTJk+d9NlBHR07pdFqZTEb5fF6FQqH42c7tuVyuy4VuM5mM0ul0r9s7Ojq61JDNnovh/Xco6217RUWFCoWC8vl8cVsqlVI2m+11e2+1D3Sfzr2EKWGgAkmpkr1OSei9zozez+d9KvXrdC6v92d2bl7zdZ/ieZ16mtfey83PfVKX2qN/nXrPzN99OqeUrxPHUADl4b1jaBLn8oHvU9/nHX7uk/qsPYp96i23fL7g7T7xu7tfkjSe4vrdHfGLfNF17969euihh3Tvvffqf/yP/6GXXnpJ99xzjy666CLdeuut3Z6/dOlSPfDAAz1+r1wur6amJtXW1mratGlqbm5WS0tL8fOTJk1SXV2dNm3apMOHDxe319fXa/z48XruuefUdt6fPxoaGjRy5Eg9/fTTXQbE9ddfr8GDB6upqanLz29sbNTp06e1du3a4rZsNqt58+bp7bff1saNG4vbq6urNXv2bL3++uvaunVrcfuIESM0ffp07d69W7t27Spuj2qfgmC+GEwDl88XJGVK9joloffOHRS6Txk+71OpX6dcbli3zAqFoMv38W2f4nidcrl53XLrPB74uk+dSvU69ZWZr/sklf51KhQ4hgJIvvOPoUmcywe6Txc67/BxnzqV8nXK52+SlOmWW3PzNm/3id/d/ZKk8RTX7+6IX+SXF7jooov0h3/4h9qwYUNx2z333KOXXnqpS7N16umdruPGjdO5ywtU6+hR3una1z4NG5bVqVNM3ANVVRWorY13uva1T9XVQbdeq6qSjh71d59K/ToNHZrqIbNAR4/yTte+9qmnee383Hzcp06lep36yszXfepUyteJYyiAcnD+MTSJc/lA9+lC5x0+7lOnUr5OveV2/DjvdOV399KrqpKOH0/OeIrjd3eYcPjyAqNHj9aHP/zhLtsmT56sn//85z0+f9CgQRo0aFCPn6usTKmioqL4OJPJKJPJdHteZ5P3d/v53zPs9nQ6/bu3bfdve2+1D3SfKit7vpbOlCk9fjl0/oW4A+VyeWWzGY0de25CKtXr1Mnn3qusTHXrtcpKv/ep1K9TT+Pz/fNaJ1/2KY7Xqb+5+bRP/d0edp/6k5lv+3S+Ur1OY8d23mTgveNBZWWKmwz0oadjKJldGLmZI7NwejvPff/cmqS5vFPYfRrIeYer+zSQ7f3dp95y69wPH/epE7+7u2X79p56LVnjqVMpf3en1y6sp14bqMgXXWfMmNHl7dCS9O///u8aP3688ffipOrCJkyQDh3qum3KFKmHNxXjfYJAamtrV3V1tVL8EeiCeuo1xmjfyCwccjNHZuF03vWW44E5MguH3MyRWTjk1n8cQ8MhN3P87h5OQ4P0wgtdt9FrfaPXwump1waq+9L6AH3lK1/RCy+8oP/5P/+nXnvtNf3TP/2THnnkEd19991R/yhgwAYPHmy7BACAAzgemCOzcMjNHJmFQ24AANgV+aLrNddco3/913/VY489pilTpuhb3/qW/u7v/k633HJL1D8KGJBcLqempqZu114BAJQXjgfmyCwccjNHZuGQGwAA9pXkdmY33XSTbrrpplJ8awAAAAAAAABwWuTvdAUAAAAAAACAcsaiKwAAAAAAAABEiEVXlK1sNqvGxkZlsyW5ygYAwBMcD8yRWTjkZo7MwiE3AADsY9EVZe306dO2SwAAOIDjgTkyC4fczJFZOOQGAIBdLLqibOVyOa1du5a7ugJAmeN4YI7MwiE3c2QWDrkBAGAfi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6oqxxcwEAgMTxIAwyC4fczJFZOOQGAIBdHIlRtioqKjRv3jzbZQAALON4YI7MwiE3c2QWDrkBAGAf73RF2SoUCjp06JAKhYLtUgAAFnE8MEdm4ZCbOTILh9wAALCPRVeUrXw+r40bNyqfz9suBQBgEccDc2QWDrmZI7NwyA0AAPtYdAUAAAAAAACACLHoCgAAAAAAAAARYtEVZSuVSqm6ulqpVMp2KQAAizgemCOzcMjNHJmFQ24AANiXtV0AYEs2m9Xs2bNtlwEAsIzjgTkyC4fczJFZOOQGAIB9vNMVZatQKGj//v3c1RUAyhzHA3NkFg65mSOzcMgNAAD7eKcrIrVv3z4988wzevbZZ7Vt2za1tLTo1KlTqq6u1gc/+EE1NDRo8eLFmjlzpu1Slc/ntXXrVo0ZM0bptL2/P+Tzee3YsUMvvfSSNm/erJdeeknNzc3q6OiQJM2cOVPr1q2zVh+Sw6fx6Yq3335bzz//vDZt2qRt27Zpz549am1t1alTp1RRUaGamhpNmTJFs2bN0mc+8xmNHTvWdslO8G1e43hgzpXMfONKbj4dD1zJzDeu5OZTr8FfnK8BcBWLrojEli1bdMcdd2jTpk09fv7YsWM6duyYtm3bpkceeUSzZs3S8uXLVVtbG3OlbnniiSd0yy23qL293XYpSDDGZ3i33XabVq5c2ePncrmcTp8+rdbWVj399NN64IEH9PWvf13f/OY3y3phgHktHHJDHDgeIC70GuLE+RoAV7Hoikjs2rWr20nVxIkTNWXKFA0fPlzHjx/Xhg0b9MYbb0iS1q1bp4aGBv3qV7/ShAkTbJTshOPHj/MLNkqO8RmN4cOHa/LkyRo/fryqqqrU3t6u1157TZs2bVIul9OZM2e0ZMkS7d27V8uXL7ddrjXMa+GQG+LA8QBxoddgC+drAFzCoisiddVVV+nzn/+8PvWpT3X7bxuFQkGPPvqovvjFL6q9vV2tra265ZZbtGHDBit3Vk2lUhoxYoQTd3UdNWqUrrnmmuK/X/7yl/rBD35guywkjE/j0xWzZs3S/PnzdcMNN+iqq67q8TlvvfWWvvKVr+ixxx6TJK1YsULz58/XJz7xiThLdY5P8xrHA3MuZeYTV3Lz6XjgSma+cSU3n3oN/uJ8DYCrWHRFJEaPHq1ly5bp05/+tDKZTI/PSafT+uxnP6uamhp9/OMflyS98MILevrpp3XjjTfGWa6kc3d1nT59euw/93wf+9jHtH///m7/lerFF1+0VBGSyMfx6YqvfvWrF3zOqFGj9JOf/ERvvfWW1qxZI0n64Q9/WLYn8T7OaxwPzLmQmY9s5+bj8cB2Zr6ynZuPvQZ/cb4GwFVcxASRmDlzpm677bZeT6rOd/PNN+vaa68tPu7t+julls/n9eqrryqfz1v5+ZJ02WWXce0qlJyP49M3qVRKt99+e/Hxli1bLFZjl4/zGscDcy5k5iPbufl4PLCdma9s5+ZjryH5OF8DEDcWXWHFjBkzih/v27fPSg2FQkG7du1SoVCw8vMBV7kwPn00YsSI4sdtbW0WK4EpjgfmyCwc33Jz4XjgW2au8C03F3oN5YHzNQBxYtEVVpx/nSbeuQC4hfEZzs6dO4sfX3755fYKAYCIcDxAXOg1xIXzNQBxYtEVVmzbtq348bhx4yxWAuD9GJ/mWltb9d3vfrf4mOuDAUgCjgeIC72GOHC+BiBuLLoidi0tLcWLl0vSnDlzrNSRTqdVW1urdJphAHRyZXz6oL29XTt37tT3vvc9TZs2Ta2trZKkyZMn67777rNcHUxwPDBHZuH4lJsrxwOfMnOJT7m50mtIJs7XANiUtV0Ays+9995b/G9DtbW1mj9/vpU6MpmMpk2bZuVnA65yZXy6aP369froRz/a53MaGxv1k5/8RNXV1TFVhShwPDBHZuH4lJsrxwOfMnOJT7m50mtIBs7XALjE/T99IlGWL1+un//858XHS5cu1aBBg6zUks/ntWXLFq4bBfyOS+PTNzU1NXrssce0cuVKXXLJJbbLgSGOB+bILBxfcnPpeOBLZq7xJTeXeg3Jx/kagLix6IrYbN68WXfccUfx8aJFi7R48WJr9RQKBbW0tHhzV1eglFwbny4aM2aM7r77bt19992666679OlPf1rXXnutstmsjh07pkWLFmn27Nn693//d9ulwhDHA3NkFo4Publ2PPAhMxf5kJtrvYZk4HwNgEu4vABi8dvf/lbz58/Xu+++K0maOnWqHn74YctVAZAYn/01YcIEPfjgg922t7a26hvf+IYeffRRrV27Vtddd53WrVunqVOnWqgSAMLjeIC40GsoFc7XALiEd7qi5A4cOKC5c+fq4MGDks4dCFetWqUhQ4ZYrgwA43PgxowZo2XLlumee+6RJB07dkyf/OQnnf8vnQBwPo4HiAu9Bhs4XwNgA4uuKKkjR45o7ty52rNnjyRp9OjRWr16tUaPHm25snN3dZ00aZIXd3UFSsHl8emjpUuXFn9hfOWVV/TUU09Zrgj9xfHAHJmF42puLh8PXM3Mda7m5nKvoTxwvgYgTm4dhZEoJ0+e1I033qgdO3ZIkoYPH67Vq1friiuusFzZOZlMRnV1dcpkMrZLAWLn+vj0UWVlpaZPn158/Pzzz1usBiY4Hpgjs3BczM3144GLmfnAxdxc7zWUB87XAMSJRVeUxDvvvKPGxkb9+te/liQNHTpUq1at0oc//GHLlb0nl8tpw4YNyuVytksBYuXD+PRVTU1N8eMjR45YrAQmOB6YI7NwXMvNh+OBa5n5wrXcfOg1lA/O1wDEhUVXRO7dd9/VggULin81rKys1MqVK3X11VdbrqyrIAh0+PBhBUFguxQgNr6MT18dOHCg+PGwYcMsVgITHA/MkVk4LuXmy/HApcx84lJuvvQaygfnawDiwqIrItXR0aGFCxdqzZo1kqRBgwbpySef1IwZMyxXBoDxWVpHjhzRxo0bi48nT55ssRoA6B3HA8SFXoNrOF8DECcWXRGZfD6vxYsXq6mpSZKUzWb105/+VHPmzLFcGQDGp7mjR4/2+7mFQkFf+MIXdObMGUnnfqm86aabSlUaAITG8QBxodcQB87XALiMRVdEIggCfe5zn9PPfvYzSefumPrjH/9YCxYssFxZ7zKZjOrr6526wQBQCj6OTxesWLFC11xzjVasWKGTJ0/2+rzm5mY1Njbq8ccfL2772te+pksvvTSOMhEBjgfmyCwc27n5eDywnZmvbOfmY6/BT5yvAXBZ1nYBSIaHHnpIy5cvLz6+8sortX79eq1fv75fX//ggw+WqrRepdNpjR8/Pvaf+36NjY1qbW3tsu3gwYPFjzdv3qz6+vpuX9fU1KQxY8aUujwkgI/j0xWbN2/Wrbfeqmw2q7q6Ok2aNEk1NTVKpVI6cuSImpub9dprr3X5moULF+r++++3VLEbfJvXOB6YcyUz39jOzcfjge3MfGU7Nx97Df7ifA2Aq1h0RSQOHTrU5fHu3bu1e/fufn+9jROrXC6n5557Tn/8x3+sbNbeUNi5c6f279/f6+ffeecd/eY3v+m2/ezZs6UsCwni4/h0waBBg4of53I5bd++Xdu3b+/1+dXV1VqyZIm+9KUvlf07snyb1zgemHMlM9/Yzs3H44HtzHxlOzcfew1+4nwNgMs4c0HZCoJAbW1tTtzVFYB77rzzTt1www1avXq1XnzxRe3YsUMtLS06fvy4JGnIkCEaPXq06uvrNWfOHC1cuFBVVVV2i0YoHA/MkVk45GaOzMIhN5QLztcAuIxFV0RiyZIlWrJkie0yvLRv3z7bJSDhGJ/hTZw4URMnTtRdd91luxSvMK+FQ24oNY4HiAu9hjhxvgbAVdxICwAAAAAAAAAixKIrylYmk1FDQwPX8gGAMsfxwByZhUNu5sgsHHIDAMA+Li+AspVOpzVy5EjbZQAALON4YI7MwiE3c2QWDrkBAGAf73RF2ero6NDKlSvV0dFhuxQAgEUcD8yRWTjkZo7MwiE3AADsY9EVZS2Xy9kuAQDgAI4H5sgsHHIzR2bhkBsAAHax6AoAAAAAAAAAEWLRFQAAAAAAAAAixKIrylY2m9X111+vbJb7yQFAOeN4YI7MwiE3c2QWDrkBAGAfi64oa4MHD7ZdAgDAARwPzJFZOORmjszCITcAAOxi0RVlK5fLqampiZsMAECZ43hgjszCITdzZBYOuQEAYB+LrgAAAAAAAAAQIRZdAQAAAAAAACBCLLoCAAAAAAAAQIRYdEXZymazamxs5K6uAFDmOB6YI7NwyM0cmYVDbgAA2MeiK8ra6dOnbZcAAHAAxwNzZBYOuZkjs3DIDQAAu1h0RdnK5XJau3Ytd3UFgDLH8cAcmYVDbubILBxyAwDAPhZdAQAAAAAAACBCLLoCAAAAAAAAQIRYdEVZ4+YCAACJ40EYZBYOuZkjs3DIDQAAuzgSo2xVVFRo3rx5tssAAFjG8cAcmYVDbubILBxyAwDAPt7pirJVKBR06NAhFQoF26UAACzieGCOzMIhN3NkFg65AQBgH4uuKFv5fF4bN25UPp+3XQoAwCKOB+bILBxyM0dm4ZAbAAD2segKAAAAAAAAABFi0RUAAAAAAAAAIhT5ouuSJUuUSqW6/Kurq4v6xwADlkqlVF1drVQqZbsUAIBFHA/MkVk45GaOzMIhNwAA7MuW4pt+5CMf0erVq9/7IdlwP2bv3qgqSq6eMiK3/slms5o9e7btMrzRU19t3y41NMRfiy+2b+++jfF5YfSaOXptYDge9F9dnfTmm9K5U8hzmVVWShMm2KzKfXv3Su3tErn1X0+ZjR0rvfqqzarcxxg1xzE0HM7XzNFr4bDmYY7MwilFRiVZdM1ms7rssssG/H3OnWihLz1lRG79UygU9Prrr2vcuHFKp7nSxoX01FenTkkvvBB/LT5jfF4YvRYNeq3/OB7035tvnhuP5zt1Sjp0yE49PiM3c+cWE9EXxmg0OIZeGOdr0aDXLow1D3NkFk4pMirJouvu3bs1ZswYfeADH1BDQ4OWLl2q2traHp975swZnTlzpvj45MmT5302UEdHTul0WplMRvl8XoVCofjZzu25XE5BEBS3ZzIZpdPpXrd3dHR0qaHznbi5XK5f2ysqKlQoFLrcDTSVSimbzfa6vbfaB7pP517CrW2tMAAAfA9JREFU9/+3oUCdT/Fxn+J6nd59911t3bpVI0aM0EUXXZSIfSrl6yQF6t5rMHduXuuUlPEUbe/1NK/B3LleS/pcHsU+nTlzpng8qKioSMQ+lep1YnzCrq7HUMnv8VSaOYIxGo33ei2Jc3kU+0SvRYXf3S+0T739HurzPtn63d3nfYrndYp+Xot80fWP/uiP9Oijj2rSpEk6cOCAHnjgAX30ox/V9u3bVV1d3e35S5cu1QMPPNDj98rl8mpqalJtba2mTZum5uZmtbS0FD8/adIk1dXVadOmTTp8+HBxe319vcaPH6/nnntObW1txe0NDQ0aOXKknn766S5BX3/99Ro8eLCampq6/PzGxkadPn1aa9euLW7LZrOaN2+e3n77bW3cuLG4vbq6WrNnz9brr7+urVu3FrePGDFC06dP1+7du7Vr167i9qj2KQjm6/1Nkcvl1dbW7u0+xf06PfPMM4nbJyn61+m9SQgDUSgEXV5veq/7PuVy80SvDVznMbRc5vKB7NPLL78s6dzxICn7VKrXSVogwJYgUJee9H08lWKO4Bgajc5jqJTMuTyKfcrnb5KU6U+c6AO/u194nwqFnhcQfd4nW7+7+7xPcbxOpTiGpoKub5uM3PHjxzV+/Hh9//vf1+c+97lun+/pna7jxo2TdEJVVdU6epR3uva1T8OGZXXqVNcJqKoqUOcbhn3cpzjf6frMM89o7ty5vNO1H/tUXR106zWYq6oKdPQo73Tta596mtdgrrPXkj6XR7FPp0+f1tNPP625c+fyTtcL1M74hE3vP4ZKfo+nUswRjNFonN9rSZzLo9gnei0a/O5+4X3q6ffQqirp+HF/98nG7+5VVdLRo/7uUxyv03vz2klJQ3XixAkNGTJEA1HyP4Necsklmjhxol577bUePz9o0CANGjSox89VVqZUUVFRfJzJZJTJdP9rWmd4/d1+/vcMuz2dTvd43bfetvdW+0D3qbKy+3WbKitT6rxRqY/71FeNptv72qeLLrqoy6UF+qrdl30q5es0dmzqd9dSC5TPF5TJpFVZmeLGDH147yYg72U2dmyqx9eV3nuv9rFjRa8Z6k+vJXUuj2KfKioquh0PJL/3qVSvU0/nHVVV0pQpPX45fqenMcq81rft23s+x03SeOpre9h9Yoya6+/5Gr3XdTvna+Z66zV+dz+nt9orK1M9HA/83qdSv069ZebzPsXxOvV0DB2oki+6njp1Snv27NGnP/1p469lwr6wCRO6Xxif3Ponm81q+vTptsvwxnt3C06J/0pkisxM0GsDQWZhcDzov57OO6ZMkc77X2boE2O0vxoaut+Qh3PcC2OMDgTj0wTnawNBZiZY8zBHZuH0lNtARX6L3q9+9at69tlntW/fPm3YsEE333yzMpmMFi1aFPWPAgYkn8/r1Vdffd8F4XEh5GaOzMIhN3NkFg65IS70GuAuxmc45GaOzIDyEfmi6xtvvKFFixZp0qRJ+vM//3NdeumleuGFFzRixIiofxQwIIVCQbt27epyHRFcGLmZI7NwyM0cmYVDbogLvQa4i/EZDrmZIzOgfER+eYHHH3886m8JAAAAAAAAAN6I/J2uAAAAAAAAAFDOWHRF2Uqn06qtre3xDnvoHbmZI7NwyM0cmYVDbogLvQa4i/EZDrmZIzOgfER+eQHAF5lMRtOmTbNdhnfIzRyZhUNu5sgsHHJDXOg1wF2Mz3DIzRyZAeWDP62gbOXzeW3ZsoW7RhoiN3NkFg65mSOzcMgNcaHXAHcxPsMhN3NkBpQPFl1RtgqFglpaWrhrpCFyM0dm4ZCbOTILh9wQF3oNcBfjMxxyM0dmQPlg0RUAAAAAAAAAIsSiKwAAAAAAAABEiEVXlK10Oq1JkyZx10hD5GaOzMIhN3NkFg65IS70GuAuxmc45GaOzIDykbVdAGBLJpNRXV2d7TK8Q27myCwccjNHZuGQG+JCrwHuYnyGQ27myAwoH/xpBWUrl8tpw4YNyuVytkvxCrmZI7NwyM0cmYVDbogLvQa4i/EZDrmZIzOgfLDoirIVBIEOHz6sIAhsl+IVcjNHZuGQmzkyC4fcEBd6DXAX4zMccjNHZkD5YNEVAAAAAAAAACLEoisAAAAAAAAARIhFV5StTCaj+vp6ZTIZ26V4hdzMkVk45GaOzMIhN8SFXgPcxfgMh9zMkRlQPrK2CwBsSafTGj9+vO0yvENu5sgsHHIzR2bhkBviQq8B7mJ8hkNu5sgMKB+80xVlK5fLac2aNdw10hC5mSOzcMjNHJmFQ26IC70GuIvxGQ65mSMzoHyw6IqyFQSB2trauGukIXIzR2bhkJs5MguH3BAXeg1wF+MzHHIzR2ZA+eDyAoBl+XxeO3bs0EsvvaTNmzfrpZdeUnNzszo6OiRJM2fO1Lp16+wW6SByQ1z27dunZ555Rs8++6y2bdumlpYWnTp1StXV1frgBz+ohoYGLV68WDNnzrRdqjMYn+GQmznGp7m3335bzz//vDZt2qRt27Zpz549am1t1alTp1RRUaGamhpNmTJFs2bN0mc+8xmNHTvWdskAgBLgGBoOuZkr58xYdAUseuKJJ3TLLbeovb3ddileITfEYcuWLbrjjju0adOmHj9/7NgxHTt2TNu2bdMjjzyiWbNmafny5aqtrY25UrcwPsMhNzOMz/Buu+02rVy5ssfP5XI5nT59Wq2trXr66af1wAMP6Otf/7q++c1vKp3mP8gBQBJwDA2H3MyRGYuuKGOZTEYNDQ1W7xp5/Phx737BJjdzLmTmI9u57dq1q9sJwsSJEzVlyhQNHz5cx48f14YNG/TGG29IktatW6eGhgb96le/0oQJE2yUbD0zyb/xKZGbj3wcn5IbvXa+4cOHa/LkyRo/fryqqqrU3t6u1157TZs2bVIul9OZM2e0ZMkS7d27V8uXL7ddLlBSro1PX5CbOduZ+XoMtY3czJEZi64oY+l0WiNHjrRdhiRp1KhRuuaaa4r/fvnLX+oHP/iB7bJ6RG7mXMrMJ67kdtVVV+nzn/+8PvWpT3X7b7aFQkGPPvqovvjFL6q9vV2tra265ZZbtGHDBqVSqdhrdSUzyZ/xKZGbz3wan5IbvTZr1izNnz9fN9xwg6666qoen/PWW2/pK1/5ih577DFJ0ooVKzR//nx94hOfiLNUIFYujE8fkZs5VzLz7RjqCnIzV86ZseiKstXR0aGnn35af/Inf6KKigorNXzsYx/T/v37u719/sUXX7RST3+QmzkXMvOR7dxGjx6tZcuW6dOf/nSv70RIp9P67Gc/q5qaGn384x+XJL3wwgt6+umndeONN8ZZriT7mUn+jU+J3Hzk4/iU3Oi1r371qxd8zqhRo/STn/xEb731ltasWSNJ+uEPf8iiKxLNhfHpI3IzZzszX4+htpGbOTKTuDgTyloul7P68y+77DIvr1dCbuZsZ+Yrm7nNnDlTt912W7/+69fNN9+sa6+9tvi4t+slxsF2r/k4PiVy842v41Oy32v9lUqldPvttxcfb9myxWI1QDx8GZ+uITdznOP6h9zMkRmLrgAARGLGjBnFj/ft22evEADdMD7DGTFiRPHjtrY2i5UAAGzhGBoOuZlLYmYsugIAEIHzrzmUz+ctVgLg/Rif4ezcubP48eWXX26vEACANRxDwyE3c0nMjEVXlK1sNqvrr79e2SyXNjZBbubILBzfctu2bVvx43HjxlmpwbfMXEFuyefC+JT86rXW1lZ997vfLT7meq5IOp/Gp0vIzZxvmblyDPUNuZlLYmYsuqKsDR482HYJXiI3c2QWji+5tbS0FG82I0lz5syxVosvmbmG3JLLpfEpud1r7e3t2rlzp773ve9p2rRpam1tlSRNnjxZ9913n+XqgNJzeXy6jNzM+ZKZa8dQX5CbuaRmxqIrylYul1NTUxMXfjdEbubILByfcrv33nuL/wWmtrZW8+fPt1KHT5m5hNySzZXxKbnXa+vXr1cqlSr+u/jii/WRj3xEX/3qV3Xo0CFJUmNjozZs2KDq6mrL1QKl5dr49AW5mfMpM5eOoT4hN3NJzYxFVwAABmD58uX6+c9/Xny8dOlSDRo0yGJFADoxPsOrqanRY489ppUrV+qSSy6xXQ4AIGYcQ8MhN3NJzsyPi4gAAOCgzZs364477ig+XrRokRYvXmyxIgCdGJ8XNmbMGN19992SpCAI1NbWpl27dunll1/WsWPHtGjRIj3yyCN6+OGHNXHiRMvVAgDiwjE0HHIzl/TMWHQFACCE3/72t5o/f77effddSdLUqVP18MMPW64KgMT47K8JEybowQcf7La9tbVV3/jGN/Too49q7dq1uu6667Ru3TpNnTrVQpUAgDhxDA2H3MyVQ2ZcXgBlK5vNqrGx0Zu7RrqC3MyRWTgu53bgwAHNnTtXBw8elHRu4WLVqlUaMmSI1bpczsxl5JYsro5PyZ9eGzNmjJYtW6Z77rlHknTs2DF98pOfLF5rDUgiX8ana8jNnMuZuXwMdRm5mSuXzFh0RVk7ffq07RK8RG7myCwcF3M7cuSI5s6dqz179kiSRo8erdWrV2v06NGWKzvHxcx8QG7J4Pr4lPzqtaVLlxZ/+XnllVf01FNPWa4IKC2fxqdLyM2ci5n5cAx1EbmZK6fMWHRF2crlclq7dq0Xd410CbmZI7NwXMzt5MmTuvHGG7Vjxw5J0vDhw7V69WpdccUVlis7x8XMfEBuyeD6+JT867XKykpNnz69+Pj555+3WA1QWr6NT1eQmzkXM/PhGOoicjNXbpmx6AoAQD+88847amxs1K9//WtJ0tChQ7Vq1Sp9+MMftlwZAMZn6dTU1BQ/PnLkiMVKAAClwDE0HHIzV46ZsegKAMAFvPvuu1qwYEHxXV6VlZVauXKlrr76asuVAWB8ltaBAweKHw8bNsxiJQCAqHEMDYfczJVrZiy6oqy5ePFyH5CbOTILx4XcOjo6tHDhQq1Zs0aSNGjQID355JOaMWOG5cp65kJmPiI3P/k2PiW/eu3IkSPauHFj8fHkyZMtVgOUnk/j0yXkZs6FzHw8hrqA3MyVc2b2RzpgSUVFhebNm2e7DO+QmzkyC8eF3PL5vBYvXqympiZJ506Qf/rTn2rOnDlW6+qNC5n5iNz85Nv4lOz32tGjR/v9btVCoaAvfOELOnPmjKRzvyDddNNNpSwPsMr2+PQVuZlzITMfj6EuIDdz5Z4Z73RF2SoUCjp06JAKhYLtUrxCbubILBzbuQVBoM997nP62c9+JklKp9P68Y9/rAULFlippz9sZ+YrcvOPj+NTst9rK1as0DXXXKMVK1bo5MmTvT6vublZjY2Nevzxx4vbvva1r+nSSy+No0zACtvj01fkZs52Zr4eQ20jN3NkxjtdUcby+bw2btyoxsZGpdP2/v7Q2Nio1tbWLtsOHjxY/Hjz5s2qr6/v9nVNTU0aM2ZMqcvrhtzMuZKZb2zn9tBDD2n58uXFx1deeaXWr1+v9evX9+vrH3zwwVKV1ivbmXXyaXxK5OYjH8en5Eavbd68Wbfeequy2azq6uo0adIk1dTUKJVK6ciRI2pubtZrr73W5WsWLlyo+++/30q9QFxcGJ8+IjdztjPz9RhqG7mZIzMWXQHrdu7cqf379/f6+XfeeUe/+c1vum0/e/ZsKctyHrmh1A4dOtTl8e7du7V79+5+f30SThLCYnyGQ279x/gMZ9CgQcWPc7mctm/fru3bt/f6/Orqai1ZskRf+tKXlMlk4igRAFBiHEPDITdzZMaiKwAAAFAW7rzzTt1www1avXq1XnzxRe3YsUMtLS06fvy4JGnIkCEaPXq06uvrNWfOHC1cuFBVVVV2iwYAAPAUi64oW6lUStXV1UqlUlbr2Ldvn9Wfb4rczLmSmW9s57ZkyRItWbLEys8Oy3ZmnXwanxK5+cjH8Sm50WsTJ07UxIkTddddd1mrAXCRC+PTR+RmznZmvh5DbSM3c2TGoivKWDab1ezZs22X4R1yM0dm4ZCbOTILh9wQF3oNcBfjMxxyM0dmQPngStcoW4VCQfv37+dOm4bIzRyZhUNu5sgsHHJDXOg1wF2Mz3DIzRyZAeWDRVeUrXw+r61btyqfz9suxSvkZo7MwiE3c2QWDrkhLvQa4C7GZzjkZo7MgPLBoisAAAAAAAAARIhFVwAAAAAAAACIEIuuKFupVEojRozgTpuGyM0cmYVDbubILBxyQ1zoNcBdjM9wyM0cmQHlI2u7AMCWbDar6dOn2y7DO+RmjszCITdzZBYOuSEu9BrgLsZnOORmjsyA8sE7XVG28vm8Xn31VS5gbojczJFZOORmjszCITfEhV4D3MX4DIfczJEZUD5YdEXZKhQK2rVrlwqFgu1SvEJu5sgsHHIzR2bhkBviQq8B7mJ8hkNu5sgMKB8sugIAAAAAAABAhFh0BQAAAAAAAIAIseiKspVOp1VbW6t0mmFggtzMkVk45GaOzMIhN8SFXgPcxfgMh9zMkRlQPrK2CwBsyWQymjZtmu0yvENu5sgsHHIzR2bhkBviQq8B7mJ8hkNu5sgMKB/8aQVlK5/Pa8uWLdw10hC5mSOzcMjNHJmFQ26IC70GuIvxGQ65mSMzoHyw6IqyVSgU1NLSwl0jDZGbOTILh9zMkVk45Ia40GuAuxif4ZCbOTIDygeLrgAAAAAAAAAQIRZdAQAAAAAAACBCLLqibKXTaU2aNIm7RhoiN3NkFg65mSOzcMgNcaHXAHcxPsMhN3NkBpSPrO0CAFsymYzq6upsl+EdcjNHZuGQmzkyC4fcEBd6DXAX4zMccjNHZkD54E8rKFu5XE4bNmxQLpezXYpXyM0cmYVDbubILBxyQ1zoNcBdjM9wyM0cmQHlg0VXlK0gCHT48GEFQWC7FK+QmzkyC4fczJFZOOSGuNBrgLsYn+GQmzkyA8oHi64AAAAAAAAAECEWXQEAAAAAAAAgQiVfdP3Od76jVCqlL3/5y6X+UYCRTCaj+vp6ZTIZ26V4hdzMkVk45GaOzMIhN8SFXgPcxfgMh9zMkRlQPrKl/OYvvfSSfvjDH2rq1Kmhvn7v3ogLSqCeMiK3vtXVSW++KZ37m8N4SVJlpTRhgs2q3Ld3r9TeLp2f29ix0quv2qzKbfRaOD31Grn1jczCYV4zx3lHOBwPzG3f3n0bvXZhjFFzjM9wOIaao9fC4XhgjmNBOKXIqGSLrqdOndItt9yif/iHf9C3v/3tUN/j3CSOvvSUEbn17c03pVOnum47dUo6dMhOPT47d9KA3tBr0SE3c2QWDvNa3zjvCIfjQTTotQtjjJpjfEaHY2jf6LXoMK/1jWNBOKXIqGSLrnfffbfmzZunOXPm9LnoeubMGZ05c6b4+OTJk+d9NlBHR07pdFqZTEb5fF6FQqH42c7tuVyuy53/MpmM0ul0r9s7Ojq61JDNnoshl8v1a3tFRYUKhYLy+XxxWyqVUjab7XV7b7UPdJ/OvYQpdRWo8yk+7lOpX6cSv8G77CRpPEXde+fG5vvHJwC3BSoUgrI5jzDdp97OO6SUt/sUx+vUmREG6tzvBufzeTyVpvd6HqOdufm5T+pSe/SvU0+ZIZxA+XwhQeOpa+2l+d0dYSV7Lh/YPvV23uHzPsXzOkU/Rkuy+vT444/r5Zdf1ksvvXTB5y5dulQPPPBAj5/L5fJqampSbW2tpk2bpubmZrW0tBQ/P2nSJNXV1WnTpk06fPhwcXt9fb3Gjx+v5557Tm1tbcXtDQ0NGjlypJ5++ukuQV9//fUaPHiwmpqauvz8xsZGnT59WmvXri1uy2azmjdvnt5++21t3LixuL26ulqzZ8/W66+/rq1btxa3jxgxQtOnT9fu3bu1a9eu4vao9ikI5uv9TZHL5dXW1u7tPpX6dZJmC9FJ0niKuvdyuWFikR/wSy6X1+uvv1k25xGm+yQt6DEzKevtPsXxOuXzBUlcu2+ggkBdXj/fx1Mpei+Xm6f3n3t0/k7l6z51KtXr1FNmCCeXy6u5eVtixlOnUv7ujvCSPJcPdJ/eW0Dsyud9iuN1KsXxIBV0/dPLgL3++uv6wz/8Qz3zzDPFa7nOmjVL9fX1+ru/+7tuz+/pna7jxo2TdEJVVdU6epR3uva1T8OGZXXqVNeJu6oqUOcbhn3cp1K/TjU12W7/rQPhVFVJR48mZzxF3XtDh6a6jU8AbquqCnTiBO907a323s472tp4p2tf+1RdHXA8iEBVVaCjR5MznkrRe72N0c7cfNynTqV6nXrKDOFUVQU6fpx3upr87o5wqqqk48eTO5cPdJ96Ou/gd/cL79N7Y/SkpKE6ceKEhgwZooGIfNH1iSee0M0339zlTnz5fF6pVErpdFpnzpzp8y59J0+e1NChQyWd0MiRQ/TWW1FWlzyjRnW/BszIkSK3PvSUWVWVNGWKnXp8sX1792sQ0Wt9o9fCee/GDIGCIFAqlVJlZYqbDPSBzMJhXjPHeUc4HA/M9TSvjR2b4iY9F8AYNcf4DIdjqDl6LRyOB+Y4FoTzXm7RLbpG/v8obrjhBm3btq3Ltttvv111dXX67//9v/e54Pp+/LJ4YRMmdB9M5Na3njKbMkU67x3y6EFDg/TCC1230Wt9o9cGimvimiMzE8xr5jjvCIfjwUAwr5lgjJpjfIbDMdQcvTZQHA/6i2NBOD3lNlDpaL/dues5TJkypcu/iy++WJdeeqmm8CccAEA/dXR0aOXKld3+ywh6R2YAkoZ5DQAgcTyAnyJfdAUAICrd75yOCyEzAEnDvAYAkDgewD+x3KZx3bp1cfwYAAAAAAAAALCOd7oCAAAAAAAAQIRYdAUAOCmbzer6669XNhvLf8pIBDIDkDTMawAAieMB/MSiKwDAWYMHD7ZdgnfIDEDSMK8BACSOB/APi64AACflcjk1NTVxwXwDZAYgaZjXAAASxwP4iUVXAAAAAAAAAIgQi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6AgCclM1m1djYyB1KDZAZgKRhXgMASBwP4CcWXQEAzjp9+rTtErxDZgCShnkNACBxPIB/WHQFADgpl8tp7dq13KHUAJkBSBrmNQCAxPEAfmLRFQAAAAAAAAAixKIrAAAAAAAAAESIRVcAgLO4UL45MgOQNMxrAACJ4wH8Q8cCAJxUUVGhefPm2S7DK2QGIGmY1wAAEscD+Il3ugIAnFQoFHTo0CEVCgXbpXiDzAAkDfMaAEDieAA/segKAHBSPp/Xxo0blc/nbZfiDTIDkDTMawAAieMB/MTlBRCZt99+W88//7w2bdqkbdu2ac+ePWptbdWpU6dUUVGhmpoaTZkyRbNmzdJnPvMZjR071nbJ1pFZOOQWzr59+/TMM8/o2Wef1bZt29TS0qJTp06purpaH/zgB9XQ0KDFixdr5syZtkuF5+g1c8xriBNj1Fw+n9eOHTv00ksvafPmzXrppZfU3Nysjo4OSdLMmTO1bt06u0U6hnkNcBfjMzyOoebKOrPAMSdOnAgkBdKJ4LrrbFfjvuuuCwKp6z9buc2bN+93r92F/w0aNChYsmRJkM/nY6+TzMIhN3OuZPbyyy8H1157bb8zmzVrVrB///74C32fs2fPBk888URw9uxZ26V4w3ZmvvWaK2M0CJjXks6V3Hwbo0Fgf14LgiD413/916CysrLPrGbOnGmtvvO50mtBwLyWdORmzqXMfBmf57N9PPDpGOpKr/mUWRCcn9u5dckTJ04M+HvyTleUxPDhwzV58mSNHz9eVVVVam9v12uvvaZNmzYpl8vpzJkzWrJkifbu3avly5fbLtcJZBYOuV3Yrl27tGnTpi7bJk6cqClTpmj48OE6fvy4NmzYoDfeeEOStG7dOjU0NOhXv/qVJkyYYKNkSVIqlVJ1dbVSqZS1GnxjOzNfe801zGsoFR/HqO15TZKOHz+u9vZ2az8/CZjXAHf5Mj5tHw98PIbaRmYS73T1nCt/wQiCIPjbv/3b4OGHHw52797d63MOHjwYLFq0qMtfM/7lX/4lxirJLCxyM+dKZo899lggKbjqqquC73znO8Ebb7zR7Tn5fD740Y9+1OWdPNddd11QKBTiLxje8q3XXBmjQcC8lnSu5ObbGHXFsmXLAknBqFGjgptuuil44IEHgqampuBLX/oS73TtA/NaspGbOZcy82V8usSnY6grveZTZkFQmne6sujqOVcGk4lCoRDMnj27OKDmzJkT688ns3DIzZwrma1bty5YtmxZkMvlLvjcX/ziF11OrFatWhVDhT3L5/PBvn37rP9XJp/Yzsy3XnNljJpgXvOTK7n5NkaDwP68FgRBcODAgR7/u+P999/PomsEmNf8RG7mfMzM9vg8n+3jgU/HUFd6zafMgqA0i67pAb1NFgghlUrp9ttvLz7esmWLxWr8QGbhkNs5M2fO1G233aZMJnPB595888269tpri49XrlxZytL6lM/ntXXrVu5QasB2Zr72mk+Y1zAQPo5R2/OaJF122WWqra219vOTjnkNcJdL49P28cDHY6htZCax6AorRowYUfy4ra3NYiX+ILNwyM3cjBkzih/v27fPXiFIPHotHOY1xIUxirgwrwHuYnyGwzHUXBIzY9EVVuzcubP48eWXX26vEI+QWTjkZu78i9PzLlOUEr0WDvMa4sIYRVyY1wB3MT7D4RhqLomZseiK2LW2tuq73/1u8fEnPvEJi9X4gczCIbdwtm3bVvx43Lhx1upIpVIaMWKE1TtW+8a3zFzpNZ8wryFOLoxR3+Y1mGNeA9zl0vj07XjgwjHUN0nMjEVXxKK9vV07d+7U9773PU2bNk2tra2SpMmTJ+u+++6zXJ2byCwcchuYlpYWrVmzpvh4zpw51mrJZrOaPn26stmstRp841NmLvWa65jXYIMrY9SneQ39x7wGuMvV8enT8cCVY6hPkpqZ+90KL61fv14f/ehH+3xOY2OjfvKTn6i6ujqmqtxGZuGQW7Tuvffe4n/lqK2t1fz5863Vks/ntXv3bn3oQx/q18XX4VdmLvWaa5jX4AJXxqhP8xp6x7wGuMuX8enT8cCVY6hPkpoZ73RF7GpqavTYY49p5cqVuuSSS2yX4wUyC4fczCxfvlw///nPi4+XLl2qQYMGWaunUCho165dKhQK1mrwjS+ZudZrPmFeQxxcGqO+zGsIj3kNcJdL49OX44FLx1BfJDkz3umKkhgzZozuvvtuSVIQBGpra9OuXbv08ssv69ixY1q0aJEeeeQRPfzww5o4caLlat1AZuGQWzQ2b96sO+64o/h40aJFWrx4scWKkFT02oUxr8EmxihKgXkNcBfjMzocQ80lPrPAMSdOnAgkBdKJ4LrrbFfjvuuuCwKp6z+Xc3vzzTeD22677XevsYKamprgN7/5Taw1kFk45GbOl8z27t0bXHbZZcWspk6dGpw4ccJ2WcHZs2eDJ554Ijh79qztUrzhemau9ZovY7QT85q/fMnNtTEaBG7Pa/fff38xq5kzZ9ouJwgCf3qtE/Oav8jNnG+ZuTA+z+fy8SAI3DqG+tJrLmUWBOfndm5dMopauLwAYjVmzBgtW7ZM99xzjyTp2LFj+uQnP1m8dge6I7NwyK1/Dhw4oLlz5+rgwYOSpAkTJmjVqlUaMmSI5cqkdDqt2tpapdMcqvrL5cxc7jVfMK+hlFwdoy7Paxg45jXAXa6NT5ePB64eQ11WLpm5160oC0uXLi0OpldeeUVPPfWU5YrcR2bhkFvvjhw5orlz52rPnj2SpNGjR2v16tUaPXq05crOyWQymjZtmvMXyneJq5m53mu+YV5D1Fweo67Oa4gW8xrgLlfGp6vHA5ePoa4qp8xYdIUVlZWVmj59evHx888/b7EaP5BZOOTWs5MnT+rGG2/Ujh07JEnDhw/X6tWrdcUVV1iu7D35fF5btmzh3S4GXMzMh17zDfMaouT6GHVxXkP0mNcAd7kyPl08Hrh+DHVRuWXGoiusqampKX585MgRi5X4g8zCIbeu3nnnHTU2NurXv/61JGno0KFatWqVPvzhD1uurKtCoaCWlhbn71DqEtcy86XXfMS8hij4MEZdm9dQOsxrgLtcGJ+uHQ98OIa6phwzY9EV1hw4cKD48bBhwyxW4g8yC4fc3vPuu+9qwYIFxb9QV1ZWauXKlbr66qstV4akoddKi3kNA8UYhWuY1wB3MT674hhqrlwzY9EVVhw5ckQbN24sPp48ebLFavxAZuGQ23s6Ojq0cOFCrVmzRpI0aNAgPfnkk5oxY4blypA09FppMa9hoBijcA3zGuAuxmdXHEPNlXNmLLoiEkePHu33cwuFgr7whS/ozJkzks4NuJtuuqlUpTmLzMIht3Dy+bwWL16spqYmSVI2m9VPf/pTzZkzx3JlvUun05o0aZKTdyh1lQuZ+dhrtjGvIU6+jVEX5jWYY14D3OXr+HTheODbMdQF5Z4ZZy+IxIoVK3TNNddoxYoVOnnyZK/Pa25uVmNjox5//PHitq997Wu69NJL4yjTKWQWDrmZC4JAn/vc5/Szn/1M0rkTlh//+MdasGCB5cr6lslkVFdX59wdSl1mOzNfe8025jXExccxanteQzjMa4C7fB2fto8HPh5DbSMzKWu7ACTH5s2bdeuttyqbzaqurk6TJk1STU2NUqmUjhw5oubmZr322mtdvmbhwoW6//77LVVsH5mFQ25mHnroIS1fvrz4+Morr9T69eu1fv36fn39gw8+WKrS+pTL5bRp0yZde+21ymY5XPWH7cx87TUXMK8hDj6OUdvzWqfGxka1trZ22Xbw4MHix5s3b1Z9fX23r2tqatKYMWNKXZ6TmNcAd/k4Pm0fD3w8htpGZiy6IiKDBg0qfpzL5bR9+3Zt37691+dXV1dryZIl+tKXvlS271wgs3DIzdyhQ4e6PN69e7d2797d76+3dbALgkCHDx9WEARWfr6PbGfma6/ZxryGuPg4Rm3Pa5127typ/fv39/r5d955R7/5zW+6bT979mwpy3IW8xrgLl/Hp+3jgY/HUNvIjEVXROTOO+/UDTfcoNWrV+vFF1/Ujh071NLSouPHj0uShgwZotGjR6u+vl5z5szRwoULVVVVZbdoy8gsHHIDkDTMawCShnkNcBfjE4gPi66IzMSJEzVx4kTdddddtkvxBpmFQ25mlixZoiVLltguA2WAXguPeQ1xYIyGt2/fPtsleId5DXAX49Mcx1BzZMaNtAAAjspkMqqvr+e/GRogMwBJw7wGAJA4HsBPvNMVAOCkdDqt8ePH2y7DK2QGIGmY1wAAEscD+Il3ugIAnJTL5bRmzRrlcjnbpXiDzAAkDfMaAEDieAA/segKAHBSEARqa2uzfsdqn5AZgKRhXgMASBwP4CcWXQEAAAAAAAAgQiy6AgAAAAAAAECEWHQFADgpk8mooaGBO5QaIDMAScO8BgCQOB7AT1nbBQAA0JN0Oq2RI0faLsMrZAYgaZjXAAASxwP4iXe6AgCc1NHRoZUrV6qjo8N2Kd4gMwBJw7wGAJA4HsBPLLoCAJyVy+Vsl+AdMgOQNMxrAACJ4wH8w6IrAAAAAAAAAESIRVcAAAAAAAAAiBCLrgAAJ2WzWV1//fXKZrnnY3+RGYCkYV4DAEgcD+AnFl0BAM4aPHiw7RK8Q2YAkoZ5DQAgcTyAf1h0BQA4KZfLqampiQvmGyAzAEnDvAYAkDgewE8sugIAAAAAAABAhFh0BQAAAAAAAIAIsegKAAAAAAAAABFi0RUA4KRsNqvGxkbuUGqAzAAkDfMaAEDieAA/segKAHDW6dOnbZfgHTIDkDTMawAAieMB/MOiKwDASblcTmvXruUOpQbIDEDSMK8BACSOB/ATi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6AgCcxYXyzZEZgKRhXgMASBwP4J/IF10feughTZ06VUOGDNGQIUPU0NCgp556KuofAwBIuIqKCs2bN08VFRW2S/EGmQFIGuY1AIDE8QB+ivzPBB/84Af1ne98Rx/60IcUBIGWL1+u//Sf/pO2bNmij3zkI0bfa+/eqKtLnp4y2r5damiIvxZfbN/efRu9dmH0mjl6LZy6Oun/b+/Ow6Oq83yPf2qBCGYxGAIBSRRoCDYitIIEumVVNAgudLeCC24zjw7ut72t18cW79xp2u72dveMPqIzDoujqGO3elsQBdlEwIjAsKgZFiVqkCVAFiIhVXXuHzQFgZDknFSd3zmV9+t5eJ6qk0ryrU99f79T9cvhnG+/lSRLlmUpEAioY8eAevY0XZl37dgh1dZKJ2bWvXtAX3xhujJvY16zj3nNmcYyIreWicVi2rdvn3JychQM8p/0msO8Zh/zmjPMa/YxPp1p7H0unw2axrzmTDIyCliWZSX+xzbUqVMn/e53v9Mdd9zR7GOrqqqUlZUlqVLp6Zmqrk52df6WkSHV1Jiuwv/S00WvNYNeSwx6rXn0WmLQa82j1xKDXmteY71Gbi1TX1+vBQsWqLi4mKObWoB5LTEYn81jXrOP8QmTGJ/NOz5GqyRlqbKyUpmZma36mUk9IUY0GtV//ud/6tChQyo6zZ9v6urqVFdXF79fVVV1wlct1ddHFAwGFQqFFI1GFYvF4l89tj0SiejEteNQKKRgMHja7fX19Q1qOHZekEgk0qLt7dq1UywWUzQajW8LBAIKh8On3X662lv7nI6+hAGhtSxJgaS9TqnQe8cyQmsdndeOSfYc4c/eY15LjKO9Zmr/5Ifeo9cS5ej+wSvvjbzYe6fbh/r5Obn1Oh37umUdPcIpFZ5Tc9tb95yY1xLj+Pu1VBpPzW2385wa7zVL0WjMt8+Jz+5Idak0npIzRyR+jCZl0XXTpk0qKirS4cOHlZ6erjfffFPnn39+o4+dMWOGnnzyyUa/FolEtWDBAuXn52vQoEHauHGjysrK4l/v27evCgsLVVJSor1798a3Dxw4UAUFBVqxYoWqT1jKLyoqUm5urt5///0GQY8aNUodOnTQggULGvz+4uJiff/991q6dGl8Wzgc1vjx47Vv3z6tXr06vj0jI0OjR4/W119/rQ0bNsS3d+7cWcOGDdPWrVtVWloa356o52RZE8TE3XrRaExSKGmvUyr03vFJCK0Ri1kNXu9kzxF+7L1IZLzotdY7tg81tX/yQ+/FYuxDEyESObp/8Mp7Iy/23rH3GSfz83Ny+3WKRCI6fPhwSj2nZLxO7EMT49g+VErN8ZSI5xSNXqWT57VIJKqNGzf59jnx2R2pLpXGUzLmiGTsQ5NyeoEjR46orKxMlZWVeuONN/Rv//ZvWr58eaMLr40d6dqjRw8dPb1Ahvbv50jXpp5Tp05h1dQwcbdWerql6mqOdG3qOWVkWPRaAqSnW9q/nyNdm3pOzGuJcazXUuuvzw1rb+1zotcS49g+1CvvjbzYe43tQ9PTpQMH/Puc3HqdIpGIVq1apUsvvVThcDglnlNz21vznJjXEuPE92upNJ6a227nOTXWa+nplg4e5EhXPrvDi9LTpf37U2c8JWOOOD5GE3d6AVfO6Tp27Fj16tVLzz//fLOPPfGcrrm5mdq9O9nV+dvxC84c17GjOKl0E46fiPu47t3FBWeaQa/ZR68506WLtGdPw23p6VL//mbq8YPNm089R1hurtiHNoN5zT7mNWcam9cYo0gG5jX7mNecYV6zj/HpTGNjlNyaxrzmzPF5zSfndD0mFos1OJq1pRhEzTs2aGKxmL7++mv16NGDK7u2EJnZQ685R2b29Ox56pv4/v2lE/4XC05SVCStWdNwG/vQ5jGvOUdm9jQ2rzFGW4Zes4d5zTkys4d5zT7GZ+uQm31kZk9j81prJTz1Rx99VCtWrNBXX32lTZs26dFHH9WyZct04403JvpX4QTRaFQbNmw46eTmaAqZOUNu9pEZ4G2MUfvIDG6h15whN/vIDG6h15whN/vIzLyEH+m6Z88e3XLLLdq1a5eysrI0YMAAvffee7rssssS/asAAAAAAAAAwHMSvuj64osvJvpHAgAAAAAAAIBvcFKHFBEIBNS5c2cFAlwNsaXIzBlys4/MAG9jjNpHZnALveYMudlHZnALveYMudlHZua5ciEtJF84HNawYcNMl+ErZOYMudlHZoC3MUbtIzO4hV5zhtzsIzO4hV5zhtzsIzPzONI1RUSjUX3xxRecINkGMnOG3OwjM8DbGKP2kRncQq85Q272kRncQq85Q272kZl5LLqmiFgsptLSUsViMdOl+AaZOUNu9pEZ4G2MUfvIDG6h15whN/vIDG6h15whN/vIzDwWXQEAAAAAAAAggVh0BQAAAAAAAIAEYtE1RQSDQeXn5ysY5CVtKTJzhtzsIzPA2xij9pEZ3EKvOUNu9pEZ3EKvOUNu9pGZeWHTBSAxQqGQBg0aZLoMXyEzZ8jNPjIDvI0xah+ZwS30mjPkZh+ZwS30mjPkZh+Zmcdyd4qIRqNav349V6WzgcycITf7yAzwNsaofWQGt9BrzpCbfWQGt9BrzpCbfWRmHouuKSIWi6msrIyr0tlAZs6Qm31kBngbY9Q+MoNb6DVnyM0+MoNb6DVnyM0+MjOPRVcAAAAAAAAASCAWXQEAAAAAAAAggVh0TRHBYFB9+/blqnQ2kJkz5GYfmQHexhi1j8zgFnrNGXKzj8zgFnrNGXKzj8zMC5suAIkRCoVUWFhougxfITNnyM0+MgO8jTFqH5nBLfSaM+RmH5nBLfSaM+RmH5mZx3J3iohEIlq1apUikYjpUnyDzJwhN/vIDPA2xqh9ZAa30GvOkJt9ZAa30GvOkJt9ZGYei64pwrIs7d27V5ZlmS7FN8jMGXKzj8wAb2OM2kdmcAu95gy52UdmcAu95gy52Udm5rHoCgAAAAAAAAAJxDldkVBfffWVFi1apOXLl2vTpk0qKytTTU2NMjIydM4556ioqEhTpkzRiBEjTJfqOUeOHNFrr72mefPmacuWLdq9e7eys7N13nnn6brrrtOtt96qnJwc02V6Br1mXzQa1ZYtW/TJJ59o7dq1+uSTT7Rx40bV19dLkkaMGKFly5aZLdJj9u3bp48++kglJSXatGmTtm/frvLyctXU1Khdu3bKzs5W//79NXLkSN1yyy3q3r276ZI9gfHpDGMUbqHX4Bb2B3AL85p9jE/ABZbHVFZWWpIsqdIaOtR0Nf4RjUatr776yopGo0Z+/7p166whQ4b87bVr/t/IkSOtnTt3Gqn1GNOZnejzzz+3Bg4c2GRmubm51vz5802Xajw3es2ZN9980+rYsWOTWY0YMcJYfScaOtSypIb/TO0Pxo8f3+JeS0tLs6ZPn27kdfZKZn4cn5bFGHXCC5n5iVfGqGXRa22F6dz8uD8wnZnfMK85Z7rX/Dg+Lct8bn5EZvYcn9eOrktWVla2+mdypGuKCAaDKigoMPb7S0tLVVJS0mBbnz591L9/f+Xk5OjgwYNatWqVvvnmG0nSsmXLVFRUpA8//FA9e/Y0UbLxzI755ptvNGbMGJWXl0uSAoGALr30UvXq1Ut79+7V4sWL9f3332vPnj265pprtHDhQo0ePdpYvaZzo9ecOXjwoGpra43W4Hc5OTnq16+fCgoKlJ6ertraWm3btk0lJSWKRCKqq6vT9OnTtWPHDs2ZM8d0uUb4cXxKjFEnvJAZnKHX2gbTuflxf2A6MzjHvGaPH8enZD43PyIz81h0TRGRSEQrVqzQpZdeqnDY3Mvau3dv3XnnnbrppptO+W+2sVhMs2fP1r333qva2lqVl5frxhtv1KpVqxQIBFyv1SuZTZkyJb7gWlBQoLffflsXXnhh/Ov79u3TDTfcoA8++ED19fX62c9+pu3bt+uss84yUq9XcqPXnOnSpYsGDx4c//fee+/pT3/6k9GavGzkyJGaMGGCxowZo969ezf6mN27d+vBBx/UvHnzJElz587VhAkT9NOf/tTNUj3FT+NTYow64aXM4Ay9ltq8kpuf9gdeyQzOMa/Z46fxKXknNz8hM/NIPUVYlqXq6mpjV6XLy8vTrFmzdPPNNysUCjX6mGAwqNtvv13Z2dm67rrrJElr1qzR+++/r3HjxrlZriTzmUnSggUL9OGHH0qS2rdvr7/+9a+64IILGjwmJydHb7/9tgYMGKAdO3Zo//79+u1vf6tf//rXJko2nhu95swVV1yhnTt3Kj8/v8H2jz/+2FBF/vCLX/yi2cd06dJFL7/8snbv3q0lS5ZIkp5//vk2uejqx/EpMUad8EJmcIZeaxtM5+bH/YHpzOAc85o9fhyfkvnc/IjMzAuaLgCpYcSIEbr11ltPO2mf6Nprr9WQIUPi9+fPn5/M0jzt2Wefjd+eOnXqKQuux5x55pn63//7f8fvP//884pEIkmvz4voNWe6du16yhtRJE4gENBtt90Wv79+/XqD1ZjD+HSOMQq30GtwA/sDuIl5zR7GJ+AeFl1hxPDhw+O3v/rqK3OFGFRTU6MPPvggfv/EBZvGTJo0Senp6ZKk/fv3a8WKFUmtL1XQa3BL586d47erq6sNVuIfjE8AgMT+APAyxifgHIuuKSIUCqmoqKhFf63yghPPAxONRo3UYDqzVatWqa6uTtLRI1kHDx7c5OPPOOMMFRUVxe8f+2/MbjOdm130Gtzy2WefxW+fe+655grxES+MT4kx6gSZwS30mjN+y80L+wO/ZQb/8luveWF8Sv7LzQvIzDwWXVNEMBhUbm6ugkF/vKSbNm2K3+7Ro4eRGkxn9vnnn8dvX3DBBS06sfWPfvSjRr/fTaZzs4tegxvKy8v1+9//Pn6/LZ7P1QkvjE+JMeoEmcEt9JozfsvNC/sDv2UG//Jbr3lhfEr+y80LyMw8kk8R9fX1mj9/vurr602X0qyysrIGR2mOHTvWSB2mMystLY3fLigoaNH3nHiuoi+++CLhNbWE6dzsoNeQTLW1tfrss8/09NNPa9CgQSovL5ck9evXT4888ojh6rzPK+NTYow6QWZwC73mjJ9y88r+wE+Zwd/81GteGZ+Sv3LzCjIzr/lD6+Abfrmw0kMPPRT/bwn5+fmaMGGCsVpMZlZRURG/3aVLlxZ9T9euXeO39+/fn/CaWopes88vmeH0Vq5cqZ/85CdNPqa4uFgvv/yyMjIyXKrKv7w0PiXGqBNkBrfQa874JTcv7Q/8khn8zy+95qXxKfknNy8hM7M40hWumjNnjv785z/H78+YMUNpaWkGKzKnpqYmfrtDhw4t+p4TH3fi9+NU9BrclJ2drXnz5mn+/Pk666yzTJfjeYxPAIDE/gDwMsYn0Hoc6QrXrF27VnfddVf8/uTJkzVlyhSDFZl1+PDh+O327du36HtO3Ml9//33Ca8pVdBrSIZu3bpp2rRpkiTLslRdXa3S0lKtW7dOBw4c0OTJk/XCCy9o5syZ6tOnj+FqvYvxCQCQ2B8AXsb4BBKDRdcUEQ6HNWrUqBZdjMmEL7/8UhMmTIgvNA4YMEAzZ840WpPpzM4444z47SNHjrToe+rq6uK3W3p0bKKZzq059BqSpWfPnnrmmWdO2V5eXq7HHntMs2fP1tKlSzV06FAtW7ZMAwYMMFClt3lxfEqMUSfIDG6h15zxem5e3B94PTOkDq/3mhfHp+T93LyIzMzj9AIpxNQiXHN27dqlyy67TN99952kowsXCxcuVGZmpuHKzGaWnp4ev93So1ZPfNyJ3+82es0+r2aG1uvWrZtmzZql++67T5J04MAB3XDDDfHzX+EoL49PiTHqBJnBLfSaM17Nzcv7A69mhtTj1V7z8viUvJubl5GZWSy6pohIJKIFCxZ47iTJFRUVuuyyy7R9+3ZJUl5enhYvXqy8vDzDlZnP7Oyzz47f3r17d4u+59jOT5I6deqU8JpawnRup0OvwbQZM2bE35B+/vnnevfddw1X5B1eHp8SY9QJMoNb6DVnvJqbl/cHXs0Mqcervebl8Sl5NzcvIzPzWHRF0lRVVWncuHHasmWLJCknJ0eLFy/WeeedZ7gyb+jbt2/89s6dO1v0PWVlZfHbhYWFCa/Jr+g1eEHHjh01bNiw+P2PPvrIYDXewfgEAEjsDwAvY3wCycGiK5Li0KFDKi4u1qeffipJysrK0sKFC3X++ecbrsw7+vXrF7+9adOmFv31ad26dY1+f1tGr8FLsrOz47crKioMVuINjE8AgMT+APAyxieQPCy6IuEOHz6siRMnxo/y6tixo+bPn6+LLrrIcGXeMmzYMKWlpUk6uqNbu3Ztk4+vq6vTmjVr4vdHjx6d1Pr8gF6D1+zatSt+29QpQLyC8QkAkNgfAF7G+ASSi0XXFBEOh1VcXGz8qnT19fWaNGmSlixZIklKS0vT22+/reHDhxutqzGmM0tPT9eYMWPi92fPnt3k4//yl7+ourpa0tHFnEsvvTSZ5Z2W6dyOodfgNRUVFVq9enX8fls+Gt1P41NijDpBZnALveaMV3Lz0/7AK5kh9Xml1/w0PiXv5OYnZGYei64p5MQr25sQjUY1ZcoULViwQNLRAf76669r7NixRutqiunM/uEf/iF+e/bs2fFz6JystrZWv/rVr+L3//7v/97oxGk6N3oNbti/f3+LHxuLxXTPPfeorq5O0tE3rVdddVWySvM0P45PiTHqBJnBLfSaM6Zz8+P+wHRmaDtM95ofx6dkPjc/IjOzWHRNEZFIREuXLjV2VTrLsnTHHXfojTfekCQFg0G99NJLmjhxopF6WsJ0ZpI0fvx4/eQnP5F09PQBV111lTZu3NjgMRUVFbrmmmu0bds2SUePcv3lL3/peq3HmM6NXoNb5s6dq8GDB2vu3Lmqqqo67eM2btyo4uJivfrqq/FtDz/8sM4++2w3yvQUP45PiTHqBJnBLfSaM6Zz8+P+wHRmaDtM95ofx6dkPjc/IjPzOMYYCfHcc89pzpw58fu9evXSypUrtXLlyhZ9/zPPPJOs0jzvlVde0ZAhQ7Rr1y599dVXGjhwoEaMGKFevXpp7969Wrx4sWprayUd/wvkWWedZbZog+g154qLi1VeXt5g23fffRe/vXbtWg0cOPCU71uwYIG6deuW7PI8ae3atZo6darC4bAKCwvVt29fZWdnKxAIqKKiQhs3boz/QeSYSZMm6YknnjBUsVmMz9ZhjMIt9BqSjf0B3Ma81nKMT8A9LLoiIfbs2dPg/tatW7V169YWf39bnrjPOeccLVmyRJMnT9aGDRtkWZaWLVumZcuWNXhc586dNWvWrAbngW2L6DXnPvvsM+3cufO0Xz906JD+67/+65TtR44cSWZZnnXsQnfS0b8Sb968WZs3bz7t4zMyMjR9+nTdf//9CoVCbpToOYzP1mGMwi30GpKN/QHcxrzWcoxPwD0suqYQTo5sn1cyKyws1Mcff6xXX31V8+bN05YtW7R7926dddZZ6tmzp6677jrddtttysnJMV2qJO/k5idk5j933323xowZo8WLF+vjjz/Wli1bVFZWpoMHD0qSMjMzlZeXp4EDB2rs2LGaNGmS0tPTzRYNxxij9pEZ3EKvOUNu9pEZ3EKvOUNu9pGZWQHLsizTRZyoqqpKWVlZkio1dGimTrgQNACgDSgqktasabht6FCxP2gCmQHexhgFkGqY1wCkmuPzWpWkLFVWViozM7NVP5MLaaWIWCymPXv2KBaLmS7FN8jMGXKzj8wAb2OM2kdmcAu95gy52UdmcAu95gy52Udm5rHomiKi0ahWr16taDRquhTfIDNnyM0+MgO8jTFqH5nBLfSaM+RmH5nBLfSaM+RmH5mZx6IrAAAAAAAAACQQi64AAAAAAAAAkEAsuqaIQCCgjIwMBQIB06X4Bpk5Q272kRngbYxR+8gMbqHXnCE3+8gMbqHXnCE3+8jMvIBlWZbpIk5UVVWlrKwsSZUaOjSTqx8CQBvD1XDtIzPA2xijAFIN8xqAVHN8XquSlKXKykplZma26mdypGuKiMVi2rlzJ1els4HMnCE3+8gM8DbGqH1kBrfQa86Qm31kBrfQa86Qm31kZh6LrikiGo1qw4YNXJXOBjJzhtzsIzPA2xij9pEZ3EKvOUNu9pEZ3EKvOUNu9pGZeSy6AgAAAAAAAEACsegKAAAAAAAAAAnEomuKCAQC6ty5M1els4HMnCE3+8gM8DbGqH1kBrfQa86Qm31kBrfQa86Qm31kZl7YdAFIjHA4rGHDhpkuw1fIzBlys4/MAG9jjNpHZnALveYMudlHZnALveYMudlHZuZxpGuKiEaj+uKLLzhBsg1k5gy52UdmgLcxRu0jM7iFXnOG3OwjM7iFXnOG3OwjM/NYdE0RsVhMpaWlisVipkvxDTJzhtzsIzPA2xij9pEZ3EKvOUNu9pEZ3EKvOUNu9pGZeSy6AgAAAAAAAEACsegKAAAAAAAAAAnEomuKCAaDys/PVzDIS9pSZOYMudlHZoC3MUbtIzO4hV5zhtzsIzO4hV5zhtzsIzPzwqYLQGKEQiENGjTIdBm+QmbOkJt9ZAZ4G2PUPjKDW+g1Z8jNPjKDW+g1Z8jNPjIzj+XuFBGNRrV+/XquSmcDmTlDbvaRGeBtjFH7yAxuodecITf7yAxuodecITf7yMw8Fl1TRCwWU1lZGVels4HMnCE3+8gM8DbGqH1kBrfQa86Qm31kBrfQa86Qm31kZh6LrgAAAAAAAACQQCy6AgAAAAAAAEACseiaIoLBoPr27ctV6WwgM2fIzT4yA7yNMWofmcEt9Joz5GYfmcEt9Joz5GYfmZmX8ORnzJihwYMHKyMjQ7m5ubrmmmtUWlqa6F+Dk4RCIRUWFioUCpkuxTfIzBlys4/MAG9jjNpHZnALveYMudlHZnALveYMudlHZuaFE/0Dly9frmnTpmnw4MGKRCL6X//rf+nyyy/XZ599pjPPPNPWz9qxI9HVpZ7CQunbbyXJUjQaUygUVMeOAfXsaboy79qxQ6qtlU7MrHv3gL74wnRl3kav2UevOdPY3M/+oGmN5bN5s1RU5H4tfsIYtY99gTObN5+6jXmtafSaM43Na+TWNPYFzvB+zT7mNWeY1+xjXnMmGXNYwLIsK/E/9ri9e/cqNzdXy5cv16WXXtrs46uqqpSVlSWpUunpmaquTmZ1/peRIdXUmK7C/9LTRa81g15LDHqteY31Grk1jfGZOPRa0+i1xKHXmkavwSTGZ/N4v2Yf8xpMYnw27/gYrZKUpcrKSmVmZrbqZyb8SNeTVVZWSpI6derU6Nfr6upUV1cXv19VVXXCVy3V10cUDAYVCoUUjUYVi8XiXz22PRKJ6MS141AopGAweNrt9fX1DWoIh4/GEIlEWrS9Xbt2isViikaj8W2BQEDhcPi0209Xe2uf09GXMCC0liUpkLTXKRV671hGaK2j89oxyZ4j/Nl7jc1rx3Pz53NSg9oT/zqxL0gcS7GYlULjqWHtrX1O9FpipfZc3rrn9LcqBJhx/H1HKoynZMwRp3u/dvSoOn8+Jz67I9Wl0nhKzhyR+DGa1EXXWCymBx54QMOHD1f//v0bfcyMGTP05JNPNvq1SCSqBQsWKD8/X4MGDdLGjRtVVlYW/3rfvn1VWFiokpIS7d27N7594MCBKigo0IoVK1R9wlJ+UVGRcnNz9f777zcIetSoUerQoYMWLFjQ4PcXFxfr+++/19KlS+PbwuGwxo8fr3379mn16tXx7RkZGRo9erS+/vprbdiwIb69c+fOGjZsmLZu3drg3LaJek6WNUFM3K0XjcYkhZL2OqVC7x2fhNAasZjV4PVO9hzhx96LRMbr5F47tj/w63M6JlmvU2OZwZlIJKqvv/42ZcbTMYnqPWliC1JES6XyXN7a5xSJBMS8BlNOfN+RCuMpGXNENHqVpIbniYxEotq4cZNvnxOf3ZHqUmk8JWOOSMZnqqSeXuDuu+/Wu+++q5UrV+qcc85p9DGNHenao0cPHT29QIb27+dI16aeU6dOYdXUMHG3Vnq6pepqjnRt6jllZFj0WgKkp1vav58jXZt6To3Nayfm5sfndEyyXif2BYmTnm6pspIjXU9XO72WOOnp0oEDqTuXt/Y5ZWaKXoMxJ77vSIXxlIw54nTv1w4e5EhXPrvDi9LTpf37U2c8JWOOOD5GE3d6gaQtut5zzz16++23tWLFCp133nkt/r4Tz+mam5up3buTUV3q6NJF2rOn4bb0dOk0BxZDRy9mcfK5dHJzRa81g16zj15zprFeI7emHb8ww3EdO4oLDDSDMWof+wJnjl/Q4rju3cUFLZpArznTWK+xP2ga+wJneL9mH/OaM8xr9jGvOXN8jHr4nK6WZenee+/Vm2++qWXLltlacD0Zg6h5PXueOnH37y+dcLQ3TlJUJK1Z03AbvdY8es0+es2ZxnqN3Jp2bOEmEoloxYoVuvTSS086LyIawxi1j31B6zBGW45eax16reXYFzjD+zX7mNdah3mt5ZjXnGlsjLZWwjt12rRpeuWVV/T2228rIyND3333nSQpKytLHTp0SPSvAwAAf2NZlqqrq5XEMwcBaAXGKNxCrwFINcxr8KNgon/gc889p8rKSo0cOVJ5eXnxf6+99lqifxUAAAAAAAAAeE5STi8AAAAAAAAAAG1Vwo90BQAAZoRCIRUVFSkUCpkuBUAjGKNwC70GINUwr8GPOPswAAApIhgMKjc313QZAE6DMQq30GsAUg3zGvyII10BAEgR9fX1mj9/vurr602XAqARjFG4hV4DkGqY1+BHLLoCAJBCIpGI6RIANIExCrfQawBSDfMa/IZFVwAAAAAAAABIIBZdAQAAAAAAACCBWHQFACBFhMNhjRo1SuEw18kEvIgxCrfQawBSDfMa/IhFVwAAUkiHDh1MlwCgCYxRuIVeA5BqmNfgNyy6AgCQIiKRiBYsWMBFBgCPYozCLfQagFTDvAY/YtEVAAAAAAAAABKIRVcAAAAAAAAASCAWXQEAAAAAAAAggVh0BQAgRYTDYRUXF3NVV8CjGKNwC70GINUwr8GPWHQFACCFfP/996ZLANAExijcQq8BSDXMa/AbFl0BAEgRkUhES5cu5aqugEcxRuEWeg1AqmFegx+x6AoAAAAAAAAACcTJMADDvvrqKy1atEjLly/Xpk2bVFZWppqaGmVkZOicc85RUVGRpkyZohEjRpgu1TP27dunjz76SCUlJdq0aZO2b9+u8vJy1dTUqF27dsrOzlb//v01cuRI3XLLLerevbvpkj2BXnOG3OAWeg1uodfgBt6vwU3Ma3ALvWZfm87M8pjKykpLkiVVWkOHmq7G+4YOtSyp4T9ya5pXMlu3bp01ZMiQv/V78/9Gjhxp7dy50/1C/8YruVmWZY0fP77FuaWlpVnTp0+3otGo63V6JTN6zRm/5WZZlnXkyBHrnXfesY4cOWK0Dr+g1+zzSmZ+ZXqM0mtth+lesyzer6U6r+TGvNZ2mJ7X6DX7/JSZZZ2Y29F1ycrKylb/TI50BQwpLS1VSUlJg219+vRR//79lZOTo4MHD2rVqlX65ptvJEnLli1TUVGRPvzwQ/Xs2dNEyZ6Uk5Ojfv36qaCgQOnp6aqtrdW2bdtUUlKiSCSiuro6TZ8+XTt27NCcOXNMl2sEveaMH3Nr166dxo8fb+R3wzk/9hqcMT1G6bW2w3SvnYz3a0gW5rW2w/S8Rq/ZR2acXgAwrnfv3rrzzjt10003nfLfqmKxmGbPnq17771XtbW1Ki8v14033qhVq1YpEAgYqti8kSNHasKECRozZox69+7d6GN2796tBx98UPPmzZMkzZ07VxMmTNBPf/pTN0v1FHrNGT/lFovFtG/fPuXk5CgY5LTtfuOnXoMzXhmj9Frq80Kv8X4NbmJeS31emNckes2JNp1ZAo7ATShOL2CPVw4b9xOvZLZs2TJr1qxZViQSafaxf/nLXxocdr9w4UIXKmzIK7nZEYvFrNGjR8dzGzt2rKu/3yuZ0WvO+C03yzr6367eeustTi/QQvSafV7JzK9Mj1F6re0w3Wt28H7Nn7ySG/Na22F6XqPX7PNTZpaVnNMLcBgMYMiIESN06623KhQKNfvYa6+9VkOGDInfnz9/fjJLSxmBQEC33XZb/P769esNVmMOveYMucEt9BrcQq/Bi3i/htZgXoNb6DX7yExi0RXwieHDh8dvf/XVV+YK8ZnOnTvHb1dXVxusxD/oNWfIDW6h1+AWeg1u4f0a3MK8BrfQa/alYmYsugI+ceL5TKLRqMFK/OWzzz6L3z733HPNFeIj9JozXsgtEAgoIyMjNc5/hNPyQq/BGb+NUXrNv/zWa7xfg1uY1/zLb/MavWZfKmbGhbQAn9i0aVP8do8ePQxW4h/l5eX6/e9/H7/PRRlahl5zxgu5hcNhjR492sjvhnu80Gtwxm9jlF7zLz/1Gu/X4CbmNf/y07wm0WtOpGJmHOkK+EBZWZmWLFkSvz927FiD1XhbbW2tPvvsMz399NMaNGiQysvLJUn9+vXTI488Yrg676PXnPFKbrFYTDt37lQsFjPy+5F8Xuk1OOOnMUqv+ZvXe433azCBec3fvD6vnYhesy9VM+NIV8AHHnroofjh9fn5+ZowYYLhirxj5cqV+slPftLkY4qLi/Xyyy8rIyPDpar8i15zxiu5RaNRbdiwQd26dVMwyN9VU5FXeg3O+GmM0mv+5rVe4/0avIB5zd+8Nq81hV6zL1Uz83anAtCcOXP05z//OX5/xowZSktLM1iRf2RnZ2vevHmaP3++zjrrLNPleB695gy5wS30GtxCr8FNvF+DG5jX4BZ6zb5UzowjXQEPW7t2re666674/cmTJ2vKlCkGK/Kebt26adq0aZIky7JUXV2t0tJSrVu3TgcOHNDkyZP1wgsvaObMmerTp4/har2LXnOG3OAWeg1uodeQDLxfg0nMa3ALvWZfqmfGoivgUV9++aUmTJigw4cPS5IGDBigmTNnGq7Ke3r27KlnnnnmlO3l5eV67LHHNHv2bC1dulRDhw7VsmXLNGDAAANVehu95owXcwsEAurcubNvruqKlvFir8EZr49Rei11eK3XeL8GU5jXUofX5rWT0Wv2tYXMOL0A4EG7du3SZZddpu+++07S0TeqCxcuVGZmpuHK/KNbt26aNWuW7rvvPknSgQMHdMMNN8TPE4Oj6DVnvJpbOBzWsGHDFA7zN9VU4dVegzNeHqP0Wmrxcq+diPdrSCbmtdTi5XmNXrOvrWTGoivgMRUVFbrsssu0fft2SVJeXp4WL16svLw8w5X504wZM+IT9+eff653333XcEXeQa854+XcotGovvjiCz6spggv9xqc8eoYpddSj1d77XR4v4ZEY15LPV6d1+g1+9pSZiy6Ah5SVVWlcePGacuWLZKknJwcLV68WOedd57hyvyrY8eOGjZsWPz+Rx99ZLAa76DXnPF6brFYTKWlpYrFYqZLQSt5vdfgjBfHKL2WmrzYa03h/RoSiXktNXlxXqPX7GtrmbHoCnjEoUOHVFxcrE8//VSSlJWVpYULF+r88883XJn/ZWdnx29XVFQYrMQb6DVnyA1uodfgFnoNXsL7NSQC8xrcQq/Z1xYzY9EV8IDDhw9r4sSJ8b/qd+zYUfPnz9dFF11kuLLUsGvXrvjtTp06GazEPHrNGXKDW+g1uIVeg9fwfg2txbwGt9Br9rXVzFh0BQyrr6/XpEmTtGTJEklSWlqa3n77bQ0fPtxwZamhoqJCq1evjt/v16+fwWrMotec8VNuwWBQ+fn5CgbZvfuRn3oNznhljNJrqc8rvdZSvF9DazGvpT6vzGv0mn1tOTN/7IWBFBWNRjVlyhQtWLBA0tErMr7++usaO3as4cq8a//+/S1+bCwW0z333KO6ujpJRyf3q666KlmleRq95ozfcguFQho0aJBCoZDpUmCT33oNznhhjNJrbYPpXuP9GtzEvNY2mJ7XJHrNibaeGYuugCGWZemOO+7QG2+8IenoX+5eeuklTZw40XBl3jZ37lwNHjxYc+fOVVVV1Wkft3HjRhUXF+vVV1+Nb3v44Yd19tlnu1Gmp9Brzvgxt2g0qvXr13vuqq5omh97Dc6YHqP0Wtthutd4vwa3MK+1HabnNXrNPjKTwqYLANqq5557TnPmzInf79Wrl1auXKmVK1e26PufeeaZZJXmeWvXrtXUqVMVDodVWFiovn37Kjs7W4FAQBUVFdq4caO2bdvW4HsmTZqkJ554wlDFZtFrzvgxt1gsprKyMvXv35+jXX3Ej70GZ0yPUXqt7TDdaxLv1+AO5rW2w/S8Rq/ZR2YsugLG7Nmzp8H9rVu3auvWrS3+/lSYgJxIS0uL345EItq8ebM2b9582sdnZGRo+vTpuv/++9vsIhS95gy5wS30GtxCr8EtvF+DW5jX4BZ6zT4yY9EVgM/cfffdGjNmjBYvXqyPP/5YW7ZsUVlZmQ4ePChJyszMVF5engYOHKixY8dq0qRJSk9PN1s0AABAG8L7NQAApIBlWZbpIk5UVVWlrKwsSZUaOjRTJ1zEEo0oKpLWrGm4behQkVsTyMwZcrOPzJwhN+ei0ai2bt2qH/zgBxwp1AL0mn1k1jqM0Zaj11qHXms5es0ZcrOPzFqHea3l6DVnjudWJSlLlZWVyszMbNXP5EhXAABSRCgUUmFhoekyAJwGYxRuodcApBrmNfhR0HQBAAAgMSKRiFatWqVIJGK6FACNYIzCLfQagFTDvAY/YtEVAIAUYVmW9u7dK4+dOQjA3zBG4RZ6DUCqYV6DH7HoCgAAAAAAAAAJxKIrAAAAAAAAACQQi64AAKSIUCikgQMHckVXwKMYo3ALvQYg1TCvwY/CpgsAAACJEQwGVVBQYLoMAKfBGIVb6DUAqYZ5DX7Eka4AAKSISCSiJUuWcFVXwKMYo3ALvQYg1TCvwY9YdAUAIEVYlqXq6mqu6gp4FGMUbqHXAKQa5jX4EYuuAAAAAAAAAJBALLoCAAAAAAAAQAKx6AoAQIoIhUIqKiriqq6ARzFG4RZ6DUCqYV6DH4VNFwAAABIjGAwqNzfXdBkAToMxCrfQawBSDfMa/IgjXQEASBH19fWaP3++6uvrTZcCoBGMUbiFXgOQapjX4EcsugIAkEIikYjpEgA0gTEKt9BrAFIN8xr8hkVXAAAAAAAAAEggFl0BAAAAAAAAIIFYdAUAIEWEw2GNGjVK4TDXyQS8iDEKt9BrAFIN8xr8iEVXAABSSIcOHUyXAKAJjFG4hV4DkGqY1+A3LLoCAJAiIpGIFixYwEUGAI9ijMIt9BqAVMO8Bj9i0RUAAAAAAAAAEohFVwAAAAAAAABIIBZdAQAAAAAAACCBWHQFACBFhMNhFRcXc1VXwKMYo3ALvQYg1TCvwY8Svui6YsUKTZgwQd26dVMgENBbb72V6F8BAABO4/vvvzddAoAmMEbhFnoNQKphXoPfJPxPBIcOHdKFF16o22+/Xdddd12rftaOHQkqKoU1lhG5NY3MnCE3+8jMmcYy2rxZKipyvxa/2LFDqq09ejsS6ahwWOreXfriC7N1eR1j1D7GpzONjdGOHaWePc3W5WWbN5+6jfHZvMJC6dtvj96m11qGXnOGfah97EOd4X2ufYxPZ5KRUcIXXa+88kpdeeWVCflZxwYWTq+xjMitaWTmDLnZR2bONJZRTY20Zo37tfhPQMd27cc+dOP0GKP2MT5b6/gYramR9uwxW43fMD6b9+23R3uLXmsdeq157EPtYx/aWrzPbSnGpzPJyMj4yTDq6upUV1cXv19VVXXCVy3V10cUDAYVCoUUjUYVi8XiXz22PRKJyLKs+PZQKKRgMHja7fX19Q1qOHZOkEgk0qLt7dq1UywWUzQajW8LBAIKh8On3X662lv7nI6+hAE1ZOnYQ/z4nJL9OjXe9pakgG+fkxuv07GMTubn55Ts1+loXqeOz/r644/323Ny53VqbF6DfUd7LVXGUzJ673T70FjM8u1zSvbrxPiEWQ33oZK/x1Ny5gjGaGIc77VUnMsT8ZxOtw+NRmO+fU5mPrvDqVQaT3x298rrlPgxanzRdcaMGXryyScb/VokEtWCBQuUn5+vQYMGaePGjSorK4t/vW/fviosLFRJSYn27t0b3z5w4EAVFBRoxYoVqq6ujm8vKipSbm6u3n///QZBjxo1Sh06dNCCBQsa/P7i4mJ9//33Wrp0aXxbOBzW+PHjtW/fPq1evTq+PSMjQ6NHj9bXX3+tDRs2xLd37txZw4YN09atW1VaWhrfnqjnZFkTdHJTRCJRVVfX+vY5Jft1kkbrZNFoTFLIt8/Jjdfp+CTUkJ+fU7Jfp0ik0ymZxWJWg5/jt+fkxusUiYw/JTfYd2wfmirjKRm9F4s1vg/9+utvffuckv06SRMFmGJZatCTfh9PyZgj2IcmxrF9qJSac3kinlM0epWk0Cm5bdy4ybfPycRndziXSuOJz+7eeJ2SsQ8NWA3/9JLYHx4I6M0339Q111xz2sc0dqRrjx49JFUqPT1D+/dzpGtTz6lTp7BqahpO3Onplo4dMOzH55Ts1yk7O/y3/3Z1XHq6pepqjnRt6jllZFiN9Jq0f79/n1OyX6esrECj43P/fo50beo5NTavwb5jvZYq4ykZvXe6fWhlJUe6nq52xidMOnkfKvl7PCVjjmCMJsaJvZaKc3kintPp9qEHD3Kkq53P7nAmPV06eDB1xhOf3b3xOh0fo1WSslRZWanMzEy1hvFF15NVVVUpKytLUqVyczO1e3eyqksNXbqceo6m3FyRWxPIzBlys4/MnDl+ERBLlmUpEAioY8cAFwFpwubNOuWPSfRa8xij9jE+nTl+ERBya6nGMuvePcCFU5rR2LyWni7172+mHj+g15xhH2of+1BneJ9rH+PTmeO5JW7R1dP/94TJp3k9e546mMitaWTmDLnZR2bOHPuQU18f0YIFC1RcXKx27dqZLcrjiopOvQgDvdY8xqh9jM/WITf7yMyexua1/v2lE/4nKE6DXrOHfah97EOd4X2ufYxPZxrLrbUSvuhaU1Ojbdu2xe9/+eWX2rBhgzp16qT8/PxE/zoAAAAAAAAA8JSEL7quXbtWo0aNit9/6KGHJElTp07V7NmzE/3rAAAAAAAAAMBTEr7oOnLkSCXxNLEAgDYiEAgoIyNDgQAXHAC8hvHpDLnZR2ZwC70Gt9BrQNvh6XO6AgDarnA4rNGjR5suA0AjGJ/OkJt9ZAa30GtwC70GtB1B0wUAANCYWCymnTt3KhaLmS4FwEkYn86Qm31kBrfQa3ALvQa0HSy6AgA8KRqNasOGDYpGo6ZLAXASxqcz5GYfmcEt9BrcQq8BbQeLrgAAAAAAAACQQCy6AgAAAAAAAEACsegKAPCkQCCgzp07c2VXwIMYn86Qm31kBrfQa3ALvQa0HWHTBQAA0JhwOKxhw4aZLgNAIxifzpCbfWQGt9BrcAu9BrQdHOkKAPCkaDSqL774gosMAB7E+HSG3OwjM7iFXoNb6DWg7WDRFQDgSbFYTKWlpYrFYqZLAXASxqcz5GYfmcEt9BrcQq8BbQeLrgAAAAAAAACQQCy6AgAAAAAAAEACsegKAPCkYDCo/Px8BYPsqgCvYXw6Q272kRncQq/BLfQa0HaETRcAAEBjQqGQBg0aZLoMAI1gfDpDbvaRGdxCr8Et9BrQdvCnFQCAJ0WjUa1fv54ruwIexPh0htzsIzO4hV6DW+g1oO1g0RUA4EmxWExlZWVc2RXwIManM+RmH5nBLfQa3EKvAW0Hi64AAAAAAAAAkEAsugIAAAAAAABAAnEhLSTUV199pUWLFmn58uXatGmTysrKVFNTo4yMDJ1zzjkqKirSlClTNGLECNOlesK+ffv00UcfqaSkRJs2bdL27dtVXl6umpoatWvXTtnZ2erfv79GjhypW265Rd27dzddsmfQa6kvGAyqb9++XNnVhxifzvgpN8anM+RmH5nBLfSav7EPtYfPoYBLLI+prKy0JFlSpTV0qOlqvG/oUMuSGv4zkdu6deusIUOG/O21a/7fyJEjrZ07d7pfqOWdzCzLssaPH9/izNLS0qzp06db0WjUSK1eyY1eA07llV7z0/i0LHIDkHq8Mq8h9Xml19iHOsPn0NRGZs4cz+3oumRlZWWrfyZHuiIhSktLVVJS0mBbnz591L9/f+Xk5OjgwYNatWqVvvnmG0nSsmXLVFRUpA8//FA9e/Y0UbLn5OTkqF+/fiooKFB6erpqa2u1bds2lZSUKBKJqK6uTtOnT9eOHTs0Z84c0+UaQ6+1HZFIRCUlJRoyZIjCYXZXfsD4dMaPuTE+nSE3+8gMbqHX/Il9aOvxORRIHvMjHCmld+/euvPOO3XTTTed8l8QYrGYZs+erXvvvVe1tbUqLy/XjTfeqFWrVikQCBiq2KyRI0dqwoQJGjNmjHr37t3oY3bv3q0HH3xQ8+bNkyTNnTtXEyZM0E9/+lM3S/Ucei31WZalvXv3yrIs06XAJsanM37KjfHpDLnZR2ZwC73mb+xD7eFzKOAOFl2REHl5eZo1a5ZuvvlmhUKhRh8TDAZ1++23Kzs7W9ddd50kac2aNXr//fc1btw4N8v1jF/84hfNPqZLly56+eWXtXv3bi1ZskSS9Pzzz7fZnR29BngX49MZcgMAwBn2oc7wORRwB2cJR0KMGDFCt95662l3dCe69tprNWTIkPj9+fPnJ7O0lBAIBHTbbbfF769fv95gNWbRa4B3MT6dITcAAJxhH5pcfA4FWodFVxgxfPjw+O2vvvrKXCE+0rlz5/jt6upqg5X4C73mX6FQSAMHDmzRm2j4E+PTGS/kxvh0htzsIzO4hV5rG9iH2sfnUMA5Ti8AI048d040GjVYiX989tln8dvnnnuuuUJ8hl7zr2AwqIKCAtNlIIkYn854ITfGpzPkZh+ZwS30WtvAPtQ+PocCznGkK4zYtGlT/HaPHj0MVuIP5eXl+v3vfx+/z3l0Wo5e869IJKIlS5YoEomYLgVJwvh0xgu5MT6dITf7yAxuodfaBvah9vA5FGgdFl3hurKysviJuCVp7NixBqvxrtraWn322Wd6+umnNWjQIJWXl0uS+vXrp0ceecRwdf5Ar/mbZVmqrq7mKsIpivHpjFdyY3w6Q272kRncQq+lPvahLcPnUCBxOL0AXPfQQw/F/ytHfn6+JkyYYLgib1i5cqV+8pOfNPmY4uJivfzyy8rIyHCpKn+j1wDvYnw6Q24AADjDPrRxfA4FkocjXeGqOXPm6M9//nP8/owZM5SWlmawIn/Izs7WvHnzNH/+fJ111lmmy/EFeg3wLsanM+QGAIAz7EOd4XMo0Doc6QrXrF27VnfddVf8/uTJkzVlyhSDFXlLt27dNG3aNEnH/8tJaWmp1q1bpwMHDmjy5Ml64YUXNHPmTPXp08dwtd5Gr6WGUCikoqIi31zZFS3D+HTGa7kxPp0hN/vIDG6h11IX+9Cm8TkUSB4WXeGKL7/8UhMmTNDhw4clSQMGDNDMmTMNV+UtPXv21DPPPHPK9vLycj322GOaPXu2li5dqqFDh2rZsmUaMGCAgSq9j15LHcFgULm5uabLQAIxPp3xYm6MT2fIzT4yg1votdTEPrR5fA4FkofTCyDpdu3apcsuu0zfffedpKOT+sKFC5WZmWm4Mn/o1q2bZs2apfvuu0+SdODAAd1www3x8xHhOHottdTX12v+/Pmqr683XQoSgPHpjFdzY3w6Q272kRncQq+lHvahrcPnUKD1WHRFUlVUVOiyyy7T9u3bJUl5eXlavHix8vLyDFfmPzNmzIi/Qfj888/17rvvGq7IW+i11BSJREyXgARgfDrj9dwYn86Qm31kBrfQa6mDfWji8DkUcI5FVyRNVVWVxo0bpy1btkiScnJytHjxYp133nmGK/Onjh07atiwYfH7H330kcFqvIVeA7yL8ekMuQEA4Az70MTicyjgHIuuSIpDhw6puLhYn376qSQpKytLCxcu1Pnnn2+4Mn/Lzs6O366oqDBYiXfQa4B3MT6dITcAAJxhH5ocfA4FnGHRFQl3+PBhTZw4Mf4XsI4dO2r+/Pm66KKLDFfmf7t27Yrf7tSpk8FKvIFeS23hcFijRo1SOMw1H/2I8emMX3JjfDpDbvaRGdxCr/kf+9Dk4XMo4AyLrkio+vp6TZo0SUuWLJEkpaWl6e2339bw4cMNV+Z/FRUVWr16dfx+v379DFZjHr3WNnTo0MF0CXCA8emM33JjfDpDbvaRGdxCr/kX+9Dk4XMo4ByLrkiYaDSqKVOmaMGCBZKO/gXv9ddf19ixYw1X5k379+9v8WNjsZjuuece1dXVSTr6JuKqq65KVmmeR6+1DZFIRAsWLPDVhQbA+HTKb7kxPp0hN/vIDG6h1/yLfag9fA4F3MOiKxLCsizdcccdeuONNyRJwWBQL730kiZOnGi4Mu+aO3euBg8erLlz56qqquq0j9u4caOKi4v16quvxrc9/PDDOvvss90o03PoNcC7GJ/OkBsAAM6wD7WPz6GAe/xzEhF42nPPPac5c+bE7/fq1UsrV67UypUrW/T9zzzzTLJK87S1a9dq6tSpCofDKiwsVN++fZWdna1AIKCKigpt3LhR27Zta/A9kyZN0hNPPGGoYvPoNcC7GJ/OkBsAAM6wD3WGz6GAO1h0RULs2bOnwf2tW7dq69atLf7+trizS0tLi9+ORCLavHmzNm/efNrHZ2RkaPr06br//vsVCoXcKNGT6DXAuxifzpAbAADOsA+1j8+hgHtYdAUMufvuuzVmzBgtXrxYH3/8sbZs2aKysjIdPHhQkpSZmam8vDwNHDhQY8eO1aRJk5Senm62aMBF4XBYxcXFvrqyK9BWMD6dITf7yAxuodfgFtO9xudQwD3sUZAQ06dP1/Tp002X4Tt9+vRRnz599A//8A+mS/ENeq1t+f7775WRkWG6DLQQ49MZv+bG+HSG3OwjM7iFXvMf9qHO8DkUcAcX0gIAeFIkEtHSpUu5ijDgQYxPZ8jNPjKDW+g1uIVeA9oOFl0BAAAAAAAAIIFYdAUAAAAAAACABGLRFQDgWVzMAvAuxqcz5GYfmcEt9BrcQq8BbQMjHQDgSe3atdP48eNNlwGgEYxPZ8jNPjKDW+g1uIVeA9oOjnQFAHhSLBbTnj17FIvFTJcC4CSMT2fIzT4yg1voNbiFXgPaDhZdAQCeFI1GtXr1akWjUdOlADgJ49MZcrOPzOAWeg1uodeAtoNFVwAAAAAAAABIIBZdAQAAAAAAACCBWHQFAHhSIBBQRkaGAoGA6VIAnITx6Qy52UdmcAu9BrfQa0DbETZdAAAAjQmHwxo9erTpMgA0gvHpDLnZR2ZwC70Gt9BrQNvBka4AAE+KxWLauXMnV3YFPIjx6Qy52UdmcAu9BrfQa0DbwaIrAMCTotGoNmzYwJVdAQ9ifDpDbvaRGdxCr8Et9BrQdrDoCgAAAAAAAAAJxKIrAAAAAAAAACQQi64AAE8KBALq3LkzV3YFPIjx6Qy52UdmcAu9BrfQa0DbETZdAAAAjQmHwxo2bJjpMgA0gvHpDLnZR2ZwC70Gt9BrQNvBka4AAE+KRqP64osvuMgA4EGMT2fIzT4yg1voNbiFXgPaDhZdAQCeFIvFVFpaqlgsZroUACdhfDpDbvaRGdxCr8Et9BrQdrDoCgAAAAAAAAAJxKIrAAAAAAAAACQQi64AAE8KBoPKz89XMMiuCvAaxqcz5GYfmcEt9BrcQq8BbUfYdAEAADQmFApp0KBBpssA0AjGpzPkZh+ZwS30GtxCrwFtR9L+tPLss8/q3HPP1RlnnKFLLrlEJSUlyfpVAIAUFI1GtX79eq7sCngQ49MZcrOPzOAWeg1uodeAtiMpR7q+9tpreuihhzRz5kxdcskl+uMf/6hx48aptLRUubm5Lf45mzdLRUXJqDB1bN586rYdO9yvw08ay4deax69Zh+95syOHVJtrSQFFYlcoHA4qI4dpZ49TVfmXYxPZxij9jE+nSE3+8jMGfYHzsViMZWVlal///4KhUKmy/E89qH2Ma85w7xmH+PTmcZ6rbUClmVZif6hl1xyiQYPHqxnnnlG0tEdWI8ePXTvvffqkUceafJ7q6qqlJWVJalSUmaiS2sT0tOl6mrTVXhXRoZUU2O6itRArzWNXoNJjM/mMUYBtAXsD1qmvr5eCxYsUHFxsdq1a2e6HM9jHwqTmNeaxvhsrSpJWaqsrFRmZuvWJRN+pOuRI0f06aef6tFHH41vCwaDGjt2rFavXn3K4+vq6lRXVxe/X1lZ+bdbVYkurc2wLEvHYoxEIg2+Fg6HG93erl07xWKxBv/FIRAIKBwOn3Z7NBpVLBaLbw8GgwqFQqfdHolEdOIafygUUjAYPO32+vr6FtVu9zlZFqcyThTLkioqkvM6pULvWVZAUkCACZZlqaIikjLjKRlzxNH9AWMUQGo7tj+QUnMuT9RzsixLtbW1qqioaLDo6ufnlMzXiX0oTLIs6cCB1BlPiZ4jjm5jfDp3dD0yEceoJnz1ad++fYpGo+rSpUuD7V26dNEXX3xxyuNnzJihJ598spGf1CPRpbUZhw5JZ51lugq0BYcOSTk5pqsA0BjGJwBAYn8AIPUcOiR16mS6CqS6ioqKv/1PfOeMH/L36KOP6qGHHorfP3jwoAoKClRWVtbqJ9eWVFVVqUePHvr6669bffhzW0FmzpCbfWTmDLnZR2bOkJt9ZOYMudlHZs6Qm31k5gy52UdmzpCbfWTmTGVlpfLz89UpASv7CV90zcnJUSgU0u7duxts3717t7p27XrK49PS0pSWlnbK9qysLJrCgczMTHKzicycITf7yMwZcrOPzJwhN/vIzBlys4/MnCE3+8jMGXKzj8ycITf7yMyZYDDY+p+RgDoaaN++vS666CJ98MEH8W2xWEwffPCBirhUGgAAAAAAAIAUl5TTCzz00EOaOnWqLr74Yg0ZMkR//OMfdejQId12223J+HUAAAAAAAAA4BlJWXS9/vrrtXfvXv3qV7/Sd999p4EDB2rhwoWnXFyrMWlpaXriiScaPeUATo/c7CMzZ8jNPjJzhtzsIzNnyM0+MnOG3OwjM2fIzT4yc4bc7CMzZ8jNPjJzJpG5BSzLshJQEwAAAAAAAABASTinKwAAAAAAAAC0ZSy6AgAAAAAAAEACsegKAAAAAAAAAAnEoisAAAAAAAAAJJDnFl2fffZZnXvuuTrjjDN0ySWXqKSkxHRJnrZixQpNmDBB3bp1UyAQ0FtvvWW6JM+bMWOGBg8erIyMDOXm5uqaa65RaWmp6bI877nnntOAAQOUmZmpzMxMFRUV6d133zVdlq/85je/USAQ0AMPPGC6FE+bPn26AoFAg3+FhYWmy/K8b7/9VjfddJPOPvtsdejQQRdccIHWrl1ruixPO/fcc0/ptUAgoGnTppkuzbOi0agef/xxnXfeeerQoYN69eqlf/zHfxTXZW1adXW1HnjgARUUFKhDhw4aNmyYPvnkE9NleUpz72kty9KvfvUr5eXlqUOHDho7dqy2bt1qplgPaS63v/zlL7r88st19tlnKxAIaMOGDUbq9JKmMquvr9cvf/lLXXDBBTrzzDPVrVs33XLLLSovLzdXsEc012vTp09XYWGhzjzzTGVnZ2vs2LH6+OOPzRTrEXY+q991110KBAL64x//6Fp9XtVcbrfeeusp792uuOIKM8V6REt67fPPP9fEiROVlZWlM888U4MHD1ZZWZn7xXpIc7k19jkhEAjod7/7XYt/h6cWXV977TU99NBDeuKJJ7Ru3TpdeOGFGjdunPbs2WO6NM86dOiQLrzwQj377LOmS/GN5cuXa9q0aVqzZo0WLVqk+vp6XX755Tp06JDp0jztnHPO0W9+8xt9+umnWrt2rUaPHq2rr75aW7ZsMV2aL3zyySd6/vnnNWDAANOl+MIPf/hD7dq1K/5v5cqVpkvytAMHDmj48OFq166d3n33XX322Wd6+umnlZ2dbbo0T/vkk08a9NmiRYskST/72c8MV+ZdTz31lJ577jk988wz+vzzz/XUU0/pt7/9rf7lX/7FdGmeduedd2rRokV66aWXtGnTJl1++eUaO3asvv32W9OleUZz72l/+9vf6p//+Z81c+ZMffzxxzrzzDM1btw4HT582OVKvaW53A4dOqQf//jHeuqpp1yuzLuayqy2tlbr1q3T448/rnXr1ukvf/mLSktLNXHiRAOVektzvdanTx8988wz2rRpk1auXKlzzz1Xl19+ufbu3etypd7R0s/qb775ptasWaNu3bq5VJm3tSS3K664osF7uHnz5rlYofc0l9n27dv14x//WIWFhVq2bJk2btyoxx9/XGeccYbLlXpLc7md2GO7du3Sv//7vysQCGjSpEkt/yWWhwwZMsSaNm1a/H40GrW6detmzZgxw2BV/iHJevPNN02X4Tt79uyxJFnLly83XYrvZGdnW//2b/9mugzPq66utn7wgx9YixYtskaMGGHdf//9pkvytCeeeMK68MILTZfhK7/85S+tH//4x6bL8L3777/f6tWrlxWLxUyX4lnjx4+3br/99gbbrrvuOuvGG280VJH31dbWWqFQyHrnnXcabP/Rj35kPfbYY4aq8raT39PGYjGra9eu1u9+97v4toMHD1ppaWnWvHnzDFToTU19Fvjyyy8tSdb69etdrcnrWvL5qaSkxJJk7dy5052ifKAluVVWVlqSrMWLF7tTlMedLrNvvvnG6t69u7V582aroKDA+sMf/uB6bV7WWG5Tp061rr76aiP1+EFjmV1//fXWTTfdZKYgn2jJvHb11Vdbo0ePtvVzPXOk65EjR/Tpp59q7Nix8W3BYFBjx47V6tWrDVaGVFdZWSlJ6tSpk+FK/CMajerVV1/VoUOHVFRUZLocz5s2bZrGjx/fYH5D07Zu3apu3bqpZ8+euvHGG9v8f31pzv/7f/9PF198sX72s58pNzdXgwYN0r/+67+aLstXjhw5ov/4j//Q7bffrkAgYLoczxo2bJg++OAD/fd//7ck6b/+67+0cuVKXXnllYYr865IJKJoNHrK0SQdOnTgKP4W+vLLL/Xdd9812I9mZWXpkksu4XMCkq6yslKBQEBnnXWW6VJ848iRI3rhhReUlZWlCy+80HQ5nhWLxXTzzTfr4Ycf1g9/+EPT5fjKsmXLlJubq759++ruu+9WRUWF6ZI8KxaLaf78+erTp4/GjRun3NxcXXLJJZya0qbdu3dr/vz5uuOOO2x9n2cWXfft26doNKouXbo02N6lSxd99913hqpCqovFYnrggQc0fPhw9e/f33Q5nrdp0yalp6crLS1Nd911l958802df/75psvytFdffVXr1q3TjBkzTJfiG5dccolmz56thQsX6rnnntOXX36pn/zkJ6qurjZdmmft2LFDzz33nH7wgx/ovffe091336377rtPc+bMMV2ab7z11ls6ePCgbr31VtOleNojjzyiG264QYWFhWrXrp0GDRqkBx54QDfeeKPp0jwrIyNDRUVF+sd//EeVl5crGo3qP/7jP7R69Wrt2rXLdHm+cOyzAJ8T4LbDhw/rl7/8pSZPnqzMzEzT5XjeO++8o/T0dJ1xxhn6wx/+oEWLFiknJ8d0WZ711FNPKRwO67777jNdiq9cccUVmjt3rj744AM99dRTWr58ua688kpFo1HTpXnSnj17VFNTo9/85je64oor9P777+vaa6/Vddddp+XLl5suzzfmzJmjjIwMXXfddba+L5ykegBfmDZtmjZv3syRJi3Ut29fbdiwQZWVlXrjjTc0depULV++nIXX0/j66691//33a9GiRW3+fDl2nHjE3IABA3TJJZeooKBAr7/+uu2/LLYVsVhMF198sX79619LkgYNGqTNmzdr5syZmjp1quHq/OHFF1/UlVdeyfnUmvH666/r5Zdf1iuvvKIf/vCH2rBhgx544AF169aNXmvCSy+9pNtvv13du3dXKBTSj370I02ePFmffvqp6dIAnEZ9fb1+/vOfy7IsPffcc6bL8YVRo0Zpw4YN2rdvn/71X/9VP//5z/Xxxx8rNzfXdGme8+mnn+pPf/qT1q1bx/+wsemGG26I377gggs0YMAA9erVS8uWLdOYMWMMVuZNsVhMknT11VfrwQcflCQNHDhQq1at0syZMzVixAiT5fnGv//7v+vGG2+0/bneM0e65uTkKBQKaffu3Q227969W127djVUFVLZPffco3feeUdLly7VOeecY7ocX2jfvr169+6tiy66SDNmzNCFF16oP/3pT6bL8qxPP/1Ue/bs0Y9+9COFw2GFw2EtX75c//zP/6xwOMxfY1vorLPOUp8+fbRt2zbTpXhWXl7eKX/86NevH6dlaKGdO3dq8eLFuvPOO02X4nkPP/xw/GjXCy64QDfffLMefPBBjuZvRq9evbR8+XLV1NTo66+/VklJierr69WzZ0/TpfnCsc8CfE6AW44tuO7cuVOLFi3iKNcWOvPMM9W7d28NHTpUL774osLhsF588UXTZXnShx9+qD179ig/Pz/+OWHnzp36H//jf+jcc881XZ6v9OzZUzk5OXxWOI2cnByFw2E+K7TChx9+qNLSUkefFTyz6Nq+fXtddNFF+uCDD+LbYrGYPvjgA84ZiYSyLEv33HOP3nzzTS1ZskTnnXee6ZJ8KxaLqa6uznQZnjVmzBht2rRJGzZsiP+7+OKLdeONN2rDhg0KhUKmS/SFmpoabd++XXl5eaZL8azhw4ertLS0wbb//u//VkFBgaGK/GXWrFnKzc3V+PHjTZfiebW1tQoGG759DIVC8aMo0LQzzzxTeXl5OnDggN577z1dffXVpkvyhfPOO09du3Zt8DmhqqpKH3/8MZ8TkHDHFly3bt2qxYsX6+yzzzZdkm/xWeH0br75Zm3cuLHB54Ru3brp4Ycf1nvvvWe6PF/55ptvVFFRwWeF02jfvr0GDx7MZ4VWePHFF3XRRRc5Oke1p04v8NBDD2nq1Km6+OKLNWTIEP3xj3/UoUOHdNttt5kuzbNqamoa/EXnyy+/1IYNG9SpUyfl5+cbrMy7pk2bpldeeUVvv/22MjIy4ucCy8rKUocOHQxX512PPvqorrzySuXn56u6ulqvvPKKli1bxpuCJmRkZJxyruAzzzxTZ599NucQbsIvfvELTZgwQQUFBSovL9cTTzyhUCikyZMnmy7Nsx588EENGzZMv/71r/Xzn/9cJSUleuGFF/TCCy+YLs3zYrGYZs2apalTpyoc9tTbIk+aMGGC/umf/kn5+fn64Q9/qPXr1+v//t//q9tvv910aZ723nvvybIs9e3bV9u2bdPDDz+swsJC3uOeoLn3tA888ID+z//5P/rBD36g8847T48//ri6deuma665xlzRHtBcbvv371dZWZnKy8slKf6hu2vXrm32KOGmMsvLy9NPf/pTrVu3Tu+8846i0Wj8s0KnTp3Uvn17U2Ub11RuZ599tv7pn/5JEydOVF5envbt26dnn31W3377rX72s58ZrNqs5sbnyQv67dq1U9euXdW3b1+3S/WUpnLr1KmTnnzySU2aNEldu3bV9u3b9T//5/9U7969NW7cOINVm9Vcrz388MO6/vrrdemll2rUqFFauHCh/vrXv2rZsmXmivaAlqynVVVV6T//8z/19NNPO/sllsf8y7/8i5Wfn2+1b9/eGjJkiLVmzRrTJXna0qVLLUmn/Js6darp0jyrsbwkWbNmzTJdmqfdfvvtVkFBgdW+fXurc+fO1pgxY6z333/fdFm+M2LECOv+++83XYanXX/99VZeXp7Vvn17q3v37tb1119vbdu2zXRZnvfXv/7V6t+/v5WWlmYVFhZaL7zwgumSfOG9996zJFmlpaWmS/GFqqoq6/7777fy8/OtM844w+rZs6f12GOPWXV1daZL87TXXnvN6tmzp9W+fXura9eu1rRp06yDBw+aLstTmntPG4vFrMcff9zq0qWLlZaWZo0ZM4ZxazWf26xZsxr9+hNPPGG0bpOayuzLL7887WeFpUuXmi7dqKZy+/77761rr73W6tatm9W+fXsrLy/PmjhxolVSUmK6bKPsflYvKCiw/vCHP7haoxc1lVttba11+eWXW507d7batWtnFRQUWH/3d39nfffdd6bLNqolvfbiiy9avXv3ts444wzrwgsvtN566y1zBXtES3J7/vnnrQ4dOjh+3xawLMtytlwLAAAAAAAAADiZZ87pCgAAAAAAAACpgEVXAAAAAAAAAEggFl0BAAAAAAAAIIFYdAUAAAAAAACABGLRFQAAAAAAAAASiEVXAAAAAAAAAEggFl0BAAAAAAAAIIFYdAUAAAAAAACABGLRFQAAAAAAAAASiEVXAAAAAAAAAEggFl0BAAAAAAAAIIFYdAUAAAAAAACABPr/9+llssEPsQcAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1700x1700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "    arcs = {\"arcs\": result }\n",
    "    Vis(m, n, grids, arcs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gurobi solver code.\n",
    "\n",
    "> Note: The formulation is a little bit complicated. For simple and clear formulation, refer to SCIP code above.\n",
    ">\n",
    "> The Gurobi code is useful and proved to be correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All lines (After double) 1224\n",
      "Set parameter LazyConstraints to value 1\n",
      "Gurobi Optimizer version 11.0.2 build v11.0.2rc0 (mac64[arm] - Darwin 23.5.0 23F79)\n",
      "\n",
      "CPU model: Apple M3 Pro\n",
      "Thread count: 11 physical cores, 11 logical processors, using up to 11 threads\n",
      "\n",
      "Optimize a model with 1405 rows, 1224 columns and 6056 nonzeros\n",
      "Model fingerprint: 0x47b8c35b\n",
      "Variable types: 0 continuous, 1224 integer (1224 binary)\n",
      "Coefficient statistics:\n",
      "  Matrix range     [1e+00, 1e+00]\n",
      "  Objective range  [1e+00, 1e+00]\n",
      "  Bounds range     [1e+00, 1e+00]\n",
      "  RHS range        [1e+00, 3e+00]\n",
      "Presolve removed 399 rows and 252 columns\n",
      "Presolve time: 0.02s\n",
      "Presolved: 1006 rows, 972 columns, 4437 nonzeros\n",
      "Variable types: 0 continuous, 972 integer (972 binary)\n",
      "\n",
      "Root relaxation: objective 2.240000e+02, 668 iterations, 0.01 seconds (0.01 work units)\n",
      "\n",
      "    Nodes    |    Current Node    |     Objective Bounds      |     Work\n",
      " Expl Unexpl |  Obj  Depth IntInf | Incumbent    BestBd   Gap | It/Node Time\n",
      "\n",
      "     0     0  224.00000    0  329          -  224.00000      -     -    0s\n",
      "     0     0  249.06250    0  424          -  249.06250      -     -    0s\n",
      "     0     0  251.50000    0  410          -  251.50000      -     -    0s\n",
      "     0     0  251.50000    0  412          -  251.50000      -     -    0s\n",
      "     0     0  265.00000    0  391          -  265.00000      -     -    0s\n",
      "     0     0  265.68750    0  410          -  265.68750      -     -    0s\n",
      "     0     0  265.68750    0  410          -  265.68750      -     -    0s\n",
      "     0     0  273.75000    0  431          -  273.75000      -     -    0s\n",
      "     0     0  273.75000    0  422          -  273.75000      -     -    0s\n",
      "     0     0  281.33333    0  398          -  281.33333      -     -    0s\n",
      "     0     0  281.91667    0  421          -  281.91667      -     -    0s\n",
      "     0     0  281.91667    0  448          -  281.91667      -     -    0s\n",
      "     0     0  285.00000    0  418          -  285.00000      -     -    0s\n",
      "     0     0  285.00000    0  372          -  285.00000      -     -    0s\n",
      "     0     0  287.71667    0  406          -  287.71667      -     -    0s\n",
      "     0     0  287.71667    0  294          -  287.71667      -     -    0s\n",
      "     0     0  289.50000    0  305          -  289.50000      -     -    0s\n",
      "     0     0  289.80000    0  307          -  289.80000      -     -    0s\n",
      "     0     0  290.07143    0  287          -  290.07143      -     -    0s\n",
      "     0     0  290.08333    0  276          -  290.08333      -     -    0s\n",
      "     0     0  291.06667    0  289          -  291.06667      -     -    0s\n",
      "     0     0  291.06667    0  232          -  291.06667      -     -    0s\n",
      "     0     0  291.06667    0  294          -  291.06667      -     -    0s\n",
      "     0     0  291.06667    0  158          -  291.06667      -     -    0s\n",
      "The length is 16\n",
      "Add cut to eliminate Tour:[2, 3, 20, 21]\n",
      "Add cut to eliminate Tour:[4, 5, 22, 23, 37, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 59, 60, 72, 73, 74, 75, 76]\n",
      "Add cut to eliminate Tour:[130, 131, 6, 7, 8, 9, 10, 135, 205, 148, 24, 25, 26, 153, 28, 154, 155, 166, 170, 43, 44, 173, 46, 172, 171, 184, 185, 186, 187, 188, 61, 62, 63, 64, 189, 190, 191, 203, 204, 77, 78, 79, 80, 81, 82, 209, 208, 207, 206, 221, 94, 95, 96, 97, 98, 99, 100, 222, 112, 113, 114, 115, 116, 117]\n",
      "Add cut to eliminate Tour:[12, 13, 14, 15, 30, 31, 32, 33, 47, 48, 49, 50, 51, 65, 66, 67, 68, 69, 83, 84]\n",
      "Add cut to eliminate Tour:[52, 53, 70, 71]\n",
      "Add cut to eliminate Tour:[136, 137, 138, 139, 85, 86, 87, 88, 89, 102, 103, 104, 105, 106, 107, 118, 119, 120, 121, 122, 123, 124]\n",
      "Add cut to eliminate Tour:[128, 129, 164, 165, 110, 111, 146, 147, 92, 93]\n",
      "Add cut to eliminate Tour:[108, 109, 144, 145, 126, 127]\n",
      "Add cut to eliminate Tour:[132, 133, 134, 167, 168, 169, 149, 150, 151, 152]\n",
      "Add cut to eliminate Tour:[160, 161, 196, 197, 141, 142, 177, 178, 179, 159]\n",
      "Add cut to eliminate Tour:[263, 264, 265, 266, 267, 268, 269, 283, 284, 285, 286, 287, 301, 174, 175, 176, 303, 302, 304, 305, 319, 192, 193, 194, 320, 321, 322, 323, 210, 211, 212, 213, 214, 215, 227, 228, 229, 230, 231, 232, 233, 245, 246, 247, 248, 249, 250, 251]\n",
      "Add cut to eliminate Tour:[198, 199, 200, 180, 181, 182, 216, 217]\n",
      "Add cut to eliminate Tour:[201, 202, 219, 220]\n",
      "Add cut to eliminate Tour:[256, 259, 260, 261, 270, 271, 272, 273, 274, 278, 279, 288, 289, 290, 291, 292, 296, 306, 307, 308, 309, 310, 311, 312, 313, 314, 224, 225, 226, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 252, 253, 254, 255]\n",
      "Add cut to eliminate Tour:[257, 258, 293, 294, 295, 275, 276, 277]\n",
      "Add cut to eliminate Tour:[297, 298, 299, 300, 280, 281, 282, 315, 316, 317]\n",
      "     0     2  291.06667    0  158          -  291.06667      -     -    0s\n",
      "The length is 10\n",
      "Add cut to eliminate Tour:[1, 2, 3, 19, 20, 21]\n",
      "Add cut to eliminate Tour:[128, 4, 5, 144, 145, 22, 23, 37, 38, 39, 40, 41, 42, 54, 55, 56, 57, 58, 59, 60, 72, 73, 74, 75, 76, 91, 92, 93, 108, 109, 110, 111, 126, 127]\n",
      "Add cut to eliminate Tour:[6, 7, 8, 9, 10, 24, 25, 26, 28, 43, 44, 46, 61, 62, 63, 64, 77, 78, 79, 80, 81, 82, 94, 95, 96, 97, 98, 99, 100, 112, 113, 114, 115, 116, 117, 129, 130, 131, 132, 133, 134, 135, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 185, 186, 187, 188, 189, 190, 191, 203, 204, 205, 206, 207, 208, 209, 221, 222]\n",
      "Add cut to eliminate Tour:[12, 13, 14, 15, 30, 31, 32, 33, 47, 48, 49, 50, 51, 65, 66, 67, 68, 69, 83, 84, 101, 102]\n",
      "Add cut to eliminate Tour:[34, 35, 70, 71, 52, 53]\n",
      "Add cut to eliminate Tour:[263, 264, 265, 266, 139, 140, 141, 142, 267, 268, 269, 283, 284, 157, 285, 159, 160, 286, 287, 301, 174, 175, 303, 177, 302, 304, 305, 319, 192, 193, 194, 195, 320, 321, 322, 323, 210, 211, 212, 85, 86, 87, 88, 89, 213, 214, 215, 227, 228, 229, 230, 103, 104, 105, 106, 107, 231, 249, 250, 232, 251, 233, 245, 246, 247, 248, 121, 122, 123, 124]\n",
      "Add cut to eliminate Tour:[136, 137, 138, 118, 119, 120]\n",
      "Add cut to eliminate Tour:[178, 179, 196, 197]\n",
      "Add cut to eliminate Tour:[256, 257, 258, 259, 260, 261, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 306, 307, 180, 181, 182, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 198, 199, 200, 216, 217, 224, 225, 226, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 252, 253, 254, 255]\n",
      "Add cut to eliminate Tour:[201, 202, 183, 184, 219, 220]\n",
      "The length is 6\n",
      "Add cut to eliminate Tour:[0, 1, 2, 3, 18, 19, 20, 21]\n",
      "Add cut to eliminate Tour:[4, 5, 6, 7, 8, 9, 10, 22, 23, 24, 25, 26, 28, 37, 38, 39, 40, 41, 42, 43, 44, 46, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 216, 217, 219, 220, 221, 222, 224, 225, 226, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317]\n",
      "Add cut to eliminate Tour:[11, 12, 13, 14, 15, 29, 30, 31, 32, 33, 47, 48, 49, 50, 51, 65, 66, 67, 68, 69, 83, 84]\n",
      "Add cut to eliminate Tour:[34, 35, 70, 71, 16, 17, 52, 53]\n",
      "Add cut to eliminate Tour:[85, 86, 87, 88, 89, 103, 104, 105, 106, 107, 121, 122, 123, 124, 138, 139, 140, 141, 142, 156, 157, 158, 159, 160, 161, 174, 175, 176, 177, 178, 179, 192, 193, 194, 196, 197, 210, 211, 212, 213, 214, 215, 227, 228, 229, 230, 231, 232, 233, 245, 246, 247, 248, 249, 250, 251, 263, 264, 265, 266, 267, 268, 269, 283, 284, 285, 286, 287, 301, 302, 303, 304, 305, 319, 320, 321, 322, 323]\n",
      "Add cut to eliminate Tour:[136, 137, 118, 119]\n",
      "The length is 5\n",
      "Add cut to eliminate Tour:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 216, 217, 219, 220, 221, 222, 224, 225, 226, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317]\n",
      "Add cut to eliminate Tour:[12, 13, 30, 31]\n",
      "Add cut to eliminate Tour:[14, 15, 16, 17, 32, 33, 34, 35, 47, 48, 49, 50, 51, 52, 53, 65, 66, 67, 68, 69, 70, 71, 83, 84]\n",
      "Add cut to eliminate Tour:[85, 86, 87, 88, 89, 103, 104, 105, 106, 107, 118, 119, 120, 121, 122, 123, 124, 136, 137, 138, 139, 140, 141, 142, 157, 158, 159, 160, 161, 174, 175, 176, 177, 178, 179, 192, 193, 194, 196, 197, 210, 211, 212, 213, 214, 215, 227, 228, 229, 230, 231, 232, 233, 245, 246, 247, 248, 249, 250, 251, 263, 264, 265, 266, 267, 268, 269, 283, 284, 285, 286, 287, 301, 302, 303, 304, 305, 319, 320, 321, 322, 323]\n",
      "Add cut to eliminate Tour:[288, 289, 306, 307]\n",
      "The length is 4\n",
      "Add cut to eliminate Tour:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 216, 217, 219, 220, 221, 222, 224, 225, 226, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317]\n",
      "Add cut to eliminate Tour:[11, 12, 13, 14, 15, 16, 17, 29, 30, 31, 32, 33, 34, 35, 47, 48, 49, 50, 51, 52, 53, 65, 66, 67, 68, 69, 70, 71, 83, 84]\n",
      "Add cut to eliminate Tour:[263, 264, 265, 266, 139, 140, 141, 142, 269, 267, 268, 283, 284, 157, 158, 159, 160, 161, 285, 286, 287, 301, 174, 175, 303, 177, 178, 179, 302, 176, 304, 305, 319, 192, 320, 321, 194, 196, 197, 193, 322, 323, 210, 211, 212, 85, 86, 87, 88, 89, 213, 215, 214, 227, 228, 229, 230, 103, 104, 105, 106, 107, 231, 249, 233, 251, 232, 250, 245, 246, 247, 248, 121, 122, 123, 124]\n",
      "Add cut to eliminate Tour:[101, 102, 136, 137, 138, 118, 119, 120]\n",
      "The length is 2\n",
      "Add cut to eliminate Tour:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 216, 217, 219, 220, 221, 222, 224, 225, 226, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317]\n",
      "Add cut to eliminate Tour:[11, 12, 13, 14, 15, 16, 17, 29, 30, 31, 32, 33, 34, 35, 47, 48, 49, 50, 51, 52, 53, 65, 66, 67, 68, 69, 70, 71, 83, 84, 85, 86, 87, 88, 89, 101, 102, 103, 104, 105, 106, 107, 118, 119, 120, 121, 122, 123, 124, 136, 137, 138, 139, 140, 141, 142, 157, 158, 159, 160, 161, 174, 175, 176, 177, 178, 179, 192, 193, 194, 196, 197, 210, 211, 212, 213, 214, 215, 227, 228, 229, 230, 231, 232, 233, 245, 246, 247, 248, 249, 250, 251, 263, 264, 265, 266, 267, 268, 269, 283, 284, 285, 286, 287, 301, 302, 303, 304, 305, 319, 320, 321, 322, 323]\n",
      "The length is 1\n",
      "*  395    10              16     316.0000000  299.66667  5.17%  29.8    0s\n",
      "\n",
      "Cutting planes:\n",
      "  Gomory: 29\n",
      "  Clique: 5\n",
      "  MIR: 5\n",
      "  Zero half: 158\n",
      "  RLT: 152\n",
      "  Lazy constraints: 43\n",
      "\n",
      "Explored 492 nodes (16599 simplex iterations) in 0.53 seconds (0.57 work units)\n",
      "Thread count was 11 (of 11 available processors)\n",
      "\n",
      "Solution count 1: 316 \n",
      "\n",
      "Optimal solution found (tolerance 1.00e-04)\n",
      "Best objective 3.160000000000e+02, best bound 3.160000000000e+02, gap 0.0000%\n",
      "\n",
      "User-callback calls 2285, time in user-callback 0.03 sec\n",
      "316.0\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABV0AAAVOCAYAAABhXJkTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzde3TV9Z3v/9e+xJSYgEEuAhoULZeWKkwPHoLTcrU6wbAsdGYJ1mt7OvZmp646bX9dbXHOnOHMnHad6Tp2VZ01R8Dj6PS0VWeGVCkFigiCqVBuyuEiRA1yvyQEY/bl9wfNhkh2yOeT796fz/e7n4+1XM3+5tL3fuX9/ny/fNh8dyybzWYFAAAAAAAAAAhE3HUBAAAAAAAAABAlbLoCAAAAAAAAQIDYdAUAAAAAAACAALHpCgAAAAAAAAABYtMVAAAAAAAAAALEpisAAAAAAAAABIhNVwAAAAAAAAAIEJuuAAAAAAAAABAgNl0BAAAAAAAAIEBsugIAAAAAAABAgIw3XdesWaP6+noNHz5csVhMzz//fJfPx2Kxbv/7H//jfwRVMwAAAAAAAAB4y3jT9fTp07rhhhv005/+tNvPHzhwoMt///t//2/FYjHNmzevz8UCAAAAAAAAgO9i2Ww2a/3NsZiee+453X777Xm/5vbbb1dLS4t++9vf2v7fAAAAAAAAAEBoJAv5ww8ePKhly5ZpyZIleb+mvb1d7e3tuceZTEbHjh3T5ZdfrlgsVsjyAAAAAAAAAECSlM1m1dLSouHDhyse79tbYRV003XJkiWqqqrS3Llz837NokWL9MgjjxSyDAAAAAAAAADolbfffltXXnlln35GQW8vMHbsWN188836X//rf+X9GR9+pevJkydVU1Mj6W1J/W1LA1AEl14q7d/f0eVYMnn273JSqVSvjpeVlSmTySidTueOxWIxJZPJvMfT6bQymUzueDweVyKRyHs8lUrp/KUukUgoHo/nPd7REcxzuvLKmE6f5hX7Qbj00qz27z+bc9C/pyj03siRSXoNAAA4demlWb39dsaLa6NOPl3vcb0GhMUpSVfpxIkTGjBgQJ9+UsFe6fryyy9r586d+td//dcev668vFzl5eXdfKa/Kiv7a/z4wtQXFXv3Sm1tkpRVNivFYlJFRUyjRrmuzF9kZmfbNqm1teuxSy+VLr/cTT1hcOml0unTXY9VVop17SLoNXP0mh3OB+bIzA65mSMzO+Rmjszs5Lteq652U08YcL1mhxk1R2Z2PryuBXHL04Jtuv7zP/+zPvnJT+qGG26w/hnjx0vr1wdYVIRls2f/Vi+ZTIpb4fYOmZmprZVefbXrMRbtno0aJR061PUY69rF0Wvm6LW+4XxgjszskJs5MrNDbubIzAzXa+a4XusbZtQcmZnpbl3rK+M7wra2tmrz5s3avHmzJOmtt97S5s2b1dTUlPuaU6dO6f/+3/+rL37xi4EVip6lUik1NDRc8M8pkB+ZAQAkzgc2yMwOuZkjMzvkZo7MAL8xo+bIzD3jV7o2NjZq+vTpuccPPfSQJOmee+7R4sWLJUnPPvusstms5s+fH0yVAAAAAAAAABASxpuu06ZN08Xee+tLX/qSvvSlL1kXBQAAAAAAAABhZXx7AQAAAAAAAABAfmy6RkQymVRdXZ2SyYK9N1rkkBkAQOJ8YIPM7JCbOTKzQ27myAzwGzNqjszcY9M1Qs6cOeO6hNAhMwCAxPnABpnZITdzZGaH3MyRGeA3ZtQcmbnFpmtEpFIprVq1inelM0BmAACJ84ENMrNDbubIzA65mSMzwG/MqDkyc49NVwAAAAAAAAAIEJuuAAAAAAAAABAgNl0jhJsjmyMzAIDE+cAGmdkhN3NkZofczJEZ4Ddm1ByZuUX6EVFWVqbZs2e7LiNUyAwAIHE+sEFmdsjNHJnZITdzZAb4jRk1R2bu8UrXiMhkMjp06JAymYzrUkKDzAAAEucDG2Rmh9zMkZkdcjNHZoDfmFFzZOYem64RkU6ntX79eqXTadelhAaZAQAkzgc2yMwOuZkjMzvkZo7MAL8xo+bIzD02XQEAAAAAAAAgQGy6AgAAAAAAAECA2HSNiFgspqqqKsViMdelhAaZAQAkzgc2yMwOuZkjMzvkZo7MAL8xo+bIzL2k6wIQjGQyqRkzZrguI1TIDAAgcT6wQWZ2yM0cmdkhN3NkBviNGTVHZu7xSteIyGQy2r9/P+9KZ4DMAAAS5wMbZGaH3MyRmR1yM0dmgN+YUXNk5h6brhGRTqe1efNm3pXOAJkBACTOBzbIzA65mSMzO+RmjswAvzGj5sjMPTZdAQAAAAAAACBA3NMVQCjt27dPv/nNb/S73/1OW7duVVNTk1pbW1VVVaUrr7xStbW1WrBggaZOneq6VC8cOXJEr7zyijZu3KitW7dqz549am5uVmtrq8rKylRdXa3x48dr2rRpuvvuuzVixAjXJXuDXjNDrwH+Y10DEDWsa+bIDCiCrGdOnjyZlZSVTmYnT3ZdTXh0dHRkX3nllWxHR4frUkKDzMxMnpzNSl3/czGjr7/+evbGG2/84zpx8f+mTZuW3b9/f/ELzfqTWTabzc6ePbvXmZWXl2cXLlyYTafTTmr1JTd6zU6Yeq0T5wNzZGbHdW5hWtc6uc4srMjNHJmZ8eXaI0zrGpn1DTNqjszMnJvRs/uSJ0+e7PPP5JWuEZFMJjVlyhTXZYQKmYXTzp07tXHjxi7HRo8erfHjx2vQoEE6ceKE1q1bp3feeUeStHr1atXW1urll1/WqFGjXJTsnUGDBmncuHEaOXKkKisr1dbWpt27d2vjxo1KpVJqb2/XwoULtXfvXi1ZssR1uc7Qa30Xll7jfGCOzOy4zi2M65rrzMKK3MyRWTiFcV1zLayZMaPmyMw9Nl0jIp1Oa9euXfroRz+qRCLhupxQILNwu+666/TFL35Rn//85y/458mZTEaLFy/W17/+dbW1tam5uVl33nmn1q1bp1gs5qhit6ZNm6b6+nrNnDlT1113Xbdfc/DgQX3zm9/UM888I0launSp6uvr9bnPfa6YpXqHXjMTxl7jfGCOzOz4kluY1jVfMgsbcjNHZuEWpnXNF2HLjBk1R2bu8UZaEZHJZLRz505lMhnXpYQGmYXTsGHD9OSTT+rNN9/Ut7/97W7vBxmPx3X//ffr//yf/5M79uqrr2r58uXFLNUr3/rWt/SXf/mXeTfBJGno0KF6+umnNWPGjNyxxx9/vBjleYlesxPGXuN8YI7M7LjOLYzrmuvMworczJFZOIVxXXMtrJkxo+bIzD02XQGEytSpU3Xvvff26m/qPvvZz+rGG2/MPV62bFkhS4uEWCym++67L/d406ZNDqtxi14rLHoNKD7WNQBRw7pmjsyA4mHTFUCk3XTTTbmP9+3b566QEBk8eHDu45aWFoeVhAu9Zo5eA/zGugYgaljXzJEZYI9N14iIx+OqqalRPM6vtLfIrDScf8+hdDrtsJLw2LFjR+7jq6++2l0hIUOvmfOl1zgfmCMzO2HLzYd1LWyZ+YLczJFZafBhXQsbXzJjRs2RmXu8kVZEJBIJTZw40XUZoUJmpWHr1q25j6+66iqHlYRDc3OzfvSjH+Uel/qbaJmg18z41GucD8yRmZ2w5ebDuha2zHxBbubIrDT4sK6FjS+ZMaPmyMw9trsjIp1Oa9OmTfxtnQEyi76mpiatXLky93jWrFkOq/FXW1ubduzYoR//+MeaOHGimpubJUnjxo3Td77zHcfVhQO91ju+9hrnA3NkZidMufmyroUpM5+Qmzkyiz5f1rUw8SkzZtQcmbnHpmtEZDIZNTU18a50Bsgs+h566KHcCaampkb19fWOK/LD2rVrFYvFcv9deuml+vjHP65vfetbOnTokCSprq5O69atU1VVleNqw4Fe615Yeo3zgTkysxOm3HxZ18KUmU/IzRyZRZ8v61qY+JQZM2qOzNxj0xVAJC1ZskS//OUvc48XLVqk8vJyhxWFQ3V1tZ555hktW7ZMl112metyQoFes0OvAf5iXQMQNaxr5sgM6Dvu6QogchobG/XAAw/kHs+fP18LFixwWJFfhg8frq9+9auSpGw2q5aWFu3cuVOvv/66jh8/rvnz5+uJJ57QY489ptGjRzuu1m/0Ws/oNSB8WNcARA3rmjkyA4LBpmtExONxjRkzhnelM0Bm0fTWW2+pvr5e77//viTp+uuv12OPPea4Kr+MGjVKjz766AXHm5ub9b3vfU+LFy/WqlWrNHnyZK1evVrXX3+9gyr9R69dXFh6jfOBOTKz43tuPq5rvmfmK3IzR2bR5OO65jtfM2NGzZGZeyQfEYlEQmPHjlUikXBdSmiQWfQcOHBAN998s9577z1JZzd8XnzxRfXv399xZeEwfPhwPfnkk3rwwQclScePH9cdd9zBjde7Qa/1jW+9xvnAHJnZ8Tk3X9c1nzPzGbmZI7Po8XVd85nPmTGj5sjMPTZdIyKVSmndunVKpVKuSwkNMouWo0eP6uabb9aePXskScOGDdOKFSs0bNgwx5WFz6JFi3IXVm+88YZ+/etfO67IL/RacHzpNc4H5sjMjq+5+byu+ZqZ78jNHJlFi8/rmq98z4wZNUdm7rHpGhHZbFaHDx9WNpt1XUpokFl0nDp1Srfccou2b98uSRo0aJBWrFiha665xnFl4VRRUaEpU6bkHr/yyisOq/ELvRYsX3qN84E5MrPjY26+r2s+ZhYG5GaOzKLD93XNR2HIjBk1R2busekKINROnz6turo6/f73v5ckDRgwQC+++KI+9rGPOa4s3Kqrq3MfHz161GEl/qDXCoNeA9xhXQMQNaxr5sgMKBw2XQGE1vvvv685c+bkXh1XUVGhZcuW6ZOf/KTjysLvwIEDuY8HDhzosBI/0GuFQ68BbrCuAYga1jVzZAYUFpuuEZFIJDRhwgRukGyAzMKto6ND8+bN08qVKyVJ5eXleuGFF3TTTTc5riz8jh49qvXr1+cejxs3zmE17tFrheNLr3E+MEdmdnzJLUzrmi+ZhQ25mSOzcAvTuuaLsGXGjJojM/fYdI2IeDyukSNHKh7nV9pbZBZe6XRaCxYsUENDgyQpmUzq5z//uWbNmuW4Mj8dO3as11+byWT0ta99Te3t7ZLOXnzddttthSrNe/SambD2GucDc2Rmx4fcwrau+ZBZGJGbOTILr7Ctaz4IY2bMqDkyc4/kIyKVSmnlypW8K50BMgunbDarL3zhC/rFL34h6eyJ5KmnntKcOXMcV+avpUuXatKkSVq6dKlOnTqV9+u2bNmiuro6Pfvss7ljDz/8sC6//PJilOkdes1cWHuN84E5MrPjOrcwrmuuMwsrcjNHZuEUxnXNtbBmxoyaIzP3kq4LQDCy2axaWlp4VzoDZBZOP/vZz7RkyZLc42uvvVZr167V2rVre/X9jz76aKFK81pjY6PuueceJZNJjR07VmPGjFF1dbVisZiOHj2qLVu2aPfu3V2+Z968efrhD3/oqGL36DU7Yew1zgfmyMyO69zCuK65ziysyM0cmYVTGNc118KaGTNqjszcY9MVQKgcOnSoy+Ndu3Zp165dvf7+UrywKi8vz32cSqW0bds2bdu2Le/XV1VVaeHChfrGN75R0vf/odfM0WuA31jXAEQN65o5MgOKh01XAIi4L3/5y5o5c6ZWrFihDRs2aPv27WpqatKJEyckSf3799ewYcM0YcIEzZo1S/PmzVNlZaXbohFK9BoAAAAAnBXLevY641OnTmnAgAGSTmry5P46702N0YNMJqMjR45o0KBB3CS5l8jMTG2t9OqrXY9NnixmtAdkZofczJFZ33A+MEdmdsjNHJnZITdzZGaGaw9zZNY3zKg5MjNzbkZPSRqgkydPqn///n36mbzSNSLi8biGDBniuoxQITMAgMT5wAaZ2SE3c2Rmh9zMkRngN2bUHJm5x1Z3RHR0dGjZsmXq6OhwXUpokBkAQOJ8YIPM7JCbOTKzQ27myAzwGzNqjszcY9M1QlKplOsSQofMAAAS5wMbZGaH3MyRmR1yM0dmgN+YUXNk5habrgAAAAAAAAAQIDZdAQAAAAAAACBAbLpGRDKZ1PTp05VM8t5ovUVmAACJ84ENMrNDbubIzA65mSMzwG/MqDkyc49N1wjp16+f6xJCh8wAABLnAxtkZofczJGZHXIzR2aA35hRc2TmFpuuEZFKpdTQ0MBNkg2QGQBA4nxgg8zskJs5MrNDbubIDPAbM2qOzNxj0xUAAAAAAAAAAsSmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64RkUwmVVdXx7vSGSAzAIDE+cAGmdkhN3NkZofczJEZ4Ddm1ByZucema4ScOXPGdQmhQ2YAAInzgQ0ys0Nu5sjMDrmZIzPAb8yoOTJzi03XiEilUlq1ahXvSmeAzAAAEucDG2Rmh9zMkZkdcjNHZoDfmFFzZOYem64AAAAAAAAAECA2XQEAAAAAAAAgQGy6Rgg3RzZHZgAAifOBDTKzQ27myMwOuZkjM8BvzKg5MnOL9COirKxMs2fPdl1GqJAZAEDifGCDzOyQmzkys0Nu5sgM8Bszao7M3OOVrhGRyWR06NAhZTIZ16WEBpkBACTOBzbIzA65mSMzO+RmjswAvzGj5sjMPTZdIyKdTmv9+vVKp9OuSwkNMgMASJwPbJCZHXIzR2Z2yM0cmQF+Y0bNkZl7bLoCAAAAAAAAQIDYdAUAAAAAAACAALHpGhGxWExVVVWKxWKuSwkNMgMASJwPbJCZHXIzR2Z2yM0cmQF+Y0bNkZl7xpuua9asUX19vYYPH65YLKbnn3/+gq954403NGfOHA0YMECXXnqpJk2apKampiDqRR7JZFIzZsxQMpl0XUpokBkAQOJ8YIPM7JCbOTKzQ27myAzwGzNqjszcM07+9OnTuuGGG3T//fdr7ty5F3x+z549+tM//VN94Qtf0COPPKL+/ftr+/bt+shHPmJc3N69xt9ScsaOld59V5KyymSyisdjqqiIadQo15X5a+9eqa1NIjMz27ZdeIwZ7Vl3+ZDZxZGbue7y2bZNqq0tfi1hwvnAXHeZjRgR05tvuq7Mb1yvmWM+7TCj5phPO/zZwBzXuHaYUXOcC+wUYh5j2Ww2a/3NsZiee+453X777bljd9xxh8rKyvTUU09Z/cxTp05pwIABkk6qsrK/WlpsqysNVVVSa6vrKlCqKivFjPagu/kks4sjN3OcC+AS83lxzChcYkZ7xnwGh17rGde4dpjRYNBrF3eu105JGqCTJ0+qf//+ffqZgb7GOJPJaNmyZfrrv/5r3XLLLdq0aZOuueYaffe73+2yMXu+9vZ2tbe35x6fOnXqvM9m1dGRUjweVyKRUDqdViaTyX2283gqldL5e8eJRELxeDzv8Y6Oji41dL7UOpVK9ep4WVmZMpmM0ul07lgsFlMymcx7PF/tfX1OZ3+F3J8D7kRpnoJeI87O5ofn8+y6FtbnVJzfU3fr2rncwvmc1KX24H9PnAvgUlZSLELzdFaQa0RnRoAb586hUZin4NcIzqHBySqdzkR2LS/Mn92z6vySMD6nYvyeOIcGJ0rzVJjeC/58EOim66FDh9Ta2qr//t//u/72b/9Wf//3f68XX3xRc+fO1apVqzR16tQLvmfRokV65JFHuv15qVRaDQ0Nqqmp0cSJE7Vly5Yu94YdM2aMxo4dq40bN+rw4cO54xMmTNDIkSO1Zs0atZy3lV9bW6shQ4Zo+fLlXYKePn26+vXrp4aGhi7//3V1dTpz5oxWrVqVO5ZMJjV79mwdOXJE69evzx2vqqrSjBkz9Pbbb2vz5s2544MHD9aUKVO0a9cu7dy5M3c8qOeUzdaLBQguRWmegl4jUqmB+vAym8lku/ycsD2nYvyeUqnZF+TWeT4I63PqVKjfU3eZAcWSSp29SI3KPEnBrxHpdEZSoneBAgE7/xwahXkKeo3gHBqcVCqtLVu2RnYtL8Sf3VOptFpa2kL7nIrxe8pk2HQNSpTmqRC9V4jzQaC3F2hubtaIESM0f/58/cu//Evu6+bMmaNLL71UzzzzzAU/o7tXul511VU6e3uBKh07xitde3pOAwcm1drKAgQ3KiulY8eiM09BrxEDBsQumM/KyqyOHeOVrj09p+7WtfNzC+Nz6lSo3xPnArhUWZlVSwuvdO3pOVVVZZlROHP+OTQK8xT0GsE5NDiVlVmdOMErXU3+7F5ZmVXnP/YN43Mqxu+Jc2gw+LP7xZ/TuRn19PYCgwYNUjKZ1Mc+9rEux8eNG6e1a9d2+z3l5eUqLy/v9nMVFTGVlZXlHicSiT/+E62u8r0TW77j5/9M2+PxeFzxeLzXx/PV3tfnVFHR/X1hxo/v9tuh828qfU5FhbgR90V0l9uIEdGap55qND0ej8e7nc8Pr2udwvKcivF76m1uYXpOvT1u+5xGjOh8g4FzWNcujvOBuW3bup9PKTrzdL6gnlNFRYzrNUPMp518M/rh/g7zPAW9RvDnKTvd/9kglvvdRHEtL8Sf3SsqYorF8tee77gvz6mnGk2P56udc6i57s8F0Zqnnmo0Pd5Ze3cz2leBbrpecsklmjRpUpeXDkvS//t//08jR440/nlcVF3cqFHSoUNdj40fL533am/kkU6ntWvXLn30ox/tdtjRPXLrve7mk3Xt4sjNXOc7kTKfdsit92prpVdf7XqM+bw4rtfsMZ9mmFFzzGffMKO9xzWuHWbUHOcCO931Wl9duA19Ea2trdq8eXPuXg1vvfWWNm/enLsXw8MPP6x//dd/1T/90z9p9+7devTRR/Xv//7v+spXvhJo4UBfZTIZ7dy5s8tL2nFx5Ab4i/m0Q26Av5hPwG/MKADkZ/xK18bGRk2fPj33+KGHHpIk3XPPPVq8eLE++9nP6rHHHtOiRYv04IMPasyYMfrlL3+pP/3TPw2uagAAAAAAAADwlPGm67Rp03Sx9966//77df/991sXBQAAAAAAAABhZXx7ASAq4vG4ampqur3ZM/IjN8BfzKcdcgP8xXwCfmNGASC/QN9ICwiTRCKhiRMnui4jdMgN8BfzaYfcAH8xn4DfmFEAyI+/jkLJSqfT2rRpk9LptOtSQoXcAH8xn3bIDfAX8wn4jRkFgPzYdEXJymQyampq4p02DZEb4C/m0w65Af5iPgG/MaMAkB+brgAAAAAAAAAQIDZdAQAAAAAAACBAbLqiZMXjcY0ZM4Z32jREboC/mE875Ab4i/kE/MaMAkB+SdcFAK4kEgmNHTvWdRmhQ26Av5hPO+QG+Iv5BPzGjAJAfvx1FEpWKpXSunXrlEqlXJcSKuQG+Iv5tENugL+YT8BvzCgA5MemK0pWNpvV4cOHlc1mXZcSKuQG+Iv5tENugL+YT8BvzCgA5MemKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64oWYlEQhMmTFAikXBdSqiQG+Av5tMOuQH+Yj4BvzGjAJBf0nUBgCvxeFwjR450XUbokBvgL+bTDrkB/mI+Ab8xowCQH690RclKpVJauXIl77RpiNwAfzGfdsgN8BfzCfiNGQWA/Nh0RcnKZrNqaWnhnTYNkRvgL+bTDrkB/mI+Ab8xowCQH7cXABxLp9Pavn27XnvtNTU2Nuq1117Tli1b1NHRIUmaOnWqVq9e7bZIADDAumbuyJEjeuWVV7Rx40Zt3bpVe/bsUXNzs1pbW1VWVqbq6mqNHz9e06ZN0913360RI0a4LhkAAABAD9h0BRx6/vnndeedd6qtrc11KQAQCNY1O/fee6+WLVvW7edSqZTOnDmj5uZmLV++XI888oi++93v6vvf/77icf7REgAAAOAjNl1RshKJhGpra52+0+aJEydCtzHhQ24AuufDfLKu9d2gQYM0btw4jRw5UpWVlWpra9Pu3bu1ceNGpVIptbe3a+HChdq7d6+WLFniulygoHybTwBdMaMAkB+brihZ8XhcQ4YMcV2GJGno0KGaNGlS7r+XXnpJP/nJT1yX1S2fcgPQlU/zybpmZtq0aaqvr9fMmTN13XXXdfs1Bw8e1De/+U0988wzkqSlS5eqvr5en/vc54pZKlBUPswngPyYUQDIj01XlKyOjg4tX75cn/nMZ1RWVuakhltvvVX79+9XTU1Nl+MbNmxwUk9v+JAbgO75MJ+sa3a+9a1vXfRrhg4dqqeffloHDx7UypUrJUmPP/44m66INB/mE0B+zCgA5MeNwFDSUqmU0///K6644oKNiTBwnRuA/FzPJ+taYcViMd133325x5s2bXJYDVAcYZlPoFQxowDQPTZdAQAAQmTw4MG5j1taWhxWAgAAACAfNl0BAABCZMeOHbmPr776aneFAAAAAMiLTVeUrGQyqenTpyuZ5NbGJsgN8BfzaSdMuTU3N+tHP/pR7jH3c0XUhWk+gVLEjAJAfmy6oqT169fPdQmhRG6Av5hPOz7n1tbWph07dujHP/6xJk6cqObmZknSuHHj9J3vfMdxdUDh+TyfAJhRAMiHTVeUrFQqpYaGBm78bojcAH8xn3Z8y23t2rWKxWK5/y699FJ9/OMf17e+9S0dOnRIklRXV6d169apqqrKcbVAYfk2nwC6YkYBID82XQEAAEKiurpazzzzjJYtW6bLLrvMdTkAAAAA8uDGKwAAAB4ZPny4vvrVr0qSstmsWlpatHPnTr3++us6fvy45s+fryeeeEKPPfaYRo8e7bhaAAAAAN1h0xUAAMAjo0aN0qOPPnrB8ebmZn3ve9/T4sWLtWrVKk2ePFmrV6/W9ddf76BKAAAAAD3h9gIoWclkUnV1dbzTpiFyA/zFfNoJS27Dhw/Xk08+qQcffFCSdPz4cd1xxx1Kp9OOKwMKJyzzCZQqZhQA8mPTFSXtzJkzrksIJXID/MV82glTbosWLVL//v0lSW+88YZ+/etfO64IKKwwzSdQiphRAOgem64oWalUSqtWreKdNg2RG+Av5tNO2HKrqKjQlClTco9feeUVh9UAhRW2+QRKDTMKAPmx6QoAABAy1dXVuY+PHj3qsBIAAAAA3WHTFQAAIGQOHDiQ+3jgwIEOKwEAAADQHTZdUdK44bsdcgP8xXzaCVNuR48e1fr163OPx40b57AaoPDCNJ9AKWJGAaB7rI4oWWVlZZo9e7brMkKH3AB/MZ92XOd27NixXr9aNZPJ6Gtf+5ra29slSeXl5brtttsKWR7glOv5BNAzZhQA8uOVrihZmUxGhw4dUiaTcV1KqJAb4C/m047r3JYuXapJkyZp6dKlOnXqVN6v27Jli+rq6vTss8/mjj388MO6/PLLi1Em4ITr+QTQM2YUAPLjla4oWel0WuvXr1ddXZ3icXd//1BXV6fm5uYux957773cx42NjZowYcIF39fQ0KDhw4cXurwL+JIbgAv5Mp+sa+YaGxt1zz33KJlMauzYsRozZoyqq6sVi8V09OhRbdmyRbt37+7yPfPmzdMPf/hDJ/UCxeLDfALIjxkFgPzYdAUc27Fjh/bv35/386dPn9Yf/vCHC45/8MEHhSwLAKyxrpkpLy/PfZxKpbRt2zZt27Yt79dXVVVp4cKF+sY3vqFEIlGMEgEAAAAYYtMVAADAoS9/+cuaOXOmVqxYoQ0bNmj79u1qamrSiRMnJEn9+/fXsGHDNGHCBM2aNUvz5s1TZWWl26IBAAAA9IhNV5SsWCymqqoqxWIxp3Xs27fP6f+/KV9yA3AhX+aTdc3c6NGjNXr0aH3lK19xVgPgIx/mE0B+zCgA5MemK0pWMpnUjBkzXJcROuQG+Iv5tENugL+YT8BvzCgA5MedrlGyMpmM9u/fzzttGiI3wF/Mpx1yA/zFfAJ+Y0YBID82XVGy0um0Nm/erHQ67bqUUCE3wF/Mpx1yA/zFfAJ+Y0YBID82XQEAAAAAAAAgQGy6AgAAAAAAAECA2HRFyYrFYho8eDDvtGmI3AB/MZ92yA3wF/MJ+I0ZBYD8kq4LAFxJJpOaMmWK6zJCh9wAfzGfdsgN8BfzCfiNGQWA/HilK0pWOp3Wm2++yU3fDZEb4C/m0w65Af5iPgG/MaMAkB+brihZmUxGO3fuVCaTcV1KqJAb4C/m0w65Af5iPgG/MaMAkB+brgAAAAAAAAAQIDZdAQAAAAAAACBAbLqiZMXjcdXU1CgeZwxMkBvgL+bTDrkB/mI+Ab8xowCQX9J1AYAriURCEydOdF1G6JAb4C/m0w65Af5iPgG/MaMAkB9/HYWSlU6ntWnTJt5p0xC5Af5iPu2QG+Av5hPwGzMKAPmx6YqSlclk1NTUxDttGiI3wF/Mpx1yA/zFfAJ+Y0YBID82XQEAAAAAAAAgQGy6AgAAAAAAAECA2HRFyYrH4xozZgzvtGmI3AB/MZ92yA3wF/MJ+I0ZBYD8kq4LAFxJJBIaO3as6zJCh9wAfzGfdsgN8BfzCfiNGQWA/PjrKJSsVCqldevWKZVKuS4lVMgN8BfzaYfcAH8xn4DfmFEAyI9NV5SsbDarw4cPK5vNui4lVMgN8BfzaYfcAH8xn4DfmFEAyI9NVwAAAAAAAAAIEJuuAAAAAAAAABAgNl1RshKJhCZMmKBEIuG6lFAhN8BfzKcdcgP8xXwCfmNGASA/403XNWvWqL6+XsOHD1csFtPzzz/f5fP33nuvYrFYl/9uvfXWoOoFAhOPxzVy5EjF4/zdgwlyA/zFfNohN8BfzCfgN2YUAPJLmn7D6dOndcMNN+j+++/X3Llzu/2aW2+9VU8++WTucXl5uVVxe/dafVtJ6S6jbduk2tri1xIWe/dKbW2SlFU6nVYikdCIETG9+abryvw2dqz07rvS+blVVMQ0apTryvy1bduFx1jXLo51zRzrmh3WNXOsa3ZY18yxrtnprteY0Z4xn3a6m1HOoT3jHGqHdc0cmdkpREbGm65/9md/pj/7sz/r8WvKy8t1xRVXWBfV6ewijp50l1Frq/Tqq8WvJXxi6hyBs3/oRk/effdsb52fW2urdOiQy6rCh3Xt4ljX+oJ1zQTrWjBY1y6Oda0vWNdMdNdrzGjPmM++4hzaF8znxbGumSMzO4XIyHjTtTdWr16tIUOGqLq6WjNmzNDf/u3f6vLLL+/2a9vb29Xe3p57fOrUqfM+m1VHR0rxeFyJRELpdFqZTCb32c7jqVRK2Ww2dzyRSCgej+c93tHR0aWGZPJsDKlUqlfHy8rKlMlklE6nc8disZiSyWTe4/lq7+tzOvsrjAl9lZUUK9jvKQq915kR+ursutap0GtEOHuPdS0YZ3vN1fkpDL1HrwXl7PnBl2sjH3uPc2hQup5DJb+uy/3ove7WtXO5hfM5qUvtwf+eOBfApaw62zMa89Rz7TbPKd85NMzPydWf3cP8nIrzewr+fBD4puutt96quXPn6pprrtGePXv0//1//5/+7M/+TOvXr+/25tqLFi3SI4880u3PSqXSamhoUE1NjSZOnKgtW7aoqakp9/kxY8Zo7Nix2rhxow4fPpw7PmHCBI0cOVJr1qxRS0tL7nhtba2GDBmi5cuXdwl6+vTp6tevnxoaGrr8/9fV1enMmTNatWpV7lgymdTs2bN15MgRrV+/Pne8qqpKM2bM0Ntvv63Nmzfnjg8ePFhTpkzRrl27tHPnztzxoJ5TNlsvLhL6Lp3OSEoU7PcUhd47twihLzKZbJffd6HXiDD2Xio1W/Ra33WeQ12dn8LQe5kM59AgpFJnzw++XBv52Hud1xnom2xWXX5/rq+NfOy97s6hneeDsD6nToX6PXHdAZdSqbRaWtoiM0+dglwjMpnuNxDD/Jxc/dk9zM+pGL+nQpwPYtmuL5s0++ZYTM8995xuv/32vF+zd+9eXXvttVqxYoVmzpx5wee7e6XrVVddJemkKiurdOwYr3Tt6TkNHJhUayt/YOyrysqsWlp4pWtPz6mqKkuvBaCyMqtjx3ila0/PiXUtGJ29Fq2/fe5ae1+fE70WjM5zqC/XRj72HufQYHz4HCr5dV3uQ+91t66dn1sYn1OnQv2eOBfApcrKrDr/sW8U5ulitds8p+7OoZWV0okT4X1OLv7sXlkpHTsW3udUjN/TufPBKUkDdPLkSfXv3199UfC/0hs1apQGDRqk3bt3d7vpWl5enveNtioqYiorK8s9TiQS3b5atjO83h4//2faHo/H492+Q2O+4/lq7+tzGjHiwvtbVVSIG5j3YNu2znv4nVNRcXZBKtTvqVOYe6+iInZBbpWV0vjx3X45dP4bDJwzYkSs298rvXeudtY1c/nWtfN/j8U+P3XyufcqKi7MjXWtZ/nWNcmfa6NOPvXeiBEx1jVDvVnXOtF752rvbl3rLrcwPafeHrd9Tlx32OnufEBuPct3Do39cW8sCvPUl+P5au/uz6EVFeF+Ti7+7F5REe7nVIzfU3fn0L4q+KbrO++8o6NHj2rYsGHG38uCfXGd7+Da0dGh5cuX6zOf+Uze5sJZtbUX3hifXru4UaMuvDH++PHSef+yAHkwn2ZY18yxrtlhXbPHfJphXTPHumanu3WN3HrGfPYNuZkjMzOsa+bIzE53ufWV8aZra2urdu/enXv81ltvafPmzRo4cKAGDhyoRx55RPPmzdMVV1yhPXv26K//+q913XXX6ZZbbgm0cFzowy+TBuAP5tMOuQH+Yj7tkBvgL+bTDrmZIzOgNBhvujY2Nmr69Om5xw899JAk6Z577tHPfvYzbdmyRUuWLNGJEyc0fPhwfeYzn9F//a//Ne8tBAAAAAAAAAAgSow3XadNm6ae3nvrpZde6lNBAAAAAAAAABBmF97lFqGUTCY1ffr0vDcXBuAO82mH3AB/MZ92yA3wF/Nph9zMkRlQOth0jZB+/fq5LgFAHsynHXID/MV82iE3wF/Mpx1yM0dmQGlg0zUiUqmUGhoauCE34CHm0w65Af5iPu2QG+Av5tMOuZkjM6B0sOkKAAAAAAAAAAFi0xUAAAAAAAAAAsSmKwAAAAAAAAAEiE3XiEgmk6qrq+MdEAEPMZ92yA3wF/Nph9wAfzGfdsjNHJkBpYNN1wg5c+aM6xIA5MF82iE3wF/Mpx1yA/zFfNohN3NkBpQGNl0jIpVKadWqVbwDIuAh5tMOuQH+Yj7tkBvgL+bTDrmZIzOgdLDpCgAAAAAAAAABYtMVAAAAAAAAAALEpmuEcCNuwF/Mpx1yA/zFfNohN8BfzKcdcjNHZkBpYNIjoqysTLNnz3ZdBoBuMJ92yA3wF/Nph9wAfzGfdsjNHJkBpYNXukZEJpPRoUOHlMlkXJcC4EOYTzvkBviL+bRDboC/mE875GaOzIDSwaZrRKTTaa1fv17pdNp1KQA+hPm0Q26Av5hPO+QG+Iv5tENu5sgMKB1sugIAAAAAAABAgNh0BQAAAAAAAIAA8UZaeezbt0+/+c1v9Lvf/U5bt25VU1OTWltbVVVVpSuvvFK1tbVasGCBpk6d6rpUSVIsFlNVVZVisZjrUmDgyJEjeuWVV7Rx40Zt3bpVe/bsUXNzs1pbW1VWVqbq6mqNHz9e06ZN0913360RI0a4LtkbYZpRX+YznU5r+/bteu2119TY2KjXXntNW7ZsUUdHhyRp6tSpWr16tdMaz+dDbswoiiVsvebDfIYRuYVXmK47YMeX+Qxbr5GbOTILN3KDkaxnTp48mZWUlU5mJ08u/v//66+/nr3xxhv/WMPF/5s2bVp2//79xS8U1iZPzmalrv+56LVsNpudPXt2r3utvLw8u3Dhwmw6nXZSqy+5MaN2nnvuuWxFRUWPWU2dOtV1md4Jy4z6Mp9h41NuYek1oFh8mc+wXXf4khvMha3XfEFu5sKWmS/rWphy8yWzsDmX29l9yZMnT/b5Z/JK1w/ZuXOnNm7c2OXY6NGjNX78eA0aNEgnTpzQunXr9M4770iSVq9erdraWr388ssaNWqUi5IlnX0HxLfffltXXXWV4nHuGhFGgwYN0rhx4zRy5EhVVlaqra1Nu3fv1saNG5VKpdTe3q6FCxdq7969WrJkietynQnjjPownydOnFBbW5uT/29bPuR2PmYUxRKGXvNtPsOC3MInjNcdsON6PsPaa+RmjszCidxgg03XPK677jp98Ytf1Oc///kL/glfJpPR4sWL9fWvf11tbW1qbm7WnXfeqXXr1jn7JwLpdFqbN2/W8OHDuYgPkWnTpqm+vl4zZ87Udddd1+3XHDx4UN/85jf1zDPPSJKWLl2q+vp6fe5znytmqd4J04z6NJ9Dhw7VpEmTcv+99NJL+slPfuK0pnx8yI0ZRbGErdd8mM8wIrfwCtN1B+z4Mp9h6zVyM0dm4UZuMMGm64cMGzZMTz75pO666y4lEoluvyYej+v+++9XdXW15s6dK0l69dVXtXz5ct1yyy3FLBch961vfeuiXzN06FA9/fTTOnjwoFauXClJevzxx0t2Q4cZtXPrrbdq//79qqmp6XJ8w4YNjioKB2YUxUKvAX7iugPFQq/ZITdzZGaH3GCDv2L/kKlTp+ree+/NO0Tn++xnP6sbb7wx93jZsmWFLA0lLBaL6b777ss93rRpk8Nq3GJG7VxxxRUXbLgiOMwoioVeA4qL6w4UC71mh9zMkZkdcoMNNl376Kabbsp9vG/fPmd1xGIxDR48mJesR9jgwYNzH7e0tDisJFx8mFHm007YcmNGUSw+9FrY5tMX5BZ9Plx3wE7Y5tOXXiM3c2RWGsgNErcX6LPzF8p0Ou2sjmQyqSlTpjj7/0fh7dixI/fx1Vdf7a6QkPFhRplPO2HLjRlFsfjQa2GbT1+QW/T5cN0BO2GbT196jdzMkVlpIDdIvNK1z7Zu3Zr7+KqrrnJWRzqd1ptvvskwR1Rzc7N+9KMf5R5z/77e82FGmU87YcqNGUWx+NJrYZpPn5Bb9Plw3QE7YZtPX3qN3MyRWWkgN0hsuvZJU1NT7o0sJGnWrFnOaslkMtq5c6cymYyzGhCstrY27dixQz/+8Y81ceJENTc3S5LGjRun73znO46rCwdfZpT5tON7bswoisXHXvN9Pn1FbtHmy3UH7IRpPn3qNXIzR2bRR27oxO0F+uChhx7K/e1UTU2N6uvrHVeEMFu7dq0+9alP9fg1dXV1evrpp1VVVVWkqsKNGUWQmFEUC70GhBPXHSgWes0OuZkjMzvkhk680tXSkiVL9Mtf/jL3eNGiRSovL3dYEaKsurpazzzzjJYtW6bLLrvMdTmhwIyimJhRFAu9BviJ6w4UC71mh9zMkZkdcsP5eKWrhcbGRj3wwAO5x/Pnz9eCBQscViTF43HV1NQoHmcfPayGDx+ur371q5KkbDarlpYW7dy5U6+//rqOHz+u+fPn64knntBjjz2m0aNHO67Wb77NKPNpx7fcmFEUSxh6zbf5DAtyiybfrjtgJwzz6WOvkZs5MosucsMFsp45efJkVlJWOpmdPNl1NRfau3dv9oorrvhjjcpef/312ZMnT7ouCwYmT85mpa7/+dhrnd59993svffem+u56urq7B/+8Iei1xGW3JhRMz/84Q9zWU2dOtV1OaHkw4yGZT59E7bcfOg1oFjCMp++XXeEJTeY863XwoLczPmWWVjWNZ9yC0tmvjmX29l9ySB+f/7+1YqHDhw4oJtvvlnvvfeeJGnUqFF68cUX1b9/f8eVnX0HxE2bNoXmHRDRe8OHD9eTTz6pBx98UJJ0/Phx3XHHHfyuu+HrjDKfdsKSGzOKYvGp18Iyn74ht2jx9boDdnyeT597jdzMkVn0kBvyYdO1l44ePaqbb75Ze/bskSQNGzZMK1as0LBhwxxXdlYmk1FTU1Mo3gERdhYtWpRbtN944w39+te/dlyRX3yeUebTTthyY0ZRLD70Wtjm0xfkFh0+X3fAjq/z6XuvkZs5MosWckNP2HTthVOnTumWW27R9u3bJUmDBg3SihUrdM011ziuDKWkoqJCU6ZMyT1+5ZVXHFbjF2YUPmBGUSz0GuAW1x0oFnrNDrmZIzM75IaLYdP1Ik6fPq26ujr9/ve/lyQNGDBAL774oj72sY85rgylqLq6Ovfx0aNHHVbiD2YUPmFGUSz0GuAG1x0oFnrNDrmZIzM75IbeYNO1B++//77mzJmTewVJRUWFli1bpk9+8pOOK7tQPB7XmDFjvH4HRPTdgQMHch8PHDjQYSV+CMuMMp92wpgbM4picd1rYZxPH5BbuIXlugN2fJrPMPUauZkjs/AjN/RW0nUBvuro6NC8efO0cuVKSVJ5ebleeOEF3XTTTY4r614ikdDYsWNdl4ECOnr0qNavX597PG7cOIfVuBemGWU+7YQtN2YUxeJDr4VtPn1BbuEVpusO2PFlPsPWa+RmjszCjdxgwv1frXgonU5rwYIFamhokCQlk0n9/Oc/16xZsxxXll8qldK6deuUSqVcl4JeOnbsWK+/NpPJ6Gtf+5ra29slnV3Yb7vttkKV5r2wzSjzacd1bswoiiWMveZ6PsOK3MIpbNcdsOPDfIax18jNHJmFF7nBFJuuH5LNZvWFL3xBv/jFLySdfen/U089pTlz5jiurGfZbFaHDx9WNpt1XQp6aenSpZo0aZKWLl2qU6dO5f26LVu2qK6uTs8++2zu2MMPP6zLL7+8GGV6J4wzynzacZ0bM4piCWOvuZ7PsCK38AnjdQfsuJ7PsPYauZkjs3AiN9jg9gIf8rOf/UxLlizJPb722mu1du1arV27tlff/+ijjxaqNERQY2Oj7rnnHiWTSY0dO1ZjxoxRdXW1YrGYjh49qi1btmj37t1dvmfevHn64Q9/6Khi95hRe3V1dWpubu5y7L333st93NjYqAkTJlzwfQ0NDRo+fHihy/MSM4piodcAP3HdgWKh1+yQmzkys0NusMGm64ccOnSoy+Ndu3Zp165dvf5+Bgm9VV5envs4lUpp27Zt2rZtW96vr6qq0sKFC/WNb3xDiUSiGCV6iRm1t2PHDu3fvz/v50+fPq0//OEPFxz/4IMPClmWt5hRFAu9BviL6w4UC71mh9zMkZkdcoMNNl0jIpFIaMKECfzhK0S+/OUva+bMmVqxYoU2bNig7du3q6mpSSdOnJAk9e/fX8OGDdOECRM0a9YszZs3T5WVlW6LhhXm047r3JhRFEsYe831fIYVuQH+Yj7tkJs5MgNKRyzr2U2lTp06pQEDBkg6qcmT++u8N+cFAlFbK736atdjkyeLXrsIcgP8xXzaITfAX8ynHXIDEDWsa+bIzM653E5JGqCTJ0+qf//+ffqZvJFWRKRSKa1cuZJ3wwU8xHzaITfAX8ynHXID/MV82iE3c2QGlA42XSMim82qpaWFd8MFPMR82iE3wF/Mpx1yA/zFfNohN3NkBpQONl0BAAAAAAAAIEBsugIAAAAAAABAgNh0jYhEIqHa2lreARHwEPNph9wAfzGfdsgN8BfzaYfczJEZUDqSrgtAMOLxuIYMGeK6DADdYD7tkBvgL+bTDrkB/mI+7ZCbOTIDSgevdI2Ijo4OLVu2TB0dHa5LAfAhzKcdcgP8xXzaITfAX8ynHXIzR2ZA6WDTNUJSqZTrEgDkwXzaITfAX8ynHXID/MV82iE3c2QGlAY2XQEAAAAAAAAgQGy6AgAAAAAAAECA2HSNiGQyqenTpyuZ5L3RAN8wn3bIDfAX82mH3AB/MZ92yM0cmQGlg03XCOnXr5/rEgDkwXzaITfAX8ynHXID/MV82iE3c2QGlAY2XSMilUqpoaGBG3IDHmI+7ZAb4C/m0w65Af5iPu2QmzkyA0oHm64AAAAAAAAAECA2XQEAAAAAAAAgQGy6AgAAAAAAAECA2HSNiGQyqbq6Ot4BEfAQ82mH3AB/MZ92yA3wF/Nph9zMkRlQOth0jZAzZ864LgFAHsynHXID/MV82iE3wF/Mpx1yM0dmQGlg0zUiUqmUVq1axTsgAh5iPu2QG+Av5tMOuQH+Yj7tkJs5MgNKB5uuAAAAAAAAABAgNl0BAAAAAAAAIEBsukYIN+IG/MV82iE3wF/Mpx1yA/zFfNohN3NkBpQGJj0iysrKNHv2bNdlAOgG82mH3AB/MZ92yA3wF/Nph9zMkRlQOoxf6bpmzRrV19dr+PDhisViev755/N+7QMPPKBYLKZ//Md/7EOJ6I1MJqNDhw4pk8m4LgXAhzCfdsgN8BfzaYfcAH8xn3bIzRyZAaXD+JWup0+f1g033KD7779fc+fOzft1zz33nF599VUNHz7curht26TaWutvLwl790ptbZIUUyo1UMlkTCNGSG++6boyf+3de+Exeu3itm278Fh3WeKcsWOld9+Vzp/Pigpp1CjXlfmtu3WN3HrGfNrhfGCO6w47nA/Msa7Z6S4jcusZ82mH6zVzZGaH84E5rnHtdNdrfRXLZrNZ62+OxfTcc8/p9ttv73L83Xff1X/+z/9ZL730kmbPnq2/+qu/0l/91V/16meeOnVKAwYMkHRSUn/b0kpaZaXU0uK6Cn9VVUmtra6riAZ6rWf0GlxiPi+OGQ0GvXZx9Fow6LWL667XyK1nzCcQPqxrPWNd66tTkgbo5MmT6t+/b/uSgd/TNZPJ6K677tLDDz+sj3/84xf9+vb2drW3t+cenzp1KuiSSlBWnVvpqVSqy2c6b9j94eNlZWXKZDJKp9O5Y7FYTMlkMu/xdDrd5Z9ExONxJRKJvMdTqZTO3+NPJBKKx+N5j3d0dPSqdtPnxK2Mg1Wo31MUek+K/fE/wIWsOjpSkZmnQqwRZ88HzGjfZSXFIruWB/GcOjNCX51d184X5esIu+fU3bp2LrdwPid1qT343xPnAiCMor2W9+05cd3hj8B3n/7+7/9eyWRSDz74YK++ftGiRXrkkUeCLqOkpVJptbS0qV+/fmpoaOjyubq6Op05c0arVq3KHUsmk5o9e7aOHDmi9evX545XVVVpxowZevvtt7V58+bc8cGDB2vKlCnatWuXdu7cmTteU1OjiRMnasuWLWpqasodHzNmjMaOHauNGzfq8OHDueMTJkzQyJEjtWbNGrWc99dUtbW1GjJkiJYvX95l4Zo+fXogz0ma0ZsY0UuF+j1FofdSqYFikx+upFJpNTQ0RGaeCrFGZDL14oK071KptKRkZNfyIJ5TOp2RlOhdoMgrm1WX31/UryNsnlMqNVsfvvboPB+E9Tl1KtTvqbvMAPgvymt5X5/T2Q1d1jUfBHp7gd///veaPXu2Xn/99dy9XK+++uoeby/Q3Stdr7rqKnF7AXuVlVl1vmA4DH8LU+y/WaquTvJS+4BUVkrHjoX3bwAL3XsDBsTU2sqGDtyorMzq2DFe6drTcxo4MMmMBqCyMquWFl7p2tNzqqrK0msB6FzXzhfl6wib59TdunZ+bmF8Tp0K9XviXACET2WldOJEdNfyvj4nrjv6KrjbCwS66fqP//iPeuihh/74cuaz0um04vG4rrrqKu3bt++iP7Pznq6XXnpCl146gJtKX8S2bRfeq2PIEOngQTf1hMG5m+VnlclkFY/HVFERo9cu4tyN38/lNmJEjDdP6cHQodKhQ12PVVZK48e7qScsuus1ZrRnzKcdzgfmuO6ww/nAHOuane56jRntGfNph+s1c2Rmh/OBOa5x7XT2WjZ7UqdPX+bfPV3vuusuzZo1q8uxW265RXfddZfuu+8+o5+1f39Kl18eZHXRVFsrvfpq12MMUs86F+eOjpQaGhpUV1ensrIyt0WFCLn13qhRF17Ejx8vnfcvTNADes0cmZnhfGCO6w47nA/sMZ9muus1ZrRnzGffMKPmyMwOufUe17h9c/RoSoMGBfOzjDddW1tbtXv37tzjt956S5s3b9bAgQNVU1Ojyz+0U1pWVqYrrrhCY8aM6Xu1AAAAAAAAAOA5403XxsZGTZ8+Pff4oYcekiTdc889Wrx4cWCFAQAAAAAAAEAYGW+6Tps2TSa3ge3NfVy7E4tx018UViwW0+DBg+k1Q+SGYqHXzJGZHXID/MV8An5jRs2RmR1yM0dmdoLMK9B7ugap8x3ggEJJJpOaMmWK6zJCh9xQLPSaOTKzQ26Av5hPwG/MqDkys0Nu5sjMTpD7kfHAflLA0um06xIQcel0Wm+++Sa9ZojcUCz0mjkys0NugL+YT8BvzKg5MrNDbubIzE6QeXm76ZrJZFyXgIjLZDLauXMnvWaI3FAs9Jo5MrNDboC/mE/Ab8yoOTKzQ27myMxOkHl5u+kKAAAAAAAAAGHEpisAAAAAAAAABMjbTdd43NvSEBHxeFw1NTX0miFyQ7HQa+bIzA65Af5iPgG/MaPmyMwOuZkjMztB5hXcW3IFLJFIuC4BEZdIJDRx4kTXZYQOuaFY6DVzZGaH3AB/MZ+A35hRc2Rmh9zMkZmdIPcjvd3u5t3VUGjpdFqbNm2i1wyRG4qFXjNHZnbIDfAX8wn4jRk1R2Z2yM0cmdkJMi9vN115dzUUWiaTUVNTE71miNxQLPSaOTKzQ26Av5hPwG/MqDkys0Nu5sjMTpB5ebvpCgAAAAAAAABhxKYrAAAAAAAAAATI201X3l0NhRaPxzVmzBh6zRC5oVjoNXNkZofcAH8xn4DfmFFzZGaH3MyRmZ0g80oG9pMCFuS7hQHdSSQSGjt2rOsyQofcUCz0mjkys0NugL+YT8BvzKg5MrNDbubIzE6Q+5HebnenUinXJSDiUqmU1q1bR68ZIjcUC71mjszskBvgL+YT8Bszao7M7JCbOTKzE2Re3m66ZrNZ1yUg4rLZrA4fPkyvGSI3FAu9Zo7M7JAb4C/mE/AbM2qOzOyQmzkysxNkXt5uugIAAAAAAABAGHl7T1eXjhw5oldeeUUbN27U1q1btWfPHjU3N6u1tVVlZWWqrq7W+PHjNW3aNN19990aMWKE65IB4KL27dun3/zmN/rd736nrVu3qqmpSa2traqqqtKVV16p2tpaLViwQFOnTnVdKiLigw8+0L/+67/qmWee0fbt23Xw4EFVV1frmmuu0dy5c3Xvvfdq0KBBrsv0AtceKBZ6zU46ndb27dv12muvqbGxUa+99pq2bNmijo4OSdLUqVO1evVqt0UiErheQ7GwrtkhN3Mlva5lPXPy5MmspOzx48ed1TB79uyspF79V15enl24cGE2nU47qXXy5GxW6vrf5MlOSgmddDqd3bdvn7PfXViRW+/5Mp+vv/569sYbb+z1ujZt2rTs/v37i1/oh9Br5nzK7I033shOmDChx14bMmRIdtmyZa5L9SK3sFx7+LKuhY1PuYWl1zr5MJ/PPfdctqKiosespk6d6qy+8/nUa2HhS2Zcr5UOHzIL07rWidzMuc4srOva8ePHs5KyJ0+e7PPP8vaVrvG4H3c+GDRokMaNG6eRI0eqsrJSbW1t2r17tzZu3KhUKqX29nYtXLhQe/fu1ZIlS1yXCwPxeFwjR450XUbokFv47Ny5Uxs3buxybPTo0Ro/frwGDRqkEydOaN26dXrnnXckSatXr1Ztba1efvlljRo1ykXJkug1G75k9s4772jmzJlqbm6WJMViMX3605/Wtddeq8OHD2vFihU6c+aMDh06pNtvv10vvviiZsyY4axeX3LrxLUHiiUMvebDfJ44cUJtbW1Oa0D0cb1WOnzILIzrGrmZc51ZmNe1oHi76ery3dWmTZum+vp6zZw5U9ddd123X3Pw4EF985vf1DPPPCNJWrp0qerr6/W5z32umKWiD1KplNasWaNPf/rTSia9HQXvkFt4XXfddfriF7+oz3/+8xf8c9FMJqPFixfr61//utra2tTc3Kw777xT69atUywWc1IvvWbOl8wWLFiQ23AdOXKkXnjhBd1www25zx85ckR33HGHfvvb36qjo0N//ud/rj179uiyyy5zUq8PuXHtgWIJW6/5MJ+dhg4dqkmTJuX+e+mll/STn/zEaU2IHq7Xos+nzMK0rpGbOV8yC+O6FhRvV8Wsw3dX+9a3vnXRrxk6dKiefvppHTx4UCtXrpQkPf744/zBJ0Sy2axaWlp4Jz9D5BY+w4YN05NPPqm77rpLiUSi26+Jx+O6//77VV1drblz50qSXn31VS1fvly33HJLMcvNodfM+ZBZQ0ODXn75ZUnSJZdcon//93/XJz7xiS5fM2jQIL3wwgu6/vrrtXfvXh07dkz/8A//oL/7u79zUbIXuXHtgWIJW6/5MJ+33nqr9u/fr5qami7HN2zY4KgiRBHXa6XDh8zCuK6RmznXmYV5XQuKH/+GP6RisZjuu+++3ONNmzY5rAYAujd16lTde++9eU905/vsZz+rG2+8Mfd42bJlhSwNEfTTn/409/E999xzwYZrp0svvVR/8zd/k3v8+OOPO/1XLmHBtQeKhV4754orrrjgD9hA0LheQzGxrtkhNzOsa2y69tngwYNzH7e0tDisBACCcdNNN+U+3rdvn7tCEDqtra367W9/m3t8/oZNd+bNm6fKykpJ0rFjx7RmzZqC1hcVXHugWOg1wF9crwGImiiua95uuvZmJ9wHO3bsyH189dVXuysExhKJhGpra0PTa74gt+g7/9456XTaWR30mjnXma1bt07t7e2Szr6SddKkST1+/Uc+8hHV1tbmHnf+M+Zic52bKa49UCw+9FrY5hMoFq7XwovM7JCbubBl5tO6FhRvN12DfLewQmlubtaPfvSj3GPuqRYu8XhcQ4YMCUWv+YTcom/r1q25j6+66ipnddBr5lxn9sYbb+Q+/sQnPtGrG/b/yZ/8SbffX0yuczPBtQeKxZdeC9N8AsXE9Vp4kZkdcjMXtsx8WtcC+1mB/aSAdXR0uC6hW21tbdqxY4d+/OMfa+LEibl3Zx43bpy+853vOK4OJjo6OrRs2TJve81X5BZtTU1NXV5tOGvWLGe10GvmXGe2c+fO3McjR47s1fecf1+sN998M/CaesN1bhfDtQeKxcde830+ARe4Xgs3MrNDbubClJlv61pQLv4SlBK3du1afepTn+rxa+rq6vT000+rqqqqSFUhKLxpix1yi66HHnoo9085ampqVF9f77Qees2cy8yOHj2a+3jo0KG9+p4rrrgi9/GxY8cCr6m3fOo1rj1QLGHpNZ/mE/AB12vhR2Z2yM1cWDLzbV0LirevdA2D6upqPfPMM1q2bJkuu+wy1+UAQJ8sWbJEv/zlL3OPFy1apPLycocVIWxaW1tzH/fr169X33P+153//ege1x4oFnoN8BPXawCiJsrrGq90vYjhw4frq1/9qiQpm82qpaVFO3fu1Ouvv67jx49r/vz5euKJJ/TYY49p9OjRjqsFADuNjY164IEHco/nz5+vBQsWOKwIYfT+++/nPr7kkkt69T3nX1CdOXMm8JrCiGsPFAu9BoQL12sAoibq65q3m669efONYhg1apQeffTRC443Nzfre9/7nhYvXqxVq1Zp8uTJWr16ta6//noHVcJGMpnU9OnTvem1sCC36HnrrbdUX1+f2zC7/vrr9dhjjzmuil6z4Tqzj3zkI7mPP/jgg159T3t7e+7j3r46Nmiuc/swrj1QLGHoNd/mE3CF67XoIDM75GbO98x8XteCwu0FLA0fPlxPPvmkHnzwQUnS8ePHdccdd+TuQYFwcPUH/LAjt+g4cOCAbr75Zr333nuSzv4B/MUXX1T//v0dV3YWvWbOZWaVlZW5j3v7qtXzv+787y+2MPQa1x4oFt96LQzzCRQS12vRQ2Z2yM2cr5n5vq4FxdtN17Dc7HfRokW5pnjjjTf061//2nFF6K1UKqWGhobQ9JovyC06jh49qptvvll79uyRJA0bNkwrVqzQsGHDHFd2Fr1mznVml19+ee7jgwcP9up7Oi+0JGngwIGB19QbrnMzxbUHisWHXgvbfAJB43otesjMDrmZ8zWzMKxrQfF20zUsKioqNGXKlNzjV155xWE1ANA7p06d0i233KLt27dLkgYNGqQVK1bommuucVwZwmzMmDG5j/fv39+r72lqasp9PHbs2MBriiKuPVAs9BrgFtdrAKKm1NY1Nl0DUF1dnfv46NGjDisBgIs7ffq06urq9Pvf/16SNGDAAL344ov62Mc+5rgyhN24ceNyH2/durVXf0v8+uuvd/v96BnXHigWeg1wg+s1AFFTiusam64BOHDgQO5jV/80EgB64/3339ecOXNyr1aqqKjQsmXL9MlPftJxZYiCKVOmqLy8XNLZi6rGxsYev769vV2vvvpq7vGMGTMKWl+UcO2BYqHXgOLjeg1A1JTquubtpquv7672YUePHtX69etzj3mVTngkk0nV1dWFptd8QW7h1dHRoXnz5mnlypWSpPLycr3wwgu66aabHFfWPXrNnOvMKisrNXPmzNzjxYsX9/j1v/rVr9TS0iLp7GbOpz/96UKWl5fr3Exx7YFi8aHXwjafQF9xvRZ9ZGaH3Mz5klkY17WgeLvp6sqxY8d6/bWZTEZf+9rX1N7eLuls49x2222FKg0F0Nt310ZX5BY+6XRaCxYsUENDg6SzJ5Kf//znmjVrluPKekavmXOd2Ve+8pXcx4sXL87dr+nD2tra9IMf/CD3+Etf+pLTC0KXuXHtgWIJa6+5XteAYuF6rXSQmR1yM+c6s7Cua0HxdtPV1burLV26VJMmTdLSpUt16tSpvF+3ZcsW1dXV6dlnn80de/jhh7u8czP8lkqltGrVKu/eyc935BY+2WxWX/jCF/SLX/xCkhSPx/XUU09pzpw5jivrGb1mzofMZs+erU996lOSzt4+4LbbbtOWLVu6fM3Ro0d1++23a/fu3ZLOvsr129/+dtFr7eQ6N649UCxh7DXX8wkUC9drpYPM7JCbOdeZhXldCwqvy+5GY2Oj7rnnHiWTSY0dO1ZjxoxRdXW1YrGYjh49qi1btuT+oNhp3rx5+uEPf+ioYgDI72c/+5mWLFmSe3zttddq7dq1Wrt2ba++/9FHHy1UaYiof/mXf9GNN96oAwcOaN++fZowYYKmTp2qa6+9VocPH9aKFSvU1tYm6dzfdl922WVui3aMaw8UC71mp66uTs3NzV2Ovffee7mPGxsbNWHChAu+r6GhQcOHDy90eYgArtdQbKxrdsit91jX2HS9QOcbgEhnd7e3bdumbdu25f36qqoqLVy4UN/4xjeUSCSKUSIAGDl06FCXx7t27dKuXbt6/f1RONmhuK688kqtXLlS8+fP1+bNm5XNZrV69WqtXr26y9cNHjxYTz75ZJf7wJYirj1QLPSavR07dmj//v15P3/69Gn94Q9/uOD4Bx98UMiyECFcr6HYWNfskFvvsa6x6XqBL3/5y5o5c6ZWrFihDRs2aPv27WpqatKJEyckSf3799ewYcM0YcIEzZo1S/PmzVNlZaXbomHN9Q2lw4rcUCz0mjlfMhs7dqw2bNigZ599Vs8884y2b9+ugwcP6rLLLtOoUaM0d+5c3XfffRo0aJDrUiW5zY1rDxRLWHvNl3UNQPeYUXNkZofczJGZW7FsNpt1XcT5Tp06pQEDBujkyZPq37+/63K8V1srvfpq12OTJ0vnvdEsAEeYTwBRw7pmh9xQLPSaOTIDAJwvyH1Jb99IK5PJuC4BEZfJZHTo0CF6zRC5oVjoNXNkZofcAH8xn4DfmFFzZGaH3MyRmZ0g8/J20zWdTrsuARGXTqe1fv16es0QuaFY6DVzZGaH3AB/MZ+A35hRc2Rmh9zMkZmdIPPydtMVAAAAAAAAAMKITVcAAAAAAAAACJC3m66xWMx1CYi4WCymqqoqes0QuaFY6DVzZGaH3AB/MZ+A35hRc2Rmh9zMkZmdIPNKBvaTApZMelsaIiKZTGrGjBmuywgdckOx0GvmyMwOuQH+Yj4BvzGj5sjMDrmZIzM7Qe5HevtKV95dDYWWyWS0f/9+es0QuaFY6DVzZGaH3AB/MZ+A35hRc2Rmh9zMkZmdIPPydtOVd1dDoaXTaW3evJleM0RuKBZ6zRyZ2SE3wF/MJ+A3ZtQcmdkhN3NkZifIvLzddAUAAAAAAACAMGLTFQAAAAAAAAAC5O2mK++uhkKLxWIaPHgwvWaI3FAs9Jo5MrNDboC/mE/Ab8yoOTKzQ27myMxOkHkF95ZcAQvy3cKA7iSTSU2ZMsV1GaFDbigWes0cmdkhN8BfzCfgN2bUHJnZITdzZGYnyP1Ib1/pyo1+UWjpdFpvvvkmvWaI3FAs9Jo5MrNDboC/mE/Ab8yoOTKzQ27myMxOSbyRViaTcV0CIi6TyWjnzp30miFyQ7HQa+bIzA65Af5iPgG/MaPmyMwOuZkjMztB5uXtpisAAAAAAAAAhBGbrgAAAAAAAAAQIG83XeNxb0tDRMTjcdXU1NBrhsgNxUKvmSMzO+QG+Iv5BPzGjJojMzvkZo7M7ASZV3BvyRWwRCLhugREXCKR0MSJE12XETrkhmKh18yRmR1yA/zFfAJ+Y0bNkZkdcjNHZnaC3I/0drubd1dDoaXTaW3atIleM0RuKBZ6zRyZ2SE3wF/MJ+A3ZtQcmdkhN3NkZifIvLzddOXd1VBomUxGTU1N9JohckOx0GvmyMwOuQH+Yj4BvzGj5sjMDrmZIzM7Qebl7aYrAAAAAAAAAIQRm64AAAAAAAAAECBvN115dzUUWjwe15gxY+g1Q+SGYqHXzJGZHXID/MV8An5jRs2RmR1yM0dmdoLMKxnYTwpYkO8WBnQnkUho7NixrssIHXJDsdBr5sjMDrkB/mI+Ab8xo+bIzA65mSMzO0HuRxpv365Zs0b19fUaPny4YrGYnn/++S6fX7hwocaOHatLL71U1dXVmjVrljZs2GBcWCqVMv4ewEQqldK6devoNUPkhmKh18yRmR1yA/zFfAJ+Y0bNkZkdcjNHZnaCzMv4la6nT5/WDTfcoPvvv19z58694POjR4/Wo48+qlGjRunMmTP6n//zf+ozn/mMdu/ercGDB/f6/6emJqFLL5VGjTKtsLRs23bhsb17i19HmIwdK737riQllErdqGQyoYoKeu1i9u6V2tokcus95tMOM2quu/kcMUJ6803XlfmNXjPHumanu4y2bZNqa4tfS1iwrtnprteY0Z6RmR3OoeZY1+zQa+b4s7udztyy2eBe6RrLZrNZ62+OxfTcc8/p9ttvz/s1p06d0oABA7RixQrNnDnzoj+z8+ulk5L625ZW0iorpZYW11X4q6pKam11XQVKFfN5ccxoMOi1i6PXgkGvXRy9Fgx67eK66zVy6xmZ2WFdCwa9dnH0GorvlKQBOnnypPr379u+ZEHv6frBBx/oiSee0IABA3TDDTd0+zXt7e1qb2/PPT516lQhSyoRWXVupX/4ZdHJZLLb42VlZcpkMkqn07ljsVhMyWQy7/F0Oq1MJpM7Ho/HlUgk8h5PpVI6f48/kUgoHo/nPd7R0dGr2k2fk8e3MkZJyKqj41yvhn2eCrNGJCXF8keIXjrba1Fdy4N4TvRaULKSYiVzHWHznDozQl91PYdKpXUN27vn1N26di63cD4ndak9+N9Tz5mF8zmpx9qDeE6cQ4PCn90v9pw4hyLMCrL79B//8R+644471NbWpmHDhuk3v/mNBg0a1O3XLlq0SI888kghyihZqVRaLS1t6tevnxoaGrp8rq6uTmfOnNGqVatyx5LJpGbPnq0jR45o/fr1ueNVVVWaMWOG3n77bW3evDl3fPDgwZoyZYp27dqlnTt35o7X1NRo4sSJ2rJli5qamnLHx4wZo7Fjx2rjxo06fPhw7viECRM0cuRIrVmzRi3n/fVebW2thgwZouXLl3dZjKdPnx7Ic5Jm9CZGoCAymWyXHg77PBVijUilZou/HOm7VCqthoaGyK7lQTynTKZeXMT3XSqVlpQsmesIm+eUTmck8SaxfZXNqsvvr9SuYXvznLo7h3aeD8L6nDoV6vd0sczC+Jw6FfL3lE7fJta1vuPP7hd/TpkMm64Ir4LcXuD06dM6cOCAjhw5on/6p3/SypUrtWHDBg0ZMuSCn9HdK12vuuoqcXsBe5WVWXW+YJi/Lbuw9urqJP88Ac5UVmZ17BivdO3pOQ0cmFRrKxdWfdXZa1Fdy4N4TvRaMCors2pp4ZWuPT2nqqosvRaAD59DpdK6hu3Nc+puXTs/tzA+p06F+j1dLLMwPqdOhfw9cQ4NBn92v/hz4hyK4gvu9gIFv6erJH30ox/V/fffr+9+97sX/Znn39O1srK/xo+3ra40nLtBclbpdFqJREIjRsS4GXcPhg6VDh3qeqyyUvTaRXTXaxUVMW7G3QPm0w4zam7btgvvdTVkiHTwoJt6woJeM8e6Zufcm4BwDu0t1jU73a1r5NYzMrPDOdQc65odes0cf3a3c25GQ3JP106ZTKbLq1l7a/x46bxXl6MHHR0pNTQ0qK6uTmVlZa7L8dqoURcu2vRa79Fr5sjMDDNqrrZWevXVrse4qLo4es0e65qZzk1pcus91jU73a1r5NYzMrPDOdQc65odes0e1x1mupvRvjLedG1tbdXu3btzj9966y1t3rxZAwcO1OWXX67/9t/+m+bMmaNhw4bpyJEj+ulPf6p3331Xf/7nfx5o4QAAAAAAAADgI+NN18bGRk2fPj33+KGHHpIk3XPPPXrsscf05ptvasmSJTpy5Iguv/xyTZo0SS+//LI+/vGPB1c1AAAAAAAAAHjKeNN12rRp6uk2sL/61a/6VBDsJBIJ1dbWKpHgHSRRWPSaOTIDEDWsa3bIDQAAFAvXHe4V5Z6uKLx4PK4hQ4a4LgMlgF4zR2YAooZ1zQ65AQCAYuG6w7246wIQjI6ODi1btkwdHR2uS0HE0WvmyAxA1LCu2SE3AABQLFx3uMema4SkUinXJaBE0GvmyAxA1LCu2SE3AABQLFx3uMWmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64RkUwmNX36dCWTvDcaCoteM0dmAKKGdc0OuQEAgGLhusM9Nl0jpF+/fq5LQImg18yRGYCoYV2zQ24AAKBYuO5wi03XiEilUmpoaOAmySg4es0cmQGIGtY1O+QGAACKhesO99h0BQAAAAAAAIAAsekKAAAAAAAAAAFi0xUAAAAAAAAAAsSma0Qkk0nV1dXxrnQoOHrNHJkBiBrWNTvkBgAAioXrDvfYdI2QM2fOuC4BJYJeM0dmAKKGdc0OuQEAgGLhusMtNl0jIpVKadWqVbwrHQqOXjNHZgCihnXNDrkBAIBi4brDPTZdAQAAAAAAACBAbLoCAAAAAAAAQIDYdI0Qbo6MYqHXzJEZgKhhXbNDbgAAoFi47nCL9COirKxMs2fPdl0GSgC9Zo7MAESNL+taOp3W9u3b9dprr6mxsVGvvfaatmzZoo6ODknS1KlTtXr1ardFnseH3I4cOaJXXnlFGzdu1NatW7Vnzx41NzertbVVZWVlqq6u1vjx4zVt2jTdfffdGjFihNN6AeBiWNfMkZm9ffv26Te/+Y1+97vfaevWrWpqalJra6uqqqp05ZVXqra2VgsWLNDUqVNdl+rFdUepY9M1IjKZjI4cOaJBgwYpHucFzCgces0cmQGIGh/Wteeff1533nmn2tranPz/2/Aht3vvvVfLli3r9nOpVEpnzpxRc3Ozli9frkceeUTf/e539f3vf5/zFwBvsa6ZIzNzmzZt0gMPPKCNGzd2+/njx4/r+PHj2rp1q5544glNmzZNS5YsUU1NTZErPceH645Sx6ZrRKTTaa1fv151dXUMEwqKXjNHZgCixod17cSJE6HacJX8yO18gwYN0rhx4zRy5EhVVlaqra1Nu3fv1saNG5VKpdTe3q6FCxdq7969WrJkietyAeCiWNfMkVnv7Ny584IN19GjR2v8+PEaNGiQTpw4oXXr1umdd96RJK1evVq1tbV6+eWXNWrUKBcle3fdUYrYdAUAAEBoDR06VJMmTcr999JLL+knP/mJ67K8NW3aNNXX12vmzJm67rrruv2agwcP6pvf/KaeeeYZSdLSpUtVX1+vz33uc8UsFQB6hXXNHJnZu+666/TFL35Rn//85y+47UImk9HixYv19a9/XW1tbWpubtadd96pdevWKRaLOaoYLrHpCgAAgNC59dZbtX///gv+2d6GDRscVRQO3/rWty76NUOHDtXTTz+tgwcPauXKlZKkxx9/vOT/oA3AT6xr5sjM3LBhw/Tkk0/qrrvuUiKR6PZr4vG47r//flVXV2vu3LmSpFdffVXLly/XLbfcUsxy4QleXxwRsVhMVVVV/O0JCo5eM0dmAKLGh3XtiiuucHqfNBs+5NZbsVhM9913X+7xpk2bHFYDAH3HumaOzM6ZOnWq7r333rwbruf77Gc/qxtvvDH3ON/9cwstTNcdUcWma0Qkk0nNmDFDySQvXkZh0WvmyAxA1LCu2QlbboMHD8593NLS4rASAAgG65o5MrNz00035T7et2+fkxrCdt0RRWy6RkQmk9H+/fuVyWRcl4KIo9fMkRmAqGFdsxO23Hbs2JH7+Oqrr3ZXCAAEhHXNHJnZOf/Vpel02kkNYbvuiCI2XSMinU5r8+bNzoYZpYNeM0dmAKKGdc1OmHJrbm7Wj370o9zjUr2HH4DoYF0zR2b2tm7dmvv4qquuclJDmK47oopNVwAAAABqa2vTjh079OMf/1gTJ05Uc3OzJGncuHH6zne+47g6ADDHumaOzPquqakp9+ZjkjRr1iyH1cAlbuwAAAAAlKC1a9fqU5/6VI9fU1dXp6efflpVVVVFqgoA7LGumSOz4D300EO5V5fW1NSovr7ecUVwhVe6RkQsFtPgwYN5VzoUHL1mjswARA3rmp0w5VZdXa1nnnlGy5Yt02WXXea6HADoM9Y1c2RmbsmSJfrlL3+Ze7xo0SKVl5c7qSVM1x1RxStdIyKZTGrKlCmuy0AJoNfMkRmAqGFds+NbbsOHD9dXv/pVSVI2m1VLS4t27typ119/XcePH9f8+fP1xBNP6LHHHtPo0aMdVwsAF8e6Zo7MgtPY2KgHHngg93j+/PlasGCBs3p8u+4oRWy6RkQ6ndauXbv00Y9+VIlEwnU5iDB6zRyZAYga1jU7vuU2atQoPfrooxccb25u1ve+9z0tXrxYq1at0uTJk7V69Wpdf/31DqoEgN5jXTNHZsF46623VF9fr/fff1+SdP311+uxxx5zWpNv1x2liNsLREQmk9HOnTuVyWRcl4KIo9fMkRmAqGFdsxOW3IYPH64nn3xSDz74oCTp+PHjuuOOO3j3YwChxbpmjsx678CBA7r55pv13nvvSTq7kf3iiy+qf//+TusKy3VHlLHpCgAAAOACixYtyv2B8Y033tCvf/1rxxUBQN+wrpkjs54dPXpUN998s/bs2SNJGjZsmFasWKFhw4Y5rgw+YNMVAAAAwAUqKiq63AvulVdecVgNAPQd65o5Msvv1KlTuuWWW7R9+3ZJ0qBBg7RixQpdc801jiuDL9h0jYh4PK6amhrF4/xKUVj0mjkyAxA1rGt2wphbdXV17uOjR486rAQAgsG6Zo7MLnT69GnV1dXp97//vSRpwIABevHFF/Wxj33McWXnhPG6I2p4I62ISCQSmjhxousyUALoNXNkBiBqWNfshDG3AwcO5D4eOHCgw0oAIBisa+bIrKv3339fc+bMyb3qt6KiQsuWLdMnP/lJx5V1Fcbrjqhhuzsi0um0Nm3axE2tUXD0mjkyAxA1rGt2wpbb0aNHtX79+tzjcePGOawGAPqOdc0cmXXV0dGhefPmaeXKlZKk8vJyvfDCC7rpppscV3ahsF13RBGbrhGRyWTU1NTEu9Kh4Og1c2QGIGpY1+y4zu3YsWO9/tpMJqOvfe1ram9vl3T2D5W33XZboUoDACusa+bIzF46ndaCBQvU0NAgSUomk/r5z3+uWbNmOa6se66vO8CmKwAAAFASli5dqkmTJmnp0qU6depU3q/bsmWL6urq9Oyzz+aOPfzww7r88suLUSYA9Brrmjkys5PNZvWFL3xBv/jFLySdvV/qU089pTlz5jiuDD7jnq4AAAAIpbq6OjU3N3c59t577+U+bmxs1IQJEy74voaGBg0fPrzQ5XmpsbFR99xzj5LJpMaOHasxY8aourpasVhMR48e1ZYtW7R79+4u3zNv3jz98Ic/dFQxAPSMdc0cmZn72c9+piVLluQeX3vttVq7dq3Wrl3bq+9/9NFHC1UaPMama0TE43GNGTOGd6VDwdFr5sgMQNT4sq7t2LFD+/fvz/v506dP6w9/+MMFxz/44INClpWX69zKy8tzH6dSKW3btk3btm3L+/VVVVVauHChvvGNbyiRSBSjRAAwwrpmjszsHDp0qMvjXbt2adeuXb3+fhebrq6vO8Cma2QkEgmNHTvWdRkoAfSaOTIDEDWsa3Zc5/blL39ZM2fO1IoVK7RhwwZt375dTU1NOnHihCSpf//+GjZsmCZMmKBZs2Zp3rx5qqysdFYvAFwM65o5Misdrq87wKZrZKRSKW3cuFE33nijkkl+rSgces0cmQGIGl/WtX379jn7/7bhQ26jR4/W6NGj9ZWvfMXJ/z8ABI11zRyZmVu4cKEWLlzougwjPlx3lDpeYxwR2WxWhw8fVjabdV0KIo5eM0dmAKKGdc0OuQEAgGLhusM9Nl0BAAAAAAAAIEBsugIAAAAAAABAgNh0jYhEIqEJEyaU9LsJojjoNXNkBiBqWNfskBsAACgWrjvc4066ERGPxzVy5EjXZaAE0GvmyAxA1LCu2SE3AABQLFx3uMcrXSMilUpp5cqVSqVSrktBxNFr5sgMQNSwrtkhNwAAUCxcd7jHpmtEZLNZtbS08K50KDh6zRyZAYga1jU75AYAAIqF6w732HQFAAAAAAAAgACx6QoAAAAAAAAAAWLTNSISiYRqa2t5VzoUHL1mjswARA3rmh1yAwAAxcJ1h3tJ1wUgGPF4XEOGDHFdBkoAvWaOzABEDeuaHXIDAADFwnWHe7zSNSI6Ojq0bNkydXR0uC4FEUevmSMzAFHDumaH3AAAQLFw3eEem64RkkqlXJeAEkGvmSMzAFHDumaH3AAAQLFw3eEWm64AAAAAAAAAECA2XQEAAAAAAAAgQGy6RkQymdT06dOVTPLeaCgses0cmQGIGtY1O+QGAACKhesO99h0jZB+/fq5LgElgl4zR2YAooZ1zQ65AQCAYuG6wy02XSMilUqpoaGBmySj4Og1c2QGIGpY1+yQGwAAKBauO9xj0xUAAAAAAAAAAsSmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64RkUwmVVdXx7vSoeDoNXNkBiBqWNfskBsAACgWrjvcY9M1Qs6cOeO6BJQIes0cmQGIGtY1O+QGAACKhesOt4w3XdesWaP6+noNHz5csVhMzz//fO5zHR0d+va3v61PfOITuvTSSzV8+HDdfffdam5uDrJmdCOVSmnVqlW8Kx0Kjl4zR2YAooZ1zQ65AQCAYuG6wz3j1xifPn1aN9xwg+6//37NnTu3y+fa2tr0+uuv6/vf/75uuOEGHT9+XN/4xjc0Z84cNTY2Ghe3bZtUW2v8bSVl716prU2SkkqlZiuZTGjECOnNN11X5q+9ey88Rq9dHL1mbuxY6d13pfMzq6iQRo1yXZnftm278Fh3c4tzusuHzC6O3Myxrtnp7hxKbj3jXGCHdc0cmdkhN3P8OdQO5wNzXK/Z6a7X+iqWzWaz1t8ci+m5557T7bffnvdrXnvtNd14443av3+/ampqLvozT506pQEDBkg6Kam/bWklrbJSamlxXYW/qqqk1lbXVUQDvdYzei049FrPuus1Mrs4cjPHugaXmM+LY10zR2Z2yM0c59Dg0Gs9o9f66pSkATp58qT69+/bvmTB76Z78uRJxWIxXXbZZd1+vr29Xe3t7bnHp06dKnRJJSCrzq30D7+MvPMGyh8+XlZWpkwmo3Q6nTsWi8WUTCbzHk+n08pkMrnj8XhciUQi7/FUKqXz9/gTiYTi8Xje4x0dHb2q3fQ5FaHtS0qhfk9R6D0p9sf/0HdZdXSczbnQa0Q4ey+pC3vtbGbhfU5nFfL3lC+3TCYb2udU6N9T95kBxXLuXNApzPNUmDUi//kgvM9JXWoP/vfUc2bhfE7qsfYgnlO+3NLpTGifU6F/T5xDgxWleQq696Ss6DU/FHT36f3339e3v/1tzZ8/P+/u8KJFi/TII48UsoySk0ql1dLSpn79+qmhoaHL5+rq6nTmzBmtWrUqdyyZTGr27Nk6cuSI1q9fnzteVVWlGTNm6O2339bmzZtzxwcPHqwpU6Zo165d2rlzZ+54TU2NJk6cqC1btqipqSl3fMyYMRo7dqw2btyow4cP545PmDBBI0eO1Jo1a9Ry3l9T1dbWasiQIVq+fHmXhWv69OmBPCdpRm9iRC8V6vcUhd5LpQaKTf5gpFLpXP6FXiPC2Hup1Gx9uNc6Mwvrc5IK/3vKZOr14QvSVCqtt99+N7TPqdC/J2mOAFeyWXXpybDPUyHWiJ7OB2F9Tp0K9Xu6WGZhfE6dCvl7Sqdvk5S4ILctW7aG9jkV+veUzV543QF7UZqnoHvv7IYufw71QcFuL9DR0aF58+bpnXfe0erVq/Nuunb3SterrrpK3F7AXmVlVp0vGA7D38IU+2+WqquTvNQ+IJWV0rFj4f0bwEL33oABMbW2cmEVhMrKrI4d45Wu+Y4PHJi8oNc6Mwvrc+pUyN9TvtxOnuSVrvlq7y4zoFjOPxd0CvM8FWKN6Ol8ENbn1KlQv6eLZRbG59SpkL+nfLmdOMErXfM9J86hwamslE6ciM48Bd17VVVZeq1PPL+9QEdHh/7iL/5C+/fv18qVK3sssry8XOXl5Rccv/TSrC69lBv9Xsy2bRfeq6OiIqbYH+errKys2+/r7ng8Hv/jS9F7dzyRSCiRSPT6eOdi1NvjJrXnO95d7SNGdN5UOqtUKv3Hm0rH6LWL6L7XCvd76ul4WHqvoqL7e12NH9/tj8EfnXvDmXMzOmJE7IKc6b1zx7vrtYqKrpmF7Tmdr1C/p3y5xeNnT6JhfE6dCvV7Yl2z0926xrVHz3p7LpDCO089Hbd9Tr05H/RUu4/PqbfHbZ9TbzML03Pqy/HePqd8uXU+jzA+p06F+j3x51A7+c4HUZqnTkE9p4qKGNdrFjp7LZvN6vTpYH5m4JuunRuuu3bt0qpVq3T55Zdb/Zz9+1Oy/NaSUlsrvfpq12Ms2j17882z/9vRkVJDQ4Pq6uryLpw4h14zN2qUdOhQ12Pjx0vn/QsT9IAZ7b3ueo35vDhyM8e61jesa+bIzAzrmjkys0Nu5vhzaN+QW+9xvdY3R4+mNGhQMD/LeNO1tbVVu3fvzj1+6623tHnzZg0cOFDDhg3T5z73Ob3++uv6j//4D6XTab333nuSpIEDB+qSSy4JpmoAAAAAAAAA8JTxpmtjY6OmT5+ee/zQQw9Jku655x4tXLhQ//Zv/ybp7A18z7dq1SpNmzat1/8/sRj3n0BhxWIxVVVV0WuAp5hRAFHDumaOzABEDeuaHXJDsQTZY8abrtOmTVNP773Vh/fl6iLfvSmAoCSTSc2YMcN1GQDyYEYBRA3rmjkyAxA1rGt2yA3FEuR+5IV37vXE+e/MBhRCJpPR/v376TXAU8wogKhhXTNHZgCihnXNDrmhWILsMW83XdPptOsSEHHpdFqbN2+m1wBPMaMAooZ1zRyZAYga1jU75IZiCbLHvN10BQAAAAAAAIAwYtMVAAAAAAAAAALk7aYr70iHQovFYho8eDC9BniKGQUQNaxr5sgMQNSwrtkhNxRLkD0W3FtyBSzIdwsDupNMJjVlyhTXZQDIgxkFEDWsa+bIDEDUsK7ZITcUS5D7kd6+0pWbI6PQ0um03nzzTXoN8BQzCiBqWNfMkRmAqGFds0NuKJaSeCOtTCbjugREXCaT0c6dO+k1wFPMKICoYV0zR2YAooZ1zQ65oViC7DFvN10BAAAAAAAAIIzYdAUAAAAAAACAAHm76RqPe1saIiIej6umpoZeAzzFjAKIGtY1c2QGIGpY1+yQG4olyB4L7i25ApZIJFyXgIhLJBKaOHGi6zIA5MGMAoga1jVzZAYgaljX7JAbiiXI/Uhv/4qAd6RDoaXTaW3atIleAzzFjAKIGtY1c2QGIGpY1+yQG4olyB7zdtOVd6RDoWUyGTU1NdFrgKeYUQBRw7pmjswARA3rmh1yQ7EE2WPebroCAAAAAAAAQBix6QoAAAAAAAAAAfL2jbR4R7pwSqfT2r59u1577TU1Njbqtdde05YtW9TR0SFJmjp1qlavXu22yD+Kx+MaM2aM0147cuSIXnnlFW3cuFFbt27Vnj171NzcrNbWVpWVlam6ulrjx4/XtGnTdPfdd2vEiBHOakW4hbHXfJhRKVzrGlBKWNdKA5kB6I0wXa/5sq7t27dPv/nNb/S73/1OW7duVVNTk1pbW1VVVaUrr7xStbW1WrBggaZOneq0zk6+5AZzYey1oHi76Rrku4WhOJ5//nndeeedamtrc11KryQSCY0dO9ZpDffee6+WLVvW7edSqZTOnDmj5uZmLV++XI888oi++93v6vvf/z4nGhgLY6/5MKNhW9eAUsK6VhrIDMDFhO16zfW6tmnTJj3wwAPauHFjt58/fvy4jh8/rq1bt+qJJ57QtGnTtGTJEtXU1BS50q5c5wZzYe61oHi76ZpKpVyXAEMnTpwIzYlOOttjGzdu1I033qhk0v0oDBo0SOPGjdPIkSNVWVmptrY27d69Wxs3blQqlVJ7e7sWLlyovXv3asmSJa7LRYiFpdd8mNGwrWtAqWJdiy4yA3AxYbtec72u7dy584JNsNGjR2v8+PEaNGiQTpw4oXXr1umdd96RJK1evVq1tbV6+eWXNWrUqKLX28l1bjAX5l4Liredms1mXZcAS0OHDtWkSZNy/7300kv6yU9+4rqsC2SzWR0+fNhpr02bNk319fWaOXOmrrvuum6/5uDBg/rmN7+pZ555RpK0dOlS1dfX63Of+1wxS0XIhbHXfJjRTmFZ14BSwrpWGsgMQG+F5XrNl3Xtuuuu0xe/+EV9/vOfv+AWPJlMRosXL9bXv/51tbW1qbm5WXfeeafWrVunWCzmpF5fcoO5MPZaULzddEX43Hrrrdq/f/8FLwXfsGGDo4r8961vfeuiXzN06FA9/fTTOnjwoFauXClJevzxx9l0hRF6zQ7rGuAv1jUAgMT1mqlhw4bpySef1F133ZX3n1HH43Hdf//9qq6u1ty5cyVJr776qpYvX65bbrmlmOUixOg1iRtDIjBXXHGF83tvRFUsFtN9992Xe7xp0yaH1SDK6LWuWNeA8GNdA4Bo43rNzNSpU3Xvvff26r6Vn/3sZ3XjjTfmHue7lzrQHXrN401X3kgLhZZIJDRhwoTQ9NrgwYNzH7e0tDisBFHnS6+FbUYB+It1LbzIDEDUhG1du+mmm3If79u3z1kdYcsN5nzqtaB4e3sB3p0dhRaPxzVy5EjXZfTajh07ch9fffXV7gpB5PnSa2GbUQD+Yl0LLzIDEDVhW9fOv69mOp12VkfYcoM5n3otsJ8V2E8KWJDvFgZ0J5VKaeXKlaHotebmZv3oRz/KPeZedCgUn3otTDMKwF+sa+FGZgCiJmzr2tatW3MfX3XVVc7qCFtuMOdTrwXF201X3pEOhZbNZtXS0uJtr7W1tWnHjh368Y9/rIkTJ6q5uVmSNG7cOH3nO99xXB2ixNde831GAfiLdS06yAxA1IRpXWtqasq9EaUkzZo1y1ktYcoN5nzrtaB4e3sBoNSsXbtWn/rUp3r8mrq6Oj399NOqqqoqUlWIInoNQNSwrgEAELyHHnoo98+8a2pqVF9f77giRFVUe83bV7oCOKe6ulrPPPOMli1bpssuu8x1OYgweg1A1LCuAQBgbsmSJfrlL3+Ze7xo0SKVl5c7rAhRFeVe8/aVrrwjHQotkUiotrbWm14bPny4vvrVr0o6908ndu7cqddff13Hjx/X/Pnz9cQTT+ixxx7T6NGjHVeLMAtLr/k2owD8xboWXWQGIGrCsK41NjbqgQceyD2eP3++FixY4LCicOQGc772WlC83XQN8t3CgO7E43ENGTLEdRk5o0aN0qOPPnrB8ebmZn3ve9/T4sWLtWrVKk2ePFmrV6/W9ddf76BKREFYes23GQXgL9a16CIzAFHj+7r21ltvqb6+Xu+//74k6frrr9djjz3muCr/c4M5n3stsJ8V2E8KWEdHh+sSEHEdHR1atmyZ9702fPhwPfnkk3rwwQclScePH9cdd9yRu98JEBTfei0sMwrAX6xr4UdmAKLG53XtwIEDuvnmm/Xee+9JOvuXmi+++KL69+/vuDK/c4M533stKN5uugLFkEqlXJfQa4sWLcotQG+88YZ+/etfO64IUeVTr4VpRgH4i3Ut3MgMQNT4uK4dPXpUN998s/bs2SNJGjZsmFasWKFhw4Y5ruwcH3ODuTD0WlDYdAVCoqKiQlOmTMk9fuWVVxxWgyij1wBEDesaAAD5nTp1Srfccou2b98uSRo0aJBWrFiha665xnFliJpS6zU2XYEQqa6uzn189OhRh5Ug6ug1AFHDugYAwIVOnz6turo6/f73v5ckDRgwQC+++KI+9rGPOa4MUVOKvebtpmsy6e17fCEiksmkpk+fHqpeO3DgQO7jgQMHOqwEUedDr4VxRgH4i3UtnMgMQNT4tK69//77mjNnTu5fgFRUVGjZsmX65Cc/6biyC/mUG8yFrdeC4u2mK1AM/fr1c11Crx09elTr16/PPR43bpzDahBlPvVamGYUgL9Y18KNzABEjQ/rWkdHh+bNm6eVK1dKksrLy/XCCy/opptuclxZfj7kBnNh7LWgeLvpyg2SUWipVEoNDQ3Oeu3YsWO9/tpMJqOvfe1ram9vl3R2kbrtttsKVRoiJqy95npGAfiLda10kBmAqPFhXUun01qwYIEaGhoknX1l389//nPNmjXLWU0X40NuMBfWXguKt5uuQNQtXbpUkyZN0tKlS3Xq1Km8X7dlyxbV1dXp2WefzR17+OGHdfnllxejTEQAvQYgaljXAACwk81m9YUvfEG/+MUvJEnxeFxPPfWU5syZ47gyRA29JnEzDASqrq5Ozc3NXY699957uY8bGxs1YcKEC76voaFBw4cPL3R53mlsbNQ999yjZDKpsWPHasyYMaqurlYsFtPRo0e1ZcsW7d69u8v3zJs3Tz/84Q8dVYywotfssa4BfmJdAwB04nqt9372s59pyZIlucfXXnut1q5dq7Vr1/bq+x999NFClYaIodfYdEXAduzYof379+f9/OnTp/WHP/zhguMffPBBIcvyUnl5ee7jVCqlbdu2adu2bXm/vqqqSgsXLtQ3vvENJRKJYpSIiKDX+oZ1DfAP6xoA4Hxcr/XeoUOHujzetWuXdu3a1evvj8JGGIqDXvN405V3pEOhJZNJ1dXVOeu1L3/5y5o5c6ZWrFihDRs2aPv27WpqatKJEyckSf3799ewYcM0YcIEzZo1S/PmzVNlZaWTWhFuYe011zMKwF+sa6WDzABEDeuaHXJDsQTZY3QrArVv3z7XJRg5c+aMqqqqnP3/jx49WqNHj9ZXvvIVZzWgNIS111zPqBS+dQ0oFaxrpYPMAFxM2K7XXK5rCxcu1MKFC538f/cV54NwCXOvBcXbN9LiHelQaKlUSqtWraLXAE8xowCihnXNHJkBiBrWNTvkhmIJsse83XQFAAAAAAAAgDBi0xUAAAAAAAAAAsSmK0oaN+EG/MaMAoga1jVzZAYgaljX7JAbwsbbji0rK3NdAiKurKxMs2fPdl0GgDyYUQBRw7pmjswARA3rmh1yQ7EEuR/p7StdM5mM6xIQcZlMRocOHaLXAE8xowCihnXNHJkBiBrWNTvkhmIJsse83XRNp9OuS0DEpdNprV+/nl4DPMWMAoga1jVzZAYgaljX7JAbiiXIHvN20xUAAAAAAAAAwohNVwAAAAAAAAAIkLebrrFYzHUJiLhYLKaqqip6DfAUMwogaljXzJEZgKhhXbNDbiiWIHssGdhPClgy6W1piIhkMqkZM2a4LgNAHswogKhhXTNHZgCihnXNDrmhWILcj/T2la68Ix0KLZPJaP/+/fQa4ClmFEDUsK6ZIzMAUcO6ZofcUCxB9pi3m668Ix0KLZ1Oa/PmzfQa4ClmFEDUsK6ZIzMAUcO6ZofcUCxB9pi3m64AAAAAAAAAEEZsugIAAAAAAABAgLzddOUd6VBosVhMgwcPptcATzGjAKKGdc0cmQGIGtY1O+SGYgmyx4J7S66ABfluYUB3ksmkpkyZ4roMAHkwowCihnXNHJkBiBrWNTvkhmIJcj/S21e6cnNkFFo6ndabb75JrwGeYkYBRA3rmjkyAxA1rGt2yA3FUhJvpJXJZFyXgIjLZDLauXMnvQZ4ihkFEDWsa+bIDEDUsK7ZITcUS5A95u2mKwAAAAAAAACEEZuuAAAAAAAAABAgbzdd43FvS0NExONx1dTU0GuAp5hRAFHDumaOzABEDeuaHXJDsQTZY8G9JVfAEomE6xIQcYlEQhMnTnRdBoA8mFEAUcO6Zo7MAEQN65odckOxBLkf6e1fEfCOdCi0dDqtTZs20WuAp5hRAFHDumaOzABEDeuaHXJDsQTZY8abrmvWrFF9fb2GDx+uWCym559/vsvnf/WrX+kzn/mMLr/8csViMW3evNmqMN6RDoWWyWTU1NRErwGeYkYBRA3rmjkyAxA1rGt2yA3FEmSPGd9e4PTp07rhhht0//33a+7cud1+/k//9E/1F3/xF/ov/+W/WBc2cmRSl14qjRpl/SNKwrZtFx7bu7f4dYTJ2LHSu+9KUlKp1GwlkwlVVNBrF0Ovmesun23bpNra4tcSJnv3Sm1t0vkzOmKE9OabrivzF71mh3XNHL1mh3XNHNdrdljXzLGu2aHXzLGu2enuHEpuPWM+/RHLZrNZ62+OxfTcc8/p9ttvv+Bz+/bt0zXXXKNNmzZpwoQJvf6Zp06d0oABAySdlNTftrSSVlkptbS4rsJfVVVSa6vrKqKBXusZvRYceq1n9Fpw6LWe0WvBodd6Rq8Fh17rGb0WHHqtZ/QaXGI+e+/o0aMaNGiQTp48qf79+7Yv6fyNtNrb29Xe3p57fOrUKYfVREVWnVvpqVSqy2eSyWS3x8vKypTJZLrcuyIWiymZTOY9nk6nu7zsOh6PK5FI5D2eSqV0/h5/IpFQPB7Pe7yjo6NXtZs+Jw/aPlIK9XuKQu9JsT/+h77LqqPjbM6FXiPC2XtJ0WtBySqTyTo5P4Wh9+i1YPlybeRj7/2xCiEI586hrq+N/Ow91rXgZJVOZzy5NjrLp96j1+BalOapkGuE09sLBG3RokV65JFHXJcRKalUWi0tberXr58aGhq6fK6urk5nzpzRqlWrcseSyaRmz56tI0eOaP369bnjVVVVmjFjht5+++0u9+YdPHiwpkyZol27dmnnzp254zU1NZo4caK2bNmipqam3PExY8Zo7Nix2rhxow4fPpw7PmHCBI0cOVJr1qxRy3l/5VJbW6shQ4Zo+fLlXQZi+vTpgTwnaUZvYkQvFer3FIXeS6UGyoNlNhJSqXQu/0KvEWHsvVRqtui1YKRSab399rtOzk9h6D1pTi9SRG/5cm3kY++lUvxFeVDOP4e6vjbysfc4hwYnlUpry5atXlwbSf71XjZbLzZd4VKU5qmQa0Q8bvz2V3k5v71Ad690veqqq8TtBexVVmbV+YJh/sbiwtqrq5P8s46AVFZKx47xt2X5ntOAATG1tnJhFYTKyqyOHeOVrvmODxyYpNcCUlmZ1cmTvNI1X+30WnAqK6Xjx/24NvKx9/r3F70WkPPPoa6vjXzsPda14FRWZnXiBK90zfec6DW4xJ/de/+cjh8/rqFDh0bj9gLl5eUqLy/v9nOVldL48UUuKGTO3VQ6q1Qq/cc3Zogp9se1vKysrNvv6+54PB7vdkc/3/FEIqFEItHr413/udjFj5vUnu94d7VXVFx4Lx167eLy9Vqhfk89HQ9L740Y0Xmz/HOZVVTEuOn7RWzbduGMVlRc2Gv03rnj9JqdfOtaPH72JFrs81NPx33pPXrNTvfrmj/XRj0dd9V7XK/Z6e31Gr3HObSv8vVa5+/G9bXR+XzpPdY1O931GjPaM/7s3rfn1F1dtpxvuvZk/HjpvFf4ogcdHSk1NDSorq4ub3PhrFGjpEOHuh6j13qPXuu9znelJjMztbXSq692PcZFVc/otb4ht96j1+ywrpnjeq1vmNHeY13rG3LrPda1vqHXzJGZe8abrq2trdq9e3fu8VtvvaXNmzdr4MCBqqmp0bFjx9TU1KTm5mZJyt274YorrtAVV1wRUNkAAAAAAAAA4Cfju8M2NjZq4sSJmjhxoiTpoYce0sSJE/WDH/xAkvRv//ZvmjhxombPni1JuuOOOzRx4kQ99thjAZaND0skEpowYUKgL4MGukOvmSMzFAu9ZofczJEZ4Ddm1ByZ2SE3FAu9Zo7M7Di9vcC0adPU03tv3Xvvvbr33nv7UhMsxONxjRw50nUZKAH0mjkyQ7HQa3bIzRyZAX5jRs2RmR1yQ7HQa+bIzE5396a1/lmB/SQ4lUqltHLlygveiQ0IGr1mjsxQLPSaHXIzR2aA35hRc2Rmh9xQLPSaOTKzE2RebLpGRDabVUtLS4+vQgaCQK+ZIzMUC71mh9zMkRngN2bUHJnZITcUC71mjszsBJkXm64AAAAAAAAAECA2XQEAAAAAAAAgQGy6RkQikVBtbS3vSoeCo9fMkRmKhV6zQ27myAzwGzNqjszskBuKhV4zR2Z2gswrGdhPglPxeFxDhgxxXQZKAL1mjsxQLPSaHXIzR2aA35hRc2Rmh9xQLPSaOTKzE48H9/pUXukaER0dHVq2bJk6Ojpcl4KIo9fMkRmKhV6zQ27myAzwGzNqjszskBuKhV4zR2Z2gsyLTdcISaVSrktAiaDXzJEZioVes0Nu5sgM8Bszao7M7JAbioVeM0dmbrHpCgAAAAAAAAABYtMVAAAAAAAAAALEpmtEJJNJTZ8+Xckk742GwqLXzJEZioVes0Nu5sgM8Bszao7M7JAbioVeM0dmdoLMi03XCOnXr5/rElAi6DVzZIZiodfskJs5MgP8xoyaIzM75IZiodfMkZlbbLpGRCqVUkNDAzdJRsHRa+bIDMVCr9khN3NkBviNGTVHZnbIDcVCr5kjMztB5sWmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64AAAAAAAAAECA2XSMimUyqrq6Od6VDwdFr5sgMxUKv2SE3c2QG+I0ZNUdmdsgNxUKvmSMzO0HmxaZrhJw5c8Z1CbCwb98+/dM//ZM+//nP64YbblB1dbXKyso0cOBAXX/99frLv/xL/e53v3NdZhc+9Fo6ndaWLVv0z//8z/ryl7+s//Sf/pMuueQSxWIxxWIxTZs2zXWJXfiQGezQa+ZY10qDD5mFsdd8QG6lwYcZDRsys0NuKBYfei1s51AfMuv0wQcf6KmnnlJdXZ1Gjhypj3zkIxo2bJimTJmiH/3oRzpy5IjrEoOX9czJkyezkrLSyezkya6rCY8PPvgg+/zzz2c/+OAD16V4b/LkbFbq+p+LXnv99dezN9544x/7/eL/TZs2Lbt///7iF/ohPvTac889l62oqOgxr6lTpzqr78N8yCxMfJnRbJZeM8W6VjpcZxa2XvNlXQtTbr5kFlauZzSMyMwOufUe61rfuO61MJ1DO7nO7HxvvPFGdsKECT1mNmTIkOyyZctcl5o9cuRIVlL25MmTff5ZvMYYcGTnzp3auHFjl2OjR4/W+PHjNWjQIJ04cULr1q3TO++8I0lavXq1amtr9fLLL2vUqFEuSvbGiRMn1NbW5roMlAB6zQzrGoqFXrNDbgAA2OEcau+dd97RzJkz1dzcLEmKxWL69Kc/rWuvvVaHDx/WihUrdObMGR06dEi33367XnzxRc2YMcNx1cFg0xVw7LrrrtMXv/hFff7zn9eIESO6fC6TyWjx4sX6+te/rra2NjU3N+vOO+/UunXrFIvFHFXsj6FDh2rSpEm5/1566SX95Cc/cV0WIoheM8O6hmKh1+yQGwAAdjiHmluwYEFuw3XkyJF64YUXdMMNN+Q+f+TIEd1xxx367W9/q46ODv35n/+59uzZo8suu8xRxcFh0zVCuDlyuAwbNkxPPvmk7rrrLiUSiW6/Jh6P6/7771d1dbXmzp0rSXr11Ve1fPly3XLLLcUstwvXvXbrrbdq//79qqmp6XJ8w4YNjiq6ONeZwQ69ZoZ1rbTQa+FDbqWFdc0cmdkhNxQL1x7mXM9nQ0ODXn75ZUnSJZdcon//93/XJz7xiS5fM2jQIL3wwgu6/vrrtXfvXh07dkz/8A//oL/7u79zUXKgeCOtiCgrK9Ps2bNVVlbmuhT00tSpU3XvvffmXbDP99nPflY33nhj7vGyZcsKWVqPfOi1K6644oJNMJ/5kBns0GtmWNdKh+vMwtprrpFb6XA9o2FEZnbIDcXiutfCeA51nZkk/fSnP819fM8991yw4drp0ksv1d/8zd/kHj/++ONKpVIFr687QebFpmtEZDIZHTp0SJlMxnUpKJCbbrop9/G+ffuc1UGvmSMzFEvYeo11LbzClpkvvRY25BZeYZtRH5CZHXJDsYSt13w4h7rOrLW1Vb/97W9zj++7774ev37evHmqrKyUJB07dkxr1qwpaH35BJkXm64RkU6ntX79eqXTadeloEDOvweMy98zvWaOzFAsYes11rXwCltmvvRa2JBbeIVtRn1AZnbIDcUStl7z4RzqOrN169apvb1d0tlXsk6aNKnHr//IRz6i2tra3OOVK1cWtL58gsyLTVcgJLZu3Zr7+KqrrnJYCQAEg3UNxUKv2SE3AADscA6V3njjjdzHn/jEJ3p1f9k/+ZM/6fb7w4pNVyAEmpqauvwtz6xZsxxWAwB9x7qGYqHX7JAbAAB2OIeetXPnztzHI0eO7NX3nP9+Gm+++WbgNRUbm64REYvFVFVV1eUl7IiOhx56KPcS95qaGtXX1zurhV4zR2YoljD1GutauIUpM596LUzILdzCNKO+IDM75IZiCVOv+XIOdZ3Z0aNHcx8PHTq0V99zxRVX5D4+duxY4DX1RpB5Xfy1vQiFZDKpGTNmuC4DBbBkyRL98pe/zD1etGiRysvLndVDr5kjMxRLWHqNdS38wpKZb70WFuQWfmGZUZ+QmR1yQ7GEpdd8Ooe6zqy1tTX3cb9+/Xr1Ped/3fnfX0y9uQ1Cb/FK14jIZDLav39/aN7JD73T2NioBx54IPd4/vz5WrBggcOK6DUbZIZiCUOvsa5FQxgy87HXwoDcoiEMM+obMrNDbiiWMPSab+dQ15m9//77uY8vueSSXn3P+RvUZ86cCbym3ggyLzZdIyKdTmvz5s2heSc/XNxbb72l+vr63EJ1/fXX67HHHnNcFb1mg8xQLL73GutadPiema+95jtyiw7fZ9RHZGaH3FAsvveaj+dQ15l95CMfyX38wQcf9Op72tvbcx/39tWxQQsyLzZdAQ8dOHBAN998s9577z1J0qhRo/Tiiy+qf//+jisDADusaygWes0OuQEAYIdzaPcqKytzH/f2Vavnf9353x9WbLoCnjl69Khuvvlm7dmzR5I0bNgwrVixQsOGDXNcGQDYYV1DsdBrdsgNAAA7nEPzu/zyy3MfHzx4sFff07lxLUkDBw4MvKZiY9M1ImKxmAYPHhyKd/JDfqdOndItt9yi7du3S5IGDRqkFStW6JprrnFc2Tn0mjkyQ7H42Gusa9HkY2Zh6DUfkVs0+TijviMzO+SGYvGx13w/h7rObMyYMbmP9+/f36vvaWpqyn08duzYwGvqjSDzCu4tueBUMpnUlClTXJeBPjh9+rTq6ur0+9//XpI0YMAAvfjii/rYxz7muLKu6DVzZIZi8a3XWNeiy7fMwtJrviG36PJtRsOAzOyQG4rFt14LwznUdWbjxo3Lfbx161alUiklkz1vQ77++uvdfn8xXaxGE7zSNSLS6bTefPNNb28qjZ69//77mjNnjl555RVJUkVFhZYtW6ZPfvKTjiu7EL1mjsxQLD71GutatPmUWZh6zSfkFm0+zWhYkJkdckOx+NRrYTmHus5sypQpKi8vl3R2k7qxsbHHr29vb9err76aezxjxoyC1pcPb6SFC2QyGe3cuVOZTMZ1KTDU0dGhefPmaeXKlZKk8vJyvfDCC7rpppscV9Y9es0cmaFYfOk11rXo8yWzsPWaL8gt+nyZ0TAhMzvkhmLxpdfCdA51nVllZaVmzpyZe7x48eIev/5Xv/qVWlpaJJ29n+unP/3pQpaXV5B5sekKOJROp7VgwQI1NDRIOvsy9p///OeaNWuW48oAwA7rGoqFXrNDbgAA2OEcau4rX/lK7uPFixfn7n/7YW1tbfrBD36Qe/ylL30p0H/m7wqbroAj2WxWX/jCF/SLX/xCkhSPx/XUU09pzpw5jisDADusaygWes0OuQEAYIdzqJ3Zs2frU5/6lKSztw+47bbbtGXLli5fc/ToUd1+++3avXu3pLOvcv32t79d9FoLIfzbxpB0duBramoUj7OPHhY/+9nPtGTJktzja6+9VmvXrtXatWt79f2PPvpooUrrkS+9VldXp+bm5i7H3nvvvdzHjY2NmjBhwgXf19DQoOHDhxe6vC58yQx26LXeY10rHa4zC2uvuUZupcP1jIYRmdkhNxSL614L4znUdWad/uVf/kU33nijDhw4oH379mnChAmaOnWqrr32Wh0+fFgrVqxQW1ubpHOvHr7sssuc1RtkXmy6RkQikdDEiRNdlwEDhw4d6vJ4165d2rVrV6+/39UffHzptR07dmj//v15P3/69Gn94Q9/uOD4Bx98UMiyuuVLZrBDr/Ue61rpcJ1ZWHvNNXIrHa5nNIzIzA65oVhc91oYz6GuM+t05ZVXauXKlZo/f742b96sbDar1atXa/Xq1V2+bvDgwXryySe73AfWhUQiEdjP4q+jIiKdTmvTpk1evJMfoo1eM0dmKBZ6zQ65mSMzwG/MqDkys0NuKBZ6zZxPmY0dO1YbNmzQkiVLdOutt+qqq67SJZdcoiFDhmjy5Mn6h3/4B+3YsUOzZ892XWqgebHpGhGZTEZNTU3O38kPvbdw4UJls1nr/1zxpdf27dtnldvVV19d9Fp9yQx26LXeY10rHa4zC2uvuUZupcP1jIYRmdkhNxSL614L4znUdWYfdskll+juu+/Wr3/9azU1Nam9vV0HDx7U+vXr9fDDD2vQoEGuS5SkQPNi0xUAAAAAAAAAAsSmKwAAAAAAAAAEiE3XiIjH4xozZozzd6VD9NFr5sgMxUKv2SE3c2QG+I0ZNUdmdsgNxUKvmSMzO0HmlQzsJ8GpRCKhsWPHui4DJYBeM0dmKBZ6zQ65mSMzwG/MqDkys0NuKBZ6zRyZ2UkkEoH9LLa7IyKVSmndunVKpVKuS0HE0WvmyAzFQq/ZITdzZAb4jRk1R2Z2yA3FQq+ZIzM7QebFpmtEZLNZHT58mHeWRcHRa+bIDMVCr9khN3NkBviNGTVHZnbIDcVCr5kjMztB5sWmKwAAAAAAAAAEiE1XAAAAAAAAAAgQm64RkUgkNGHChEBv+At0h14zR2YoFnrNDrmZIzPAb8yoOTKzQ24oFnrNHJnZCTKvZGA/CU7F43GNHDnSdRkoAfSaOTJDsdBrdsjNHJkBfmNGzZGZHXJDsdBr5sjMTjwe3OtTeaVrRKRSKa1cuZJ3pUPB0WvmyAzFQq/ZITdzZAb4jRk1R2Z2yA3FQq+ZIzM7QebFpmtEZLNZtbS08K50KDh6zRyZoVjoNTvkZo7MAL8xo+bIzA65oVjoNXNkZifIvNh0BQAAAAAAAIAAsekKAAAAAAAAAAFi0zUiEomEamtreVc6FBy9Zo7MUCz0mh1yM0dmgN+YUXNkZofcUCz0mjkysxNkXsnAfhKcisfjGjJkiOsyUALoNXNkhmKh1+yQmzkyA/zGjJojMzvkhmKh18yRmZ14PLjXp/JK14jo6OjQsmXL1NHR4boURBy9Zo7MUCz0mh1yM0dmgN+YUXNkZofcUCz0mjkysxNkXmy6RkgqlXJdAkoEvWaOzFAs9JodcjNHZoDfmFFzZGaH3FAs9Jo5MnOLTVcAAAAAAAAACBCbrgAAAAAAAAAQIDZdIyKZTGr69OlKJnlvNBQWvWaOzFAs9JodcjNHZoDfmFFzZGaH3FAs9Jo5MrMTZF5sukZIv379XJeAEkGvmSMzFAu9ZofczJEZ4Ddm1ByZ2SE3FAu9Zo7M3GLTNSJSqZQaGhq4STIKjl4zR2YoFnrNDrmZIzPAb8yoOTKzQ24oFnrNHJnZCTIv403XNWvWqL6+XsOHD1csFtPzzz/f5fPZbFY/+MEPNGzYMPXr10+zZs3Srl27gqoXAID/n737j66qvvP9/zo/IiUmYJAfAiUoWggtw4RxdAzcDogw9gbhjqUzt2Bbte2d8UdrW297r71d/YrTzqVzp+2arussrbO6EDodnU7b0XsvkSoDaBEUqdDwQxmEQtSAID+DQcg5Z3//oDkS84N8dvbZn89nn+djLdbK2TlJ3vt13p/P3vnksDcAAAAAAE5LBUEQmHzBU089peeff15XX321Pv7xj+tf//Vf9ad/+qfFz//N3/yNli5dquXLl+uKK67QN7/5TW3btk07d+7UBz7wgQt+/5MnT2ro0KGSTqiqaoimTDHdpfKyd6/U3i5JgXK5vLLZjMaOTenVV21X5q5Ro6RDh7puGzlSeustO/X4oq5OevNN6fxeq6xMacIE25W5q6fxSWYXtn27dOpU122M0b4xPsNhjJrjvCMczj3M9ZRZVZX43eACmNfMkVk4HA/MMa+Fwxg1x/gcmCNHjmj48OE6ceKEhgwZMqDvZbzo2uWLU6kui65BEGjMmDH6r//1v+qrX/2qJOnEiRMaNWqUHn30UX3yk5+84Pc8f9FVGtjOlauqKqmtzXYV7qqu7r6gQ2YX1lNuQFwYo31jfMImxueFce5hjnkN8A/zWt+Y12AT47P/olx0jfQWZr/97W918OBBzZkzp7ht6NCh+qM/+iNt3Lixx0XXM2fO6MyZM8XHJ0+ejLKkMhWocyn9/dei6LwL2/u3V1RUqFAoKJ/PF7elUills9let+fzeRUKheL2dDqtTCbT6/ZcLqfz1/gzmYzS6XSv2zs6OvpVu+k+9dz2gaSUt/sUx+vUmRFgR6COjnPjIQnjKfo5IivGJ+w5d3xIzng6J8o5ordjqM/7VOrX6XdVCIBPAuXzhcTO5QPdJ87XYFuSxlMp54goRbroevDgQUnSqFGjumwfNWpU8XPvt3TpUj3wwANRllH2crm82traNXjwYDU1NXX5XGNjo06fPq21a9cWt2WzWc2bN09vv/22Nm7cWNxeXV2t2bNn6/XXX9fWrVuL20eMGKHp06dr9+7d2rVrV3F7bW2tpk2bpubmZrW0tBS3T5o0SXV1ddq0aZMOHz5c3F5fX6/x48frueeeU9t5f3JpaGjQyJEj9fTTT3cZENdff30k+yTN7pZZPl+QlPF2n+J4nc5NQpFOGUC/5XL54jhJwniKeo7I5eaJ8Qlbcrlzx4ekjCcp+jmi8zzj/Xzep1K/Trlcb38oB+CqXC6v5uZtiZ3LB7pPQTBfLLrCpiSNp1LOEefedBaNSC8vsGHDBs2YMUOtra0aPXp08Xl//ud/rlQqpX/+53/u9j16eqfruHHjxOUFwquqCtT5hmH+YtG99pqabA//xS9QWxvvdO1rn6qrA506xUkC7KiqCnT0KO907W37sGFZxies6TyGJmU8dYpyjujpGFpVJR075u8+lfp1GjJEzGuAZ6qqAh0/zjtde9snztdgU1WVdPRocsZTKeeIo0eP6rLLLnPv8gKXXXaZJOmtt97qsuj61ltvqb6+vsevGTRokAYNGtRt+8UXB7r4YnFx5Avo6YYzlZUppX43l1dUVPT4dT1tT6fTPa7o97Y9k8n87r/M9W971/8uduHtJrX3tr2n2isre85M8nef+toe1T5VVqZ6vB4dF37vHRd9D6e3C7+/fzz4PJ6iniN6mtcYnxfGGDXX23mHlJzxdL6o9qmnY2hlpd/7VOrXaexYbhAYBvOaOTILp7fjQee8kMS5fKD7xLwWDmPUXM/jM1njqa8aTbe/v/beflYYkS66XnHFFbrsssv0b//2b8VF1pMnT+rFF1/UnXfeafS99u/P6dJLo6wumRoapBde6LqNyadvEyZ0v2skmV1YT7lNmSKd9y589KKjI6empiY1Njb2OvmjO3LrP8bnwNBr/cd5Rzice5jrvMMy4zMccjNHZmY4HphjXhsYcus/xqc7jBddT506pddee634+Le//a22bt2qYcOGqba2Vl/+8pf17W9/Wx/60Id0xRVX6Jvf/KbGjBlTvAQBAJSjKP9aVk7IDXGh1wB3MT7DITdzZIa40GvhkBt8Y9yxmzdv1vXXX198fO+990qSbr31Vj366KP6b//tv+mdd97RX/zFX+j48eP6D//hP2jVqlX6wAc+YPRz+MsFgKSoqKjQvHnzbJfhHXJDXOg1wF2Mz3DIzRyZIS70WjjkhrhEuR5pfEuuWbNmKQiCbv8effRRSeculvtXf/VXOnjwoN59912tXr1aEydONC7s/AvqAoDPCoWCDh06xLxmiNwQF3oNcBfjMxxyM0dmiAu9Fg65IS5R9pjxomtczr9zGAD4LJ/Pa+PGjcxrhsgNcaHXAHcxPsMhN3NkhrjQa+GQG+ISZY85u+gKAAAAAAAAAD5i0RUAAAAAAAAAIuTsomsqlbJdAgBEIpVKqbq6mnnNELkhLvQa4C7GZzjkZo7MEBd6LRxyQ1yi7LFsZN8pYtmss6UBgJFsNqvZs2fbLsM75Ia40GuAuxif4ZCbOTJDXOi1cMgNcYlyPdLZd7pyRzoASVEoFLR//37mNUPkhrjQa4C7GJ/hkJs5MkNc6LVwyA1xibLHnF105Y50AJIin89r69atzGuGyA1xodcAdzE+wyE3c2SGuNBr4ZAb4hJljzm76AoAAAAAAAAAPmLRFQAAAAAAAAAi5OyiK3ekA5AUqVRKI0aMYF4zRG6IC70GuIvxGQ65mSMzxIVeC4fcEJcoeyy6W3JFLMq7hQGATdlsVtOnT7ddhnfIDXGh1wB3MT7DITdzZIa40GvhkBviEuV6pLPvdOXiyACSIp/P69VXX2VeM0RuiAu9BriL8RkOuZkjM8SFXguH3BCXsriRVqFQsF0CAESiUCho165dzGuGyA1xodcAdzE+wyE3c2SGuNBr4ZAb4hJljzm76AoAAAAAAAAAPmLRFQAAAAAAAAAi5OyiazrtbGkAYCSdTqu2tpZ5zRC5IS70GuAuxmc45GaOzBAXei0cckNcouyx6G7JFbFMJmPtZ7/99tt6/vnntWnTJm3btk179uxRa2urTp06pYqKCtXU1GjKlCmaNWuWPvOZz2js2LHWanXNvn379Mwzz+jZZ5/Vtm3b1NLSolOnTqm6ulof/OAH1dDQoMWLF2vmzJm2S4XnfOq1TCajadOm2S7Dq8wkcvOZb5m50Guce4TjW6/BnAvj00eu5JbP57Vjxw699NJL2rx5s1566SU1Nzero6NDkjRz5kytW7fObpG/40pmSD56LRxyQ1wiXY8MHHPixIlAUnD06FFrNcybNy+Q1K9/gwYNCpYsWRLk83krtV53XRBIXf9dd138dbz88svBtdde2+/cZs2aFezfvz/+QgN3MvONK7n51Gudcrlc8PLLLwe5XM7Kz/cxsyAgNxOMz4Gx3WtB4M+5B70Wjiu5+ciF8ekjF3L713/916CysrLPsTlz5kxr9b2fC5n5hHktPHotHHLrP8bnwBw9ejSQFJw4cWLA38vZd7q6cke64cOHa/LkyRo/fryqqqrU3t6u1157TZs2bVIul9OZM2e0ZMkS7d27V8uXL7ddrjW7du3Spk2bumybOHGipkyZouHDh+v48ePasGGD3njjDUnSunXr1NDQoF/96leaMGGCjZLhKR97rVAoqKWlRVOmTLHyLn4fM5PIzUe+Zma7196Pc48L87XXYM618ekLF3I7fvy42tvbrfzsMFzIDOWBXguH3BCXKNcjnV10tWnWrFmaP3++brjhBl111VU9Puett97SV77yFT322GOSpBUrVmj+/Pn6xCc+EWepzrnqqqv0+c9/Xp/61Ke6/dfHQqGgRx99VF/84hfV3t6u1tZW3XLLLdqwYYNSqZSliuEres0cmYVDbubIzBznHuHQa4D7Ro0apWuuuab475e//KV+8IMf2C4LAICSY9G1B1/96lcv+JxRo0bpJz/5id566y2tWbNGkvTDH/6wbH/xGT16tJYtW6ZPf/rTvf7VKZ1O67Of/axqamr08Y9/XJL0wgsv6Omnn9aNN94YZ7nwGL1mjszCITdzZBYe5x5m6DXAfR/72Me0f/9+1dbWdtn+4osvWqoIAIB4OXvbNx/uSJdKpXT77bcXH2/ZssViNXbNnDlTt912W7/e5n/zzTfr2muvLT5euXJlKUtDwvjYa+l0WpMmTbI2r/mYmURuPvI1M9u9ZoJzj3N87TWY82l8usSF3C677LJuC64ucyEzlAd6LRxyQ1yi7DFnu9WXa3SMGDGi+HFbW5vFSvwyY8aM4sf79u2zVwgSz4Vey2Qyqqur82ZecyEzidzKgSuZ+dZrnHuYc6XXYM638ekKcjNHZogLvRYOuSEuUfaYs4uuuVzOdgn9snPnzuLHl19+ub1CPHP+tdTy+bzFSpB0LvRaLpfThg0bvJnXXMhMIrdy4EpmvvUa5x7mXOk1mPNtfLqC3MyRGeJCr4VDbohLlD3m7KJrEAS2S7ig1tZWffe73y0+LsdrqoW1bdu24sfjxo2zWAmSzoVeC4JAhw8f9mJek9zITCK3cuBKZj71Guce4bjSazDn0/h0CbmZIzPEhV4Lh9wQlyh7zNlFV1e1t7dr586d+t73vqdp06aptbVVkjR58mTdd999lqvzQ0tLS/EGIJI0Z84ci9Ugyeg1c2QWDrmZI7P+49xjYOg1AAAA2JC1XYDr1q9fr49+9KN9PqexsVE/+clPVF1dHVNVfrv33nuL/7WvtrZW8+fPt1wRkopeM0dm4ZCbOTLrHece0aLXAAAAYIOz73T14eLINTU1euyxx7Ry5UpdcskltsvxwvLly/Xzn/+8+Hjp0qUaNGiQxYqQVC71WiaTUX19vfPzmkuZSeSWZK5l5kuvSZx7mHKt12DOp/HpEnIzR2aIC70WDrkhLlH2mLPvdE2n3VgPHjNmjO6++25J567r0NbWpl27dunll1/WsWPHtGjRIj3yyCN6+OGHNXHiRMvVum3z5s264447io8XLVqkxYsXW6wISeVar6XTaY0fP97az+8P1zKTyC2pXMzMtV7j3CMaLvYazLk2Pn1BbubIDHGh18IhN8QlyvVIN1Y2e+DKHekmTJigBx98UA8++KD+/u//XitWrNCLL76o/fv367bbbpMkrV27Vtddd52am5vtFuuw3/72t5o/f77effddSdLUqVP18MMPW64KSeRir+VyOa1Zs8aZee39XMxMIrckcjUz13qNc4+Bc7XXYM618ekLcjNHZogLvRYOuSEuUfaYs4uurt+RbsyYMVq2bJnuueceSdKxY8f0yU9+snjNMLznwIEDmjt3rg4ePCjp3C+Tq1at0pAhQyxXhqRxtdc636nm4rzmamYSuSWNy5m53Gvn49yjf1zuNZjzZXy6htzMkRniQq+FQ26IS5Q95uyiqy+WLl1aPIl/5ZVX9NRTT1muyC1HjhzR3LlztWfPHknS6NGjtXr1ao0ePdpyZUgaes0cmYVDbubILFqce/SOXgMAAIArWHQdoMrKSk2fPr34+Pnnn7dYjVtOnjypG2+8UTt27JAkDR8+XKtXr9YVV1xhuTIkDb1mjszCITdzZBY9zj16Rq8BAADAJc4uuvp0R7qamprix0eOHLFYiTveeecdNTY26te//rUkaejQoVq1apU+/OEPW64MSeNDr2UyGTU0NDgzr/mQmURuSeBLZq71Wn9w7tGVL70Gcz6OTxeQmzkyQ1zotXDIDXGJsseykX2niEV5t7BSO3DgQPHjYcOGWazEDe+++64WLFhQfOdNZWWlVq5cqauvvtpyZUgaX3otnU5r5MiRtsuQ5E9mErn5zqfMXOq1/uLc4z0+9RrM+Tg+XUBu5sgMcaHXwiE3xCXK9UhnVzY7Ojpsl9AvR44c0caNG4uPJ0+ebLEa+zo6OrRw4UKtWbNGkjRo0CA9+eSTmjFjhuXKkDQ+9VpHR4dWrlxpfV7zKTOJ3HzmW2au9Fp/ce7xHt96DeZ8G5+uIDdzZIa40GvhkBviEmWPObvoasvRo0f7/dxCoaAvfOELOnPmjKRzJ/o33XRTqUpzXj6f1+LFi9XU1CRJymaz+ulPf6o5c+ZYrgxJ42Ov5XI5qz/fx8wkcvORr5nZ7DXOPcLxtddgzvaxwFfkZo7MEBd6LRxyg29YdH2fFStW6JprrtGKFSt08uTJXp/X3NysxsZGPf7448VtX/va13TppZfGUaZzgiDQ5z73Of3sZz+TdO7t2D/+8Y+1YMECy5Uhaeg1c2QWDrmZI7NwOPcwR68BAADAdc5e09WmzZs369Zbb1U2m1VdXZ0mTZqkmpoapVIpHTlyRM3NzXrttde6fM3ChQt1//33W6rYvoceekjLly8vPr7yyiu1fv16rV+/vl9f/+CDD5aqNCQMvWaOzMIhN3NkFh7nHmboNcAPjY2Nam1t7bLt4MGDxY83b96s+vr6bl/X1NSkMWPGlLo8AABKytlF12zWTmmDBg0qfpzL5bR9+3Zt37691+dXV1dryZIl+tKXvlTWd9E7dOhQl8e7d+/W7t27+/31/PKD/vKx17LZrK6//npr85qPmUnk5iNfM7Pda5x7mPO112DO9vj0lSu57dy5U/v37+/18++8845+85vfdNt+9uzZUpbVI1cyQ/LRa+GQG+ISZY/Rre9z55136oYbbtDq1av14osvaseOHWppadHx48clSUOGDNHo0aNVX1+vOXPmaOHChaqqqrJbNADnDR482HYJXiI3xMVmr3HuAfSNY0E45GaOzBAXei0ccoNvUkEQBLaLON/Jkyc1dOhQvf3222V5jTJTDQ3SCy903XbdddJ5NzXG+5BZOOQWXkdHh5qamtTY2KiKigrb5XiD3PqP8Tkw9Fr/0WvhkFt4jM9wyM0cmZlhXguPXguH3PqP8TkwR44c0fDhw3XixAkNGTJkQN+LG2kBAAAAAAAAQIRYdAUAAAAAAACACLHoCgAAAAAAAAARcnbRlTvSAUiKbDarxsZG5jVD5Ia40GuAuxif4ZCbOTJDXOi1cMgNcYmyx5xddAWAJDl9+rTtErxEbogLvQa4i/EZDrmZIzPEhV4Lh9zgG2cXXXO5nO0SACASuVxOa9euZV4zRG6IC70GuIvxGQ65mSMzxIVeC4fcEJcoe8zZRVcAAAAAAAAA8BGLrgAAAAAAAAAQIRZdASAGXPA9HHJDXOg1wF2Mz3DIzRyZIS70WjjkBt8427EVFRW2SwCASFRUVGjevHm2y/AOuSEu9BrgLsZnOORmjswQF3otHHJDXKJcj3T2na6FQsF2CQAQiUKhoEOHDjGvGSI3xIVeA9zF+AyH3MyRGeJCr4VDbohLlD3m7KJrPp+3XQIARCKfz2vjxo3Ma4bIDXGh1wB3MT7DITdzZIa40GvhkBviEmWPObvoCgAAAAAAAAA+YtEVAAAAAAAAACLk7KJrKpWyXQIARCKVSqm6upp5zRC5IS70GuAuxmc45GaOzBAXei0cckNcouyxbGTfKWLZrLOlAYCRbDar2bNn2y7DO+SGuNBrgLsYn+GQmzkyQ1zotXDIDXGJcj3S2Xe6ckc6AElRKBS0f/9+5jVD5Ia40GuAuxif4ZCbOTJDXOi1cMgNcYmyx5xddOWOdACSIp/Pa+vWrcxrhsgNcaHXAHcxPsMhN3NkhrjQa+GQG+ISZY85u+gKAAAAAAAAAD5i0RUAAAAAAAAAIuTsoit3pAOQFKlUSiNGjGBeM0RuiAu9BriL8RkOuZkjM8SFXguH3BCXKHssultyRSzKu4UBgE3ZbFbTp0+3XYZ3yA1xodcAdzE+wyE3c2SGuNBr4ZAb4hLleqSz73Tl4sgAkiKfz+vVV19lXjNEbogLvQa4i/EZDrmZIzPEhV4Lh9wQl7K4kVahULBdAgBEolAoaNeuXcxrhsgNcaHXAHcxPsMhN3NkhrjQa+GQG+ISZY+VZNG1ra1NX/7ylzV+/HgNHjxY06dP10svvVSKHwUAAAAAAAAATinJhVM///nPa/v27frxj3+sMWPG6B//8R81Z84c7dy5U2PHju3X9xg/PquLL5YmTChFhcmxfXv3bXv3xl+HT3rKh8wujNzM1dVJb74pSVnlcvOUzWZUWcm8diF790rt7RK59R/HgnAYo+botXB6ymj7dqmhIf5afMGxIJyechs7Vnr1VduVIWn43cAc5x3hMK+Z47wjnM5eC4LolkpTQRAEkX03SadPn1Z1dbWefPJJzZs3r7j96quv1n/8j/9R3/72t/v8+pMnT2ro0KGSTkgaEmVpZaOqSmprs12Fu6qrpVOnum4jswsjN3M9ZQbEhfF5YYzRaNBrF0avwSbGaP/k83k1Nzdr6tSpymQytstxHr8bmONYEB16rW/02kCdlDRUJ06c0JAhA1uXjPydrrlcTvl8Xh/4wAe6bB88eLDWr1/f7flnzpzRmTNnio9PnjwZdUllKFDnUnoul+vymc67sL1/e0VFhQqFQpcLBqdSKWWz2V635/P5Lte6SKfTymQyvW7P5XI6f40/k8konU73ur2jo6NftZvuU89tH0hKebtPcbxOnRm9n8/7VOrX6Vxe3TMD4hGooyOXmPFUijni3PGAMTpw544PSZ3Lo9in3o6hQDzOHQ+kZIynUs4R9fX1yuVyXb6/7/vUU+1R7FPPx9BA+XzB230q9evEeUe0kjSe4vrdHfGLfNG1urpaDQ0N+ta3vqXJkydr1KhReuyxx7Rx40ZdddVV3Z6/dOlSPfDAA1GXUdZyubza2to1ePBgNTU1dflcY2OjTp8+rbVr1xa3ZbNZzZs3T2+//bY2btxY3F5dXa3Zs2fr9ddf19atW4vbR4wYoenTp2v37t3atWtXcXttba2mTZum5uZmtbS0FLdPmjRJdXV12rRpkw4fPlzcXl9fr/Hjx+u5555T23l/pmpoaNDIkSP19NNPd5m4rr/++kj2SZrdLbN8viAp4+0+xfE6nTsodJ8yfN6nUr9OudywHjMD4pDL5dXU1JSY8VSKOaJQmC9OSAculzt3fEjqXB7FPnWeZwA2dB4PpGSMp1LNETNnztSePXv0xhtvJGafSvk65fM36f3zWi6XV3PzNm/3qdSvUxBw3hGlJI2nuH53R/wiv7yAJO3Zs0ef/exn9dxzzymTyegP/uAPNHHiRP3617/WK6+80uW5Pb3Tddy4ceLyAuFVVQXqfMOwD3+FifsvSzU12R7+K0ygtjbe6drXPlVXBzp1qutJQlWVdPSov/tU6tdp6NBUt8yAuFRVBTp6lHe69rVPw4ZlGaMR6DyGJnUuj2KfejqGAnHpPB5IyRhPpZojgiDQU089pblz56qioiIR+1TK16mnY2hVVaDjx3mna2/7xHlHdKqqpOPHkzOe4vjdHSaiu7xASRZdO73zzjs6efKkRo8erf/8n/+zTp06pZUrV/b5Nedf07WqaoimTClVdcnw3kWlA+Vy+d9dVDrFRaX7MGqUdOhQ120jR0pvvWWnHl+Qm7meMquqEvPaBfQ0r1VWprjJQB84FoTDGDVHr4Xz3s1TmNf6i2NBONu3d7+OH+dr/dPR0aGmpiY1NjZ2WXRFz/jdwBznHeEwr5njvCOc93rN4Wu6nu/iiy/WxRdfrGPHjumXv/yl/tf/+l9GXz9linTeO7HRh46OHCcJ/TRhQveDHZPPhZGbuZ4yY17rP+Y1c2RmhjEaHr1mpnNRmtzMkZmZhgbphRe6buN8DaXA7wbmOO8Ih3nNHOcd4fTUawNVkkXXX/7ylwqCQJMmTdJrr72mr33ta6qrq9Ptt99eih8HnXt7+aRJk3530WQA8B/zmjkyQ1zotXDIzRyZIS70GoCkYV6zrySLridOnNDXv/51vfHGGxo2bJgWLlyov/7rv2ZlvYQymYzq6upslwEAkWFeM0dmiAu9Fg65mSMzxIVeA5A0zGv2lWS5+8///M+1Z88enTlzRgcOHNCDDz74u+u0olRyuZw2bNjQ7eLNAOAr5jVzZIa40GvhkJs5MkNc6DUAScO8Zh/vMU6IIAh0+PBhlfC+aAAQK+Y1c2SGuNBr4ZCbOTJDXOg1AEnDvGYfi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6JkQmk1F9fb0ymYztUgAgEsxr5sgMcaHXwiE3c2SGuNBrAJKGec2+rO0CEI10Oq3x48fbLgMAIsO8Zo7MEBd6LRxyM0dmiAu9BiBpmNfs452uCZHL5bRmzRruSgcgMZjXzJEZ4kKvhUNu5sgMcaHXACQN85p9LLomRBAEamtr4650ABKDec0cmSEu9Fo45GaOzBAXeg1A0jCv2ceiKwAAAAAAAABEiEVXAAAAAAAAAIgQi64Jkclk1NDQwF3pACQG85o5MkNc6LVwyM0cmSEu9BqApGFesy9ruwBEI51Oa+TIkbbLAIDIMK+ZIzPEhV4Lh9zMkRniQq8BSBrmNft4p2tCdHR0aOXKlero6LBdCgBEgnnNHJkhLvRaOORmjswQF3oNQNIwr9nHomuC5HI52yUAQKSY18yRGeJCr4VDbubIDHGh1wAkDfOaXSy6AgAAAAAAAECEWHQFAAAAAAAAgAix6JoQ2WxW119/vbJZ7o0GIBmY18yRGeJCr4VDbubIDHGh1wAkDfOafSy6JsjgwYNtlwAAkWJeM0dmiAu9Fg65mSMzxIVeA5A0zGt2seiaELlcTk1NTdYvkpzP59Xc3Kwf/ehHuvPOO/WHf/iHuuiii5RKpZRKpTRr1iyr9bnm7bff1pNPPqlvfOMbWrBggT7ykY+opqZGFRUVqqys1NixY3XjjTdq6dKlevPNN22X65R9+/bpH/7hH/SpT31Kv//7v1/MbdiwYZo6dar+8i//Us8++6ztMp3iW2auzGs+cSUz33oN5lzpNd+4kptPY9SFzDhfC8+n3w1c6DUA7uMYChO8xxiReeKJJ3TLLbeovb3ddineuO2227Ry5coeP5fL5XT69Gm1trbq6aef1gMPPKCvf/3r+uY3v6l0unz/XrJlyxbdcccd2rRpU4+fP3bsmI4dO6Zt27bpkUce0axZs7R8+XLV1tbGXKk7yAxxodcAtzFGw+F8LRx+NwCQJBxDEQaLrojM8ePHOakagOHDh2vy5MkaP368qqqq1N7ertdee02bNm1SLpfTmTNntGTJEu3du1fLly+3Xa41u3bt6nagmzhxoqZMmaLhw4fr+PHj2rBhg9544w1J0rp169TQ0KBf/epXmjBhgo2SrSMzxIVeA9zGGB04ztf6j98NACQJx1CEwaIrIjdq1Chdc801xX+//OUv9YMf/MB2WU6aNWuW5s+frxtuuEFXXXVVj89566239JWvfEWPPfaYJGnFihWaP3++PvGJT8RZqnOuuuoqff7zn9enPvUpjR07tsvnCoWCHn30UX3xi19Ue3u7Wltbdcstt2jDhg1KpVKWKraPzBAXeg1wG2PUDOdrA8PvBgCShGMojASOOXHiRCApkE4E111nuxp/FAqF4OzZs0GhULBWw4EDB4L9+/d3237//ff/7jVVMHPmzPgLe5/rrgsCqes/13utUCgEs2fPLuY4Z86c2GtwJbd169YFy5YtC3K53AWf+4tf/KKYmaRg1apVMVT4HjIbGBfmNd/Yzsy3XnNljPrIdq/5ynZuvo3RILCfmQnO17ry5XeDTj71mgtc6jVfkFk4ruTGMTT53uu1c+uSJ06cGPD3LO8LDSXM6dOnrf78yy67jOuVlEgqldLtt99efLxlyxaL1dg1c+ZM3XbbbcpkMhd87s0336xrr722+Li367Elnc+Z2Z7XfGQzM597DeYYn+EwRs350mucr3Xl4+8GvvQagPhxDEUYLLomRC6X09q1a7krXYKNGDGi+HFbW5vFSvwyY8aM4sf79u2zV4hHXMmMec2cb5m50msw51uvucK33FwYo75lxvmav3zrNQBu4xgKiUVXwBs7d+4sfnz55ZfbK8Qz5187J5/PW6zEH2SGuNBrgNsYo+Y4XwMASBxDcQ6LroAHWltb9d3vfrf4mJsy9N+2bduKH48bN85iJf4gM8SFXgPcxhg1w/kaAKATx1BILLomSjabtV0CItTe3q6dO3fqe9/7nqZNm6bW1lZJ0uTJk3XfffdZrs4PLS0tWrNmTfHxnDlzLFbjB9cyY14z50tmrvUazPnSa67xJTeXxqjLmXG+liwu9xoAf3AMRSfST4iKigrNmzfPdhkYgPXr1+ujH/1on89pbGzUT37yE1VXV8dUld/uvffe4n/lqK2t1fz58y1X5D6XMmNeM+dTZi71Gsz51Gsu8Sk3V8aoa5lxvpZcrvUaAH9xDEUn3umaEIVCQYcOHVKhULBdCkqgpqZGjz32mFauXKlLLrnEdjleWL58uX7+858XHy9dulSDBg2yWJH7XMuMec2cL5m51msw50uvucaX3Fwao75kJnG+5jufeg2AuziG4nwsuiZEPp/Xxo0buUCzx8aMGaO7775bd999t+666y59+tOf1rXXXqtsNqtjx45p0aJFmj17tv793//ddqnO27x5s+64447i40WLFmnx4sUWK3Kfi5kxr5nzITMXew3mfOg1F/mQm2tj1LXMOF9LLtd6DYB/OIbi/bi8AOCICRMm6MEHH+y2vbW1Vd/4xjf06KOPau3atbruuuu0bt06TZ061UKV7vvtb3+r+fPn691335UkTZ06VQ8//LDlqtxGZogLvQa4jTF6YZyvAQB6wjEUPeGdroDjxowZo2XLlumee+6RJB07dkyf/OQn+WtVDw4cOKC5c+fq4MGDks79YrRq1SoNGTLEcmXuIjPEhV4D3MYYHRjO1wCgfHEMRW9YdE2IVCql6upqpVIp26WgRJYuXVqctF955RU99dRTlityy5EjRzR37lzt2bNHkjR69GitXr1ao0ePtlyZu1zPjHnNnKuZud5rMOdqr7nO1dxcHqOuZtYbztf85VuvAXADx1D0hUXXhMhms5o9e7ayWa4YkVSVlZWaPn168fHzzz9vsRq3nDx5UjfeeKN27NghSRo+fLhWr16tK664wnJl7vIhM+Y1cy5m5kOvwZyLveYDF3NzfYy6mFlfOF/zl2+9BsA+jqG4EBZdE6JQKGj//v3clS7hampqih8fOXLEYiXueOedd9TY2Khf//rXkqShQ4dq1apV+vCHP2y5Mnf5khnzmjnXMvOl12DOtV7zhWu5+TBGXcusPzhf85OPvQbAHo6h6A8WXRMin89r69atXDcq4Q4cOFD8eNiwYRYrccO7776rBQsWFN9FUllZqZUrV+rqq6+2XJm7fMqMec2cS5n51Gsw51Kv+cSl3HwZoy5l1l+cr/nJx14DYAfHUPQXi66AJ44cOaKNGzcWH0+ePNliNfZ1dHRo4cKFWrNmjSRp0KBBevLJJzVjxgzLlbmLzBAXeg1wG2O0dDhfA4Bk4xgKEyy6ApYcPXq0388tFAr6whe+oDNnzkg6N7HfdNNNpSrNefl8XosXL1ZTU5Okc9eq+elPf6o5c+ZYrsxdZIa40GuA2xijZjhfAwB04hgKUyy6JkQqldKIESO4K51HVqxYoWuuuUYrVqzQyZMne31ec3OzGhsb9fjjjxe3fe1rX9Oll14aR5nOCYJAn/vc5/Szn/1MkpROp/XjH/9YCxYssFyZu3zNjHnNnO3MfO01mLPda76ynZuPY9R2ZpyvlQ/bvQbAbRxDEQa3MEuIbDbb5U6ptjQ2Nqq1tbXLtoMHDxY/3rx5s+rr67t9XVNTk8aMGVPq8pyzefNm3Xrrrcpms6qrq9OkSZNUU1OjVCqlI0eOqLm5Wa+99lqXr1m4cKHuv/9+SxXb99BDD2n58uXFx1deeaXWr1+v9evX9+vrH3zwwVKV5ixfM3NlXvOJ7cx87TWYs91rvrKdm49j1HZmEudrA+HT7wYu9BoAd3EMRRgsuiZEPp/X7t279aEPfUiZTMZaHTt37tT+/ft7/fw777yj3/zmN922nz17tpRlOWnQoEHFj3O5nLZv367t27f3+vzq6motWbJEX/rSl6y+xrYdOnSoy+Pdu3dr9+7d/f76clzU8TUzV+Y1n9jOzNdegznbveYr27n5OEZtZ8b52sD49LuB7V4D4DaOoQiDRdeEKBQK2rVrl6688koGkyfuvPNO3XDDDVq9erVefPFF7dixQy0tLTp+/LgkaciQIRo9erTq6+s1Z84cLVy4UFVVVXaLBmLEvGaOzBAXei0ccjNnOzPO18qH7V4DgKgxr9nHoisitW/fPtsleGXixImaOHGi7rrrLtuleGPJkiVasmSJ7TK8QmaIC70GuI0xGg7na+HxuwGApOAYijC4kRYAAAAAAAAARIhF14RIp9Oqra1VOs1LCiAZmNfMkRniQq+FQ27myAxxodcAJA3zmn1cXiAhMpmMpk2bZrsMAIgM85o5MkNc6LVwyM0cmSEu9BqApGFes4/l7oTI5/PasmWL8vm87VIAIBLMa+bIDHGh18IhN3NkhrjQawCShnnNPhZdE6JQKKilpUWFQsF2KQAQCeY1c2SGuNBr4ZCbOTJDXOg1AEnDvGYfi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6JkQ6ndakSZO4Kx2AxGBeM0dmiAu9Fg65mSMzxIVeA5A0zGv2ZW0XgGhkMhnV1dXZLgMAIsO8Zo7MEBd6LRxyM0dmiAu9BiBpmNfsY7k7IXK5nDZs2KBcLme7FACIBPOaOTJDXOi1cMjNHJkhLvQagKRhXrOPRdeECIJAhw8fVhAEtksBgEgwr5kjM8SFXguH3MyRGeJCrwFIGuY1+1h0BQAAAAAAAIAIsegKAAAAAAAAABFi0TUhMpmM6uvrlclkbJcCAJFgXjNHZogLvRYOuZkjM8SFXgOQNMxr9mVtF4BopNNpjR8/3nYZABAZ5jVzZIa40GvhkJs5MkNc6DUAScO8Zh/vdE2IXC6nNWvWcFc6AInBvGaOzBAXei0ccjNHZogLvQYgaZjX7GPRNSGCIFBbWxt3pQOQGMxr5sgMcaHXwiE3c2SGuNBrAJKGec0+Fl0BAAAAAAAAIEIsugIAAAAAAABAhFh0TYhMJqOGhgbuSgcgMZjXzJEZ4kKvhUNu5sgMcaHXACQN85p9WdsFIBrpdFojR460XQYARIZ5zRyZIS70WjjkZo7MEBd6DUDSMK/ZxztdE6Kjo0MrV65UR0eH7VIAIBLMa+bIDHGh18IhN3NkhrjQawCShnnNPhZdEySXy9kuAQAixbxmjswQF3otHHIzR2aIC70GIGmY1+yKfNE1n8/rm9/8pq644goNHjxYV155pb71rW8pCIKofxQAAAAAAAAAOCfya7r+zd/8jR566CEtX75cH/nIR7R582bdfvvtGjp0qO655x6j77V9u9TQEHWFybJ3r9TeLklZ5XLzlM1mNHas9Oqrtitz19693bfRaxe2fXv3bT1liff0lA+ZXVhdnfTmm9L581plpTRhgu3K3NXTsYDMLox5zRzjMxzGqDkyC4d5zRzzWjj0mjl+NwiH39/NsU4UTinGYyqI+C2oN910k0aNGqUf/ehHxW0LFy7U4MGD9Y//+I8X/PqTJ09q6NChkk5IGhJlaWWjqkpqa7Ndhbuqq6VTp2xXkQz0Wt966jUyuzDGKGxijPaN8Qn4h3mtb8xr0aHX+sbvBuEwRqNBr13Ye712UtJQnThxQkOGDGxdMvJ3uk6fPl2PPPKI/v3f/10TJ07Ub37zG61fv17f//73e3z+mTNndObMmeLjkydPRl1SGQrUuZT+/ut3ZLPZHrdXVFSoUCgon88Xt6VSKWWz2V635/N5FQqF4vZ0Oq1MJtPr9lwu1+UyE5lMRul0utft77/Yc2+1m+5TCdq+rJXqdUpC70mp3/07X6COjvee79s+xfM6ZXvIDYhLoEIhSNB46lr7QPeJ8Qn46L1zj/I4jzDdJ+a16ATK5wtlfA7b9z713Gv87n6hfZICMUajkaTxVJrei/54EPnq03333aeTJ0+qrq6uGORf//Vf65Zbbunx+UuXLtUDDzwQdRllLZfLq62tXYMHD1ZTU1OXzzU2Nur06dNau3ZtcVs2m9W8efP09ttva+PGjcXt1dXVmj17tl5//XVt3bq1uH3EiBGaPn26du/erV27dhW319bWatq0aWpublZLS0tx+6RJk1RXV6dNmzbp8OHDxe319fUaP368nnvuObWd9yeXhoYGjRw5Uk8//XSXAXH99ddHsk/S7P7EiH4q1euUhN7L5Ybp/dNsoRB0+T6+7VMcr1MuN69bbkBccrm8Xn/9zcSMp05RzRHSgn6kCMAluVy+OJbL4TzCdJ8474hOLpdXc/O2sj2HvdA+BcF8vX9Bh9/dL7xPhQKLrlFJ0ngqRe+V4ngQ+eUFHn/8cX3ta1/T3/7t3+ojH/mItm7dqi9/+cv6/ve/r1tvvbXb83t6p+u4cePE5QXCq6oK1PmGYf5i0b32mpos/z0hIlVV0tGj/LWst30aOjSlU6e6niBUVQU6epR3uva1T8OGZbvlBsSlqirQiRO807W32hmfgH/OP/coh/MI031iXotOVVWg48d5p2tv+9RTr/G7+4X3qbo6YIxGgN/dL7xP743R6C4vEPmi67hx43Tffffp7rvvLm779re/rX/8x3/Uq/24am/nNV0vvvi4Lr54KBcwv4Dt27tf32TkSOmtt+zU44P3LpYfKJfL/+5i+Sl67QLeuxj3e7mNHZviYtx9GDVKOnSo6zbG54X1lFtVlTRlip16fNDT+GReuzDmNXOMz3AYo+bILBzmNXPMa+HQa+b43SAcfn83xzpROO+NUYev6dre3q50Ot1lWyaT6bKC3R/79+d06aVRVpZMDQ3SCy903cbk07fOE4GOjpyamprU2NioiooKu0V5hNz6b8KE7idWjM8L6ym3KVOk8/4XC3rB+AyH3PqP8Tkw9Jo5MguH3PqPeW1g6LX+43eDcPj93RzrROH0NEYHKvJF1/nz5+uv//qvVVtbq4985CPasmWLvv/97+uzn/2sWWFZrquD0spms2psbKTXDJEb4C7GZzjkhrjQa+bILBxyQ1zoNcSFXoOP0hd+ipn//b//tz7xiU/orrvu0uTJk/XVr35Vf/mXf6lvfetbUf8oYMBOnz5tuwQvkRvgLsZnOOSGuNBr5sgsHHJDXOg1xIVeg28iX3Strq7W3/3d32n//v06ffq09uzZo29/+9u66KKLjL7P+y9uC0Qtl8tp7dq19JohcgPcxfgMh9wQF3rNHJmFQ26IC72GuNBr8FHki64AAAAAAAAAUM5YdAUAAAAAAACACLHoirLGRbjDITfAXYzPcMgNcaHXzJFZOOSGuNBriAu9Bt8427EVFRW2S0DCVVRUaN68ebbL8A65Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4yNl3uhYKBdslIOEKhYIOHTpErxkiN8BdjM9wyA1xodfMkVk45Ia40GuIC70GHzm76JrP522XgITL5/PauHEjvWaI3AB3MT7DITfEhV4zR2bhkBviQq8hLvQafOTsoisAAAAAAAAA+IhFVwAAAAAAAACIkLOLrqlUynYJSLhUKqXq6mp6zRC5Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4KGu7gN5ks86WhoTIZrOaPXu27TK8Q26Auxif4ZAb4kKvmSOzcMgNcaHXEBd6DT5y9p2u3JEOpVYoFLR//356zRC5Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4yNlFV+5Ih1LL5/PaunUrvWaI3AB3MT7DITfEhV4zR2bhkBviQq8hLvQafOTsoisAAAAAAAAA+IhFVwAAAAAAAACIkLOLrtyRDqWWSqU0YsQIes0QuQHuYnyGQ26IC71mjszCITfEhV5DXOg1+Chru4DeZLPOloaEyGazmj59uu0yvENugLsYn+GQG+JCr5kjs3DIDXGh1xAXeg0+cvadrlwc2U/5fF7Nzc360Y9+pDvvvFN/+Id/qIsuukipVEqpVEqzZs2yXWJRPp/Xq6++Sq8ZIjfAXa6Mz3379ukf/uEf9KlPfUq///u/r5qaGlVUVGjYsGGaOnWq/vIv/1LPPvus1RrP50puPh1DEY4rvebTGHUlM9+4khvzmjmfxqfkTq8h+eg1+MjZt5MWCgXbJcDQE088oVtuuUXt7e22S+mXQqGgXbt26corr1Qmk7FdjjfIDXCX7fG5ZcsW3XHHHdq0aVOPnz927JiOHTumbdu26ZFHHtGsWbO0fPly1dbWxlxpV7Zzk/w7hiIc273m4xi1nZmvXMiNec2Mj+NTcqPXUB7oNfjI2UVX+Of48eOcVAFAGdu1a1e3XxYnTpyoKVOmaPjw4Tp+/Lg2bNigN954Q5K0bt06NTQ06Fe/+pUmTJhgo2RncAxFHBijiBPzmhnGJwAkD4uuiNyoUaN0zTXXFP/98pe/1A9+8APbZQEAYnLVVVfp85//vD71qU9p7NixXT5XKBT06KOP6otf/KLa29vV2tqqW265RRs2bODGCOIYingwRhEn5jUzjE8ASA5nF13TaWcvN4tefOxjH9P+/fu7/ReXF1980VJFfUun06qtraXXDJEb4C7b43P06NFatmyZPv3pT/f6377S6bQ++9nPqqamRh//+MclSS+88IKefvpp3XjjjXGW26Um2/Oab8dQhGO713wco7Yz85ULuTGvmfFxfHbWZLvXUB7oNfjI2W7lGh3+ueyyy6xfU8hEJpPRtGnT6DVD5Aa4y/b4nDlzpm677bZ+/fybb75Z1157bfHxypUrS1lan2znJvl3DEU4tnvNxzFqOzNfuZAb85oZH8en5EavoTzQa/CRs4uu3JEOpZbP57VlyxZ6zRC5Ae7ybXzOmDGj+PG+ffus1eFbbvCXb73mwhj1LTNXkFvyuTA+JXoN8aHX4CNnF10LhYLtEpBwhUJBLS0t9JohcgPc5dv4PP/6czZPoH3LDf7yrddcGKO+ZeYKcks+F8anRK8hPvQafOTsoisAAEi2bdu2FT8eN26cxUoA9IQxCriL8QkA7mPRFQAAxK6lpUVr1qwpPp4zZ47FagC8H2MUcBfjEwD84OyiK3ekQ6ml02lNmjSJXjNEboC7fBqf9957b/G/Q9bW1mr+/PnWavEpN/jNp15zZYz6lJlLyC3ZXBmfEr2G+NBr8FHWdgG94Y50KLVMJqO6ujrbZXiH3AB3+TI+ly9frp///OfFx0uXLtWgQYOs1eNLbvCfL73m0hj1JTPXkFtyuTQ+JXoN8aHX4CNn/0SQy+Vsl4CEy+Vy2rBhA71miNwAd/kwPjdv3qw77rij+HjRokVavHixxYr8yA3J4EOvuTZGfcjMReSWTK6NT4leQ3zoNfjI2UXXIAhsl4CEC4JAhw8fptcMkRvgLtfH529/+1vNnz9f7777riRp6tSpevjhhy1X5X5uSA7Xe83FMep6Zq4it+RxcXxK9BriQ6/BR84uugIAgOQ4cOCA5s6dq4MHD0qSJkyYoFWrVmnIkCGWKwMgMUYBlzE+AcBPLLoCAICSOnLkiObOnas9e/ZIkkaPHq3Vq1dr9OjRlisDIDFGAZcxPgHAX84uunIjLZRaJpNRfX09vWaI3AB3uTg+T548qRtvvFE7duyQJA0fPlyrV6/WFVdcYbmy97iYG5LJxV5zfYy6mJkPyC0ZXB+fEr2G+NBr8FHWdgG9SaedXQ9GQqTTaY0fP952Gd4hN8Bdro3Pd955R42Njfr1r38tSRo6dKhWrVqlD3/4w5Yr68q13JBcrvWaD2PUtcx8QW7+82F8SvQa4kOvwUfOrmxyRzqUWi6X05o1a+g1Q+QGuMul8fnuu+9qwYIFev755yVJlZWVWrlypa6++mrLlXXnUm5INpd6zZcx6lJmPiE3v/kyPiV6DfGh1+AjZxdduSMdSi0IArW1tdFrhsgNcJcr47Ojo0MLFy7UmjVrJEmDBg3Sk08+qRkzZlitqzeu5Ibkc6XXfBqjrmTmG3Lzl0/jU6LXEB96DT5ydtEVAAD4J5/Pa/HixWpqapIkZbNZ/fSnP9WcOXMsVwZAYowCLmN8AkCysOgKAAAiEQSBPve5z+lnP/uZpHPX3vrxj3+sBQsWWK4MgMQYBVzG+ASA5HH2Rlrckc5PjY2Nam1t7bLt4MGDxY83b96s+vr6bl/X1NSkMWPGlLq8LjKZjBoaGug1Q+QGuMv2+HzooYe0fPny4uMrr7xS69ev1/r16/v19Q8++GCpSuuT7dw6+XQMRTi2e83HMWo7M1+5khvzWv/5OD4ld3oNyUevwUfOLrqm07wJ10c7d+7U/v37e/38O++8o9/85jfdtp89e7aUZfUonU5r5MiRsf9c35Eb4C7b4/PQoUNdHu/evVu7d+/u99fb+oXRdm6dfDqGIhzbvebjGLWdma9cyY15rf98HJ+SO72G5KPX4CNnVzY7Ojpsl4CE6+jo0MqVK+k1Q+QGuIvxGQ65IS70mjkyC4fcEBd6DXGh1+AjZxdd4ad9+/YpCALjf5dffrmVenO5nJWf6ztyA9xlc3wuWbIk1DGg859NLsxrvh1DEQ5j1JwL49NHLuTGvNZ/vo5PyY1eQ3mg1+AbFl0BAAAAAAAAIEIsugIAAAAAAABAhJxddM1mnb3HFxIim83q+uuvp9cMkRvgLsZnOOSGuNBr5sgsHHJDXOg1xIVeg4+cXXQF4jB48GDbJXiJ3AB3MT7DITfEhV4zR2bhkBviQq8hLvQafOPsoisXSEap5XI5NTU10WuGyA1wF+MzHHJDXOg1c2QWDrkhLvQa4kKvwUfOLroCAAAAAAAAgI9YdAUAAAAAAACACLHoCgAAAAAAAAARcnbRlTvSodSy2awaGxvpNUPkBriL8RkOuSEu9Jo5MguH3BAXeg1xodfgI2cXXYE4nD592nYJXiI3wF2Mz3DIDXGh18yRWTjkhrjQa4gLvQbfOLvoyh3pUGq5XE5r166l1wyRG+Auxmc45Ia40GvmyCwcckNc6DXEhV6Dj5xddAUAAAAAAAAAH7HoCgAAAAAAAAARYtEVZY2LcIdDboC7GJ/hkBviQq+ZI7NwyA1xodcQF3oNvnG2YysqKmyXgISrqKjQvHnzbJfhHXID3MX4DIfcEBd6zRyZhUNuiAu9hrjQa/CRs+90LRQKtktAwhUKBR06dIheM0RugLsYn+GQG+JCr5kjs3DIDXGh1xAXeg0+cnbRNZ/P2y4BCZfP57Vx40Z6zRC5Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4yNlFVwAAAAAAAADwEYuuAAAAAAAAABAhZxddU6mU7RKQcKlUStXV1fSaIXID3MX4DIfcEBd6zRyZhUNuiAu9hrjQa/BR1nYBvclmnS0NCZHNZjV79mzbZXiH3AB3MT7DITfEhV4zR2bhkBviQq8hLvQafOTsO125Ix1KrVAoaP/+/fSaIXID3MX4DIfcEBd6zRyZhUNuiAu9hrjQa/CRs4uu3JEOpZbP57V161Z6zRC5Ae5ifIZDbogLvWaOzMIhN8SFXkNc6DX4yNlFVwAAAAAAAADwUeSLrpdffrlSqVS3f3fffXfUPwoAAAAAAAAAnBP53apeeumlLm/33r59u+bOnas/+7M/M/o+48dndfHF0oQJUVeYLNu3d9+2d2/8dfikrk56801Jyiqfv0mZTFqVlfTahezdK7W3S+fnNnas9OqrtitzV09jkfF5YeRmjnktHOY1cz2Nxe3bpYaG+GvxSU+9xhjtG5mFw7xmjvOOcDj3MMfv7gOTSqU0YsQIpVIp26U4j/O1cHoaowOVCoIgiP7bvufLX/6y/t//+3/avXt3vwbHyZMnNXToUEknJA0pZWmJVVUltbXZrsJd1dXSqVO2q0gGeq1vPfUamV0YuZljXosOvdY3eg3wD/Na3zjvCIfjQTToNZQC43OgTkoaqhMnTmjIkIGtS0b+TtfznT17Vv/4j/+oe++9t9cF1zNnzujMmTPFxydPnixlSWUiUOdSei6X6/KZbDbb4/aKigoVCoUu71JOpVLKZrO9bs/n813uHJhOp5XJZHrdnsvldP4afyaTUTqd7nV7R0dHv2o33acSt33ZKdXrlITek1K/+3e+QB0d7z3ft32K53XK9pmbn/ukLrVH/zr1lBnCCVQoBAkaT11rH+g+0WuAj947hpbHeYTpPvV93uHnPqnP2qPYJ44HUeF39/7uUz6f1549e3TVVVdp0KBBidin92+Pap+kQIxPN5R09emJJ57Q8ePHddttt/X6nKVLl+qBBx4oZRllJ5fLq62tXYMHD1ZTU1OXzzU2Nur06dNau3ZtcVs2m9W8efP09ttva+PGjcXt1dXVmj17tl5//XVt3bq1uH3EiBGaPn26du/erV27dhW319bWatq0aWpublZLS0tx+6RJk1RXV6dNmzbp8OHDxe319fUaP368nnvuObWd9+e9hoYGjRw5Uk8//XSXiev666+PZJ+k2f2JEf1UqtcpCb2Xyw3T+6fZQiHo8n1826c4Xqdcbl633HK5fLFWH/epU6lep54yQzi5XF6vv/5mYsZTp6h6T1rQjxQBuOT8Y2g5nEeY7tOFzjt83KdOpXyd8vmbJGWEgeF3d/N9On78uGbMmJGofYr6dTq3oMvvBi4o6eUFbrzxRl100UX6v//3//b6nJ7e6Tpu3DhxeYHwqqoCdb5h2Ie/wsT9l6WamixvtY9IVZV09Ki/fwEsde8NHZrSqVNd/8JYVRXo6FHe6drXPg0blu0zNx/3qVOpXqeeMkM4VVWBTpzgna691U6vAf45/xhaDucRpvt0ofMOH/epUylfJ44H0eB39/7vU0dHh5555hn9yZ/8iQYPHpyIfXr/9qj2qbo6YHwOiAeXF9i/f79Wr16tX/ziF30+b9CgQRo0aFCPn6uqkqZMKUV1yfHexfID5XJ5ZbMZjR2bUufVHCoqKnr8up62p9Pp370VvX/bM5mMMpnuf93sbXvnZNTf7Sa197a9p9orK3u+bhO91rft27vnVllZutepr+2+9F5PvVZZmerx+b7sUxyvU39z82mf+rs97D4xr4XT87yWUjp97iCahPHU3+39rX3s2M4bp7x33lFZmeLGKRfQ0/kaufWNzMLpbV57/1hO8nlEf7f3dQzt73mHq/s0kO393SfOPczxu3vf2/u7T501JGmfOkW1T2PHpjhfC6FzjAZBoHfeieZ7lmzRddmyZRo5cqTmzZsX+ntMmSKd905s9CGfL6i5eZumTp3a42DEeyZMkA4d6rqNXruwhgbphRe6bmPS7ltPvUZmF0Zu5pjXwmFeM9d5B3TOO8IhN3NkZoZ5zRznHeFw7hEe81o46XRatbW1PS5WoivO1wbm2LGChg2L5nuVZNG1UCho2bJluvXWW3tdeUe0MpmMpk2bZrsMAABQBjjvCIfczJEZgKRhXguH3MyRWThRLlCX5E8Eq1evVktLiz772c+W4tujB/l8Xlu2bHnfHSUBAACix3lHOORmjswAJA3zWjjkZo7Mwokyr5Isuv7Jn/yJgiDQxIkTS/Ht0YNCoaCWlpYuF1cGAAAoBc47wiE3c2QGIGmY18IhN3NkFk6UeXExDAAAAAAAAACIEIuuAAAAAAAAABAhFl0TIp1Oa9KkSdzJDwAAlBznHeGQmzkyA5A0zGvhkJs5MgsnyryykX0nWJXJZFRXV2e7DAAAUAY47wiH3MyRGYCkYV4Lh9zMkVk4mUwmsu/FcndC5HI5bdiwQblcznYpAAAg4TjvCIfczJEZgKRhXguH3MyRWThR5sWia0IEQaDDhw8rCALbpQAAgITjvCMccjNHZgCShnktHHIzR2bhRJkXi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6JkQmk1F9fX2kF/wFAADoCecd4ZCbOTIDkDTMa+GQmzkyCyfKvLKRfSdYlU6nNX78eNtlAACAMsB5RzjkZo7MACQN81o45GaOzMJJp6N7fyrvdE2IXC6nNWvWcFc6AABQcpx3hENu5sgMQNIwr4VDbubILJwo82LRNSGCIFBbWxt3pQMAACXHeUc45GaOzAAkDfNaOORmjszCiTIvFl0BAAAAAAAAIEIsugIAAAAAAABAhFh0TYhMJqOGhgbuSgcAAEqO845wyM0cmQFIGua1cMjNHJmFE2Ve2ci+E6xKp9MaOXKk7TIAAEAZ4LwjHHIzR2YAkoZ5LRxyM0dm4aTT0b0/lXe6JkRHR4dWrlypjo4O26UAAICE47wjHHIzR2YAkoZ5LRxyM0dm4USZF+90TZBcLme7BAAO27dvn5555hk9++yz2rZtm1paWnTq1ClVV1frgx/8oBoaGrR48WLNnDnTdqnw2Ntvv63nn39emzZt0rZt27Rnzx61trbq1KlTqqioUE1NjaZMmaJZs2bpM5/5jMaOHWu7ZGf4NkZdOO/wLTOJ3MKwnRnzGuLk2/h0hW+52Z7XfOVKbmfPntU///M/67HHHtOOHTv01ltvqaamRldccYU+/vGP67bbbtPw4cNtlynJjcx8G5+RChxz4sSJQFIgnQiuu852Nf44e/Zs8MQTTwRnz561XYrzrrsuCKSu/+i1CyM3c65k9vLLLwfXXnvt7+bWC/+bNWtWsH///vgL/R1XcvOJS5nNmzev3702aNCgYMmSJUE+n7dSqyu5+TZGg8D+eYePmQUBuYVhO7MgYF5LOlcy8218klt4LsxrPnIlt1deeSWor6/vs89GjhwZrFy50mqdQWA/Mx/HZxAEwdtvvx1ICk6cODHg78U7XQEg4Xbt2qVNmzZ12TZx4kRNmTJFw4cP1/Hjx7Vhwwa98cYbkqR169apoaFBv/rVrzRhwgQbJSMhhg8frsmTJ2v8+PGqqqpSe3u7XnvtNW3atEm5XE5nzpzRkiVLtHfvXi1fvtx2udYwRs2RWTjkNnDMaygVxmc45IY4vfHGG7rhhhvU2toqSUqlUvrjP/5jXXnllTp8+LBWr16t06dP69ChQ/rTP/1TrVq1SrNnz7ZctT2MT4l3uiZEoVAITpw4ERQKBdulOM+Vv8r6htzMuZLZY489FkgKrrrqquA73/lO8MYbb3R7Tj6fD370ox8FlZWVxb80XnfddVbmFFdy84lLmf3t3/5t8PDDDwe7d+/u9TkHDx4MFi1a1OUv2//yL/8SY5XnuJKbb2M0COyfd/iYWRCQWxi2MwsC5rWkcyUz38YnuYXnwrzmIxdy++hHP1rsofHjxwdbt27t8vnDhw8HN9xwQ/E5w4YNC44dO2an2MB+Zj6OzyAIguPHj0f2TlcWXROiUCgEZ8+eZeLuB1dOEHxDbuZcyWzdunXBsmXLglwud8Hn/uIXv+jyC+OqVatiqLArV3LziY+ZFQqFYPbs2cVemzNnTuw1uJKbb2M0COyfd/iYWRCQWxi2MzPBvOYnVzLzbXySW3g+zWsusZ3bypUri71z0UUXBc3NzT0+79SpU8GECROKz/36178ec6XvsZ2Zj+MzCKJddE0P/L2ycEEul1NTU5MTF0kG4JaZM2fqtttuUyaTueBzb775Zl177bXFxytXrixlaShjqVRKt99+e/Hxli1bLFZjl49j1PZ5h4+ZSeQWhu3MTDCvYSB8HJ8u8DE3n+Y1l9jO7e///u+LH9966636vd/7vR6fd/HFF+uv/uqvio9/+MMfWqvZdmY+jk8p2puPsegKAOhixowZxY/37dtnrxAk3ogRI4oft7W1WazEL4xRc2QWDrmZY15DXBif4ZAbwjh16pT+7d/+rfj4/D+w9WThwoWqqqqSJB09elTPPfdcSetLiiSOTxZdAQBdpFKp4sf5fN5iJUi6nTt3Fj++/PLL7RXiGcaoOTILh9zMMa8hLozPcMgNYWzYsEFnzpyRdO6drNdcc02fz//ABz6ghoaG4uM1a9aUtL6kSOL4ZNEVANDFtm3bih+PGzfOYiVIstbWVn33u98tPv7EJz5hsRq/MEbNkVk45GaGeQ1xYnyGQ24I45VXXil+/Hu/93vKZrMX/Jo/+IM/6PHr0bskjk8WXRMim82qsbGxX4MfAHrT0tLS5S+xc+bMsVgNkqa9vV07d+7U9773PU2bNk2tra2SpMmTJ+u+++6zXJ0fXBmjPp13uJKZRG5huJ4Z8xpscGV8+saV3Fyf11xlM7ddu3YVPx4/fny/vqa2trb48auvvhp5Tf3hU6+5Mj4lRZqX+8mj306fPq3q6mrbZQDw2L333lv8rxy1tbWaP3++5Yrgs/Xr1+ujH/1on89pbGzUT37yE45f/eTSGPXlvMOlzCRyC8OlzJjX4AKXxqdPXMrNpXnNJ7ZyO3LkSPHjUaNG9etrLrvssuLHR48ejbym/vKl11wan1Hina4JkcvltHbtWu6ACCC05cuX6+c//3nx8dKlSzVo0CCLFSHJampq9Nhjj2nlypW65JJLbJfjBZfGqC/nHS5lJpFbGL5kJjGvIR4ujU+fuJSbT/OaS2zmdurUqeLHgwcP7tfXnP+8878+Tr70mkvjU1KkefFOVwCANm/erDvuuKP4eNGiRVq8eLHFipAEY8aM0d133y1JCoJAbW1t2rVrl15++WUdO3ZMixYt0iOPPKKHH35YEydOtFyt2xij5sgsHHLrG/MabGJ8hkNuGKh33323+PFFF13Ur685f9Hw9OnTkdeUFEkfnyy6AkCZ++1vf6v58+cXTyamTp2qhx9+2HJVSIIJEybowQcf7La9tbVV3/jGN/Too49q7dq1uu6667Ru3TpNnTrVQpXuY4yaI7NwyO3CmNdgC+MzHHJDFD7wgQ8UPz579my/vubMmTPFj/v77thyUw7jk8sLJIgPF0cG4JYDBw5o7ty5OnjwoKRzv0yuWrVKQ4YMsVwZkmzMmDFatmyZ7rnnHknSsWPH9MlPfrJ4HSe8x+Ux6up5h8uZSeQWhquZnY95DaXk8vh0mcu5+TCvuchWblVVVcWP+/uu1fOfd/7Xx83VXnN5fEaJRdeEqKio0Lx581RRUWG7FACeOHLkiObOnas9e/ZIkkaPHq3Vq1dr9OjRlitDuVi6dGnxxOqVV17RU089Zbkit7g8Rl0973A5M4ncwnA1s94wryFqLo9Pl7mcm2/zmits5nbppZcWP37rrbf69TWdi4mSNGzYsMhr6g9Xe83l8Skp0rxYdE2IQqGgQ4cOqVAo2C4FgAdOnjypG2+8UTt27JAkDR8+XKtXr9YVV1xhuTKUk8rKSk2fPr34+Pnnn7dYjVtcH6Munne4nplEbmG4mFlfmNcQJdfHp6tcz823ec0VNnObNGlS8eP9+/f362taWlqKH9fV1UVeU3+42Guuj09JkebFomtC5PN5bdy4kf/CBOCC3nnnHTU2NurXv/61JGno0KFatWqVPvzhD1uuDOWopqam+PGRI0csVuIOH8aoa+cdPmQmkVsYrmXWH8xriIIP49NFPuTm47zmApu5TZ48ufjxtm3b+nV3+5dffrnHr4+Ta73mw/iUFGleLLoCQBl59913tWDBguI7byorK7Vy5UpdffXVlitDuTpw4EDxY1v/9coljFFzZBYOuZUO8xoGivEZDrmhVKZPn65BgwZJOrdwuHnz5j6ff+bMGb3wwgvFx7Nnzy5pfT4o1/HJoisAlImOjg4tXLhQa9askSQNGjRITz75pGbMmGG5MpSrI0eOaOPGjcXHtt4F4ArGqDkyC4fcSod5DQPF+AyH3FBKVVVVuuGGG4qPH3300T6f/4tf/EJtbW2Szv3x7Y//+I9LWZ7zynl8suiaEKlUStXV1UqlUrZLAeCgfD6vxYsXq6mpSdK5u1j+9Kc/1Zw5cyxXhiQ5evRov59bKBT0hS98QWfOnJF07uTrpptuKlVpzvNtjLpw3uFbZhK5hWE7M+Y1xMm38ekK33KzPa/5ynZud911V/HjRx99tHhN0vdrb2/X//f//X/Fx3/xF3+hbDZb8vp6Yjszyb/xKSnSvFh0TYhsNqvZs2dbG8wA3BUEgT73uc/pZz/7mSQpnU7rxz/+sRYsWGC5MiTNihUrdM0112jFihU6efJkr89rbm5WY2OjHn/88eK2r33ta13uDFtOfByjts87fMxMIrcwbGfGvIa4+Dg+XeBjbrbnNV/Zzm3evHn66Ec/Kunc5QNuuukmNTc3d3nOkSNH9Kd/+qd67bXXJJ17l+t//+//PfZaO9nOzMfxKSnSvBjlCVEoFPT6669r3LhxSqdZSwfwnoceekjLly8vPr7yyiu1fv16rV+/vl9f/+CDD5aqNCTQ5s2bdeuttyqbzaqurk6TJk1STU2NUqmUjhw5oubm5uKJaKeFCxfq/vvvt1SxfT6OUdvnHT5mJpFbGLYzk5jXEA8fx6cLfMzNhXnNRy7k9k//9E+69tprdeDAAe3bt0/19fWaOXOmrrzySh0+fFirV69We3u7pPfe0XnJJZdYqVWyn5mP41M6l1tUWHRNiHw+r61bt2rMmDFM3AC6OHToUJfHu3fv1u7du/v99eV6Eg9znTcYkKRcLqft27dr+/btvT6/urpaS5Ys0Ze+9CVlMpk4SnSSj2PU9nmHj5lJ5BaG7cyY1xAXH8enC3zMzfa85isXcvvgBz+oNWvWaNGiRdq6dauCINC6deu0bt26Ls8bMWKEli1b1uU6sDbYzszH8Smdyy0qLLoCAIBI3Hnnnbrhhhu0evVqvfjii9qxY4daWlp0/PhxSdKQIUM0evRo1dfXa86cOVq4cKGqqqrsFg0AfWBeAwCcr66uTi+++KIef/xxPfbYY9qxY4feeustXXLJJZowYYI+/vGP6/bbb9fw4cNtlwoHsOgKAAm3ZMkSLVmyxHYZKBMTJ07UxIkTu9xsAH1jjJojs3DILRzmNcSB8RkOucGGiy66SJ/5zGf0mc98xnYpTmN8ciOtxEilUhoxYgR3QAQAACXHeUc45GaOzAAkDfNaOORmjszCiTIv3umaENlsVtOnT7ddBgAAKAOcd4RDbubIDEDSMK+FQ27myCycbDa6pVLe6ZoQ+Xxer776aqQX/AUAAOgJ5x3hkJs5MgOQNMxr4ZCbOTILJ8q8WHRNiEKhoF27dqlQKNguBQAAJBznHeGQmzkyA5A0zGvhkJs5MgsnyrxYdAUAAAAAAACACLHoCgAAAAAAAAARYtE1IdLptGpra5VO85ICAIDS4rwjHHIzR2YAkoZ5LRxyM0dm4USZV3S35IJVmUxG06ZNs10GAAAoA5x3hENu5sgMQNIwr4VDbubILJxMJhPZ92K5OyHy+by2bNnCXekAAEDJcd4RDrmZIzMAScO8Fg65mSOzcKLMi0XXhCgUCmppaeGudAAAoOQ47wiH3MyRGYCkYV4Lh9zMkVk4UebFoisAAAAAAAAARIhFVwAAAAAAAACIEIuuCZFOpzVp0iTuSgcAAEqO845wyM0cmQFIGua1cMjNHJmFE2Ve2ci+E6zKZDKqq6uzXQYAACgDnHeEQ27myAxA0jCvhUNu5sgsnEwmE9n3Yrk7IXK5nDZs2KBcLme7FAAAkHCcd4RDbubIDEDSMK+FQ27myCycKPNi0TUhgiDQ4cOHFQSB7VIAAEDCcd4RDrmZIzMAScO8Fg65mSOzcKLMi0VXAAAAAAAAAIgQi64AAAAAAAAAECEWXRMik8movr4+0gv+AgAA9ITzjnDIzRyZAUga5rVwyM0cmYUTZV7ZyL4TrEqn0xo/frztMgAAQBngvCMccjNHZgCShnktHHIzR2bhpNPRvT+Vd7omRC6X05o1a7grHQAAKDnOO8IhN3NkBiBpmNfCITdzZBZOlHmx6JoQQRCora2Nu9IBAICS47wjHHIzR2YAkoZ5LRxyM0dm4USZF4uuAAAAAAAAABChkiy6vvnmm/rUpz6lSy+9VIMHD9bv/d7vafPmzaX4UQAAAAAAAADglMhvpHXs2DHNmDFD119/vZ566imNGDFCu3fvVk1NjfH32rs36uqSp65OevNNScoqCOYrlUqpslKaMMF2Ze7avr37NnrtwnrKiNz6RmbhkJs5Mgunp4y2b5caGuKvxRd790rt7RLnHWbIzRyZhcN5rjmOoeGQmzl+dw+np+PB2LHSq6/arsxd9Fo4nb0WBNEtlaaCiC/ucN999+n555/Xr371q1Bff/LkSQ0dOlTSCVVVDVFbW5TVJU91tXTqlO0q/FdVJXrtAnrqNXLrG5mFQ27myCwcjqEAygHHg75xDA2H3Mxx3hEdeq1v9NpAnZQ0VCdOnNCQIUMG9J0if6fr//k//0c33nij/uzP/kzPPvusxo4dq7vuukv/5b/8lx6ff+bMGZ05c6b4+OTJk+d9NlBHR07pdFqZTEb5fF6FQqH42c7tuVyuy4VuM5mM0ul0r9s7Ojq61JDNnovh/Xco6217RUWFCoWC8vl8cVsqlVI2m+11e2+1D3Sfzr2EKWGgAkmpkr1OSei9zozez+d9KvXrdC6v92d2bl7zdZ/ieZ16mtfey83PfVKX2qN/nXrPzN99OqeUrxPHUADl4b1jaBLn8oHvU9/nHX7uk/qsPYp96i23fL7g7T7xu7tfkjSe4vrdHfGLfNF17969euihh3Tvvffqf/yP/6GXXnpJ99xzjy666CLdeuut3Z6/dOlSPfDAAz1+r1wur6amJtXW1mratGlqbm5WS0tL8fOTJk1SXV2dNm3apMOHDxe319fXa/z48XruuefUdt6fPxoaGjRy5Eg9/fTTXQbE9ddfr8GDB6upqanLz29sbNTp06e1du3a4rZsNqt58+bp7bff1saNG4vbq6urNXv2bL3++uvaunVrcfuIESM0ffp07d69W7t27Spuj2qfgmC+GEwDl88XJGVK9joloffOHRS6Txk+71OpX6dcbli3zAqFoMv38W2f4nidcrl53XLrPB74uk+dSvU69ZWZr/sklf51KhQ4hgJIvvOPoUmcywe6Txc67/BxnzqV8nXK52+SlOmWW3PzNm/3id/d/ZKk8RTX7+6IX+SXF7jooov0h3/4h9qwYUNx2z333KOXXnqpS7N16umdruPGjdO5ywtU6+hR3una1z4NG5bVqVNM3ANVVRWorY13uva1T9XVQbdeq6qSjh71d59K/ToNHZrqIbNAR4/yTte+9qmnee383Hzcp06lep36yszXfepUyteJYyiAcnD+MTSJc/lA9+lC5x0+7lOnUr5OveV2/DjvdOV399KrqpKOH0/OeIrjd3eYcPjyAqNHj9aHP/zhLtsmT56sn//85z0+f9CgQRo0aFCPn6usTKmioqL4OJPJKJPJdHteZ5P3d/v53zPs9nQ6/bu3bfdve2+1D3SfKit7vpbOlCk9fjl0/oW4A+VyeWWzGY0de25CKtXr1Mnn3qusTHXrtcpKv/ep1K9TT+Pz/fNaJ1/2KY7Xqb+5+bRP/d0edp/6k5lv+3S+Ur1OY8d23mTgveNBZWWKmwz0oadjKJldGLmZI7NwejvPff/cmqS5vFPYfRrIeYer+zSQ7f3dp95y69wPH/epE7+7u2X79p56LVnjqVMpf3en1y6sp14bqMgXXWfMmNHl7dCS9O///u8aP3688ffipOrCJkyQDh3qum3KFKmHNxXjfYJAamtrV3V1tVL8EeiCeuo1xmjfyCwccjNHZuF03vWW44E5MguH3MyRWTjk1n8cQ8MhN3P87h5OQ4P0wgtdt9FrfaPXwump1waq+9L6AH3lK1/RCy+8oP/5P/+nXnvtNf3TP/2THnnkEd19991R/yhgwAYPHmy7BACAAzgemCOzcMjNHJmFQ24AANgV+aLrNddco3/913/VY489pilTpuhb3/qW/u7v/k633HJL1D8KGJBcLqempqZu114BAJQXjgfmyCwccjNHZuGQGwAA9pXkdmY33XSTbrrpplJ8awAAAAAAAABwWuTvdAUAAAAAAACAcsaiKwAAAAAAAABEiEVXlK1sNqvGxkZlsyW5ygYAwBMcD8yRWTjkZo7MwiE3AADsY9EVZe306dO2SwAAOIDjgTkyC4fczJFZOOQGAIBdLLqibOVyOa1du5a7ugJAmeN4YI7MwiE3c2QWDrkBAGAfi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6oqxxcwEAgMTxIAwyC4fczJFZOOQGAIBdHIlRtioqKjRv3jzbZQAALON4YI7MwiE3c2QWDrkBAGAf73RF2SoUCjp06JAKhYLtUgAAFnE8MEdm4ZCbOTILh9wAALCPRVeUrXw+r40bNyqfz9suBQBgEccDc2QWDrmZI7NwyA0AAPtYdAUAAAAAAACACLHoCgAAAAAAAAARYtEVZSuVSqm6ulqpVMp2KQAAizgemCOzcMjNHJmFQ24AANiXtV0AYEs2m9Xs2bNtlwEAsIzjgTkyC4fczJFZOOQGAIB9vNMVZatQKGj//v3c1RUAyhzHA3NkFg65mSOzcMgNAAD7eKcrIrVv3z4988wzevbZZ7Vt2za1tLTo1KlTqq6u1gc/+EE1NDRo8eLFmjlzpu1Slc/ntXXrVo0ZM0bptL2/P+Tzee3YsUMvvfSSNm/erJdeeknNzc3q6OiQJM2cOVPr1q2zVh+Sw6fx6Yq3335bzz//vDZt2qRt27Zpz549am1t1alTp1RRUaGamhpNmTJFs2bN0mc+8xmNHTvWdslO8G1e43hgzpXMfONKbj4dD1zJzDeu5OZTr8FfnK8BcBWLrojEli1bdMcdd2jTpk09fv7YsWM6duyYtm3bpkceeUSzZs3S8uXLVVtbG3OlbnniiSd0yy23qL293XYpSDDGZ3i33XabVq5c2ePncrmcTp8+rdbWVj399NN64IEH9PWvf13f/OY3y3phgHktHHJDHDgeIC70GuLE+RoAV7Hoikjs2rWr20nVxIkTNWXKFA0fPlzHjx/Xhg0b9MYbb0iS1q1bp4aGBv3qV7/ShAkTbJTshOPHj/MLNkqO8RmN4cOHa/LkyRo/fryqqqrU3t6u1157TZs2bVIul9OZM2e0ZMkS7d27V8uXL7ddrjXMa+GQG+LA8QBxoddgC+drAFzCoisiddVVV+nzn/+8PvWpT3X7bxuFQkGPPvqovvjFL6q9vV2tra265ZZbtGHDBit3Vk2lUhoxYoQTd3UdNWqUrrnmmuK/X/7yl/rBD35guywkjE/j0xWzZs3S/PnzdcMNN+iqq67q8TlvvfWWvvKVr+ixxx6TJK1YsULz58/XJz7xiThLdY5P8xrHA3MuZeYTV3Lz6XjgSma+cSU3n3oN/uJ8DYCrWHRFJEaPHq1ly5bp05/+tDKZTI/PSafT+uxnP6uamhp9/OMflyS98MILevrpp3XjjTfGWa6kc3d1nT59euw/93wf+9jHtH///m7/lerFF1+0VBGSyMfx6YqvfvWrF3zOqFGj9JOf/ERvvfWW1qxZI0n64Q9/WLYn8T7OaxwPzLmQmY9s5+bj8cB2Zr6ynZuPvQZ/cb4GwFVcxASRmDlzpm677bZeT6rOd/PNN+vaa68tPu7t+julls/n9eqrryqfz1v5+ZJ02WWXce0qlJyP49M3qVRKt99+e/Hxli1bLFZjl4/zGscDcy5k5iPbufl4PLCdma9s5+ZjryH5OF8DEDcWXWHFjBkzih/v27fPSg2FQkG7du1SoVCw8vMBV7kwPn00YsSI4sdtbW0WK4EpjgfmyCwc33Jz4XjgW2au8C03F3oN5YHzNQBxYtEVVpx/nSbeuQC4hfEZzs6dO4sfX3755fYKAYCIcDxAXOg1xIXzNQBxYtEVVmzbtq348bhx4yxWAuD9GJ/mWltb9d3vfrf4mOuDAUgCjgeIC72GOHC+BiBuLLoidi0tLcWLl0vSnDlzrNSRTqdVW1urdJphAHRyZXz6oL29XTt37tT3vvc9TZs2Ta2trZKkyZMn67777rNcHUxwPDBHZuH4lJsrxwOfMnOJT7m50mtIJs7XANiUtV0Ays+9995b/G9DtbW1mj9/vpU6MpmMpk2bZuVnA65yZXy6aP369froRz/a53MaGxv1k5/8RNXV1TFVhShwPDBHZuH4lJsrxwOfMnOJT7m50mtIBs7XALjE/T99IlGWL1+un//858XHS5cu1aBBg6zUks/ntWXLFq4bBfyOS+PTNzU1NXrssce0cuVKXXLJJbbLgSGOB+bILBxfcnPpeOBLZq7xJTeXeg3Jx/kagLix6IrYbN68WXfccUfx8aJFi7R48WJr9RQKBbW0tHhzV1eglFwbny4aM2aM7r77bt19992666679OlPf1rXXnutstmsjh07pkWLFmn27Nn693//d9ulwhDHA3NkFo4Publ2PPAhMxf5kJtrvYZk4HwNgEu4vABi8dvf/lbz58/Xu+++K0maOnWqHn74YctVAZAYn/01YcIEPfjgg922t7a26hvf+IYeffRRrV27Vtddd53WrVunqVOnWqgSAMLjeIC40GsoFc7XALiEd7qi5A4cOKC5c+fq4MGDks4dCFetWqUhQ4ZYrgwA43PgxowZo2XLlumee+6RJB07dkyf/OQnnf8vnQBwPo4HiAu9Bhs4XwNgA4uuKKkjR45o7ty52rNnjyRp9OjRWr16tUaPHm25snN3dZ00aZIXd3UFSsHl8emjpUuXFn9hfOWVV/TUU09Zrgj9xfHAHJmF42puLh8PXM3Mda7m5nKvoTxwvgYgTm4dhZEoJ0+e1I033qgdO3ZIkoYPH67Vq1friiuusFzZOZlMRnV1dcpkMrZLAWLn+vj0UWVlpaZPn158/Pzzz1usBiY4Hpgjs3BczM3144GLmfnAxdxc7zWUB87XAMSJRVeUxDvvvKPGxkb9+te/liQNHTpUq1at0oc//GHLlb0nl8tpw4YNyuVytksBYuXD+PRVTU1N8eMjR45YrAQmOB6YI7NwXMvNh+OBa5n5wrXcfOg1lA/O1wDEhUVXRO7dd9/VggULin81rKys1MqVK3X11VdbrqyrIAh0+PBhBUFguxQgNr6MT18dOHCg+PGwYcMsVgITHA/MkVk4LuXmy/HApcx84lJuvvQaygfnawDiwqIrItXR0aGFCxdqzZo1kqRBgwbpySef1IwZMyxXBoDxWVpHjhzRxo0bi48nT55ssRoA6B3HA8SFXoNrOF8DECcWXRGZfD6vxYsXq6mpSZKUzWb105/+VHPmzLFcGQDGp7mjR4/2+7mFQkFf+MIXdObMGUnnfqm86aabSlUaAITG8QBxodcQB87XALiMRVdEIggCfe5zn9PPfvYzSefumPrjH/9YCxYssFxZ7zKZjOrr6526wQBQCj6OTxesWLFC11xzjVasWKGTJ0/2+rzm5mY1Njbq8ccfL2772te+pksvvTSOMhEBjgfmyCwc27n5eDywnZmvbOfmY6/BT5yvAXBZ1nYBSIaHHnpIy5cvLz6+8sortX79eq1fv75fX//ggw+WqrRepdNpjR8/Pvaf+36NjY1qbW3tsu3gwYPFjzdv3qz6+vpuX9fU1KQxY8aUujwkgI/j0xWbN2/Wrbfeqmw2q7q6Ok2aNEk1NTVKpVI6cuSImpub9dprr3X5moULF+r++++3VLEbfJvXOB6YcyUz39jOzcfjge3MfGU7Nx97Df7ifA2Aq1h0RSQOHTrU5fHu3bu1e/fufn+9jROrXC6n5557Tn/8x3+sbNbeUNi5c6f279/f6+ffeecd/eY3v+m2/ezZs6UsCwni4/h0waBBg4of53I5bd++Xdu3b+/1+dXV1VqyZIm+9KUvlf07snyb1zgemHMlM9/Yzs3H44HtzHxlOzcfew1+4nwNgMs4c0HZCoJAbW1tTtzVFYB77rzzTt1www1avXq1XnzxRe3YsUMtLS06fvy4JGnIkCEaPXq06uvrNWfOHC1cuFBVVVV2i0YoHA/MkVk45GaOzMIhN5QLztcAuIxFV0RiyZIlWrJkie0yvLRv3z7bJSDhGJ/hTZw4URMnTtRdd91luxSvMK+FQ24oNY4HiAu9hjhxvgbAVdxICwAAAAAAAAAixKIrylYmk1FDQwPX8gGAMsfxwByZhUNu5sgsHHIDAMA+Li+AspVOpzVy5EjbZQAALON4YI7MwiE3c2QWDrkBAGAf73RF2ero6NDKlSvV0dFhuxQAgEUcD8yRWTjkZo7MwiE3AADsY9EVZS2Xy9kuAQDgAI4H5sgsHHIzR2bhkBsAAHax6AoAAAAAAAAAEWLRFQAAAAAAAAAixKIrylY2m9X111+vbJb7yQFAOeN4YI7MwiE3c2QWDrkBAGAfi64oa4MHD7ZdAgDAARwPzJFZOORmjszCITcAAOxi0RVlK5fLqampiZsMAECZ43hgjszCITdzZBYOuQEAYB+LrgAAAAAAAAAQIRZdAQAAAAAAACBCLLoCAAAAAAAAQIRYdEXZymazamxs5K6uAFDmOB6YI7NwyM0cmYVDbgAA2MeiK8ra6dOnbZcAAHAAxwNzZBYOuZkjs3DIDQAAu1h0RdnK5XJau3Ytd3UFgDLH8cAcmYVDbubILBxyAwDAPhZdAQAAAAAAACBCLLoCAAAAAAAAQIRYdEVZ4+YCAACJ40EYZBYOuZkjs3DIDQAAuzgSo2xVVFRo3rx5tssAAFjG8cAcmYVDbubILBxyAwDAPt7pirJVKBR06NAhFQoF26UAACzieGCOzMIhN3NkFg65AQBgH4uuKFv5fF4bN25UPp+3XQoAwCKOB+bILBxyM0dm4ZAbAAD2segKAAAAAAAAABFi0RUAAAAAAAAAIhT5ouuSJUuUSqW6/Kurq4v6xwADlkqlVF1drVQqZbsUAIBFHA/MkVk45GaOzMIhNwAA7MuW4pt+5CMf0erVq9/7IdlwP2bv3qgqSq6eMiK3/slms5o9e7btMrzRU19t3y41NMRfiy+2b+++jfF5YfSaOXptYDge9F9dnfTmm9K5U8hzmVVWShMm2KzKfXv3Su3tErn1X0+ZjR0rvfqqzarcxxg1xzE0HM7XzNFr4bDmYY7MwilFRiVZdM1ms7rssssG/H3OnWihLz1lRG79UygU9Prrr2vcuHFKp7nSxoX01FenTkkvvBB/LT5jfF4YvRYNeq3/OB7035tvnhuP5zt1Sjp0yE49PiM3c+cWE9EXxmg0OIZeGOdr0aDXLow1D3NkFk4pMirJouvu3bs1ZswYfeADH1BDQ4OWLl2q2traHp975swZnTlzpvj45MmT5302UEdHTul0WplMRvl8XoVCofjZzu25XE5BEBS3ZzIZpdPpXrd3dHR0qaHznbi5XK5f2ysqKlQoFLrcDTSVSimbzfa6vbfaB7pP517CrW2tMAAAfA9JREFU9/+3oUCdT/Fxn+J6nd59911t3bpVI0aM0EUXXZSIfSrl6yQF6t5rMHduXuuUlPEUbe/1NK/B3LleS/pcHsU+nTlzpng8qKioSMQ+lep1YnzCrq7HUMnv8VSaOYIxGo33ei2Jc3kU+0SvRYXf3S+0T739HurzPtn63d3nfYrndYp+Xot80fWP/uiP9Oijj2rSpEk6cOCAHnjgAX30ox/V9u3bVV1d3e35S5cu1QMPPNDj98rl8mpqalJtba2mTZum5uZmtbS0FD8/adIk1dXVadOmTTp8+HBxe319vcaPH6/nnntObW1txe0NDQ0aOXKknn766S5BX3/99Ro8eLCampq6/PzGxkadPn1aa9euLW7LZrOaN2+e3n77bW3cuLG4vbq6WrNnz9brr7+urVu3FrePGDFC06dP1+7du7Vr167i9qj2KQjm6/1Nkcvl1dbW7u0+xf06PfPMM4nbJyn61+m9SQgDUSgEXV5veq/7PuVy80SvDVznMbRc5vKB7NPLL78s6dzxICn7VKrXSVogwJYgUJee9H08lWKO4Bgajc5jqJTMuTyKfcrnb5KU6U+c6AO/u194nwqFnhcQfd4nW7+7+7xPcbxOpTiGpoKub5uM3PHjxzV+/Hh9//vf1+c+97lun+/pna7jxo2TdEJVVdU6epR3uva1T8OGZXXqVNcJqKoqUOcbhn3cpzjf6frMM89o7ty5vNO1H/tUXR106zWYq6oKdPQo73Tta596mtdgrrPXkj6XR7FPp0+f1tNPP625c+fyTtcL1M74hE3vP4ZKfo+nUswRjNFonN9rSZzLo9gnei0a/O5+4X3q6ffQqirp+HF/98nG7+5VVdLRo/7uUxyv03vz2klJQ3XixAkNGTJEA1HyP4Necsklmjhxol577bUePz9o0CANGjSox89VVqZUUVFRfJzJZJTJdP9rWmd4/d1+/vcMuz2dTvd43bfetvdW+0D3qbKy+3WbKitT6rxRqY/71FeNptv72qeLLrqoy6UF+qrdl30q5es0dmzqd9dSC5TPF5TJpFVZmeLGDH147yYg72U2dmyqx9eV3nuv9rFjRa8Z6k+vJXUuj2KfKioquh0PJL/3qVSvU0/nHVVV0pQpPX45fqenMcq81rft23s+x03SeOpre9h9Yoya6+/5Gr3XdTvna+Z66zV+dz+nt9orK1M9HA/83qdSv069ZebzPsXxOvV0DB2oki+6njp1Snv27NGnP/1p469lwr6wCRO6Xxif3Ponm81q+vTptsvwxnt3C06J/0pkisxM0GsDQWZhcDzov57OO6ZMkc77X2boE2O0vxoaut+Qh3PcC2OMDgTj0wTnawNBZiZY8zBHZuH0lNtARX6L3q9+9at69tlntW/fPm3YsEE333yzMpmMFi1aFPWPAgYkn8/r1Vdffd8F4XEh5GaOzMIhN3NkFg65IS70GuAuxmc45GaOzIDyEfmi6xtvvKFFixZp0qRJ+vM//3NdeumleuGFFzRixIiofxQwIIVCQbt27epyHRFcGLmZI7NwyM0cmYVDbogLvQa4i/EZDrmZIzOgfER+eYHHH3886m8JAAAAAAAAAN6I/J2uAAAAAAAAAFDOWHRF2Uqn06qtre3xDnvoHbmZI7NwyM0cmYVDbogLvQa4i/EZDrmZIzOgfER+eQHAF5lMRtOmTbNdhnfIzRyZhUNu5sgsHHJDXOg1wF2Mz3DIzRyZAeWDP62gbOXzeW3ZsoW7RhoiN3NkFg65mSOzcMgNcaHXAHcxPsMhN3NkBpQPFl1RtgqFglpaWrhrpCFyM0dm4ZCbOTILh9wQF3oNcBfjMxxyM0dmQPlg0RUAAAAAAAAAIsSiKwAAAAAAAABEiEVXlK10Oq1JkyZx10hD5GaOzMIhN3NkFg65IS70GuAuxmc45GaOzIDykbVdAGBLJpNRXV2d7TK8Q27myCwccjNHZuGQG+JCrwHuYnyGQ27myAwoH/xpBWUrl8tpw4YNyuVytkvxCrmZI7NwyM0cmYVDbogLvQa4i/EZDrmZIzOgfLDoirIVBIEOHz6sIAhsl+IVcjNHZuGQmzkyC4fcEBd6DXAX4zMccjNHZkD5YNEVAAAAAAAAACLEoisAAAAAAAAARIhFV5StTCaj+vp6ZTIZ26V4hdzMkVk45GaOzMIhN8SFXgPcxfgMh9zMkRlQPrK2CwBsSafTGj9+vO0yvENu5sgsHHIzR2bhkBviQq8B7mJ8hkNu5sgMKB+80xVlK5fLac2aNdw10hC5mSOzcMjNHJmFQ26IC70GuIvxGQ65mSMzoHyw6IqyFQSB2trauGukIXIzR2bhkJs5MguH3BAXeg1wF+MzHHIzR2ZA+eDyAoBl+XxeO3bs0EsvvaTNmzfrpZdeUnNzszo6OiRJM2fO1Lp16+wW6SByQ1z27dunZ555Rs8++6y2bdumlpYWnTp1StXV1frgBz+ohoYGLV68WDNnzrRdqjMYn+GQmznGp7m3335bzz//vDZt2qRt27Zpz549am1t1alTp1RRUaGamhpNmTJFs2bN0mc+8xmNHTvWdskAgBLgGBoOuZkr58xYdAUseuKJJ3TLLbeovb3ddileITfEYcuWLbrjjju0adOmHj9/7NgxHTt2TNu2bdMjjzyiWbNmafny5aqtrY25UrcwPsMhNzOMz/Buu+02rVy5ssfP5XI5nT59Wq2trXr66af1wAMP6Otf/7q++c1vKp3mP8gBQBJwDA2H3MyRGYuuKGOZTEYNDQ1W7xp5/Phx737BJjdzLmTmI9u57dq1q9sJwsSJEzVlyhQNHz5cx48f14YNG/TGG29IktatW6eGhgb96le/0oQJE2yUbD0zyb/xKZGbj3wcn5IbvXa+4cOHa/LkyRo/fryqqqrU3t6u1157TZs2bVIul9OZM2e0ZMkS7d27V8uXL7ddLlBSro1PX5CbOduZ+XoMtY3czJEZi64oY+l0WiNHjrRdhiRp1KhRuuaaa4r/fvnLX+oHP/iB7bJ6RG7mXMrMJ67kdtVVV+nzn/+8PvWpT3X7b7aFQkGPPvqovvjFL6q9vV2tra265ZZbtGHDBqVSqdhrdSUzyZ/xKZGbz3wan5IbvTZr1izNnz9fN9xwg6666qoen/PWW2/pK1/5ih577DFJ0ooVKzR//nx94hOfiLNUIFYujE8fkZs5VzLz7RjqCnIzV86ZseiKstXR0aGnn35af/Inf6KKigorNXzsYx/T/v37u719/sUXX7RST3+QmzkXMvOR7dxGjx6tZcuW6dOf/nSv70RIp9P67Gc/q5qaGn384x+XJL3wwgt6+umndeONN8ZZriT7mUn+jU+J3Hzk4/iU3Oi1r371qxd8zqhRo/STn/xEb731ltasWSNJ+uEPf8iiKxLNhfHpI3IzZzszX4+htpGbOTKTuDgTyloul7P68y+77DIvr1dCbuZsZ+Yrm7nNnDlTt912W7/+69fNN9+sa6+9tvi4t+slxsF2r/k4PiVy842v41Oy32v9lUqldPvttxcfb9myxWI1QDx8GZ+uITdznOP6h9zMkRmLrgAARGLGjBnFj/ft22evEADdMD7DGTFiRPHjtrY2i5UAAGzhGBoOuZlLYmYsugIAEIHzrzmUz+ctVgLg/Rif4ezcubP48eWXX26vEACANRxDwyE3c0nMjEVXlK1sNqvrr79e2SyXNjZBbubILBzfctu2bVvx43HjxlmpwbfMXEFuyefC+JT86rXW1lZ997vfLT7meq5IOp/Gp0vIzZxvmblyDPUNuZlLYmYsuqKsDR482HYJXiI3c2QWji+5tbS0FG82I0lz5syxVosvmbmG3JLLpfEpud1r7e3t2rlzp773ve9p2rRpam1tlSRNnjxZ9913n+XqgNJzeXy6jNzM+ZKZa8dQX5CbuaRmxqIrylYul1NTUxMXfjdEbubILByfcrv33nuL/wWmtrZW8+fPt1KHT5m5hNySzZXxKbnXa+vXr1cqlSr+u/jii/WRj3xEX/3qV3Xo0CFJUmNjozZs2KDq6mrL1QKl5dr49AW5mfMpM5eOoT4hN3NJzYxFVwAABmD58uX6+c9/Xny8dOlSDRo0yGJFADoxPsOrqanRY489ppUrV+qSSy6xXQ4AIGYcQ8MhN3NJzsyPi4gAAOCgzZs364477ig+XrRokRYvXmyxIgCdGJ8XNmbMGN19992SpCAI1NbWpl27dunll1/WsWPHtGjRIj3yyCN6+OGHNXHiRMvVAgDiwjE0HHIzl/TMWHQFACCE3/72t5o/f77effddSdLUqVP18MMPW64KgMT47K8JEybowQcf7La9tbVV3/jGN/Too49q7dq1uu6667Ru3TpNnTrVQpUAgDhxDA2H3MyVQ2ZcXgBlK5vNqrGx0Zu7RrqC3MyRWTgu53bgwAHNnTtXBw8elHRu4WLVqlUaMmSI1bpczsxl5JYsro5PyZ9eGzNmjJYtW6Z77rlHknTs2DF98pOfLF5rDUgiX8ana8jNnMuZuXwMdRm5mSuXzFh0RVk7ffq07RK8RG7myCwcF3M7cuSI5s6dqz179kiSRo8erdWrV2v06NGWKzvHxcx8QG7J4Pr4lPzqtaVLlxZ/+XnllVf01FNPWa4IKC2fxqdLyM2ci5n5cAx1EbmZK6fMWHRF2crlclq7dq0Xd410CbmZI7NwXMzt5MmTuvHGG7Vjxw5J0vDhw7V69WpdccUVlis7x8XMfEBuyeD6+JT867XKykpNnz69+Pj555+3WA1QWr6NT1eQmzkXM/PhGOoicjNXbpmx6AoAQD+88847amxs1K9//WtJ0tChQ7Vq1Sp9+MMftlwZAMZn6dTU1BQ/PnLkiMVKAAClwDE0HHIzV46ZsegKAMAFvPvuu1qwYEHxXV6VlZVauXKlrr76asuVAWB8ltaBAweKHw8bNsxiJQCAqHEMDYfczJVrZiy6oqy5ePFyH5CbOTILx4XcOjo6tHDhQq1Zs0aSNGjQID355JOaMWOG5cp65kJmPiI3P/k2PiW/eu3IkSPauHFj8fHkyZMtVgOUnk/j0yXkZs6FzHw8hrqA3MyVc2b2RzpgSUVFhebNm2e7DO+QmzkyC8eF3PL5vBYvXqympiZJ506Qf/rTn2rOnDlW6+qNC5n5iNz85Nv4lOz32tGjR/v9btVCoaAvfOELOnPmjKRzvyDddNNNpSwPsMr2+PQVuZlzITMfj6EuIDdz5Z4Z73RF2SoUCjp06JAKhYLtUrxCbubILBzbuQVBoM997nP62c9+JklKp9P68Y9/rAULFlippz9sZ+YrcvOPj+NTst9rK1as0DXXXKMVK1bo5MmTvT6vublZjY2Nevzxx4vbvva1r+nSSy+No0zACtvj01fkZs52Zr4eQ20jN3NkxjtdUcby+bw2btyoxsZGpdP2/v7Q2Nio1tbWLtsOHjxY/Hjz5s2qr6/v9nVNTU0aM2ZMqcvrhtzMuZKZb2zn9tBDD2n58uXFx1deeaXWr1+v9evX9+vrH3zwwVKV1ivbmXXyaXxK5OYjH8en5Eavbd68Wbfeequy2azq6uo0adIk1dTUKJVK6ciRI2pubtZrr73W5WsWLlyo+++/30q9QFxcGJ8+IjdztjPz9RhqG7mZIzMWXQHrdu7cqf379/f6+XfeeUe/+c1vum0/e/ZsKctyHrmh1A4dOtTl8e7du7V79+5+f30SThLCYnyGQ279x/gMZ9CgQcWPc7mctm/fru3bt/f6/Orqai1ZskRf+tKXlMlk4igRAFBiHEPDITdzZMaiKwAAAFAW7rzzTt1www1avXq1XnzxRe3YsUMtLS06fvy4JGnIkCEaPXq06uvrNWfOHC1cuFBVVVV2iwYAAPAUi64oW6lUStXV1UqlUlbr2Ldvn9Wfb4rczLmSmW9s57ZkyRItWbLEys8Oy3ZmnXwanxK5+cjH8Sm50WsTJ07UxIkTddddd1mrAXCRC+PTR+RmznZmvh5DbSM3c2TGoivKWDab1ezZs22X4R1yM0dm4ZCbOTILh9wQF3oNcBfjMxxyM0dmQPngStcoW4VCQfv37+dOm4bIzRyZhUNu5sgsHHJDXOg1wF2Mz3DIzRyZAeWDRVeUrXw+r61btyqfz9suxSvkZo7MwiE3c2QWDrkhLvQa4C7GZzjkZo7MgPLBoisAAAAAAAAARIhFVwAAAAAAAACIEIuuKFupVEojRozgTpuGyM0cmYVDbubILBxyQ1zoNcBdjM9wyM0cmQHlI2u7AMCWbDar6dOn2y7DO+RmjszCITdzZBYOuSEu9BrgLsZnOORmjsyA8sE7XVG28vm8Xn31VS5gbojczJFZOORmjszCITfEhV4D3MX4DIfczJEZUD5YdEXZKhQK2rVrlwqFgu1SvEJu5sgsHHIzR2bhkBviQq8B7mJ8hkNu5sgMKB8sugIAAAAAAABAhFh0BQAAAAAAAIAIseiKspVOp1VbW6t0mmFggtzMkVk45GaOzMIhN8SFXgPcxfgMh9zMkRlQPrK2CwBsyWQymjZtmu0yvENu5sgsHHIzR2bhkBviQq8B7mJ8hkNu5sgMKB/8aQVlK5/Pa8uWLdw10hC5mSOzcMjNHJmFQ26IC70GuIvxGQ65mSMzoHyw6IqyVSgU1NLSwl0jDZGbOTILh9zMkVk45Ia40GuAuxif4ZCbOTIDygeLrgAAAAAAAAAQIRZdAQAAAAAAACBCLLqibKXTaU2aNIm7RhoiN3NkFg65mSOzcMgNcaHXAHcxPsMhN3NkBpSPrO0CAFsymYzq6upsl+EdcjNHZuGQmzkyC4fcEBd6DXAX4zMccjNHZkD54E8rKFu5XE4bNmxQLpezXYpXyM0cmYVDbubILBxyQ1zoNcBdjM9wyM0cmQHlg0VXlK0gCHT48GEFQWC7FK+QmzkyC4fczJFZOOSGuNBrgLsYn+GQmzkyA8oHi64AAAAAAAAAECEWXQEAAAAAAAAgQiVfdP3Od76jVCqlL3/5y6X+UYCRTCaj+vp6ZTIZ26V4hdzMkVk45GaOzMIhN8SFXgPcxfgMh9zMkRlQPrKl/OYvvfSSfvjDH2rq1Kmhvn7v3ogLSqCeMiK3vtXVSW++KZ37m8N4SVJlpTRhgs2q3Ld3r9TeLp2f29ix0quv2qzKbfRaOD31Grn1jczCYV4zx3lHOBwPzG3f3n0bvXZhjFFzjM9wOIaao9fC4XhgjmNBOKXIqGSLrqdOndItt9yif/iHf9C3v/3tUN/j3CSOvvSUEbn17c03pVOnum47dUo6dMhOPT47d9KA3tBr0SE3c2QWDvNa3zjvCIfjQTTotQtjjJpjfEaHY2jf6LXoMK/1jWNBOKXIqGSLrnfffbfmzZunOXPm9LnoeubMGZ05c6b4+OTJk+d9NlBHR07pdFqZTEb5fF6FQqH42c7tuVyuy53/MpmM0ul0r9s7Ojq61JDNnoshl8v1a3tFRYUKhYLy+XxxWyqVUjab7XV7b7UPdJ/OvYQpdRWo8yk+7lOpX6cSv8G77CRpPEXde+fG5vvHJwC3BSoUgrI5jzDdp97OO6SUt/sUx+vUmREG6tzvBufzeTyVpvd6HqOdufm5T+pSe/SvU0+ZIZxA+XwhQeOpa+2l+d0dYSV7Lh/YPvV23uHzPsXzOkU/Rkuy+vT444/r5Zdf1ksvvXTB5y5dulQPPPBAj5/L5fJqampSbW2tpk2bpubmZrW0tBQ/P2nSJNXV1WnTpk06fPhwcXt9fb3Gjx+v5557Tm1tbcXtDQ0NGjlypJ5++ukuQV9//fUaPHiwmpqauvz8xsZGnT59WmvXri1uy2azmjdvnt5++21t3LixuL26ulqzZ8/W66+/rq1btxa3jxgxQtOnT9fu3bu1a9eu4vao9ikI5uv9TZHL5dXW1u7tPpX6dZJmC9FJ0niKuvdyuWFikR/wSy6X1+uvv1k25xGm+yQt6DEzKevtPsXxOuXzBUlcu2+ggkBdXj/fx1Mpei+Xm6f3n3t0/k7l6z51KtXr1FNmCCeXy6u5eVtixlOnUv7ujvCSPJcPdJ/eW0Dsyud9iuN1KsXxIBV0/dPLgL3++uv6wz/8Qz3zzDPFa7nOmjVL9fX1+ru/+7tuz+/pna7jxo2TdEJVVdU6epR3uva1T8OGZXXqVNeJu6oqUOcbhn3cp1K/TjU12W7/rQPhVFVJR48mZzxF3XtDh6a6jU8AbquqCnTiBO907a323s472tp4p2tf+1RdHXA8iEBVVaCjR5MznkrRe72N0c7cfNynTqV6nXrKDOFUVQU6fpx3upr87o5wqqqk48eTO5cPdJ96Ou/gd/cL79N7Y/SkpKE6ceKEhgwZooGIfNH1iSee0M0339zlTnz5fF6pVErpdFpnzpzp8y59J0+e1NChQyWd0MiRQ/TWW1FWlzyjRnW/BszIkSK3PvSUWVWVNGWKnXp8sX1792sQ0Wt9o9fCee/GDIGCIFAqlVJlZYqbDPSBzMJhXjPHeUc4HA/M9TSvjR2b4iY9F8AYNcf4DIdjqDl6LRyOB+Y4FoTzXm7RLbpG/v8obrjhBm3btq3Ltttvv111dXX67//9v/e54Pp+/LJ4YRMmdB9M5Na3njKbMkU67x3y6EFDg/TCC1230Wt9o9cGimvimiMzE8xr5jjvCIfjwUAwr5lgjJpjfIbDMdQcvTZQHA/6i2NBOD3lNlDpaL/dues5TJkypcu/iy++WJdeeqmm8CccAEA/dXR0aOXKld3+ywh6R2YAkoZ5DQAgcTyAnyJfdAUAICrd75yOCyEzAEnDvAYAkDgewD+x3KZx3bp1cfwYAAAAAAAAALCOd7oCAAAAAAAAQIRYdAUAOCmbzer6669XNhvLf8pIBDIDkDTMawAAieMB/MSiKwDAWYMHD7ZdgnfIDEDSMK8BACSOB/APi64AACflcjk1NTVxwXwDZAYgaZjXAAASxwP4iUVXAAAAAAAAAIgQi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6AgCclM1m1djYyB1KDZAZgKRhXgMASBwP4CcWXQEAzjp9+rTtErxDZgCShnkNACBxPIB/WHQFADgpl8tp7dq13KHUAJkBSBrmNQCAxPEAfmLRFQAAAAAAAAAixKIrAAAAAAAAAESIRVcAgLO4UL45MgOQNMxrAACJ4wH8Q8cCAJxUUVGhefPm2S7DK2QGIGmY1wAAEscD+Il3ugIAnFQoFHTo0CEVCgXbpXiDzAAkDfMaAEDieAA/segKAHBSPp/Xxo0blc/nbZfiDTIDkDTMawAAieMB/MTlBRCZt99+W88//7w2bdqkbdu2ac+ePWptbdWpU6dUUVGhmpoaTZkyRbNmzdJnPvMZjR071nbJ1pFZOOQWzr59+/TMM8/o2Wef1bZt29TS0qJTp06purpaH/zgB9XQ0KDFixdr5syZtkuF5+g1c8xriBNj1Fw+n9eOHTv00ksvafPmzXrppZfU3Nysjo4OSdLMmTO1bt06u0U6hnkNcBfjMzyOoebKOrPAMSdOnAgkBdKJ4LrrbFfjvuuuCwKp6z9buc2bN+93r92F/w0aNChYsmRJkM/nY6+TzMIhN3OuZPbyyy8H1157bb8zmzVrVrB///74C32fs2fPBk888URw9uxZ26V4w3ZmvvWaK2M0CJjXks6V3Hwbo0Fgf14LgiD413/916CysrLPrGbOnGmtvvO50mtBwLyWdORmzqXMfBmf57N9PPDpGOpKr/mUWRCcn9u5dckTJ04M+HvyTleUxPDhwzV58mSNHz9eVVVVam9v12uvvaZNmzYpl8vpzJkzWrJkifbu3avly5fbLtcJZBYOuV3Yrl27tGnTpi7bJk6cqClTpmj48OE6fvy4NmzYoDfeeEOStG7dOjU0NOhXv/qVJkyYYKNkSVIqlVJ1dbVSqZS1GnxjOzNfe801zGsoFR/HqO15TZKOHz+u9vZ2az8/CZjXAHf5Mj5tHw98PIbaRmYS73T1nCt/wQiCIPjbv/3b4OGHHw52797d63MOHjwYLFq0qMtfM/7lX/4lxirJLCxyM+dKZo899lggKbjqqquC73znO8Ebb7zR7Tn5fD740Y9+1OWdPNddd11QKBTiLxje8q3XXBmjQcC8lnSu5ObbGHXFsmXLAknBqFGjgptuuil44IEHgqampuBLX/oS73TtA/NaspGbOZcy82V8usSnY6grveZTZkFQmne6sujqOVcGk4lCoRDMnj27OKDmzJkT688ns3DIzZwrma1bty5YtmxZkMvlLvjcX/ziF11OrFatWhVDhT3L5/PBvn37rP9XJp/Yzsy3XnNljJpgXvOTK7n5NkaDwP68FgRBcODAgR7/u+P999/PomsEmNf8RG7mfMzM9vg8n+3jgU/HUFd6zafMgqA0i67pAb1NFgghlUrp9ttvLz7esmWLxWr8QGbhkNs5M2fO1G233aZMJnPB595888269tpri49XrlxZytL6lM/ntXXrVu5QasB2Zr72mk+Y1zAQPo5R2/OaJF122WWqra219vOTjnkNcJdL49P28cDHY6htZCax6AorRowYUfy4ra3NYiX+ILNwyM3cjBkzih/v27fPXiFIPHotHOY1xIUxirgwrwHuYnyGwzHUXBIzY9EVVuzcubP48eWXX26vEI+QWTjkZu78i9PzLlOUEr0WDvMa4sIYRVyY1wB3MT7D4RhqLomZseiK2LW2tuq73/1u8fEnPvEJi9X4gczCIbdwtm3bVvx43Lhx1upIpVIaMWKE1TtW+8a3zFzpNZ8wryFOLoxR3+Y1mGNeA9zl0vj07XjgwjHUN0nMjEVXxKK9vV07d+7U9773PU2bNk2tra2SpMmTJ+u+++6zXJ2byCwcchuYlpYWrVmzpvh4zpw51mrJZrOaPn26stmstRp841NmLvWa65jXYIMrY9SneQ39x7wGuMvV8enT8cCVY6hPkpqZ+90KL61fv14f/ehH+3xOY2OjfvKTn6i6ujqmqtxGZuGQW7Tuvffe4n/lqK2t1fz5863Vks/ntXv3bn3oQx/q18XX4VdmLvWaa5jX4AJXxqhP8xp6x7wGuMuX8enT8cCVY6hPkpoZ73RF7GpqavTYY49p5cqVuuSSS2yX4wUyC4fczCxfvlw///nPi4+XLl2qQYMGWaunUCho165dKhQK1mrwjS+ZudZrPmFeQxxcGqO+zGsIj3kNcJdL49OX44FLx1BfJDkz3umKkhgzZozuvvtuSVIQBGpra9OuXbv08ssv69ixY1q0aJEeeeQRPfzww5o4caLlat1AZuGQWzQ2b96sO+64o/h40aJFWrx4scWKkFT02oUxr8EmxihKgXkNcBfjMzocQ80lPrPAMSdOnAgkBdKJ4LrrbFfjvuuuCwKp6z+Xc3vzzTeD22677XevsYKamprgN7/5Taw1kFk45GbOl8z27t0bXHbZZcWspk6dGpw4ccJ2WcHZs2eDJ554Ijh79qztUrzhemau9ZovY7QT85q/fMnNtTEaBG7Pa/fff38xq5kzZ9ouJwgCf3qtE/Oav8jNnG+ZuTA+z+fy8SAI3DqG+tJrLmUWBOfndm5dMopauLwAYjVmzBgtW7ZM99xzjyTp2LFj+uQnP1m8dge6I7NwyK1/Dhw4oLlz5+rgwYOSpAkTJmjVqlUaMmSI5cqkdDqt2tpapdMcqvrL5cxc7jVfMK+hlFwdoy7Paxg45jXAXa6NT5ePB64eQ11WLpm5160oC0uXLi0OpldeeUVPPfWU5YrcR2bhkFvvjhw5orlz52rPnj2SpNGjR2v16tUaPXq05crOyWQymjZtmvMXyneJq5m53mu+YV5D1Fweo67Oa4gW8xrgLlfGp6vHA5ePoa4qp8xYdIUVlZWVmj59evHx888/b7EaP5BZOOTWs5MnT+rGG2/Ujh07JEnDhw/X6tWrdcUVV1iu7D35fF5btmzh3S4GXMzMh17zDfMaouT6GHVxXkP0mNcAd7kyPl08Hrh+DHVRuWXGoiusqampKX585MgRi5X4g8zCIbeu3nnnHTU2NurXv/61JGno0KFatWqVPvzhD1uurKtCoaCWlhbn71DqEtcy86XXfMS8hij4MEZdm9dQOsxrgLtcGJ+uHQ98OIa6phwzY9EV1hw4cKD48bBhwyxW4g8yC4fc3vPuu+9qwYIFxb9QV1ZWauXKlbr66qstV4akoddKi3kNA8UYhWuY1wB3MT674hhqrlwzY9EVVhw5ckQbN24sPp48ebLFavxAZuGQ23s6Ojq0cOFCrVmzRpI0aNAgPfnkk5oxY4blypA09FppMa9hoBijcA3zGuAuxmdXHEPNlXNmLLoiEkePHu33cwuFgr7whS/ozJkzks4NuJtuuqlUpTmLzMIht3Dy+bwWL16spqYmSVI2m9VPf/pTzZkzx3JlvUun05o0aZKTdyh1lQuZ+dhrtjGvIU6+jVEX5jWYY14D3OXr+HTheODbMdQF5Z4ZZy+IxIoVK3TNNddoxYoVOnnyZK/Pa25uVmNjox5//PHitq997Wu69NJL4yjTKWQWDrmZC4JAn/vc5/Szn/1M0rkTlh//+MdasGCB5cr6lslkVFdX59wdSl1mOzNfe8025jXExccxanteQzjMa4C7fB2fto8HPh5DbSMzKWu7ACTH5s2bdeuttyqbzaqurk6TJk1STU2NUqmUjhw5oubmZr322mtdvmbhwoW6//77LVVsH5mFQ25mHnroIS1fvrz4+Morr9T69eu1fv36fn39gw8+WKrS+pTL5bRp0yZde+21ymY5XPWH7cx87TUXMK8hDj6OUdvzWqfGxka1trZ22Xbw4MHix5s3b1Z9fX23r2tqatKYMWNKXZ6TmNcAd/k4Pm0fD3w8htpGZiy6IiKDBg0qfpzL5bR9+3Zt37691+dXV1dryZIl+tKXvlS271wgs3DIzdyhQ4e6PN69e7d2797d76+3dbALgkCHDx9WEARWfr6PbGfma6/ZxryGuPg4Rm3Pa5127typ/fv39/r5d955R7/5zW+6bT979mwpy3IW8xrgLl/Hp+3jgY/HUNvIjEVXROTOO+/UDTfcoNWrV+vFF1/Ujh071NLSouPHj0uShgwZotGjR6u+vl5z5szRwoULVVVVZbdoy8gsHHIDkDTMawCShnkNcBfjE4gPi66IzMSJEzVx4kTdddddtkvxBpmFQ25mlixZoiVLltguA2WAXguPeQ1xYIyGt2/fPtsleId5DXAX49Mcx1BzZMaNtAAAjspkMqqvr+e/GRogMwBJw7wGAJA4HsBPvNMVAOCkdDqt8ePH2y7DK2QGIGmY1wAAEscD+Il3ugIAnJTL5bRmzRrlcjnbpXiDzAAkDfMaAEDieAA/segKAHBSEARqa2uzfsdqn5AZgKRhXgMASBwP4CcWXQEAAAAAAAAgQiy6AgAAAAAAAECEWHQFADgpk8mooaGBO5QaIDMAScO8BgCQOB7AT1nbBQAA0JN0Oq2RI0faLsMrZAYgaZjXAAASxwP4iXe6AgCc1NHRoZUrV6qjo8N2Kd4gMwBJw7wGAJA4HsBPLLoCAJyVy+Vsl+AdMgOQNMxrAACJ4wH8w6IrAAAAAAAAAESIRVcAAAAAAAAAiBCLrgAAJ2WzWV1//fXKZrnnY3+RGYCkYV4DAEgcD+AnFl0BAM4aPHiw7RK8Q2YAkoZ5DQAgcTyAf1h0BQA4KZfLqampiQvmGyAzAEnDvAYAkDgewE8sugIAAAAAAABAhFh0BQAAAAAAAIAIsegKAAAAAAAAABFi0RUA4KRsNqvGxkbuUGqAzAAkDfMaAEDieAA/segKAHDW6dOnbZfgHTIDkDTMawAAieMB/MOiKwDASblcTmvXruUOpQbIDEDSMK8BACSOB/ATi64AAAAAAAAAECEWXQEAAAAAAAAgQiy6AgCcxYXyzZEZgKRhXgMASBwP4J/IF10feughTZ06VUOGDNGQIUPU0NCgp556KuofAwBIuIqKCs2bN08VFRW2S/EGmQFIGuY1AIDE8QB+ivzPBB/84Af1ne98Rx/60IcUBIGWL1+u//Sf/pO2bNmij3zkI0bfa+/eqKtLnp4y2r5damiIvxZfbN/efRu9dmH0mjl6LZy6Oun/b+/Ow6Oq83yPf2qBCGYxGAIBSRRoCDYitIIEumVVNAgudLeCC24zjw7ut72t18cW79xp2u72dveMPqIzDoujqGO3elsQBdlEwIjAsKgZFiVqkCVAFiIhVXXuHzQFgZDknFSd3zmV9+t5eJ6qk0ryrU99f79T9cvhnG+/lSRLlmUpEAioY8eAevY0XZl37dgh1dZKJ2bWvXtAX3xhujJvY16zj3nNmcYyIreWicVi2rdvn3JychQM8p/0msO8Zh/zmjPMa/YxPp1p7H0unw2axrzmTDIyCliWZSX+xzbUqVMn/e53v9Mdd9zR7GOrqqqUlZUlqVLp6Zmqrk52df6WkSHV1Jiuwv/S00WvNYNeSwx6rXn0WmLQa82j1xKDXmteY71Gbi1TX1+vBQsWqLi4mKObWoB5LTEYn81jXrOP8QmTGJ/NOz5GqyRlqbKyUpmZma36mUk9IUY0GtV//ud/6tChQyo6zZ9v6urqVFdXF79fVVV1wlct1ddHFAwGFQqFFI1GFYvF4l89tj0SiejEteNQKKRgMHja7fX19Q1qOHZekEgk0qLt7dq1UywWUzQajW8LBAIKh8On3X662lv7nI6+hAGhtSxJgaS9TqnQe8cyQmsdndeOSfYc4c/eY15LjKO9Zmr/5Ifeo9cS5ej+wSvvjbzYe6fbh/r5Obn1Oh37umUdPcIpFZ5Tc9tb95yY1xLj+Pu1VBpPzW2385wa7zVL0WjMt8+Jz+5Idak0npIzRyR+jCZl0XXTpk0qKirS4cOHlZ6erjfffFPnn39+o4+dMWOGnnzyyUa/FolEtWDBAuXn52vQoEHauHGjysrK4l/v27evCgsLVVJSor1798a3Dxw4UAUFBVqxYoWqT1jKLyoqUm5urt5///0GQY8aNUodOnTQggULGvz+4uJiff/991q6dGl8Wzgc1vjx47Vv3z6tXr06vj0jI0OjR4/W119/rQ0bNsS3d+7cWcOGDdPWrVtVWloa356o52RZE8TE3XrRaExSKGmvUyr03vFJCK0Ri1kNXu9kzxF+7L1IZLzotdY7tg81tX/yQ+/FYuxDEyESObp/8Mp7Iy/23rH3GSfz83Ny+3WKRCI6fPhwSj2nZLxO7EMT49g+VErN8ZSI5xSNXqWT57VIJKqNGzf59jnx2R2pLpXGUzLmiGTsQ5NyeoEjR46orKxMlZWVeuONN/Rv//ZvWr58eaMLr40d6dqjRw8dPb1Ahvbv50jXpp5Tp05h1dQwcbdWerql6mqOdG3qOWVkWPRaAqSnW9q/nyNdm3pOzGuJcazXUuuvzw1rb+1zotcS49g+1CvvjbzYe43tQ9PTpQMH/Puc3HqdIpGIVq1apUsvvVThcDglnlNz21vznJjXEuPE92upNJ6a227nOTXWa+nplg4e5EhXPrvDi9LTpf37U2c8JWOOOD5GE3d6AVfO6Tp27Fj16tVLzz//fLOPPfGcrrm5mdq9O9nV+dvxC84c17GjOKl0E46fiPu47t3FBWeaQa/ZR68506WLtGdPw23p6VL//mbq8YPNm089R1hurtiHNoN5zT7mNWcam9cYo0gG5jX7mNecYV6zj/HpTGNjlNyaxrzmzPF5zSfndD0mFos1OJq1pRhEzTs2aGKxmL7++mv16NGDK7u2EJnZQ685R2b29Ox56pv4/v2lE/4XC05SVCStWdNwG/vQ5jGvOUdm9jQ2rzFGW4Zes4d5zTkys4d5zT7GZ+uQm31kZk9j81prJTz1Rx99VCtWrNBXX32lTZs26dFHH9WyZct04403JvpX4QTRaFQbNmw46eTmaAqZOUNu9pEZ4G2MUfvIDG6h15whN/vIDG6h15whN/vIzLyEH+m6Z88e3XLLLdq1a5eysrI0YMAAvffee7rssssS/asAAAAAAAAAwHMSvuj64osvJvpHAgAAAAAAAIBvcFKHFBEIBNS5c2cFAlwNsaXIzBlys4/MAG9jjNpHZnALveYMudlHZnALveYMudlHZua5ciEtJF84HNawYcNMl+ErZOYMudlHZoC3MUbtIzO4hV5zhtzsIzO4hV5zhtzsIzPzONI1RUSjUX3xxRecINkGMnOG3OwjM8DbGKP2kRncQq85Q272kRncQq85Q272kZl5LLqmiFgsptLSUsViMdOl+AaZOUNu9pEZ4G2MUfvIDG6h15whN/vIDG6h15whN/vIzDwWXQEAAAAAAAAggVh0BQAAAAAAAIAEYtE1RQSDQeXn5ysY5CVtKTJzhtzsIzPA2xij9pEZ3EKvOUNu9pEZ3EKvOUNu9pGZeWHTBSAxQqGQBg0aZLoMXyEzZ8jNPjIDvI0xah+ZwS30mjPkZh+ZwS30mjPkZh+Zmcdyd4qIRqNav349V6WzgcycITf7yAzwNsaofWQGt9BrzpCbfWQGt9BrzpCbfWRmHouuKSIWi6msrIyr0tlAZs6Qm31kBngbY9Q+MoNb6DVnyM0+MoNb6DVnyM0+MjOPRVcAAAAAAAAASCAWXQEAAAAAAAAggVh0TRHBYFB9+/blqnQ2kJkz5GYfmQHexhi1j8zgFnrNGXKzj8zgFnrNGXKzj8zMC5suAIkRCoVUWFhougxfITNnyM0+MgO8jTFqH5nBLfSaM+RmH5nBLfSaM+RmH5mZx3J3iohEIlq1apUikYjpUnyDzJwhN/vIDPA2xqh9ZAa30GvOkJt9ZAa30GvOkJt9ZGYei64pwrIs7d27V5ZlmS7FN8jMGXKzj8wAb2OM2kdmcAu95gy52UdmcAu95gy52Udm5rHoCgAAAAAAAAAJxDldkVBfffWVFi1apOXLl2vTpk0qKytTTU2NMjIydM4556ioqEhTpkzRiBEjTJfqOUeOHNFrr72mefPmacuWLdq9e7eys7N13nnn6brrrtOtt96qnJwc02V6Br1mXzQa1ZYtW/TJJ59o7dq1+uSTT7Rx40bV19dLkkaMGKFly5aZLdJj9u3bp48++kglJSXatGmTtm/frvLyctXU1Khdu3bKzs5W//79NXLkSN1yyy3q3r276ZI9gfHpDGMUbqHX4Bb2B3AL85p9jE/ABZbHVFZWWpIsqdIaOtR0Nf4RjUatr776yopGo0Z+/7p166whQ4b87bVr/t/IkSOtnTt3Gqn1GNOZnejzzz+3Bg4c2GRmubm51vz5802Xajw3es2ZN9980+rYsWOTWY0YMcJYfScaOtSypIb/TO0Pxo8f3+JeS0tLs6ZPn27kdfZKZn4cn5bFGHXCC5n5iVfGqGXRa22F6dz8uD8wnZnfMK85Z7rX/Dg+Lct8bn5EZvYcn9eOrktWVla2+mdypGuKCAaDKigoMPb7S0tLVVJS0mBbnz591L9/f+Xk5OjgwYNatWqVvvnmG0nSsmXLVFRUpA8//FA9e/Y0UbLxzI755ptvNGbMGJWXl0uSAoGALr30UvXq1Ut79+7V4sWL9f3332vPnj265pprtHDhQo0ePdpYvaZzo9ecOXjwoGpra43W4Hc5OTnq16+fCgoKlJ6ertraWm3btk0lJSWKRCKqq6vT9OnTtWPHDs2ZM8d0uUb4cXxKjFEnvJAZnKHX2gbTuflxf2A6MzjHvGaPH8enZD43PyIz81h0TRGRSEQrVqzQpZdeqnDY3Mvau3dv3XnnnbrppptO+W+2sVhMs2fP1r333qva2lqVl5frxhtv1KpVqxQIBFyv1SuZTZkyJb7gWlBQoLffflsXXnhh/Ov79u3TDTfcoA8++ED19fX62c9+pu3bt+uss84yUq9XcqPXnOnSpYsGDx4c//fee+/pT3/6k9GavGzkyJGaMGGCxowZo969ezf6mN27d+vBBx/UvHnzJElz587VhAkT9NOf/tTNUj3FT+NTYow64aXM4Ay9ltq8kpuf9gdeyQzOMa/Z46fxKXknNz8hM/NIPUVYlqXq6mpjV6XLy8vTrFmzdPPNNysUCjX6mGAwqNtvv13Z2dm67rrrJElr1qzR+++/r3HjxrlZriTzmUnSggUL9OGHH0qS2rdvr7/+9a+64IILGjwmJydHb7/9tgYMGKAdO3Zo//79+u1vf6tf//rXJko2nhu95swVV1yhnTt3Kj8/v8H2jz/+2FBF/vCLX/yi2cd06dJFL7/8snbv3q0lS5ZIkp5//vk2uejqx/EpMUad8EJmcIZeaxtM5+bH/YHpzOAc85o9fhyfkvnc/IjMzAuaLgCpYcSIEbr11ltPO2mf6Nprr9WQIUPi9+fPn5/M0jzt2Wefjd+eOnXqKQuux5x55pn63//7f8fvP//884pEIkmvz4voNWe6du16yhtRJE4gENBtt90Wv79+/XqD1ZjD+HSOMQq30GtwA/sDuIl5zR7GJ+AeFl1hxPDhw+O3v/rqK3OFGFRTU6MPPvggfv/EBZvGTJo0Senp6ZKk/fv3a8WKFUmtL1XQa3BL586d47erq6sNVuIfjE8AgMT+APAyxifgHIuuKSIUCqmoqKhFf63yghPPAxONRo3UYDqzVatWqa6uTtLRI1kHDx7c5OPPOOMMFRUVxe8f+2/MbjOdm130Gtzy2WefxW+fe+655grxES+MT4kx6gSZwS30mjN+y80L+wO/ZQb/8luveWF8Sv7LzQvIzDwWXVNEMBhUbm6ugkF/vKSbNm2K3+7Ro4eRGkxn9vnnn8dvX3DBBS06sfWPfvSjRr/fTaZzs4tegxvKy8v1+9//Pn6/LZ7P1QkvjE+JMeoEmcEt9JozfsvNC/sDv2UG//Jbr3lhfEr+y80LyMw8kk8R9fX1mj9/vurr602X0qyysrIGR2mOHTvWSB2mMystLY3fLigoaNH3nHiuoi+++CLhNbWE6dzsoNeQTLW1tfrss8/09NNPa9CgQSovL5ck9evXT4888ojh6rzPK+NTYow6QWZwC73mjJ9y88r+wE+Zwd/81GteGZ+Sv3LzCjIzr/lD6+Abfrmw0kMPPRT/bwn5+fmaMGGCsVpMZlZRURG/3aVLlxZ9T9euXeO39+/fn/CaWopes88vmeH0Vq5cqZ/85CdNPqa4uFgvv/yyMjIyXKrKv7w0PiXGqBNkBrfQa874JTcv7Q/8khn8zy+95qXxKfknNy8hM7M40hWumjNnjv785z/H78+YMUNpaWkGKzKnpqYmfrtDhw4t+p4TH3fi9+NU9BrclJ2drXnz5mn+/Pk666yzTJfjeYxPAIDE/gDwMsYn0Hoc6QrXrF27VnfddVf8/uTJkzVlyhSDFZl1+PDh+O327du36HtO3Ml9//33Ca8pVdBrSIZu3bpp2rRpkiTLslRdXa3S0lKtW7dOBw4c0OTJk/XCCy9o5syZ6tOnj+FqvYvxCQCQ2B8AXsb4BBKDRdcUEQ6HNWrUqBZdjMmEL7/8UhMmTIgvNA4YMEAzZ840WpPpzM4444z47SNHjrToe+rq6uK3W3p0bKKZzq059BqSpWfPnnrmmWdO2V5eXq7HHntMs2fP1tKlSzV06FAtW7ZMAwYMMFClt3lxfEqMUSfIDG6h15zxem5e3B94PTOkDq/3mhfHp+T93LyIzMzj9AIpxNQiXHN27dqlyy67TN99952kowsXCxcuVGZmpuHKzGaWnp4ev93So1ZPfNyJ3+82es0+r2aG1uvWrZtmzZql++67T5J04MAB3XDDDfHzX+EoL49PiTHqBJnBLfSaM17Nzcv7A69mhtTj1V7z8viUvJubl5GZWSy6pohIJKIFCxZ47iTJFRUVuuyyy7R9+3ZJUl5enhYvXqy8vDzDlZnP7Oyzz47f3r17d4u+59jOT5I6deqU8JpawnRup0OvwbQZM2bE35B+/vnnevfddw1X5B1eHp8SY9QJMoNb6DVnvJqbl/cHXs0Mqcervebl8Sl5NzcvIzPzWHRF0lRVVWncuHHasmWLJCknJ0eLFy/WeeedZ7gyb+jbt2/89s6dO1v0PWVlZfHbhYWFCa/Jr+g1eEHHjh01bNiw+P2PPvrIYDXewfgEAEjsDwAvY3wCycGiK5Li0KFDKi4u1qeffipJysrK0sKFC3X++ecbrsw7+vXrF7+9adOmFv31ad26dY1+f1tGr8FLsrOz47crKioMVuINjE8AgMT+APAyxieQPCy6IuEOHz6siRMnxo/y6tixo+bPn6+LLrrIcGXeMmzYMKWlpUk6uqNbu3Ztk4+vq6vTmjVr4vdHjx6d1Pr8gF6D1+zatSt+29QpQLyC8QkAkNgfAF7G+ASSi0XXFBEOh1VcXGz8qnT19fWaNGmSlixZIklKS0vT22+/reHDhxutqzGmM0tPT9eYMWPi92fPnt3k4//yl7+ourpa0tHFnEsvvTSZ5Z2W6dyOodfgNRUVFVq9enX8fls+Gt1P41NijDpBZnALveaMV3Lz0/7AK5kh9Xml1/w0PiXv5OYnZGYei64p5MQr25sQjUY1ZcoULViwQNLRAf76669r7NixRutqiunM/uEf/iF+e/bs2fFz6JystrZWv/rVr+L3//7v/97oxGk6N3oNbti/f3+LHxuLxXTPPfeorq5O0tE3rVdddVWySvM0P45PiTHqBJnBLfSaM6Zz8+P+wHRmaDtM95ofx6dkPjc/IjOzWHRNEZFIREuXLjV2VTrLsnTHHXfojTfekCQFg0G99NJLmjhxopF6WsJ0ZpI0fvx4/eQnP5F09PQBV111lTZu3NjgMRUVFbrmmmu0bds2SUePcv3lL3/peq3HmM6NXoNb5s6dq8GDB2vu3Lmqqqo67eM2btyo4uJivfrqq/FtDz/8sM4++2w3yvQUP45PiTHqBJnBLfSaM6Zz8+P+wHRmaDtM95ofx6dkPjc/IjPzOMYYCfHcc89pzpw58fu9evXSypUrtXLlyhZ9/zPPPJOs0jzvlVde0ZAhQ7Rr1y599dVXGjhwoEaMGKFevXpp7969Wrx4sWprayUd/wvkWWedZbZog+g154qLi1VeXt5g23fffRe/vXbtWg0cOPCU71uwYIG6deuW7PI8ae3atZo6darC4bAKCwvVt29fZWdnKxAIqKKiQhs3boz/QeSYSZMm6YknnjBUsVmMz9ZhjMIt9BqSjf0B3Ma81nKMT8A9LLoiIfbs2dPg/tatW7V169YWf39bnrjPOeccLVmyRJMnT9aGDRtkWZaWLVumZcuWNXhc586dNWvWrAbngW2L6DXnPvvsM+3cufO0Xz906JD+67/+65TtR44cSWZZnnXsQnfS0b8Sb968WZs3bz7t4zMyMjR9+nTdf//9CoVCbpToOYzP1mGMwi30GpKN/QHcxrzWcoxPwD0suqYQTo5sn1cyKyws1Mcff6xXX31V8+bN05YtW7R7926dddZZ6tmzp6677jrddtttysnJMV2qJO/k5idk5j933323xowZo8WLF+vjjz/Wli1bVFZWpoMHD0qSMjMzlZeXp4EDB2rs2LGaNGmS0tPTzRYNxxij9pEZ3EKvOUNu9pEZ3EKvOUNu9pGZWQHLsizTRZyoqqpKWVlZkio1dGimTrgQNACgDSgqktasabht6FCxP2gCmQHexhgFkGqY1wCkmuPzWpWkLFVWViozM7NVP5MLaaWIWCymPXv2KBaLmS7FN8jMGXKzj8wAb2OM2kdmcAu95gy52UdmcAu95gy52Udm5rHomiKi0ahWr16taDRquhTfIDNnyM0+MgO8jTFqH5nBLfSaM+RmH5nBLfSaM+RmH5mZx6IrAAAAAAAAACQQi64AAAAAAAAAkEAsuqaIQCCgjIwMBQIB06X4Bpk5Q272kRngbYxR+8gMbqHXnCE3+8gMbqHXnCE3+8jMvIBlWZbpIk5UVVWlrKwsSZUaOjSTqx8CQBvD1XDtIzPA2xijAFIN8xqAVHN8XquSlKXKykplZma26mdypGuKiMVi2rlzJ1els4HMnCE3+8gM8DbGqH1kBrfQa86Qm31kBrfQa86Qm31kZh6LrikiGo1qw4YNXJXOBjJzhtzsIzPA2xij9pEZ3EKvOUNu9pEZ3EKvOUNu9pGZeSy6AgAAAAAAAEACsegKAAAAAAAAAAnEomuKCAQC6ty5M1els4HMnCE3+8gM8DbGqH1kBrfQa86Qm31kBrfQa86Qm31kZl7YdAFIjHA4rGHDhpkuw1fIzBlys4/MAG9jjNpHZnALveYMudlHZnALveYMudlHZuZxpGuKiEaj+uKLLzhBsg1k5gy52UdmgLcxRu0jM7iFXnOG3OwjM7iFXnOG3OwjM/NYdE0RsVhMpaWlisVipkvxDTJzhtzsIzPA2xij9pEZ3EKvOUNu9pEZ3EKvOUNu9pGZeSy6AgAAAAAAAEACsegKAAAAAAAAAAnEomuKCAaDys/PVzDIS9pSZOYMudlHZoC3MUbtIzO4hV5zhtzsIzO4hV5zhtzsIzPzwqYLQGKEQiENGjTIdBm+QmbOkJt9ZAZ4G2PUPjKDW+g1Z8jNPjKDW+g1Z8jNPjIzj+XuFBGNRrV+/XquSmcDmTlDbvaRGeBtjFH7yAxuodecITf7yAxuodecITf7yMw8Fl1TRCwWU1lZGVels4HMnCE3+8gM8DbGqH1kBrfQa86Qm31kBrfQa86Qm31kZh6LrgAAAAAAAACQQCy6AgAAAAAAAEACseiaIoLBoPr27ctV6WwgM2fIzT4yA7yNMWofmcEt9Joz5GYfmcEt9Joz5GYfmZmX8ORnzJihwYMHKyMjQ7m5ubrmmmtUWlqa6F+Dk4RCIRUWFioUCpkuxTfIzBlys4/MAG9jjNpHZnALveYMudlHZnALveYMudlHZuaFE/0Dly9frmnTpmnw4MGKRCL6X//rf+nyyy/XZ599pjPPPNPWz9qxI9HVpZ7CQunbbyXJUjQaUygUVMeOAfXsaboy79qxQ6qtlU7MrHv3gL74wnRl3kav2UevOdPY3M/+oGmN5bN5s1RU5H4tfsIYtY99gTObN5+6jXmtafSaM43Na+TWNPYFzvB+zT7mNWeY1+xjXnMmGXNYwLIsK/E/9ri9e/cqNzdXy5cv16WXXtrs46uqqpSVlSWpUunpmaquTmZ1/peRIdXUmK7C/9LTRa81g15LDHqteY31Grk1jfGZOPRa0+i1xKHXmkavwSTGZ/N4v2Yf8xpMYnw27/gYrZKUpcrKSmVmZrbqZyb8SNeTVVZWSpI6derU6Nfr6upUV1cXv19VVXXCVy3V10cUDAYVCoUUjUYVi8XiXz22PRKJ6MS141AopGAweNrt9fX1DWoIh4/GEIlEWrS9Xbt2isViikaj8W2BQEDhcPi0209Xe2uf09GXMCC0liUpkLTXKRV671hGaK2j89oxyZ4j/Nl7jc1rx3Pz53NSg9oT/zqxL0gcS7GYlULjqWHtrX1O9FpipfZc3rrn9LcqBJhx/H1HKoynZMwRp3u/dvSoOn8+Jz67I9Wl0nhKzhyR+DGa1EXXWCymBx54QMOHD1f//v0bfcyMGTP05JNPNvq1SCSqBQsWKD8/X4MGDdLGjRtVVlYW/3rfvn1VWFiokpIS7d27N7594MCBKigo0IoVK1R9wlJ+UVGRcnNz9f777zcIetSoUerQoYMWLFjQ4PcXFxfr+++/19KlS+PbwuGwxo8fr3379mn16tXx7RkZGRo9erS+/vprbdiwIb69c+fOGjZsmLZu3drg3LaJek6WNUFM3K0XjcYkhZL2OqVC7x2fhNAasZjV4PVO9hzhx96LRMbr5F47tj/w63M6JlmvU2OZwZlIJKqvv/42ZcbTMYnqPWliC1JES6XyXN7a5xSJBMS8BlNOfN+RCuMpGXNENHqVpIbniYxEotq4cZNvnxOf3ZHqUmk8JWOOSMZnqqSeXuDuu+/Wu+++q5UrV+qcc85p9DGNHenao0cPHT29QIb27+dI16aeU6dOYdXUMHG3Vnq6pepqjnRt6jllZFj0WgKkp1vav58jXZt6To3Nayfm5sfndEyyXif2BYmTnm6pspIjXU9XO72WOOnp0oEDqTuXt/Y5ZWaKXoMxJ77vSIXxlIw54nTv1w4e5EhXPrvDi9LTpf37U2c8JWOOOD5GE3d6gaQtut5zzz16++23tWLFCp133nkt/r4Tz+mam5up3buTUV3q6NJF2rOn4bb0dOk0BxZDRy9mcfK5dHJzRa81g16zj15zprFeI7emHb8ww3EdO4oLDDSDMWof+wJnjl/Q4rju3cUFLZpArznTWK+xP2ga+wJneL9mH/OaM8xr9jGvOXN8jHr4nK6WZenee+/Vm2++qWXLltlacD0Zg6h5PXueOnH37y+dcLQ3TlJUJK1Z03AbvdY8es0+es2ZxnqN3Jp2bOEmEoloxYoVuvTSS086LyIawxi1j31B6zBGW45eax16reXYFzjD+zX7mNdah3mt5ZjXnGlsjLZWwjt12rRpeuWVV/T2228rIyND3333nSQpKytLHTp0SPSvAwAAf2NZlqqrq5XEMwcBaAXGKNxCrwFINcxr8KNgon/gc889p8rKSo0cOVJ5eXnxf6+99lqifxUAAAAAAAAAeE5STi8AAAAAAAAAAG1Vwo90BQAAZoRCIRUVFSkUCpkuBUAjGKNwC70GINUwr8GPOPswAAApIhgMKjc313QZAE6DMQq30GsAUg3zGvyII10BAEgR9fX1mj9/vurr602XAqARjFG4hV4DkGqY1+BHLLoCAJBCIpGI6RIANIExCrfQawBSDfMa/IZFVwAAAAAAAABIIBZdAQAAAAAAACCBWHQFACBFhMNhjRo1SuEw18kEvIgxCrfQawBSDfMa/IhFVwAAUkiHDh1MlwCgCYxRuIVeA5BqmNfgNyy6AgCQIiKRiBYsWMBFBgCPYozCLfQagFTDvAY/YtEVAAAAAAAAABKIRVcAAAAAAAAASCAWXQEAAAAAAAAggVh0BQAgRYTDYRUXF3NVV8CjGKNwC70GINUwr8GPWHQFACCFfP/996ZLANAExijcQq8BSDXMa/AbFl0BAEgRkUhES5cu5aqugEcxRuEWeg1AqmFegx+x6AoAAAAAAAAACcTJMADDvvrqKy1atEjLly/Xpk2bVFZWppqaGmVkZOicc85RUVGRpkyZohEjRpgu1TP27dunjz76SCUlJdq0aZO2b9+u8vJy1dTUqF27dsrOzlb//v01cuRI3XLLLerevbvpkj2BXnOG3OAWeg1uodfgBt6vwU3Ma3ALvWZfm87M8pjKykpLkiVVWkOHmq7G+4YOtSyp4T9ya5pXMlu3bp01ZMiQv/V78/9Gjhxp7dy50/1C/8YruVmWZY0fP77FuaWlpVnTp0+3otGo63V6JTN6zRm/5WZZlnXkyBHrnXfesY4cOWK0Dr+g1+zzSmZ+ZXqM0mtth+lesyzer6U6r+TGvNZ2mJ7X6DX7/JSZZZ2Y29F1ycrKylb/TI50BQwpLS1VSUlJg219+vRR//79lZOTo4MHD2rVqlX65ptvJEnLli1TUVGRPvzwQ/Xs2dNEyZ6Uk5Ojfv36qaCgQOnp6aqtrdW2bdtUUlKiSCSiuro6TZ8+XTt27NCcOXNMl2sEveaMH3Nr166dxo8fb+R3wzk/9hqcMT1G6bW2w3SvnYz3a0gW5rW2w/S8Rq/ZR2acXgAwrnfv3rrzzjt10003nfLfqmKxmGbPnq17771XtbW1Ki8v14033qhVq1YpEAgYqti8kSNHasKECRozZox69+7d6GN2796tBx98UPPmzZMkzZ07VxMmTNBPf/pTN0v1FHrNGT/lFovFtG/fPuXk5CgY5LTtfuOnXoMzXhmj9Frq80Kv8X4NbmJeS31emNckes2JNp1ZAo7ATShOL2CPVw4b9xOvZLZs2TJr1qxZViQSafaxf/nLXxocdr9w4UIXKmzIK7nZEYvFrNGjR8dzGzt2rKu/3yuZ0WvO+C03yzr6367eeustTi/QQvSafV7JzK9Mj1F6re0w3Wt28H7Nn7ySG/Na22F6XqPX7PNTZpaVnNMLcBgMYMiIESN06623KhQKNfvYa6+9VkOGDInfnz9/fjJLSxmBQEC33XZb/P769esNVmMOveYMucEt9BrcQq/Bi3i/htZgXoNb6DX7yExi0RXwieHDh8dvf/XVV+YK8ZnOnTvHb1dXVxusxD/oNWfIDW6h1+AWeg1u4f0a3MK8BrfQa/alYmYsugI+ceL5TKLRqMFK/OWzzz6L3z733HPNFeIj9JozXsgtEAgoIyMjNc5/hNPyQq/BGb+NUXrNv/zWa7xfg1uY1/zLb/MavWZfKmbGhbQAn9i0aVP8do8ePQxW4h/l5eX6/e9/H7/PRRlahl5zxgu5hcNhjR492sjvhnu80Gtwxm9jlF7zLz/1Gu/X4CbmNf/y07wm0WtOpGJmHOkK+EBZWZmWLFkSvz927FiD1XhbbW2tPvvsMz399NMaNGiQysvLJUn9+vXTI488Yrg676PXnPFKbrFYTDt37lQsFjPy+5F8Xuk1OOOnMUqv+ZvXe433azCBec3fvD6vnYhesy9VM+NIV8AHHnroofjh9fn5+ZowYYLhirxj5cqV+slPftLkY4qLi/Xyyy8rIyPDpar8i15zxiu5RaNRbdiwQd26dVMwyN9VU5FXeg3O+GmM0mv+5rVe4/0avIB5zd+8Nq81hV6zL1Uz83anAtCcOXP05z//OX5/xowZSktLM1iRf2RnZ2vevHmaP3++zjrrLNPleB695gy5wS30GtxCr8FNvF+DG5jX4BZ6zb5UzowjXQEPW7t2re666674/cmTJ2vKlCkGK/Kebt26adq0aZIky7JUXV2t0tJSrVu3TgcOHNDkyZP1wgsvaObMmerTp4/har2LXnOG3OAWeg1uodeQDLxfg0nMa3ALvWZfqmfGoivgUV9++aUmTJigw4cPS5IGDBigmTNnGq7Ke3r27KlnnnnmlO3l5eV67LHHNHv2bC1dulRDhw7VsmXLNGDAAANVehu95owXcwsEAurcubNvruqKlvFir8EZr49Rei11eK3XeL8GU5jXUofX5rWT0Wv2tYXMOL0A4EG7du3SZZddpu+++07S0TeqCxcuVGZmpuHK/KNbt26aNWuW7rvvPknSgQMHdMMNN8TPE4Oj6DVnvJpbOBzWsGHDFA7zN9VU4dVegzNeHqP0Wmrxcq+diPdrSCbmtdTi5XmNXrOvrWTGoivgMRUVFbrsssu0fft2SVJeXp4WL16svLw8w5X504wZM+IT9+eff653333XcEXeQa854+XcotGovvjiCz6spggv9xqc8eoYpddSj1d77XR4v4ZEY15LPV6d1+g1+9pSZiy6Ah5SVVWlcePGacuWLZKknJwcLV68WOedd57hyvyrY8eOGjZsWPz+Rx99ZLAa76DXnPF6brFYTKWlpYrFYqZLQSt5vdfgjBfHKL2WmrzYa03h/RoSiXktNXlxXqPX7GtrmbHoCnjEoUOHVFxcrE8//VSSlJWVpYULF+r88883XJn/ZWdnx29XVFQYrMQb6DVnyA1uodfgFnoNXsL7NSQC8xrcQq/Z1xYzY9EV8IDDhw9r4sSJ8b/qd+zYUfPnz9dFF11kuLLUsGvXrvjtTp06GazEPHrNGXKDW+g1uIVeg9fwfg2txbwGt9Br9rXVzFh0BQyrr6/XpEmTtGTJEklSWlqa3n77bQ0fPtxwZamhoqJCq1evjt/v16+fwWrMotec8VNuwWBQ+fn5CgbZvfuRn3oNznhljNJrqc8rvdZSvF9DazGvpT6vzGv0mn1tOTN/7IWBFBWNRjVlyhQtWLBA0tErMr7++usaO3as4cq8a//+/S1+bCwW0z333KO6ujpJRyf3q666KlmleRq95ozfcguFQho0aJBCoZDpUmCT33oNznhhjNJrbYPpXuP9GtzEvNY2mJ7XJHrNibaeGYuugCGWZemOO+7QG2+8IenoX+5eeuklTZw40XBl3jZ37lwNHjxYc+fOVVVV1Wkft3HjRhUXF+vVV1+Nb3v44Yd19tlnu1Gmp9Brzvgxt2g0qvXr13vuqq5omh97Dc6YHqP0Wtthutd4vwa3MK+1HabnNXrNPjKTwqYLANqq5557TnPmzInf79Wrl1auXKmVK1e26PufeeaZZJXmeWvXrtXUqVMVDodVWFiovn37Kjs7W4FAQBUVFdq4caO2bdvW4HsmTZqkJ554wlDFZtFrzvgxt1gsprKyMvXv35+jXX3Ej70GZ0yPUXqt7TDdaxLv1+AO5rW2w/S8Rq/ZR2YsugLG7Nmzp8H9rVu3auvWrS3+/lSYgJxIS0uL345EItq8ebM2b9582sdnZGRo+vTpuv/++9vsIhS95gy5wS30GtxCr8EtvF+DW5jX4BZ6zT4yY9EVgM/cfffdGjNmjBYvXqyPP/5YW7ZsUVlZmQ4ePChJyszMVF5engYOHKixY8dq0qRJSk9PN1s0AABAG8L7NQAApIBlWZbpIk5UVVWlrKwsSZUaOjRTJ1zEEo0oKpLWrGm4behQkVsTyMwZcrOPzJwhN+ei0ai2bt2qH/zgBxwp1AL0mn1k1jqM0Zaj11qHXms5es0ZcrOPzFqHea3l6DVnjudWJSlLlZWVyszMbNXP5EhXAABSRCgUUmFhoekyAJwGYxRuodcApBrmNfhR0HQBAAAgMSKRiFatWqVIJGK6FACNYIzCLfQagFTDvAY/YtEVAIAUYVmW9u7dK4+dOQjA3zBG4RZ6DUCqYV6DH7HoCgAAAAAAAAAJxKIrAAAAAAAAACQQi64AAKSIUCikgQMHckVXwKMYo3ALvQYg1TCvwY/CpgsAAACJEQwGVVBQYLoMAKfBGIVb6DUAqYZ5DX7Eka4AAKSISCSiJUuWcFVXwKMYo3ALvQYg1TCvwY9YdAUAIEVYlqXq6mqu6gp4FGMUbqHXAKQa5jX4EYuuAAAAAAAAAJBALLoCAAAAAAAAQAKx6AoAQIoIhUIqKiriqq6ARzFG4RZ6DUCqYV6DH4VNFwAAABIjGAwqNzfXdBkAToMxCrfQawBSDfMa/IgjXQEASBH19fWaP3++6uvrTZcCoBGMUbiFXgOQapjX4EcsugIAkEIikYjpEgA0gTEKt9BrAFIN8xr8hkVXAAAAAAAAAEggFl0BAAAAAAAAIIFYdAUAIEWEw2GNGjVK4TDXyQS8iDEKt9BrAFIN8xr8iEVXAABSSIcOHUyXAKAJjFG4hV4DkGqY1+A3LLoCAJAiIpGIFixYwEUGAI9ijMIt9BqAVMO8Bj9i0RUAAAAAAAAAEohFVwAAAAAAAABIIBZdAQAAAAAAACCBWHQFACBFhMNhFRcXc1VXwKMYo3ALvQYg1TCvwY8Svui6YsUKTZgwQd26dVMgENBbb72V6F8BAABO4/vvvzddAoAmMEbhFnoNQKphXoPfJPxPBIcOHdKFF16o22+/Xdddd12rftaOHQkqKoU1lhG5NY3MnCE3+8jMmcYy2rxZKipyvxa/2LFDqq09ejsS6ahwWOreXfriC7N1eR1j1D7GpzONjdGOHaWePc3W5WWbN5+6jfHZvMJC6dtvj96m11qGXnOGfah97EOd4X2ufYxPZ5KRUcIXXa+88kpdeeWVCflZxwYWTq+xjMitaWTmDLnZR2bONJZRTY20Zo37tfhPQMd27cc+dOP0GKP2MT5b6/gYramR9uwxW43fMD6b9+23R3uLXmsdeq157EPtYx/aWrzPbSnGpzPJyMj4yTDq6upUV1cXv19VVXXCVy3V10cUDAYVCoUUjUYVi8XiXz22PRKJyLKs+PZQKKRgMHja7fX19Q1qOHZOkEgk0qLt7dq1UywWUzQajW8LBAIKh8On3X662lv7nI6+hAE1ZOnYQ/z4nJL9OjXe9pakgG+fkxuv07GMTubn55Ts1+loXqeOz/r644/323Ny53VqbF6DfUd7LVXGUzJ673T70FjM8u1zSvbrxPiEWQ33oZK/x1Ny5gjGaGIc77VUnMsT8ZxOtw+NRmO+fU5mPrvDqVQaT3x298rrlPgxanzRdcaMGXryyScb/VokEtWCBQuUn5+vQYMGaePGjSorK4t/vW/fviosLFRJSYn27t0b3z5w4EAVFBRoxYoVqq6ujm8vKipSbm6u3n///QZBjxo1Sh06dNCCBQsa/P7i4mJ9//33Wrp0aXxbOBzW+PHjtW/fPq1evTq+PSMjQ6NHj9bXX3+tDRs2xLd37txZw4YN09atW1VaWhrfnqjnZFkTdHJTRCJRVVfX+vY5Jft1kkbrZNFoTFLIt8/Jjdfp+CTUkJ+fU7Jfp0ik0ymZxWJWg5/jt+fkxusUiYw/JTfYd2wfmirjKRm9F4s1vg/9+utvffuckv06SRMFmGJZatCTfh9PyZgj2IcmxrF9qJSac3kinlM0epWk0Cm5bdy4ybfPycRndziXSuOJz+7eeJ2SsQ8NWA3/9JLYHx4I6M0339Q111xz2sc0dqRrjx49JFUqPT1D+/dzpGtTz6lTp7BqahpO3Onplo4dMOzH55Ts1yk7O/y3/3Z1XHq6pepqjnRt6jllZFiN9Jq0f79/n1OyX6esrECj43P/fo50beo5NTavwb5jvZYq4ykZvXe6fWhlJUe6nq52xidMOnkfKvl7PCVjjmCMJsaJvZaKc3kintPp9qEHD3Kkq53P7nAmPV06eDB1xhOf3b3xOh0fo1WSslRZWanMzEy1hvFF15NVVVUpKytLUqVyczO1e3eyqksNXbqceo6m3FyRWxPIzBlys4/MnDl+ERBLlmUpEAioY8cAFwFpwubNOuWPSfRa8xij9jE+nTl+ERBya6nGMuvePcCFU5rR2LyWni7172+mHj+g15xhH2of+1BneJ9rH+PTmeO5JW7R1dP/94TJp3k9e546mMitaWTmDLnZR2bOHPuQU18f0YIFC1RcXKx27dqZLcrjiopOvQgDvdY8xqh9jM/WITf7yMyexua1/v2lE/4nKE6DXrOHfah97EOd4X2ufYxPZxrLrbUSvuhaU1Ojbdu2xe9/+eWX2rBhgzp16qT8/PxE/zoAAAAAAAAA8JSEL7quXbtWo0aNit9/6KGHJElTp07V7NmzE/3rAAAAAAAAAMBTEr7oOnLkSCXxNLEAgDYiEAgoIyNDgQAXHAC8hvHpDLnZR2ZwC70Gt9BrQNvh6XO6AgDarnA4rNGjR5suA0AjGJ/OkJt9ZAa30GtwC70GtB1B0wUAANCYWCymnTt3KhaLmS4FwEkYn86Qm31kBrfQa3ALvQa0HSy6AgA8KRqNasOGDYpGo6ZLAXASxqcz5GYfmcEt9BrcQq8BbQeLrgAAAAAAAACQQCy6AgAAAAAAAEACsegKAPCkQCCgzp07c2VXwIMYn86Qm31kBrfQa3ALvQa0HWHTBQAA0JhwOKxhw4aZLgNAIxifzpCbfWQGt9BrcAu9BrQdHOkKAPCkaDSqL774gosMAB7E+HSG3OwjM7iFXoNb6DWg7WDRFQDgSbFYTKWlpYrFYqZLAXASxqcz5GYfmcEt9BrcQq8BbQeLrgAAAAAAAACQQCy6AgAAAAAAAEACsegKAPCkYDCo/Px8BYPsqgCvYXw6Q272kRncQq/BLfQa0HaETRcAAEBjQqGQBg0aZLoMAI1gfDpDbvaRGdxCr8Et9BrQdvCnFQCAJ0WjUa1fv54ruwIexPh0htzsIzO4hV6DW+g1oO1g0RUA4EmxWExlZWVc2RXwIManM+RmH5nBLfQa3EKvAW0Hi64AAAAAAAAAkEAsugIAAAAAAABAAnEhLSTUV199pUWLFmn58uXatGmTysrKVFNTo4yMDJ1zzjkqKirSlClTNGLECNOlesK+ffv00UcfqaSkRJs2bdL27dtVXl6umpoatWvXTtnZ2erfv79GjhypW265Rd27dzddsmfQa6kvGAyqb9++XNnVhxifzvgpN8anM+RmH5nBLfSav7EPtYfPoYBLLI+prKy0JFlSpTV0qOlqvG/oUMuSGv4zkdu6deusIUOG/O21a/7fyJEjrZ07d7pfqOWdzCzLssaPH9/izNLS0qzp06db0WjUSK1eyY1eA07llV7z0/i0LHIDkHq8Mq8h9Xml19iHOsPn0NRGZs4cz+3oumRlZWWrfyZHuiIhSktLVVJS0mBbnz591L9/f+Xk5OjgwYNatWqVvvnmG0nSsmXLVFRUpA8//FA9e/Y0UbLn5OTkqF+/fiooKFB6erpqa2u1bds2lZSUKBKJqK6uTtOnT9eOHTs0Z84c0+UaQ6+1HZFIRCUlJRoyZIjCYXZXfsD4dMaPuTE+nSE3+8gMbqHX/Il9aOvxORRIHvMjHCmld+/euvPOO3XTTTed8l8QYrGYZs+erXvvvVe1tbUqLy/XjTfeqFWrVikQCBiq2KyRI0dqwoQJGjNmjHr37t3oY3bv3q0HH3xQ8+bNkyTNnTtXEyZM0E9/+lM3S/Ucei31WZalvXv3yrIs06XAJsanM37KjfHpDLnZR2ZwC73mb+xD7eFzKOAOFl2REHl5eZo1a5ZuvvlmhUKhRh8TDAZ1++23Kzs7W9ddd50kac2aNXr//fc1btw4N8v1jF/84hfNPqZLly56+eWXtXv3bi1ZskSS9Pzzz7fZnR29BngX49MZcgMAwBn2oc7wORRwB2cJR0KMGDFCt95662l3dCe69tprNWTIkPj9+fPnJ7O0lBAIBHTbbbfF769fv95gNWbRa4B3MT6dITcAAJxhH5pcfA4FWodFVxgxfPjw+O2vvvrKXCE+0rlz5/jt6upqg5X4C73mX6FQSAMHDmzRm2j4E+PTGS/kxvh0htzsIzO4hV5rG9iH2sfnUMA5Ti8AI048d040GjVYiX989tln8dvnnnuuuUJ8hl7zr2AwqIKCAtNlIIkYn854ITfGpzPkZh+ZwS30WtvAPtQ+PocCznGkK4zYtGlT/HaPHj0MVuIP5eXl+v3vfx+/z3l0Wo5e869IJKIlS5YoEomYLgVJwvh0xgu5MT6dITf7yAxuodfaBvah9vA5FGgdFl3hurKysviJuCVp7NixBqvxrtraWn322Wd6+umnNWjQIJWXl0uS+vXrp0ceecRwdf5Ar/mbZVmqrq7mKsIpivHpjFdyY3w6Q272kRncQq+lPvahLcPnUCBxOL0AXPfQQw/F/ytHfn6+JkyYYLgib1i5cqV+8pOfNPmY4uJivfzyy8rIyHCpKn+j1wDvYnw6Q24AADjDPrRxfA4FkocjXeGqOXPm6M9//nP8/owZM5SWlmawIn/Izs7WvHnzNH/+fJ111lmmy/EFeg3wLsanM+QGAIAz7EOd4XMo0Doc6QrXrF27VnfddVf8/uTJkzVlyhSDFXlLt27dNG3aNEnH/8tJaWmp1q1bpwMHDmjy5Ml64YUXNHPmTPXp08dwtd5Gr6WGUCikoqIi31zZFS3D+HTGa7kxPp0hN/vIDG6h11IX+9Cm8TkUSB4WXeGKL7/8UhMmTNDhw4clSQMGDNDMmTMNV+UtPXv21DPPPHPK9vLycj322GOaPXu2li5dqqFDh2rZsmUaMGCAgSq9j15LHcFgULm5uabLQAIxPp3xYm6MT2fIzT4yg1votdTEPrR5fA4FkofTCyDpdu3apcsuu0zfffedpKOT+sKFC5WZmWm4Mn/o1q2bZs2apfvuu0+SdODAAd1www3x8xHhOHottdTX12v+/Pmqr683XQoSgPHpjFdzY3w6Q272kRncQq+lHvahrcPnUKD1WHRFUlVUVOiyyy7T9u3bJUl5eXlavHix8vLyDFfmPzNmzIi/Qfj888/17rvvGq7IW+i11BSJREyXgARgfDrj9dwYn86Qm31kBrfQa6mDfWji8DkUcI5FVyRNVVWVxo0bpy1btkiScnJytHjxYp133nmGK/Onjh07atiwYfH7H330kcFqvIVeA7yL8ekMuQEA4Az70MTicyjgHIuuSIpDhw6puLhYn376qSQpKytLCxcu1Pnnn2+4Mn/Lzs6O366oqDBYiXfQa4B3MT6dITcAAJxhH5ocfA4FnGHRFQl3+PBhTZw4Mf4XsI4dO2r+/Pm66KKLDFfmf7t27Yrf7tSpk8FKvIFeS23hcFijRo1SOMw1H/2I8emMX3JjfDpDbvaRGdxCr/kf+9Dk4XMo4AyLrkio+vp6TZo0SUuWLJEkpaWl6e2339bw4cMNV+Z/FRUVWr16dfx+v379DFZjHr3WNnTo0MF0CXCA8emM33JjfDpDbvaRGdxCr/kX+9Dk4XMo4ByLrkiYaDSqKVOmaMGCBZKO/gXv9ddf19ixYw1X5k379+9v8WNjsZjuuece1dXVSTr6JuKqq65KVmmeR6+1DZFIRAsWLPDVhQbA+HTKb7kxPp0hN/vIDG6h1/yLfag9fA4F3MOiKxLCsizdcccdeuONNyRJwWBQL730kiZOnGi4Mu+aO3euBg8erLlz56qqquq0j9u4caOKi4v16quvxrc9/PDDOvvss90o03PoNcC7GJ/OkBsAAM6wD7WPz6GAe/xzEhF42nPPPac5c+bE7/fq1UsrV67UypUrW/T9zzzzTLJK87S1a9dq6tSpCofDKiwsVN++fZWdna1AIKCKigpt3LhR27Zta/A9kyZN0hNPPGGoYvPoNcC7GJ/OkBsAAM6wD3WGz6GAO1h0RULs2bOnwf2tW7dq69atLf7+trizS0tLi9+ORCLavHmzNm/efNrHZ2RkaPr06br//vsVCoXcKNGT6DXAuxifzpAbAADOsA+1j8+hgHtYdAUMufvuuzVmzBgtXrxYH3/8sbZs2aKysjIdPHhQkpSZmam8vDwNHDhQY8eO1aRJk5Senm62aMBF4XBYxcXFvrqyK9BWMD6dITf7yAxuodfgFtO9xudQwD3sUZAQ06dP1/Tp002X4Tt9+vRRnz599A//8A+mS/ENeq1t+f7775WRkWG6DLQQ49MZv+bG+HSG3OwjM7iFXvMf9qHO8DkUcAcX0gIAeFIkEtHSpUu5ijDgQYxPZ8jNPjKDW+g1uIVeA9oOFl0BAAAAAAAAIIFYdAUAAAAAAACABGLRFQDgWVzMAvAuxqcz5GYfmcEt9BrcQq8BbQMjHQDgSe3atdP48eNNlwGgEYxPZ8jNPjKDW+g1uIVeA9oOjnQFAHhSLBbTnj17FIvFTJcC4CSMT2fIzT4yg1voNbiFXgPaDhZdAQCeFI1GtXr1akWjUdOlADgJ49MZcrOPzOAWeg1uodeAtoNFVwAAAAAAAABIIBZdAQAAAAAAACCBWHQFAHhSIBBQRkaGAoGA6VIAnITx6Qy52UdmcAu9BrfQa0DbETZdAAAAjQmHwxo9erTpMgA0gvHpDLnZR2ZwC70Gt9BrQNvBka4AAE+KxWLauXMnV3YFPIjx6Qy52UdmcAu9BrfQa0DbwaIrAMCTotGoNmzYwJVdAQ9ifDpDbvaRGdxCr8Et9BrQdrDoCgAAAAAAAAAJxKIrAAAAAAAAACQQi64AAE8KBALq3LkzV3YFPIjx6Qy52UdmcAu9BrfQa0DbETZdAAAAjQmHwxo2bJjpMgA0gvHpDLnZR2ZwC70Gt9BrQNvBka4AAE+KRqP64osvuMgA4EGMT2fIzT4yg1voNbiFXgPaDhZdAQCeFIvFVFpaqlgsZroUACdhfDpDbvaRGdxCr8Et9BrQdrDoCgAAAAAAAAAJxKIrAAAAAAAAACQQi64AAE8KBoPKz89XMMiuCvAaxqcz5GYfmcEt9BrcQq8BbUfYdAEAADQmFApp0KBBpssA0AjGpzPkZh+ZwS30GtxCrwFtR9L+tPLss8/q3HPP1RlnnKFLLrlEJSUlyfpVAIAUFI1GtX79eq7sCngQ49MZcrOPzOAWeg1uodeAtiMpR7q+9tpreuihhzRz5kxdcskl+uMf/6hx48aptLRUubm5Lf45mzdLRUXJqDB1bN586rYdO9yvw08ay4deax69Zh+95syOHVJtrSQFFYlcoHA4qI4dpZ49TVfmXYxPZxij9jE+nSE3+8jMGfYHzsViMZWVlal///4KhUKmy/E89qH2Ma85w7xmH+PTmcZ6rbUClmVZif6hl1xyiQYPHqxnnnlG0tEdWI8ePXTvvffqkUceafJ7q6qqlJWVJalSUmaiS2sT0tOl6mrTVXhXRoZUU2O6itRArzWNXoNJjM/mMUYBtAXsD1qmvr5eCxYsUHFxsdq1a2e6HM9jHwqTmNeaxvhsrSpJWaqsrFRmZuvWJRN+pOuRI0f06aef6tFHH41vCwaDGjt2rFavXn3K4+vq6lRXVxe/X1lZ+bdbVYkurc2wLEvHYoxEIg2+Fg6HG93erl07xWKxBv/FIRAIKBwOn3Z7NBpVLBaLbw8GgwqFQqfdHolEdOIafygUUjAYPO32+vr6FtVu9zlZFqcyThTLkioqkvM6pULvWVZAUkCACZZlqaIikjLjKRlzxNH9AWMUQGo7tj+QUnMuT9RzsixLtbW1qqioaLDo6ufnlMzXiX0oTLIs6cCB1BlPiZ4jjm5jfDp3dD0yEceoJnz1ad++fYpGo+rSpUuD7V26dNEXX3xxyuNnzJihJ598spGf1CPRpbUZhw5JZ51lugq0BYcOSTk5pqsA0BjGJwBAYn8AIPUcOiR16mS6CqS6ioqKv/1PfOeMH/L36KOP6qGHHorfP3jwoAoKClRWVtbqJ9eWVFVVqUePHvr6669bffhzW0FmzpCbfWTmDLnZR2bOkJt9ZOYMudlHZs6Qm31k5gy52UdmzpCbfWTmTGVlpfLz89UpASv7CV90zcnJUSgU0u7duxts3717t7p27XrK49PS0pSWlnbK9qysLJrCgczMTHKzicycITf7yMwZcrOPzJwhN/vIzBlys4/MnCE3+8jMGXKzj8ycITf7yMyZYDDY+p+RgDoaaN++vS666CJ98MEH8W2xWEwffPCBirhUGgAAAAAAAIAUl5TTCzz00EOaOnWqLr74Yg0ZMkR//OMfdejQId12223J+HUAAAAAAAAA4BlJWXS9/vrrtXfvXv3qV7/Sd999p4EDB2rhwoWnXFyrMWlpaXriiScaPeUATo/c7CMzZ8jNPjJzhtzsIzNnyM0+MnOG3OwjM2fIzT4yc4bc7CMzZ8jNPjJzJpG5BSzLshJQEwAAAAAAAABASTinKwAAAAAAAAC0ZSy6AgAAAAAAAEACsegKAAAAAAAAAAnEoisAAAAAAAAAJJDnFl2fffZZnXvuuTrjjDN0ySWXqKSkxHRJnrZixQpNmDBB3bp1UyAQ0FtvvWW6JM+bMWOGBg8erIyMDOXm5uqaa65RaWmp6bI877nnntOAAQOUmZmpzMxMFRUV6d133zVdlq/85je/USAQ0AMPPGC6FE+bPn26AoFAg3+FhYWmy/K8b7/9VjfddJPOPvtsdejQQRdccIHWrl1ruixPO/fcc0/ptUAgoGnTppkuzbOi0agef/xxnXfeeerQoYN69eqlf/zHfxTXZW1adXW1HnjgARUUFKhDhw4aNmyYPvnkE9NleUpz72kty9KvfvUr5eXlqUOHDho7dqy2bt1qplgPaS63v/zlL7r88st19tlnKxAIaMOGDUbq9JKmMquvr9cvf/lLXXDBBTrzzDPVrVs33XLLLSovLzdXsEc012vTp09XYWGhzjzzTGVnZ2vs2LH6+OOPzRTrEXY+q991110KBAL64x//6Fp9XtVcbrfeeusp792uuOIKM8V6REt67fPPP9fEiROVlZWlM888U4MHD1ZZWZn7xXpIc7k19jkhEAjod7/7XYt/h6cWXV977TU99NBDeuKJJ7Ru3TpdeOGFGjdunPbs2WO6NM86dOiQLrzwQj377LOmS/GN5cuXa9q0aVqzZo0WLVqk+vp6XX755Tp06JDp0jztnHPO0W9+8xt9+umnWrt2rUaPHq2rr75aW7ZsMV2aL3zyySd6/vnnNWDAANOl+MIPf/hD7dq1K/5v5cqVpkvytAMHDmj48OFq166d3n33XX322Wd6+umnlZ2dbbo0T/vkk08a9NmiRYskST/72c8MV+ZdTz31lJ577jk988wz+vzzz/XUU0/pt7/9rf7lX/7FdGmeduedd2rRokV66aWXtGnTJl1++eUaO3asvv32W9OleUZz72l/+9vf6p//+Z81c+ZMffzxxzrzzDM1btw4HT582OVKvaW53A4dOqQf//jHeuqpp1yuzLuayqy2tlbr1q3T448/rnXr1ukvf/mLSktLNXHiRAOVektzvdanTx8988wz2rRpk1auXKlzzz1Xl19+ufbu3etypd7R0s/qb775ptasWaNu3bq5VJm3tSS3K664osF7uHnz5rlYofc0l9n27dv14x//WIWFhVq2bJk2btyoxx9/XGeccYbLlXpLc7md2GO7du3Sv//7vysQCGjSpEkt/yWWhwwZMsSaNm1a/H40GrW6detmzZgxw2BV/iHJevPNN02X4Tt79uyxJFnLly83XYrvZGdnW//2b/9mugzPq66utn7wgx9YixYtskaMGGHdf//9pkvytCeeeMK68MILTZfhK7/85S+tH//4x6bL8L3777/f6tWrlxWLxUyX4lnjx4+3br/99gbbrrvuOuvGG280VJH31dbWWqFQyHrnnXcabP/Rj35kPfbYY4aq8raT39PGYjGra9eu1u9+97v4toMHD1ppaWnWvHnzDFToTU19Fvjyyy8tSdb69etdrcnrWvL5qaSkxJJk7dy5052ifKAluVVWVlqSrMWLF7tTlMedLrNvvvnG6t69u7V582aroKDA+sMf/uB6bV7WWG5Tp061rr76aiP1+EFjmV1//fXWTTfdZKYgn2jJvHb11Vdbo0ePtvVzPXOk65EjR/Tpp59q7Nix8W3BYFBjx47V6tWrDVaGVFdZWSlJ6tSpk+FK/CMajerVV1/VoUOHVFRUZLocz5s2bZrGjx/fYH5D07Zu3apu3bqpZ8+euvHGG9v8f31pzv/7f/9PF198sX72s58pNzdXgwYN0r/+67+aLstXjhw5ov/4j//Q7bffrkAgYLoczxo2bJg++OAD/fd//7ck6b/+67+0cuVKXXnllYYr865IJKJoNHrK0SQdOnTgKP4W+vLLL/Xdd9812I9mZWXpkksu4XMCkq6yslKBQEBnnXWW6VJ848iRI3rhhReUlZWlCy+80HQ5nhWLxXTzzTfr4Ycf1g9/+EPT5fjKsmXLlJubq759++ruu+9WRUWF6ZI8KxaLaf78+erTp4/GjRun3NxcXXLJJZya0qbdu3dr/vz5uuOOO2x9n2cWXfft26doNKouXbo02N6lSxd99913hqpCqovFYnrggQc0fPhw9e/f33Q5nrdp0yalp6crLS1Nd911l958802df/75psvytFdffVXr1q3TjBkzTJfiG5dccolmz56thQsX6rnnntOXX36pn/zkJ6qurjZdmmft2LFDzz33nH7wgx/ovffe091336377rtPc+bMMV2ab7z11ls6ePCgbr31VtOleNojjzyiG264QYWFhWrXrp0GDRqkBx54QDfeeKPp0jwrIyNDRUVF+sd//EeVl5crGo3qP/7jP7R69Wrt2rXLdHm+cOyzAJ8T4LbDhw/rl7/8pSZPnqzMzEzT5XjeO++8o/T0dJ1xxhn6wx/+oEWLFiknJ8d0WZ711FNPKRwO67777jNdiq9cccUVmjt3rj744AM99dRTWr58ua688kpFo1HTpXnSnj17VFNTo9/85je64oor9P777+vaa6/Vddddp+XLl5suzzfmzJmjjIwMXXfddba+L5ykegBfmDZtmjZv3syRJi3Ut29fbdiwQZWVlXrjjTc0depULV++nIXX0/j66691//33a9GiRW3+fDl2nHjE3IABA3TJJZeooKBAr7/+uu2/LLYVsVhMF198sX79619LkgYNGqTNmzdr5syZmjp1quHq/OHFF1/UlVdeyfnUmvH666/r5Zdf1iuvvKIf/vCH2rBhgx544AF169aNXmvCSy+9pNtvv13du3dXKBTSj370I02ePFmffvqp6dIAnEZ9fb1+/vOfy7IsPffcc6bL8YVRo0Zpw4YN2rdvn/71X/9VP//5z/Xxxx8rNzfXdGme8+mnn+pPf/qT1q1bx/+wsemGG26I377gggs0YMAA9erVS8uWLdOYMWMMVuZNsVhMknT11VfrwQcflCQNHDhQq1at0syZMzVixAiT5fnGv//7v+vGG2+0/bneM0e65uTkKBQKaffu3Q227969W127djVUFVLZPffco3feeUdLly7VOeecY7ocX2jfvr169+6tiy66SDNmzNCFF16oP/3pT6bL8qxPP/1Ue/bs0Y9+9COFw2GFw2EtX75c//zP/6xwOMxfY1vorLPOUp8+fbRt2zbTpXhWXl7eKX/86NevH6dlaKGdO3dq8eLFuvPOO02X4nkPP/xw/GjXCy64QDfffLMefPBBjuZvRq9evbR8+XLV1NTo66+/VklJierr69WzZ0/TpfnCsc8CfE6AW44tuO7cuVOLFi3iKNcWOvPMM9W7d28NHTpUL774osLhsF588UXTZXnShx9+qD179ig/Pz/+OWHnzp36H//jf+jcc881XZ6v9OzZUzk5OXxWOI2cnByFw2E+K7TChx9+qNLSUkefFTyz6Nq+fXtddNFF+uCDD+LbYrGYPvjgA84ZiYSyLEv33HOP3nzzTS1ZskTnnXee6ZJ8KxaLqa6uznQZnjVmzBht2rRJGzZsiP+7+OKLdeONN2rDhg0KhUKmS/SFmpoabd++XXl5eaZL8azhw4ertLS0wbb//u//VkFBgaGK/GXWrFnKzc3V+PHjTZfiebW1tQoGG759DIVC8aMo0LQzzzxTeXl5OnDggN577z1dffXVpkvyhfPOO09du3Zt8DmhqqpKH3/8MZ8TkHDHFly3bt2qxYsX6+yzzzZdkm/xWeH0br75Zm3cuLHB54Ru3brp4Ycf1nvvvWe6PF/55ptvVFFRwWeF02jfvr0GDx7MZ4VWePHFF3XRRRc5Oke1p04v8NBDD2nq1Km6+OKLNWTIEP3xj3/UoUOHdNttt5kuzbNqamoa/EXnyy+/1IYNG9SpUyfl5+cbrMy7pk2bpldeeUVvv/22MjIy4ucCy8rKUocOHQxX512PPvqorrzySuXn56u6ulqvvPKKli1bxpuCJmRkZJxyruAzzzxTZ599NucQbsIvfvELTZgwQQUFBSovL9cTTzyhUCikyZMnmy7Nsx588EENGzZMv/71r/Xzn/9cJSUleuGFF/TCCy+YLs3zYrGYZs2apalTpyoc9tTbIk+aMGGC/umf/kn5+fn64Q9/qPXr1+v//t//q9tvv910aZ723nvvybIs9e3bV9u2bdPDDz+swsJC3uOeoLn3tA888ID+z//5P/rBD36g8847T48//ri6deuma665xlzRHtBcbvv371dZWZnKy8slKf6hu2vXrm32KOGmMsvLy9NPf/pTrVu3Tu+8846i0Wj8s0KnTp3Uvn17U2Ub11RuZ599tv7pn/5JEydOVF5envbt26dnn31W3377rX72s58ZrNqs5sbnyQv67dq1U9euXdW3b1+3S/WUpnLr1KmTnnzySU2aNEldu3bV9u3b9T//5/9U7969NW7cOINVm9Vcrz388MO6/vrrdemll2rUqFFauHCh/vrXv2rZsmXmivaAlqynVVVV6T//8z/19NNPO/sllsf8y7/8i5Wfn2+1b9/eGjJkiLVmzRrTJXna0qVLLUmn/Js6darp0jyrsbwkWbNmzTJdmqfdfvvtVkFBgdW+fXurc+fO1pgxY6z333/fdFm+M2LECOv+++83XYanXX/99VZeXp7Vvn17q3v37tb1119vbdu2zXRZnvfXv/7V6t+/v5WWlmYVFhZaL7zwgumSfOG9996zJFmlpaWmS/GFqqoq6/7777fy8/OtM844w+rZs6f12GOPWXV1daZL87TXXnvN6tmzp9W+fXura9eu1rRp06yDBw+aLstTmntPG4vFrMcff9zq0qWLlZaWZo0ZM4ZxazWf26xZsxr9+hNPPGG0bpOayuzLL7887WeFpUuXmi7dqKZy+/77761rr73W6tatm9W+fXsrLy/PmjhxolVSUmK6bKPsflYvKCiw/vCHP7haoxc1lVttba11+eWXW507d7batWtnFRQUWH/3d39nfffdd6bLNqolvfbiiy9avXv3ts444wzrwgsvtN566y1zBXtES3J7/vnnrQ4dOjh+3xawLMtytlwLAAAAAAAAADiZZ87pCgAAAAAAAACpgEVXAAAAAAAAAEggFl0BAAAAAAAAIIFYdAUAAAAAAACABGLRFQAAAAAAAAASiEVXAAAAAAAAAEggFl0BAAAAAAAAIIFYdAUAAAAAAACABGLRFQAAAAAAAAASiEVXAAAAAAAAAEggFl0BAAAAAAAAIIFYdAUAAAAAAACABPr/9+llssEPsQcAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1700x1700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def Node2Corners(m, n, i, j):\n",
    "    upperLeft = (n + 1) * i + j\n",
    "    return [\n",
    "        (upperLeft, upperLeft + 1),\n",
    "        (upperLeft + 1, upperLeft + n + 2),\n",
    "        (upperLeft + n + 2, upperLeft + n + 1),\n",
    "        (upperLeft + n + 1, upperLeft),\n",
    "        (upperLeft + 1, upperLeft),\n",
    "        (upperLeft + n + 2, upperLeft + 1),\n",
    "        (upperLeft + n + 1, upperLeft + n + 2),\n",
    "        (upperLeft, upperLeft + n + 1)\n",
    "    ]\n",
    "\n",
    "def SlitherlinkwithLazyCuts(m, n, grids) :\n",
    "    \"\"\"_summary_\n",
    "\n",
    "    Args:\n",
    "        m (_type_): 行数\n",
    "        n (_type_): 列数\n",
    "    \"\"\"\n",
    "    \n",
    "    Slitherlink = grb.Model(\"SlitherLink\")\n",
    "    x = {}\n",
    "    nodes_num = (m + 1) * (n + 1)\n",
    "    to_dict = {}\n",
    "    \n",
    "    # 按照下标对节点进行表示\n",
    "    # 节点的数量\n",
    "    for i in range(m + 1):\n",
    "        for j in range(n + 1):\n",
    "            to_dict[i * (n + 1) + j] = []\n",
    "            if j + 1 <= n:\n",
    "                x[i * (n + 1) + j, i * (n + 1) + j + 1] = Slitherlink.addVar(\n",
    "                    vtype=grb.GRB.BINARY,\n",
    "                    obj = 1,\n",
    "                    name = f\"x[{i * (n + 1) + j},{i * (n + 1) + j + 1}]\"\n",
    "                )\n",
    "                x[i * (n + 1) + j + 1, i * (n + 1) + j] = Slitherlink.addVar(\n",
    "                    vtype=grb.GRB.BINARY,\n",
    "                    obj = 1,\n",
    "                    name = f\"x[{i * (n + 1) + j + 1},{i * (n + 1) + j}]\"\n",
    "                )\n",
    "            if i < m:\n",
    "                x[i * (n + 1) + j, (i + 1) * (n + 1) + j] = Slitherlink.addVar(\n",
    "                    vtype=grb.GRB.BINARY,\n",
    "                    obj = 1,\n",
    "                    name = f\"x[{i * (n + 1)},{(i + 1) * (n + 1)}]\"\n",
    "                )\n",
    "                x[(i + 1) * (n + 1) + j, i * (n + 1) + j] = Slitherlink.addVar(\n",
    "                    vtype=grb.GRB.BINARY,\n",
    "                    obj = 1,\n",
    "                    name = f\"x[{(i + 1) * (n + 1)}, {i * (n + 1)}]\"\n",
    "                )\n",
    "            if i > 0:\n",
    "                to_dict[i * (n + 1) + j].append((i - 1) * (n + 1) + j)\n",
    "            if i < m:\n",
    "                to_dict[i * (n + 1) + j].append((i + 1) * (n + 1) + j)\n",
    "            if j > 0:\n",
    "                to_dict[i * (n + 1) + j].append(i * (n + 1) + j - 1)\n",
    "            if j < n:\n",
    "                to_dict[i * (n + 1) + j].append(i * (n + 1) + j + 1)\n",
    "    \n",
    "    print(f\"All lines (After double) {len(x)}\")\n",
    "    Slitherlink.modelSense = grb.GRB.MINIMIZE\n",
    "    Slitherlink.Params.lazyConstraints = 1\n",
    "    Slitherlink.update()\n",
    "    \n",
    "    for i in range(nodes_num):\n",
    "        # 流平衡约束（由于并不一定要访问所有的节点，所以这里不需要强制为1，相较于TSP要做一个松弛）\n",
    "        Slitherlink.addConstr(grb.quicksum(x[i, j] for j in to_dict[i]) == grb.quicksum(x[j, i] for j in to_dict[i]), name = f\"Balance_Node_{i}\")\n",
    "        Slitherlink.addConstr(grb.quicksum(x[i, j] for j in to_dict[i]) <= 1, name = f\"Balance_Node_{i}_not_greater_than1\")\n",
    "        for target in to_dict[i]:\n",
    "            if target > i:\n",
    "                Slitherlink.addConstr(x[i, target] + x[target, i] <= 1, name = f\"ChooseOne{i}_{target}\")\n",
    "    \n",
    "    for i in range(len(grids)):\n",
    "        for j in range(len(grids[0])):\n",
    "            if grids[i][j] >= 0 and grids[i][j] < 4:\n",
    "                Slitherlink.addConstr(grb.quicksum(x[xx, yy] for (xx, yy) in Node2Corners(m, n, i, j)) == grids[i][j], name = f\"#ofnode_{i}_{j}\")\n",
    "    \n",
    "    def subtourelim(model, where):\n",
    "        # 回调函数\n",
    "        if (where == grb.GRB.Callback.MIPSOL):\n",
    "            x_sol = model.cbGetSolution(model._x)\n",
    "            # 从新的 MIP 解决方案中检索值。\n",
    "            G = nx.Graph()\n",
    "            nodes_appear = []\n",
    "            for (i, j) in x.keys():\n",
    "                if (x_sol[i, j] > 0.9):\n",
    "                    if i not in nodes_appear:\n",
    "                        nodes_appear.append(i)\n",
    "                    if j not in nodes_appear:\n",
    "                        nodes_appear.append(j)\n",
    "                    G.add_edge(i, j, weight = 1)\n",
    "            components = [list(c) for c in nx.connected_components(G)]\n",
    "            # 获得当前图里所有的子环路\n",
    "            print(\"The length is \" + str(len(components)))\n",
    "            for component in components:\n",
    "                if (len(component) < len(nodes_appear)):\n",
    "                    # 消除那些环路\n",
    "                    print(f\"Add cut to eliminate Tour:{component}\")\n",
    "                    model.cbLazy(grb.quicksum(x[i,j] for i in component \\\n",
    "                        for j in component if j in to_dict[i]) <= len(component) - 1)\n",
    "                    \n",
    "    Slitherlink._x = x\n",
    "    Slitherlink.optimize(subtourelim)\n",
    "    # Slitherlink.optimize()\n",
    "    # Slitherlink.write(\"Slitherlink.lp\")\n",
    "\n",
    "    ofv = None\n",
    "    seq = []\n",
    "    arcs = []\n",
    "    solType = None\n",
    "    gap = None\n",
    "    lb = None\n",
    "    ub = None\n",
    "    runtime = None\n",
    "    if (Slitherlink.status == grb.GRB.status.OPTIMAL):\n",
    "        solType = 'IP_Optimal'\n",
    "        ofv = Slitherlink.getObjective().getValue()\n",
    "        print(ofv)\n",
    "        for i, j in x:\n",
    "            if (x[i, j].x > 0.5):\n",
    "                arcs.append([i, j])\n",
    "        gap = 0\n",
    "        lb = ofv\n",
    "        ub = ofv\n",
    "        runtime = Slitherlink.Runtime\n",
    "    elif (Slitherlink.status == grb.GRB.status.TIME_LIMIT):\n",
    "        solType = 'IP_TimeLimit'\n",
    "        ofv = None\n",
    "        seq = []\n",
    "        gap = Slitherlink.MIPGap\n",
    "        lb = Slitherlink.ObjBoundC\n",
    "        ub = Slitherlink.ObjVal\n",
    "        runtime = Slitherlink.Runtime\n",
    "\n",
    "    return {\n",
    "        \"TotalCost\": ofv,\n",
    "        \"runtime\": runtime,\n",
    "        \"arcs\": arcs\n",
    "    }\n",
    "    \n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    result = SlitherlinkwithLazyCuts(m, n, grids)\n",
    "    # print(result)\n",
    "    Vis(m, n, grids, result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "-----\n",
    "\n",
    "## Ortools solver (deprecated)\n",
    "\n",
    "- Not suitable for larger grid. Do not use them. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "# import pycosat\n",
    "import multiprocessing\n",
    "from ortools.sat.python import cp_model as cp\n",
    "\n",
    "\n",
    "class CheckGridFeasible(object):\n",
    "    def __init__(self, width, height ) -> None:\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "    \n",
    "    def get_corner_vertexes(self, vertex_id):\n",
    "        col = vertex_id % (self.width + 1)\n",
    "        row = vertex_id // (self.width + 1)\n",
    "        upper_edge = None\n",
    "        lower_edge = None\n",
    "        left_edge = None\n",
    "        right_edge = None\n",
    "        distance = self.width * (self.height + 1)\n",
    "        if row > 0:\n",
    "            upper_edge = distance + vertex_id - (self.width + 1)\n",
    "        if row < self.height:\n",
    "            lower_edge = distance + vertex_id\n",
    "        if col > 0:\n",
    "            left_edge = (self.width * row) + col - 1\n",
    "        if col < self.width:\n",
    "            right_edge = (self.width * row) + col\n",
    "        vertexes = [vertex for vertex in [upper_edge, lower_edge, left_edge, right_edge]\n",
    "                    if vertex is not None]\n",
    "        return vertexes\n",
    "\n",
    "    def get_adjacent_edges(self, edge_id):\n",
    "        num_vertexes = (self.width + 1) * (self.height + 1)\n",
    "        v1, v2 = [vertex_id for vertex_id in range(num_vertexes)\n",
    "                  if edge_id in self.get_corner_vertexes(vertex_id)]\n",
    "        edge1 = [edge for edge in self.get_corner_vertexes(v1)\n",
    "                 if edge != edge_id]\n",
    "        edge2 = [edge for edge in self.get_corner_vertexes(v2)\n",
    "                 if edge != edge_id]\n",
    "        return edge1 + edge2\n",
    "    \n",
    "    def is_one_loop(self, solution):\n",
    "        if solution is []:\n",
    "            return False\n",
    "        # print(\"UNDER CHECK\")\n",
    "        solution = [edge - 1 for edge in solution]\n",
    "        far_edges = solution[1:]\n",
    "        start = [solution[0]]\n",
    "        # Implement Fill Algorithm\n",
    "        while far_edges != []:\n",
    "            lines = [line for edge in start\n",
    "                     for line in self.get_adjacent_edges(edge)\n",
    "                     if line in far_edges]\n",
    "            if lines == [] and far_edges != []:\n",
    "                return False\n",
    "            far_edges = [edge for edge in far_edges if edge not in lines]\n",
    "            start = lines\n",
    "        \n",
    "        # self.model.solver().FinishCurrentSearch()\n",
    "        return True\n",
    "\n",
    "class VarArraySolutionCollector(cp.CpSolverSolutionCallback):\n",
    "    def __init__(self, variables, width, height, cells):\n",
    "        cp.CpSolverSolutionCallback.__init__(self)\n",
    "        self.__variables = variables\n",
    "        self.__solution_count = 0\n",
    "        self.solution_list = []\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        self.cells = cells\n",
    "        self.solution = []\n",
    "        \n",
    "        # self.model = model\n",
    "\n",
    "    def on_solution_callback(self):\n",
    "        self.__solution_count += 1\n",
    "        self.solution_list.append([self.Value(v) for v in self.__variables])\n",
    "        test_solution = [idx + 1 for idx, val in enumerate(self.__variables) if self.Value(val) == 1]\n",
    "        cgf = CheckGridFeasible(self.width, self.height)\n",
    "        if cgf.is_one_loop(test_solution):\n",
    "            # print(\"FOUND ONE\")\n",
    "            self.solution = test_solution\n",
    "            self.draw_solution()\n",
    "            # self.model.solver().Finish\n",
    "        else:\n",
    "            print(f\"# of Solution: {self.__solution_count}\")\n",
    "            \n",
    "    def draw_solution(self):\n",
    "        num_row = 4 * (self.height + 1) + 1\n",
    "        num_col = 4 * (self.width + 1) + 1\n",
    "        g = [[' ' for cols in range(num_col)] for rows in range(num_row)]\n",
    "\n",
    "        def horizontal_edge(edge):\n",
    "            col_f = edge % self.width\n",
    "            row_l = edge // self.width\n",
    "            y = 4 * row_l\n",
    "            x1 = 4 * col_f\n",
    "            x2 = 4 * (col_f + 1)\n",
    "            for x in range(x1, x2 + 1):\n",
    "                g[y][x] = '#'\n",
    "\n",
    "        def vertical_edge(edge):\n",
    "            row_f = edge // (self.width + 1)\n",
    "            col_l = edge % (self.width + 1)\n",
    "            y1 = 4 * row_f\n",
    "            y2 = 4 * (row_f + 1)\n",
    "            x = 4 * col_l\n",
    "            for y in range(y1, y2 + 1):\n",
    "                g[y][x] = '#'\n",
    "\n",
    "        def draw_numbers():\n",
    "            for row_index, row in enumerate(self.cells):\n",
    "                for col_index, val in enumerate(row):\n",
    "                    if val is not None:\n",
    "                        y = 4 * row_index + 2\n",
    "                        x = 4 * col_index + 2\n",
    "                        g[y][x] = str(val)\n",
    "\n",
    "        draw_numbers()\n",
    "        horizontal_limit = self.height * (self.width + 1)\n",
    "        horizontals = [e - 1\n",
    "                       for e in self.solution\n",
    "                       if e <= horizontal_limit]\n",
    "        verticals = [e - horizontal_limit - 1\n",
    "                     for e in self.solution\n",
    "                     if e > horizontal_limit]\n",
    "        for h_edge in horizontals:\n",
    "            horizontal_edge(edge=h_edge)\n",
    "        for v_edge in verticals:\n",
    "            vertical_edge(edge=v_edge)\n",
    "        gs = '\\n'.join([''.join(g_row) for g_row in g])\n",
    "        print(gs)\n",
    "\n",
    "class Slitherlink(object):\n",
    "\n",
    "    # Definition of some important variables\n",
    "    def __init__(self):\n",
    "        self.cells = None\n",
    "        self.width = None\n",
    "        self.height = None\n",
    "        self.cell_constraints = []\n",
    "        self.loop_constraints = []\n",
    "        # self.model = cp.CpModel()\n",
    "        # self.solver = cp.CpSolver()\n",
    "        # self.variables = []\n",
    "        \n",
    "    \"\"\"\"\n",
    "     TODO\n",
    "     Rewrite read problem function \n",
    "    \"\"\"\n",
    "\n",
    "\n",
    "\n",
    "    def read_problem(self, filename):\n",
    "        self.cells = []\n",
    "        with open(filename) as fin:\n",
    "            firstline = fin.readline().strip().split(\" \")\n",
    "            m = int(firstline[0])\n",
    "            n = int(firstline[1])\n",
    "            self.width = n\n",
    "            self.height = m\n",
    "            for idx in range(m):\n",
    "                line = fin.readline().strip().split(\" \")\n",
    "                self.cells.append([None if char == '.' else int(char)\n",
    "                            for char in line])\n",
    "\n",
    "        \n",
    "\n",
    "    def get_cell_edges(self, cell_id):\n",
    "        # Define the position of a cell by its id\n",
    "        cell_row = cell_id // self.width\n",
    "        cell_col = cell_id % self.width\n",
    "        num_horizontal = self.height * (self.width + 1)\n",
    "        # Return four integers\n",
    "        upper_edge = cell_id\n",
    "        lower_edge = upper_edge + self.width\n",
    "        left_edge = num_horizontal + ((cell_row * (self.width + 1)) + cell_col)\n",
    "        right_edge = left_edge + 1\n",
    "        return [upper_edge, lower_edge, left_edge, right_edge]\n",
    "\n",
    "    def get_corner_vertexes(self, vertex_id):\n",
    "        col = vertex_id % (self.width + 1)\n",
    "        row = vertex_id // (self.width + 1)\n",
    "        upper_edge = None\n",
    "        lower_edge = None\n",
    "        left_edge = None\n",
    "        right_edge = None\n",
    "        distance = self.width * (self.height + 1)\n",
    "        if row > 0:\n",
    "            upper_edge = distance + vertex_id - (self.width + 1)\n",
    "        if row < self.height:\n",
    "            lower_edge = distance + vertex_id\n",
    "        if col > 0:\n",
    "            left_edge = (self.width * row) + col - 1\n",
    "        if col < self.width:\n",
    "            right_edge = (self.width * row) + col\n",
    "        vertexes = [vertex for vertex in [upper_edge, lower_edge, left_edge, right_edge]\n",
    "                    if vertex is not None]\n",
    "        return vertexes\n",
    "\n",
    "    def get_adjacent_edges(self, edge_id):\n",
    "        num_vertexes = (self.width + 1) * (self.height + 1)\n",
    "        v1, v2 = [vertex_id for vertex_id in range(num_vertexes)\n",
    "                  if edge_id in self.get_corner_vertexes(vertex_id)]\n",
    "        edge1 = [edge for edge in self.get_corner_vertexes(v1)\n",
    "                 if edge != edge_id]\n",
    "        edge2 = [edge for edge in self.get_corner_vertexes(v2)\n",
    "                 if edge != edge_id]\n",
    "        return edge1 + edge2\n",
    "\n",
    "    def generate_cell_constraints(self):\n",
    "\n",
    "        # If the value of the cell is 0\n",
    "        def zero(e1, e2, e3, e4):\n",
    "            return [[-e1], [-e2], [-e3], [-e4]]\n",
    "\n",
    "        # If the value of the cell is 1\n",
    "        def one(e1, e2, e3, e4):\n",
    "            return [[e1, e2, e3, e4], [-e1, -e2], [-e1, -e3], [-e1, -e4],\n",
    "                    [-e2, -e3], [-e2, -e4], [-e3, -e4]]\n",
    "\n",
    "        # If the value of the cell is 2\n",
    "        def two(e1, e2, e3, e4):\n",
    "            return [[e2, e3, e4], [e1, e3, e4],\n",
    "                    [e1, e2, e4], [e1, e2, e3],\n",
    "                    [-e2, -e3, -e4], [-e1, -e3, -e4],\n",
    "                    [-e1, -e2, -e4], [-e1, -e2, -e3]]\n",
    "\n",
    "        # If the value of the cell is 3\n",
    "        def three(e1, e2, e3, e4):\n",
    "            return [[e1, e2], [e1, e3], [e1, e4],\n",
    "                    [e2, e3], [e2, e4], [e3, e4],\n",
    "                    [-e1, -e2, -e3, -e4]]\n",
    "\n",
    "        self.cell_constraints = []\n",
    "        # Base value of cell_id\n",
    "        cell_id = -1\n",
    "        list_value = [zero, one, two, three]\n",
    "        # TODO here\n",
    "        for row in range(self.height):\n",
    "            for col in range(self.width):\n",
    "                cell_id += 1\n",
    "                cell_value = self.cells[row][col]\n",
    "                if cell_value is None:\n",
    "                    pass\n",
    "                else:\n",
    "                    edges = [1 + e for e in self.get_cell_edges(cell_id)]\n",
    "                    clause = list_value[cell_value](*edges)\n",
    "                    # print(clause)\n",
    "                    self.cell_constraints += clause\n",
    "\n",
    "    def generate_loop_constraints(self):\n",
    "\n",
    "        # Number of correct edges if a vertex is in the corner\n",
    "        def two(e1, e2):\n",
    "            return [[-e1, e2], [e1, -e2]]\n",
    "\n",
    "        # Number of correct edges if a vertex is in the edge\n",
    "        def three(e1, e2, e3):\n",
    "            return [[-e1, e2, e3],\n",
    "                    [e1, -e2, e3],\n",
    "                    [e1, e2, -e3],\n",
    "                    [-e1, -e2, -e3]]\n",
    "\n",
    "        # Number of correct edges if a vertex is inside the board\n",
    "        def four(e1, e2, e3, e4):\n",
    "            return [[-e1, e2, e3, e4],\n",
    "                    [e1, -e2, e3, e4],\n",
    "                    [e1, e2, -e3, e4],\n",
    "                    [e1, e2, e3, -e4],\n",
    "                    [-e1, -e2, -e3],\n",
    "                    [-e1, -e2, -e4],\n",
    "                    [-e1, -e3, -e4],\n",
    "                    [-e2, -e3, -e4]]\n",
    "\n",
    "        corner_vertexes = (self.width + 1) * (self.height + 1)\n",
    "        vertex_constraints = [None, None, two, three, four]\n",
    "        for vertex_id in range(corner_vertexes):\n",
    "            vertexes = [1 + e for e in self.get_corner_vertexes(vertex_id)]\n",
    "            clause = vertex_constraints[len(vertexes)](*vertexes)\n",
    "            self.loop_constraints += clause\n",
    "\n",
    "    def call_sat_solver(self):\n",
    "        constraints = self.cell_constraints + self.loop_constraints\n",
    "        # Print number of clauses\n",
    "        numclause = len(constraints)\n",
    "        print(\"Number of clauses: \" + str(numclause))\n",
    "        # print(constraints)\n",
    "        model = cp.CpModel()\n",
    "        solver = cp.CpSolver()\n",
    "        solver.parameters.max_time_in_seconds = 10.0\n",
    "        vars = []\n",
    "        print(f\"Total Grid size: (width/height):( {self.width} , {self.height} )\")\n",
    "        for idx in range(self.width * (self.height + 1) + self.height * (self.width + 1)):\n",
    "            vars.append(model.NewBoolVar(name = f\"x[{idx + 1}]\"))\n",
    "        # print(f\"长度是{len(vars)}\")\n",
    "        for constr in constraints:\n",
    "            temp_list = []\n",
    "            for cstr in constr:\n",
    "                # print(cstr, end = \" \")\n",
    "                if cstr < 0:\n",
    "                    temp_list.append(vars[abs(cstr) - 1].Not())\n",
    "                else:\n",
    "                    # print(cstr, end = \" \")\n",
    "                    temp_list.append(vars[abs(cstr) - 1])\n",
    "            model.AddBoolOr(temp_list)\n",
    "\n",
    "        solution_collector = VarArraySolutionCollector(vars, self.width, self.height, self.cells)\n",
    "        status = solver.SearchForAllSolutions(model = model,callback=solution_collector)\n",
    "        \n",
    "        # if status == cp.OPTIMAL:\n",
    "        #     for solution in solution_collector.solution_list:\n",
    "        #         test_solution = [idx + 1 for idx, val in enumerate(solution) if val == 1]\n",
    "        #         result = self.is_one_loop(test_solution)\n",
    "        #         # print(\"CHECK!\")\n",
    "        #         if result:\n",
    "        #             self.solution = test_solution\n",
    "        #             break\n",
    "        # for solution in pycosat.itersolve(constraints):\n",
    "        #     test_solution = [edge for edge in solution if edge > 0]\n",
    "        #     result = self.is_one_loop(test_solution)\n",
    "        #     if result:\n",
    "        #         # print(result)\n",
    "        #         self.solution = test_solution\n",
    "        #         break\n",
    "    # Check if there is only a single loop\n",
    "    # def is_one_loop(self, solution):\n",
    "    #     if solution is []:\n",
    "    #         return False\n",
    "\n",
    "    #     solution = [edge - 1 for edge in solution]\n",
    "    #     far_edges = solution[1:]\n",
    "    #     start = [solution[0]]\n",
    "    #     # Implement Fill Algorithm\n",
    "    #     while far_edges != []:\n",
    "    #         lines = [line for edge in start\n",
    "    #                  for line in self.get_adjacent_edges(edge)\n",
    "    #                  if line in far_edges]\n",
    "    #         if lines == [] and far_edges != []:\n",
    "    #             return False\n",
    "    #         far_edges = [edge for edge in far_edges if edge not in lines]\n",
    "    #         start = lines\n",
    "    #     return True\n",
    "\n",
    "    def solve(self):\n",
    "        # Receive problem and take solution\n",
    "        # start time\n",
    "        start = time.time()\n",
    "        self.read_problem(\"../assets/data/Slitherlink/15x15medium1.txt\")\n",
    "        self.generate_cell_constraints()\n",
    "        self.generate_loop_constraints()\n",
    "        self.call_sat_solver()\n",
    "        \n",
    "        end = time.time()\n",
    "        print(\"Total time: \" + str(end - start))\n",
    "\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    slither = Slitherlink()\n",
    "    slither.solve()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "## A demo for subtour detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[(3, 1), (3, 4), (4, 5), (5, 3)], [(2, 3), (3, 4), (5, 3)], [(2, 3), (5, 3)], [(2, 3), (3, 4), (4, 5), (5, 3)], [(2, 3), (3, 1)], [(1, 2), (2, 3), (3, 1), (3, 4)], [(1, 2), (2, 3), (3, 1), (3, 4), (4, 5), (5, 3)], [(4, 5), (5, 3)], [(3, 4), (5, 3)], [(2, 3), (3, 1), (3, 4)], [(3, 1), (3, 4)], [(1, 2), (2, 3), (3, 1), (5, 3)], [(1, 2), (2, 3), (3, 1), (3, 4), (5, 3)], [(2, 3), (3, 1), (5, 3)], [(1, 2), (2, 3)], [(1, 2), (2, 3), (3, 1)], [(2, 3), (3, 1), (3, 4), (4, 5), (5, 3)], [(3, 1), (5, 3)], [(3, 1), (3, 4), (5, 3)], [(3, 4), (4, 5)], [(1, 2), (3, 1)], [(2, 3), (3, 1), (3, 4), (5, 3)], [(2, 3), (3, 4)], [(3, 4), (4, 5), (5, 3)]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def find_subtours(edges):\n",
    "    def dfs(edge, path, visited):\n",
    "        if visited[edge]:\n",
    "            if path and path[0] == edge:\n",
    "                subtours.add(tuple(sorted(path)))\n",
    "            return\n",
    "        visited[edge] = True\n",
    "        path.append(edge)\n",
    "\n",
    "        for adjacent in adjacency_list[edge]:\n",
    "            dfs(adjacent, path, visited)\n",
    "        \n",
    "        path.pop()\n",
    "        visited[edge] = False\n",
    "\n",
    "    # Create an adjacency list\n",
    "    adjacency_list = {edge: [] for edge in edges}\n",
    "    for edge in edges:\n",
    "        # Assuming 'edges' is a list of tuples (u, v) representing edges\n",
    "        u, v = edge\n",
    "        for adjacent_edge in edges:\n",
    "            if edge != adjacent_edge and (u in adjacent_edge or v in adjacent_edge):\n",
    "                adjacency_list[edge].append(adjacent_edge)\n",
    "\n",
    "    visited = {edge: False for edge in edges}\n",
    "    subtours = set()\n",
    "    for edge in edges:\n",
    "        dfs(edge, [], visited)\n",
    "\n",
    "    return [list(subtour) for subtour in subtours]\n",
    "\n",
    "# Example usage\n",
    "edges = [(1, 2), (2, 3), (3, 1), (3, 4), (4, 5), (5, 3)]\n",
    "subtours = find_subtours(edges)\n",
    "print(subtours)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py310_arm",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}