ecs-basecode.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing necessary libraries to use\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import norm\n",
    "from scipy.special import gamma as gamma_function\n",
    "import math\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Constrution of a class called \"Cuckoo\" which contains the main function.\n",
    "class Cuckoo():\n",
    "    \n",
    "    # Constant Parameters\n",
    "    X_min = 0            # test area lower bound\n",
    "    X_max = 100          # test area upper bound\n",
    "    alpha_min = 0.9      # step size lower bound\n",
    "    alpha_max = 1.0      # step size upper bound\n",
    "    pa_min = 0.05        # mutation probability lower bound\n",
    "    pa_max = 0.25        # mutation probability upper bound\n",
    "    N_nest = 25          # total no. of solutions in the test field\n",
    "    N_itertotal = 100    # max. no. of iterations for each node localization\n",
    "    gamma = 0.1          # noise factor\n",
    "    lamda = 1.5          # constant used in le'vy flight\n",
    "    \n",
    "    total_nodes = 0      # node density\n",
    "    anchor_percent = 0   # anchor ratio\n",
    "    t_range = 0          # transmission range\n",
    "    \n",
    "    X_anchor = []        # anchor list\n",
    "    X_unknown = []       # unknown nodes list\n",
    "    \n",
    "    X_loc = []           # (estimated coords, actual coords) pairs\n",
    "    F_mins = []          # iteration-wise optimum fitness values\n",
    "    \n",
    "\n",
    "    def __init__(self, total_nodes = 100, anchor_percent = 0.20, t_range = 25):\n",
    "        self.total_nodes = total_nodes\n",
    "        self.anchor_percent = anchor_percent\n",
    "        self.t_range = t_range\n",
    "        self.M = int(self.anchor_percent * self.total_nodes) # no. of anchor nodes\n",
    "        self.N = self.total_nodes - self.M # no. of unknown nodes        \n",
    "        \n",
    "        # Anchor Deployment\n",
    "        for i in range(self.M):\n",
    "            x_anchor = np.random.randint(self.X_max)\n",
    "            y_anchor = np.random.randint(self.X_max)\n",
    "            self.X_anchor.append([x_anchor, y_anchor])\n",
    "        \n",
    "        # Unknown Nodes Deployment\n",
    "        for i in range(self.N):\n",
    "            x_unknown = np.random.randint(self.X_max)\n",
    "            y_unknown = np.random.randint(self.X_max)\n",
    "            self.X_unknown.append([x_unknown, y_unknown])\n",
    "        \n",
    "        self.X_unknown = np.array(self.X_unknown)\n",
    "        self.X_anchor = np.array(self.X_anchor)\n",
    "    \n",
    "        # Backup of original coordinates of Anchor and Unknown nodes\n",
    "        self.X_anchor_og = self.X_anchor.copy()\n",
    "        self.X_unknown_og = self.X_unknown.copy()\n",
    "    \n",
    "    \n",
    "    def show_field(self, unk = True):\n",
    "        \"\"\"Plots the test field containing labeled nodes\"\"\"\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        if unk == True:\n",
    "            if len(self.X_unknown) != 0:\n",
    "                plt.plot(self.X_unknown[:, 0], self.X_unknown[:, 1], 'yo', label=\"Left Node\")\n",
    "            plt.plot(self.X_unknown_og[:, 0], self.X_unknown_og[:, 1], 'ro', label='Unknown Node')\n",
    "        else:\n",
    "            plt.plot(self.X_unknown_og[:, 0], self.X_unknown_og[:, 1], 'ro', label='Unknown Node')\n",
    "            if len(self.X_unknown) != 0:\n",
    "                plt.plot(self.X_unknown[:, 0], self.X_unknown[:, 1], 'yo', label=\"Left Node\")\n",
    "        plt.plot(self.X_anchor_og[:, 0], self.X_anchor_og[:, 1], 'go', label=\"Anchor Node\")\n",
    "        plt.plot(self.X_anchor[self.M:, 0], self.X_anchor[self.M:, 1], 'b^', label=\"Localized Node\", fillstyle='none', markersize=10)\n",
    "        \n",
    "        plt.legend()\n",
    "        plt.axis([0,self.X_max,0,self.X_max])\n",
    "        plt.grid()\n",
    "        plt.show()\n",
    "    \n",
    "    \n",
    "    def alpha(self, n_iter):\n",
    "        \"\"\"Step size used in Le'vy flight\"\"\"\n",
    "        return self.alpha_max - ((n_iter/ self.N_itertotal) * (self.alpha_max - self.alpha_min)) # returns step size value\n",
    "\n",
    "    def levy(self):\n",
    "        \"\"\"Returns random walk value\"\"\"\n",
    "        temp = np.power(((gamma_function(1 + self.lamda) * np.sin(np.pi * (self.lamda /2))) / (gamma_function((1 + self.lamda)/2) * self.lamda * np.power(2, ((self.lamda - 1)/2)) )), 1/self.lamda)\n",
    "        u = np.random.normal(0, temp)\n",
    "        v = np.random.normal(0,1)\n",
    "        r = u / (np.power(abs(v), (1/self.lamda)))\n",
    "\n",
    "        return r  # random walk value\n",
    "\n",
    "    \n",
    "    def limiter(self, point):\n",
    "        \"\"\"Prevents the node from exiting the test field\"\"\"\n",
    "        x = point[0]\n",
    "        y = point[1]\n",
    "        if x > self.X_max and y > self.X_max:\n",
    "            x,y = self.X_max, self.X_max\n",
    "        elif x > self.X_max and self.X_min < y < self.X_max:\n",
    "            x,y = self.X_max, y\n",
    "        elif x > self.X_max and y < self.X_min:\n",
    "            x,y = self.X_max, self.X_min\n",
    "        elif self.X_min < x < self.X_max and y < self.X_min:\n",
    "            x,y = x, self.X_min\n",
    "        elif x < self.X_min and y < self.X_min:\n",
    "            x,y = self.X_min, self.X_min\n",
    "        elif x < self.X_min and self.X_min < y < self.X_max:\n",
    "            x,y = self.X_min, y\n",
    "        elif x < self.X_min and y > self.X_max:\n",
    "            x,y = self.X_min, self.X_max\n",
    "        elif self.X_min < x < self.X_max and y > self.X_max:\n",
    "            x,y = x, self.X_max\n",
    "\n",
    "        return [x,y]\n",
    "\n",
    "    \n",
    "    def neighbours(self, node, anchors):\n",
    "        \"\"\"Returns a list of neighbouring anchor nodes within transmission range of the input node\"\"\"\n",
    "        x = node[0]\n",
    "        y = node[1]\n",
    "        X_anchor = anchors\n",
    "                \n",
    "        l = []\n",
    "        for j in range(len(X_anchor)): # for every anchor node in the list\n",
    "            dist_real = np.power((np.power((x - X_anchor[j][0]), 2) + np.power((y - X_anchor[j][1]), 2)), 0.5)\n",
    "            np.random.seed(2)\n",
    "            dist_err = dist_real + np.random.normal(0, (self.gamma*dist_real))\n",
    "            np.random.seed()\n",
    "            \n",
    "\n",
    "            if dist_err < self.t_range: # vicinity check\n",
    "                l.append(X_anchor[j])\n",
    "                \n",
    "        return l # neighbouring anchors coordinates\n",
    "\n",
    "    def objective(self, node, n_anchors, node_unknown, min_nodes = 3):\n",
    "        \"\"\"Objective function MSE (to minimize)\"\"\"\n",
    "        x = node[0]\n",
    "        y = node[1]\n",
    "        \n",
    "        x1 = node_unknown[0]\n",
    "        y1 = node_unknown[1]\n",
    "        \n",
    "        l = self.neighbours(node_unknown, n_anchors) # calculating neighbours of the unknown node\n",
    "        m = len(l)\n",
    "        rerror = []\n",
    "        if len(l) >= min_nodes:\n",
    "            for ancn in l: \n",
    "                #dij (real distance between estimated node and anchor)\n",
    "                dist_real = np.power((np.power((x - ancn[0]), 2) + np.power((y - ancn[1]), 2)), 0.5)\n",
    "                \n",
    "                #dij1 (real distance between unknown node and anchor)\n",
    "                dist_real1 = np.power((np.power((x1 - ancn[0]), 2) + np.power((y1 - ancn[1]), 2)), 0.5)\n",
    "                \n",
    "                #dij' (calculated distance between unknown node and anchor) (includes the ranging error)\n",
    "                np.random.seed(2)\n",
    "                dist_err = dist_real1 + np.random.normal(0, (self.gamma*dist_real1))\n",
    "                np.random.seed()\n",
    "                rerror.append(np.power(dist_real - dist_err,2))\n",
    "\n",
    "        # returning worst solutions (not enough neighbouring anchors) with infinite value\n",
    "        ans = None\n",
    "        if math.isnan(np.sum(rerror)/m): \n",
    "            ans = np.inf\n",
    "        else:\n",
    "            ans = np.sum(rerror)/m or None\n",
    "            \n",
    "        return ans # mean of square of ranging error\n",
    "\n",
    "    \n",
    "    def ecs(self, N_anchor, node_unknown):\n",
    "        \"\"\"Enhanced Cuckoo Search Algorithm\"\"\"\n",
    "        # Initial population (Random deployment of 'N' nests)\n",
    "        X_nest = []                   # list of candidate solutions\n",
    "        min_nodes = len(N_anchor)     # no. of neighbouring anchors\n",
    "        for i in range(self.N_nest):\n",
    "            x_nest = np.random.randint(self.X_max)\n",
    "            y_nest = np.random.randint(self.X_max)\n",
    "            X_nest.append([x_nest, y_nest])\n",
    "        \n",
    "        # Calculating fitness value of each nest\n",
    "        Obj_X_nest = []              # list of fitness values of the candidate solutions\n",
    "        for i in range(len(X_nest)):\n",
    "            Obj_X_nest.append(self.objective(X_nest[i], N_anchor, node_unknown, min_nodes) or np.inf)\n",
    "#         print(Obj_X_nest)\n",
    "        \n",
    "        N_iter = 0                   # iteration counter\n",
    "        fmins = []                   # list of best fitness value of each iteration\n",
    "        while(N_iter < self.N_itertotal): # fittest solution search loop\n",
    "            N_iter += 1              # increment in iteration counter\n",
    "            X_js = []                # list of new candidate solutions\n",
    "            Obj_X_js = []            # list of fitness values of the new candidate solutions\n",
    "            # Applying Le'vy flight to every solution\n",
    "            for i in range(len(X_nest)):\n",
    "                X_j = X_nest[i].copy()\n",
    "                X_j[0] = X_j[0] + self.alpha(N_iter) * self.levy()\n",
    "                X_j[1] = X_j[1] + self.alpha(N_iter) * self.levy()\n",
    "                \n",
    "                X_j = self.limiter(X_j)     # limit test on new solution generated by Le'vy flight\n",
    "                \n",
    "                F_j = self.objective(X_j, N_anchor, node_unknown, min_nodes) or np.inf\n",
    "                rand_k = np.random.randint(0, len(X_nest))\n",
    "                F_k = Obj_X_nest[rand_k]\n",
    "                \n",
    "                # Comparing fitness of new solution with existing solution\n",
    "                if F_j > F_k:\n",
    "                    X_j[0] = X_nest[rand_k][0]\n",
    "                    X_j[1] = X_nest[rand_k][1]\n",
    "                    F_j = F_k\n",
    "\n",
    "                X_js.append(X_j)\n",
    "                Obj_X_js.append(F_j)\n",
    "            \n",
    "            # Finding current best solution out of 'N' nests\n",
    "            Obj_X_js = np.array([np.inf if i is None else i for i in Obj_X_js])\n",
    "            F_min = Obj_X_js[np.argmin(Obj_X_js)]\n",
    "#             print(F_min)\n",
    "            current_best_sol = X_js[np.argmin(Obj_X_js)]\n",
    "            \n",
    "            # Calculation of mutation probability (Pa)\n",
    "            Pa_j = []                 # list of mutation probabilities of all the updated candidate solutions\n",
    "            for i in Obj_X_js:\n",
    "                K = i - F_min\n",
    "                if K < 1:\n",
    "                    Pa_j.append(self.pa_min + (self.pa_max - self.pa_min) * K)\n",
    "                else:\n",
    "                    Pa_j.append(self.pa_max / N_iter)\n",
    "\n",
    "            # Mutation process\n",
    "            for i in range(len(Pa_j)):\n",
    "                rand_temp = np.random.uniform(0, 1)\n",
    "                if rand_temp < Pa_j[i]:\n",
    "                    my_x = np.random.randint(self.X_max)\n",
    "                    my_y = np.random.randint(self.X_max)\n",
    "                    F_my_xy = self.objective([my_x, my_y], N_anchor, node_unknown, min_nodes) or np.inf\n",
    "                    if (Obj_X_js[i]) > (F_my_xy):\n",
    "                        X_js[i] = [my_x, my_y]\n",
    "                        Obj_X_js[i] = F_my_xy\n",
    "            \n",
    "            # Finding the best solution of current iteration\n",
    "            Obj_X_js = np.array([np.inf if i is None else i for i in Obj_X_js])\n",
    "            F_min = Obj_X_js[np.argmin(Obj_X_js)]\n",
    "#             print(F_min)\n",
    "            self.F_mins.append(F_min)\n",
    "            fmins.append(F_min)\n",
    "            \n",
    "            # Early stopping mechanism\n",
    "            if len(fmins) > 3:\n",
    "                d1 = abs(fmins[-1] - fmins[-2])\n",
    "                d2 = abs(fmins[-2] - fmins[-3])\n",
    "                d3 = abs(fmins[-3] - fmins[-4])\n",
    "                if d1 == d2 == d3 == 0:\n",
    "#                     print('Exiting', N_iter)\n",
    "                    break\n",
    "            \n",
    "            # Obtaining the coordinates of best fit solution of the iteration\n",
    "            best_sol = X_js[np.argmin(Obj_X_js)]\n",
    "            X_nest = X_js.copy()\n",
    "            Obj_X_nest = Obj_X_js.copy()\n",
    "        \n",
    "        return best_sol # returns the coordinates of the solution with global best fitness\n",
    "                \n",
    "    \n",
    "    def update_Unknown(self, indexes):        \n",
    "        \"\"\"Updating Unknown List after localization\"\"\"\n",
    "        # append the corresponding coordinates of the index values which are not localized in a list,\n",
    "        # and then update the unknown nodes' list\n",
    "        X_unknown_temp = []\n",
    "        for j in range(len(self.X_unknown)):\n",
    "            if j in indexes:\n",
    "                pass\n",
    "            else:\n",
    "                X_unknown_temp.append(self.X_unknown[j])\n",
    "\n",
    "        self.X_unknown = np.array(X_unknown_temp)\n",
    "        \n",
    "\n",
    "    def main(self):\n",
    "        \"\"\"Node Localization Process\"\"\"\n",
    "        for j in range(5):\n",
    "            localised_indexes = []\n",
    "            for i in range(len(self.X_unknown)):\n",
    "                nn = self.neighbours(self.X_unknown[i], self.X_anchor)\n",
    "    #                 print(i, end=\"\\r\")\n",
    "                if len(nn) >= 3:\n",
    "                    updated_node_location = self.ecs(nn, self.X_unknown[i])\n",
    "\n",
    "                    self.X_loc.append([updated_node_location, self.X_unknown[i]])\n",
    "\n",
    "                    # Updated \n",
    "                    X_anchor_temp = list(self.X_anchor)\n",
    "                    X_anchor_temp.append(updated_node_location)\n",
    "                    self.X_anchor = np.array(X_anchor_temp)\n",
    "\n",
    "                    localised_indexes.append(i)\n",
    "\n",
    "            self.update_Unknown(localised_indexes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EXPERIMENT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = Cuckoo(total_nodes=300, anchor_percent=0.35, t_range=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAHWCAYAAACIWdvNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzde3hU1b0//vfKEBIjEBQlopgJWokFAhFvtS0XCVa/P0uVttZLTtV6bDSpVYqt1uaU22PO8agFtAd8jLdSkyLWeimnPT3WmKhYtYIiqIjoMeEqIMKYmAtJZv3+mJmQy8xkZl/XXvv9ep48kM1c9l577b2Y+XzWZwkpJYiIiMhbMtzeASIiIkofB3AiIiIP4gBORETkQRzAiYiIPIgDOBERkQdxACciIvKgQQdwIcSjQoh9Qoh3e207VgjxdyHEtuifx/T6tzuEEB8JIbYKIS60a8eJiIj8LJVP4L8DcFG/bb8EUCelPA1AXfR3CCEmALgCwMToc1YKIQKW7S0REREBSGEAl1K+DODzfpsvAbAq+vdVAC7ttf0JKWWHlPITAB8BOMeifSUiIqIoozHwPCnlHgCI/jk6uv0kADt6PW5ndBsRERFZaIjFryfibItbq1UIUQagDACys7PPzM/Pt3hXqL9wOIyMDOYt2oltbD+2sf3Yxs748MMPP5NSHm/0+UYH8L1CiDFSyj1CiDEA9kW37wRwcq/HjQWwO94LSCmrAVQDQGFhody6dSsA4OGls7Fkdx12DgPGtgALTizB9fNfMLibBAC1m2tRWVeJ7aHtyM/NR1VJFUqLSt3eLVeEVlYga0k1svZ1o2N0AB0LypBbsdKy129oaMDMmTMtez0aiG2cGjPXPdvYGUKIJjPPN/pfrD8DuCb692sAPNdr+xVCiCwhxDgApwH4Z6ov+vDS2bjlQB12DAekAHYMB245UIeHl842uJtUu7kWZWvL0BRqgoREU6gJZWvLULu51u1dc1xoZQWGzX8A2Xu7ISSQvbcbw+Y/gNDKCrd3jchSvO79IZVpZKsBvAagUAixUwjxrwDuAnCBEGIbgAuiv0NK+R6AJwG8D+BvAH4ipexOdWeW7K5D69C+21qHRraTMZV1lWjtbO2zrbWzFZV1lS7tkXuyllQj0NF3W6Ajsp1IJ7zu/WHQr9CllFcm+KeSBI+vAlBlZGd2DktvOw1ue2h7Wtt1lrUv/v8lE20n8ipe9/6gVJbC2Jb0ttPg8nPjJwcm2q6zjtHxSxIk2k7kVbzu/UGpAXzBiSXIOdx3W87hyHY/Cq2sQPsJQyAzBNpPGGIoVltVUoWczJw+23Iyc1BVYuhLEk/rWFCG7qy+27qzItu9xIp+YVTt5loULC9AxuIMFCwv8GRM1c32cwqve5+QUrr+M378eBnz0G9K5Mm3QoqFkCffCvnQb0qkHx1aUS67siAljvx0ZUEeWlGe9mvVbKqRwWVBKRYJGVwWlDWbamzYY284tKJctuUFZFhAtuUFDLVnMvX19Za+Xn9W9ot01WyqkTlVORKL0POTU5XjeH8y08Zutp/TzFz3dvdjigCwXpoYO0XkNdzVexoZRbSfMATZewfGZtvzAsj+tMvQa3JqiP3sbmM7+kWqCpYXoCk0cNZLMDeIxnmNtr53b2ba2M328xLeK5whhNggpTzL6POV+gqdjmDCFcXjZr/QITGK1xXphAN4LyrFxphwRfG42S90SIxyuv1UuqeQfjiAR6lW5EOXhCuylpv9QofEKCfbT7V7CumHA3iUakU+citWomVpOdrzApAiEqNrWVpuadlP8h43+0VpUSmq51QjmBuEgEAwN4jqOdWeKsvrZPupdk8h/TCJLUpmCIg4TSEFIMLut5EVmJhiP7ax/bzSxl6+p3iljb2OSWwWYcyZEmEck4zgPcU9OtQrSAUH8CjGnCkexjHJKN5T3OGnhVw4gEcx5kzxMI5JRvGe4g4/LeRidD1wLeVWrASiF1d29If8jfOGyQzeU5ynQ72CVPETOFESjGMSeYsO9QpSpe0A7pckBiZY2YtxTLX55Tqn1OlQryBVWn6FHktiiMVBYkkMADw1Z3UwsQSrWIw2e283Muc/gBDAOJtFcitWIoRIzDtrXzc6RgfQsaCM7asAv1znlJ7Yua+sq8T20Hbk5+ajqqRKyz6h5TxwVRZdsFu6CzNwbqf92Mb2i7WxX65zN7AfO4PzwOPwSxIDE6zIz/xynRMlouUA7pckBiZY9eXXeKgOeRBGzp1frnOiRLQcwP2SxMAEqyP8VLyhNx0KzRg9d365zokS0XIA12HRhVSwUMQRfire0JsOhWaMnju/XOdEiWiZhQ5ELm4/XMgsFBHh13ioDnkQZs6dX65zoni0/ATuJB3ij3ZyKi7t13ioDnkQfj13RGZxADdBh/ijnZyMS/s1HqpDHoRfzx2RWRzATdAh/mgnJ+PSfo2H6pAH4ddzR2SWtjFwJ+gQf7ST03Fpv8ZDdciD8Ou5IzKDn8BN0CH+aCfGNomI7MMB3AQd4o92YmzTW/xaCMcoJrB6h67nil+hm8CFLpLz06ICXseFQdLDhYS8Q+dzpeViJhQfFyiwn1fb2EsLg6jQxukuJOQ1KrSxVVQ+V1zMhIhM82shHKOYwOodOp8rDuBE5KuEQyvioW4nsOoa07VDvHNSWwQE58Pz+R4cwInINwmHVhVfcjOBlQWk0tP/XNUWAWVzgB3D4fmFjziAE5FviqlYVXzJzQI6LCCVnv7n6o5vAa1D+z7GqwsfMQudiAD4o5iKlfFQtwro6BzTtUvvc7VzcQaAgcnbXsz34CdwAsA5wOQup2K6bseurWDlMfgxlq5TvgcHcHJ00RGi/pyM6epQfMmqY/BrLF2nfA8O4OTooiNE/TkZ09Vh8RerjsGvsXSd8j0YAyfOASZXOR3T1WHxFyuOwc+xdF3yPfgJnLSKCZH36BCX9iK2u/dxAFeYUwkm8WJCR2EIFj213fL3tvOYmIinhnTPcaox3dj5nfXSLJ5fC+iQDwCod907uj9SStd/xo8fL6mvQyvKZVcWpMSRn64syEMryg2/Zn19fcJ/q9lUI4PLglIsEvLkJcPk78+w9r2ltOeYeu9/TlWOxCL0/ORU5ciaTTWmXzsdydrYD4ye40MrymVbXkCGBWRbXmDA41U5v7pJ1O5e6ceq9Yt09wfAemli7ORiJoqyowB/qgsU2FX8385FBVRZjEOnRSCMsOscq3J+/cIr/Vi1fpHu/nAxE025mWBi13vbeUxMxFODXeeY55fiUa1fOL0/HMAV5WaCidH3Hiz2mej5ncNhOi7ORDw12FVkZGxz/G8KeX79TbXr3un94QCuKDcTTIy8dypFIeK9bjgADGmF6WISOhVn8DK7ioz8x/NAzuG+j+H5JdWue8f3x0wA3aofJrHFN1hiT7rSSUxJ973b8gJ9EpdiP215gaSvezhXpPS8VPROxAsuC7qSyOKV5B87WdFv4/WnmiLIk2+Fq+fXL7zUj1W47o3uD5jERqmyMzFFZgiIOF1JCkCEE/cxo89TlVeSf1SXrF+89GI929hm7MfOYBIbKcFo7FPXYhJ+XCTCjP5zZ1d9XcR9nNf7hZ0eXjob+T8XyFgkkP9zgYeXznZ7l8hmHMDJEkZjn7oUk+jNr4tEGBVvMZ2KCwJ4/Iy+j/N6v7DTw0tn45YDddgxPPItxY7hwC0H6jiIa44DOFnC6AILOiwu0Z9fF4kwKt5iOm3oQuXcYVr1Czst2V2H1qF9t7UOjWwnfXExE7KM0QUWdFhcojc/LxJhRKI5sjvDXyL70zAAPfqFnXYOS2876YGfwIkspmtc3y6qzeX1orEt6W0nPXAAJ09SbQGD3nSM61utd5Lfoqe246h+XwZyjnd6FpxYMnCe/OHIdtIXB3DynHhJT2Vry5QZxHWM61upf5Lfta9KPPhcF07OGAYBgWBuENVzqrVYr9kp189/AfeNKsHJzYCQwMnNwH2jSnD9/Bfc3jWyEWPg5Dnxkp5aO1tRWVepzE1ft7i+leIl+f3wbeCy3W09MW9K3/XzX8D1bu8EOYqfwMlzVFvAgNLDJD8ia3AAdwkLfRjHpCdv0yXJT+U8DD/x872UA7gLWOjDHNUWMKD06JDkp3oehl/4/V7KAdwFLPRhTmlRKarnVCOYG2TSkwfpkOSXLA+DnOP3eymT2FzAGKB5pUWlHLA9zOtJfszDUIPf76X8BO4CXWKARH7FPAw1+P1eygHcBfFigOEAEGgP+zIRg6zn58QeJ+iSh+H1fqJDPoUZ/ArdBbkVKxFCJE6Tta8bncOBIa1AZiiyAHL23m5kzn8AoehjidIRS+yJxQbZn6wXC99U1lVie2g78nPzUVVS5amwTrJ+ggk/cHPXUtb/XtoxOoCOBWW+6edCSun2PqCwsFBu3brV7d1wTfsJQ5C9d2DMpj0vgOxPuyx7n4aGBsycOdOy16OBVGhjp/qTW1RoYx0k6yevP/EC29gBQogNUsqzjD6fX6ErwO+JGGQt9idKBfuJ93EAT5MdMSO/J2KQtdifrOf1WHE8RvuJjm3hVRzA02BX0QC/J2KQtdifrKVrsRAj/UTXtvAqDuBpsKtogA6FLUgd7E/W0rVYiJF+omtbeBWz0NNgZ8zI64UtSC3sT9bROVacbj/RuS28iJ/A0+Cn2KKRhRq4uAPpyE/X/WDYFmrhAJ4Gv8QWjSzUwMUdSFd+ue5TwbZQCwfwNPgltmhkoQYu7kC68st1nwq2hVoYA0+TH2KLRhZq4OIOpDM/XPepYluog5/AaQAjCzVwcQciImdxAFeESsURjCzUoMviDkREXsEBXAGqFUcoLSpF9ZxqBHODEBAI5gZRPac66UINRp5DRETGMQaugKTFEVxKDiktKk178DXyHCIiMsbUJ3AhxM+EEO8JId4VQqwWQmQLIY4VQvxdCLEt+ucxVu2srlgcgYiI0mV4ABdCnATgZgBnSSknAQgAuALALwHUSSlPA1AX/d1SuhUMYXEEUoFKeRhENDizMfAhAI4SQgwBkANgN4BLAKyK/vsqAJeafI8+dCwYwuII5DbV8jCIaHCGB3Ap5S4A9wLYDmAPgJCU8nkAeVLKPdHH7AEw2oodjdGxYAiLI5DbuEgFkfcIKaWxJ0Zi238CcDmAQwD+COApAP8lpRzZ63EHpZQD4uBCiDIAZQBw/PHHn/nkk0+m9L6zXpoFiYH7LCDw4owXDRyJf7S0tGDYsGFu74bWvNrGM2adDxHnViAF8NKL9c7vUBJebWMvYRs74/zzz98gpTzL6PPNZKHPBvCJlHI/AAghngbwdQB7hRBjpJR7hBBjAOyL92QpZTWAagAoLCyUM2fOTOlN8zfmoynUNHB7bj5SfQ2/amho0KaNQisrkLWkGln7utExOoCOBWWOfWNx8KqJyF3zPkQYkBlA6PIJOOYP7wHwbhu3jw4ge+/ApMmO0QHljserbewlbGNvMBMD3w7ga0KIHCGEAFACYAuAPwO4JvqYawA8Z24X+2LBEHIzXnvwqokYufp9ZIQBASAjDIxc/T4OXjXR9ve2E/MwiLzHTAz8DUS+Mn8LwOboa1UDuAvABUKIbQAuiP5uGRYMITfjtblr3ofot01Et3sZ8zCIvMdUIRcp5UIAC/tt7kDk07htWDDE39ycNy/C6W33Ei5SQeQtLKVKnuPmvHmZ4IpJtJ2IyC687ZjE4hfOczNeG7p8woA5EDK6newVK+A066VZpgo4qXbNOlmYSrciWH7HWugmxJKpYvHY7L3dyJz/AEIAY4c2yq1YiRDgShb6MX94DweROAud7BEr4BSrAREr4AQgrXCaatesVcel2nuRMwzPA7dSYWGh3Lp1q9u7kbb2E4bEnXrTnhdA9qddLuxRcpwaYj+2sT0KlhfEnT4azA2icV5jyq+j2jVr1XFZ/V7sx84QQpiaB86v0E3gIiREztge2p7W9kRUu2atOi7V3oucwQHcBC5CQnZTLV7rlvzc/LS2J6LaNWvVcan2XuQMDuAmsPgF2YkLjBxhVQEn1a7Zfwt/BTmH+27LORzZbjUWwdIPB3ATWPyC7MQFRo6wqoCTatfsv9zdgOq1QPAQIGTkz+q1ke1WYxEs/TCJzUeYmGI/K9tYZoiEC4yIsPvXrVt06seqnmOd2lhlTGIjTzEa0/VjLNjueK0f21Q1Rs8x53N7h53XGQdwcozRmK5fY8F2xmv92qaqMXKOY/O5m0JNkJA987k5iKvH7uuMAzg5xmhM16+xYDvjtX5tU9UYOceVdZU9xVhiWjtbUVlXaffuUprsvs5YiY0cY3QOrmpzd51k1wIjfm5T1aR7jjmf2zvsvs74CZwcYzTep9rcXR2wTb2L87m9w+7rTLkBnMkZ+jIa01Vt7q4XPbx0NvJ/LpCxSCD/5wK/vyTPc20aSwaaMet8XyfdcT63eU4lcNp+75JSuv4zfvx4KaWUNZtqZE5VjsQi9PzkVOXImk01ksyrr693exfkoRXlsi0vIMMCsi0vIA+tKLf1eU5ToY37e+g3JTLnV+h7Xf0K8sGyEz3RplJGzn9XFqTEkZ+uLCi9z3aq2VQjg8uCUiwSMrgsaPk9UsV+bBWn+1KyexeA9dLE2KnUPHAnC/v7Eed22k/FNs7/ucCO4QO3n9wMbL/X/es/FaotQqI7FfuxVVTqS1rNA2dyBpH1dg5Lb7uKmHRHVtGpLyk1gDM5g8h6Y1vS264iJt1Zg8V79OpLSg3gTM4gst6CE0viLpix4MQSd3bIACYymsfiPRE69SWlBnAW2yey3vXzX8B9o0pwcnNkwYyTm4H7RpXg+vkvuL1rKVNtERIvYvGeCJ36klJJbGQvnRNTVME2th/b2Jh0Fk5hGztDqyQ20p9fYnCsZ0CqsTP2a+S6TuUa8cv9wigO4OQYv8TguNgEqciu2K+R6zqVa8Qv9wszOICTY/wSg+NiE6Qiu2K/Rq7rVK4Rv9wvzOBiJuQYneZfJsN6BqQqOxbHMXJdp3KN+OV+YQY/gZNjdJp/mQzrGZCfGLmuU7lG/HK/MIMDODlGp/mXybCeAfmJkeu6qqQKR/X7AvgoDOlzjVh5v9A1qZQDODlGp/mXybCeAfmJkev626+8igef60LwUKQ2QfAQ8OBzXfj2K6+aet14dE4q5TxwH+HcTvuxje3HNraf3W3s5IIiKi+SxXngRETkKU4mqOmcVOqbAdzJggAsPkB0hJ3XA681b7IyQW2wPuB0UqmTfdIXA7iTBQFYfIDoCDuvB15r3mVVgloqfcDJpFLH+6SU0vWf8ePHSzu15QWkBAb8tOUFPP1e6aqvr3d7F7THNu7Ljush1sYqX2te50Q/PrSiXLblBWRYRM7ZoRXlab9Gqn2gZlONDC4LSrFIyOCyoKzZVGPVYRjanxgA66WJsdMXhVycjLew+ADREXZeD7zWvM2KojKp9oHSolJHZoE43Sd98RW6kwUBWHyA6Ag7rwdea6RaH3B6f/wxgDtYQMQvxUqIUmHn9dA2qxD9J8HK6HbyB9Xut07vjy8GcCcLiPilWAlRKuy8Ho56cStEv20iup38QbX7rdP7w0IuPsICGPZjG9sv1sYyQ0DEuX1JAYiw+/c1L2M/dgYLuRCRL6kW/yRyGgdwRbAghV50OJ+qH0Oq8UbVj4PIKF9MI1NdbPJ/bPH67L3dyJz/AEIAY+cepMP59MIx5FasRAhA1pJqZO3rRsfoADoWlPXZPy8cB5FRjIErwKnC/oxr2a+hoQFfu2K2Yws12MXJxSbSlU4/Vvk4VMZ7hTMYA9cAC1LoRYfzqcMxAPocB1E8HMAVwGQcvehwPnU4BkCf4yCKhwO4AlQrRkDm6HA+dTgGQJ/jIIqHA7gCVCtGQObocD51OAZAn+MgiodZ6IqworA/qUOH86nDMQD6HAdRf/wETuQDbs6F5jxsInvwEziR5tycC8152ET24SdwIs1lLanuGUBjAh2R7Tq/N5HuOIATac7NudCch01kHw7gRJpzcy4052ET2YcDuA/Ubq5FwfICzHppFgqWF6B2c63bu5QUk56s5eZcaM7DJrIPk9g0V7u5FmVry9Da2QoAaAo1oWxt5OZZWlTq5q7FxaQn66Wy6IeO702kOy5mormC5QVoCjUN2B7MDaJxXqPzOzQIry8+wUUg7Mc2th/b2BlczISS2h7antZ2tzHpiYgoNRzANZefm5/Wdrcx6YkSieVGzJh1PnMjUhDLfclYnOGJ3BdKHwdwzVWVVCEnM6fPtpzMHFSVVLm0R8kx6YniieVGZO/thpCR3Ihh8x/gIJ5ALPelKdQECdmT+8JBXC8cwDVXWlSK6jnVCOYGISAQzA2iek61kglsABefoPhYECY9lXWVPYmrMa2draisq3Rpj8gOzEL3gdKiUpQWlXomMYWLT1B/zI1Ij9dyX8gYJT6BD//wQ8a0iBSj0nz8VHMjVNpnN9mZ+8I2Ts7J9lFiAAcY0yJSiWox51RyI1TbZzfZlfvCNk7O6fZRYh74WULI9dG/e2W+rxd55St0L9OljVWcjx9aWZG0IIyK++ym2s21qKyrxPbQduTn5qOqpCrl3JdE/ZhtnFy67WN2HrhyMXDGtIjcp2LMOZYbERtc+udGqLjPborlvliJbZyc0+2jzFfoMZzvS+Q+L87H9+I+ew3bODmn20epAdyL831ZLMEdTKSxV6KYc9uswkHb3a1zwxoC9lOxjVW6FzjePlJK13/OBGRbXkAeWlEuvaRmU43MqcqRWISen5yqHFmzqcbtXYurvr7e7V2wxKEV5bIrC1LiyE9XFpToP7q0sZSRdm7LC8iwiFyfn185YdB2d+LcJGvj/vusQp/wIq+0sYr3gnTaB8B6aWLsVCKJzauLmXhtoRAmWNlPlzaOJ5V2d+Lc6NzGqvBKG6t8L0gFFzNxEYsluIOJNO5Ipd15bshJfu9vHMBN8NpCISqwImeAiTTuSKXdvXhuVIqheoFKeT9e7G9W4gBugtcWCnGbVQssqJhI4weptLvXzg0Lk6RHtUVSvNbfrMYB3ASvLRTiNqsWWOCCJ+5Ipd29dm64SEp6VFskxWv9zWpMYvMRtxNTMhZnQGJgfxMQCC8Mu7BH1nO7jf3AyjaWGQIizi1QCkCE3b83uiVRG/vhGnYSk9jIM5gzQKrxeww1XbyG1cIB3AFeTJIxss+DPYc5A6Qav8dQ08VrWC0cwG3mxSQZI/ucynOYM0Cq8XsMNV28htXCGLjNVCo0kGrs0Mg+q3ScbmIM3H5sY/uxjZ3hagxcCDFSCPGUEOIDIcQWIcR5QohjhRB/F0Jsi/55jJn38DovFhowss9ePE4iIi8z+xX6fQD+JqU8HcAUAFsA/BJAnZTyNAB10d99y4tJMqnuc++YtxTpvRYRxZdK/okX82rIeoYHcCHECADTATwCAFLKw1LKQwAuAbAq+rBVAC41u5Ne5sUkmVT2uX/MOyOMAZNLVD9OItWkkkvixbwasoeZT+CnANgP4DEhxNtCiIeFEEcDyJNS7gGA6J+jLdhPz/Jikkwq+xyvAIYAEM6AZ46TSDWpFJZh8RmKMZzEJoQ4C8DrAL4hpXxDCHEfgC8A/FRKObLX4w5KKQfEwYUQZQDKAOD4448/88knnzS0H5S6lpYWDBs2zJLXmjHr/IQFMF56sd6S9/AiK9uY4tO5jVO5rpy49nRuY5Wcf/75ppLYzAzgJwB4XUpZEP19GiLx7q8AmCml3COEGAOgQUpZmOy10s1Cr91ci8q6SmwPbUd+bj6qSqo4jSEFVmaWMus8Pmbv2k/nNuaSrf7iWha6lPJTADuEELHBuQTA+wD+DOCa6LZrADxn9D3iUa2Yvl95MbZPpDodF4wh+5jNQv8pgFohxCYAxQD+HcBdAC4QQmwDcEH0d8uoVkzfr7wY2ydSnY4LxpB9hph5spRyI4B4H/9LzLxuMttD29PaTvbJrVgJRG8a2dEfIjInleuK1x4BHiylymL6REREHhjA+xcs+LfwV1hMP4nazbUoWF6AjMUZKFhewNwAIiJNKT2AxytY8KNf1eG+7PNYTD8OJvgREfmHqRi43RIVLPiXuxtwvY+nKiWSLMGP/8EhItKL0p/AuUBGepjgR0TkH0oP4F5cCCQep+LSOif4cfEGUp1q+SeqXTOq7Y8O1B7ANShY4GRcuqqkSssEPy7eQKpTLf9EtWtGtf3RheFSqlZKVko1tLICWUuqkbWvGx2jA+hYUOapggUFywvQFGoasD2YG0TjvEbL3y9ZmVmvlkd0u2xrZ2cndu7cifb29kEf297ejuxszsq1U6ptnJ2djbFjxyIzM9P2fXL6Oh+M2WvG6nuF29ewqsyWUlU6iQ3wfsECp+PSpUWl2iWsuZ0LsXPnTgwfPhwFBQUQIsHC51HNzc0YPny4I/vlV6m0sZQSBw4cwM6dOzFu3Djb90m1/BO3r5lU35f5TOYo/RW6DnSOSzvF7VyI9vZ2jBo1atDBm9QhhMCoUaNS+tbECqpd525fM/Het7YIKJgHZCyM/FlbpFY+k2o5DKngAG4zXePSTlIhF4KDt/c4ec5Uu85VuGZ6q7ltJsrmAE0jI8ueNo0EyuZEtqtAtRyGVHEAt1lpUSmq51Sz8IwJXLwBaa3NvH//fpx77rk444wz8Morr2DlysTtJITArbfe2vP7vffei0WLFtm2b7pS7TpX7Zq5M+MjtA7tu611aGS7Cry6SJbyMXAd6BiXdpqXciH27q3F//1fJTo6tiMrKx+nnFKFvDznzn9dXR1OP/10rFq1Co2NjSgvL0dFRfxs36ysLDz99NO44447cNxxxzm2jzpS7TpX6ZpRLUegP9X3LxF+Aiey0IEDT2Lr1jJ0dDQBkOjoaMLWrWXYu9f6r+I+/vhjXHTRRTjzzDMxbdo0fPDBB9i4cSNuu+02/PWvf0VxcTFuv/12fPzxxyguLsYvfvGLAa8xZMgQlJWVYdmyZQP+rampCSUlJZg8eTJKSkqwfXvkZvbJJ5/gvPPOw9lnn41f//rXfZ5zzz334Oyzz8bkyZOxcOFCy4+ZvEm1HIH+VN+/RDiAE1lo9+7FCIf7fhUXDrfi//7P+q/iysrK8Nvf/hYbNmzAvffei4qKChQXFxu8o2cAACAASURBVGPJkiW4/PLLsXHjRvznf/4nTj31VGzcuBH33HNP3Nf5yU9+gtraWoRCoT7bb7rpJlx99dXYtGkTSktLcfPNNwMAbrnlFpSXl+PNN9/ECSec0PP4559/Htu2bcM///lPbNy4ERs2bMDLL79s+XGT98TLETgKQ7Doqe1KFHZRLYchVRzAiSx0+PDOuNs7Oqz9Kq6lpQX/+Mc/cNlll6G4uBg33HAD9uzZY+i1RowYgauvvhr3339/n+2vvfYarrrqKgDAD3/4Q6xbtw4A8Oqrr+LKK6/s2R7z/PPP4/nnn8cZZ5yBqVOn4oMPPsC2bdsM7RPppX+OwMkZw/Dgc1249lWpRGEX1XIYUsUYOJGFhg4di8OHdwzYnpVl7Vdx4XAYI0eOxMaNGy15vXnz5mHq1Kn40Y9+lPAxvbO642V4Sylxxx134IYbbrBkn0gvvXMEIoVd+v57oCOygBVcSrRTLYchFfwETmShE09ciIyMvl/FZWTk4JRTrP0qbsSIERg3bhz++Mc/AogMnu+8886Axw0fPhzNzc2Dvt6xxx6LH/zgB3jkkUd6tn3961/HE088AQCora3FN7/5TQDAN77xjT7bYy688EI8+uijaGlpAQDs2rUL+/btM3iEpDMWdrGGEgP48A8/dD0GYiUW7fevUaN+gMLCamRlBQEIZGUFUVhYbToLvbW1FWPHju35Wbp0KWpra/HII49gypQpmDhxIp577rk4+zMK3/jGNzBp0qS4SWy93Xrrrfjss896fr///vvx2GOPYfLkyXj88cdx3333AQDuu+8+rFixAmeffXafuPm3vvUtXHXVVTjvvPNQVFSE73//+yn954H8R7VCM54lpXT950xASkB2ZUEeWlEuvezQinLZlRU5HqnYcdXX17u9C570/vvvp/zYL774wsY9ISnTa+N0zh0dYfe9QuX7pJMArJcmxk4lPoHH9MRAPCxrSTUCHX236XBcRERWUa3QjFcpl8Tm9RgIYztERINTqdCMVyn1CRzwfgzEaGyHcXNy2oHWA9i0dxPW716PTXs34UDrAbd3yZd47ZNRSg3gbhbbt4qRRQS42D057UDrATSFmnC4+zAA4HD3YTSFmjiIO4zXPpmhzACuSwzESGyHcXNy2q7mXQjLcJ9tYRnGruZdLu2RP/HaJzOUiIE3jx+P7K1btYmBpBvbYdycnBb75J3qdrIHr30yQ5lP4H7GOZGUTGNjIyZNmtRn26JFi3Dvvfcmfd7vfvc73HTTTXH/bWhgaFrbrbBo0SLk5OT0Ke6S7lKkixYtGlDy1ct47ZMZHMAVkChuXnPbTBQsL0DG4gwULC9QfnH5VNRurtXumAaorQUKCoCMjMifteod40nDT0KG6Hv5Z4gMnDT8JFvf97jjjsNvfvMbW9+jv8H6nJt90kjOjJWYQOdtHMAVEC9u/ti/l+CW9tfQFGqChERTqAlla8s8PeDVbq5F2doyrY6pvyFPPgmUlQFNTZHyFE1Nkd9tHMRnzpyJ22+/Heeccw7Gjx+PV155ZcBj/vKXv+C8887DZ599hmuvvRaLf7kYN869EZeedynq/rsOQwNDkT8iH3ctvAuTJk1CUVER1qxZAwCoqKjAn//8ZwDA3Llzcd111wEAHnnkEfzbv/0bGhsb8dWvfhU//vGPMXHiRHzrW99CW1tb3H297rrrsGbNGnz++ecD/m3p0qWYNGkSJk2ahOXLl/dsr6qqQmFhIWbPno2tW7f2bI+3nGp/Xx7+Mmmfc7tPujkfmgl03scBXBG5FSuR/WkXRFgi+9Mu3JnxEVo7+y5L2drZiso665eldEplXaV2x9Rf1uLFQGvfY0RrK1Bp7zF2dXXhn//8J5YvX47Fixf3+bdnnnkGd911F/7617/iuOOOAwDs2bMHr//jdTz/P8/jobsfwuS8yXjpby9h48aNeOedd/DCCy/gF7/4Bfbs2YPp06f3/Kdg165deP/99wEA69atw7Rp0wAA27Ztw09+8hO89957GDlyJP70pz/F3c9hw4bhuuuu6ynLGrNhwwY89thjeOONN/D666/joYcewttvv40NGzbgiSeewNtvv42nn34ab775Zs9z4i2n2t/B9oNJ+5wKfbL/te9UIi8T6LxPiSQ2Gmh7KP7yk4m2e4GOx9Sf2Bl/OVFsN36M8Vb+6r/9u9/9LgDgzDPPRGNjY8/2+vp6rF+/Hs8//zxGjBjRs/3SSy9FRkYGJkyYgL17I8tCrVu3DldeeSUCgQDy8vIwY8YMvPnmm5g2bRqWL1+O999/HxMmTMDBgwexZ88evPbaa7j//vtx4MABjBs3DsXFxXH3ob+bb74ZxcXFuPXWW3u2rVu3DnPnzsXRRx/dczyvvPIKwuEw5s6di5ycyAIx3/nOdwD0XU41pqOj32gEoDscPxks1uf80CcTYQKd9/ETuA2siCvl58ZffjLRdi/Q8Zj6k2PHxv+HfOPHOGrUKBw8eLDPts8//7zn0zQAZGVFAqmBQABdXV0920855RQ0Nzfjww8/7PP82OOByHoIvf/s76STTsLBgwfxt7/9DdOnT8e0adPw5JNPYtiwYRg+fPiA1+u/D/2NHDkSV111FVauPPJJM9F7A/H/A9N7OdXYz5YtWwY8LpARPxks1uf80Cd76x3vD84HaosGPqZ/Ah3j5OriAG4xq+JKVSVVyMnsuyxlTmYOqkqsXZbSSToeU38dCxcCOX2PETk5QJXxYxw2bBjGjBmDuro6AJHB+29/+1vP8p7JBINBPP3007j66qvx3nvvJX3s9OnTsWbNGnR3d2P//v14+eWXcc455wAAzjvvPCxfvrxnAL/33nt7vj43Yv78+XjwwQd7Bvrp06fj2WefRWtrK7788ks888wzmDZtGqZPn45nnnkGbW1taG5uxtq1awGkvpzqMdnHJO1zfuiTMf3j/TuGA2Vz+g7i/RPoGCdXGwdwi1kVVyotKkX1nGoEc4MQEAjmBlE9p9pzC873puMx9df1gx8A1dVAMAgIEfmzuhooNXeMv//973HnnXeiuLgYs2bNwsKFC3Hqqaem9NzCwkLU1tbisssuw8cff5zwcXPnzsXkyZMxZcoUzJo1C3fffTdOOOEEAMC0adPQ1dWFr3zlK5g6dSo+//xzUwP4cccdh7lz5/Z87T116lRce+21OOecc3Duuefi+uuvxxlnnIGpU6fi8ssvR3FxMb73ve/1ec9UllM9eujRSfucH/pkTNx4/1Dgjm8hYQId4+RqE8m+unJKYWGh7J1d6mUyQ0DEaVIpABF2t60bGhowc+ZMV/fBi7Zs2YKvfvWrKT22ubm552tlskc6bZzOudNdxuIMSAy8BwkIhBf2rcoXu1eofD/TgRBig5TyLKPP5ydwi7ldmMHNeJUv5nhrrGtfE8LvrIdcvx7hd9aja1+T27vkeSrFj43E+92+n1FyHMAt5mZhBjfjVW7PpyVzuvY1IbBjPzI6AQEgoxMI7NjPQdwE1eLHRuL9bheaoeQ4gFvMzcIMbsarVJhPS8Zl7Nk/4KtSISPbyRjV4sdG4v1u3s9ocJwHbgO3Fqp3c16nn+fT6kB0predBqfiPOvSotK0E/Tcup/R4PgJXCNuxqv8Np9WNzIzve00OMaPyW4cwDXiZrzKK/NpnUoqOtB6AJv2bsL63euxae8mHGg9YMv7WCU85njIfvVSpIhsV0UsyW7Y1q2eSLJj/JjsxgFcI27Gq7wwn9appKIDrQfQFGrqWVv7cPdhNIWaTA/izzzzDIQQcRftSFWiJUaHjA6i++TjEc4EJIBwJtB98vEYMjqY9PWuvfZanHTSST3zuT/77DMUFBSktU/XXnstnnrqqaSP8WKSHePHZDcO4Jpxa2EEIDKIN85rRHhhGI3zGpUavAHnkoqq36rGxX+4GOc8dA7mrJ6D//nofxCWYexq3mXqdVevXo1vfvObeOKJJyza076GjA4iY8pZEGedhYwpZ8UdvLu7B8ZvA4EAHn30UVv2KcarSXZuXo+kPw7g5BtOJBU9ueVJLHlpCT5t+RQSEp+2fIp/f+Xf8T8f/U/PJ3IjWlpa8Oqrr+KRRx7pM4DHCm58//vfx+mnn47S0tKeuuJvvvkmvv71r2PKlCk455xz0NzcDADYvXs3LrroIpx22mm47bbbel5r9erVKCoqwqRJk3D77bf3bB82bBgWLFiAc889F6+99tqAfZs3bx6WLVs2oP65lBK/+MUvBixPKqXETTfdhAkTJuDiiy/Gvn37ep6zYcMGzJgxA2eeeSYuvPBC7NmzBwCT7Iji0WIAj1dAhEVFrKVSQQqjnEgqWrxuMdq72vtsa+9qx8o3V2JoYKjh13322Wdx0UUXYfz48Tj22GPx1ltv9fzbW2+/hRsqb8DvX/g93t36Lv5a91ccPnwYl19+Oe67776e5UGPOuooAMDGjRuxZs0abN68GWvWrMGOHTuwe/du3H777XjxxRexceNGvPnmm3j22WcBAF9++SUmTZqEN954I2799fz8fHzzm9/E448/3mf7008/HXd50meeeQZbt27F5s2b8dBDD+Ef//gHAKCzsxM//elP8dRTT2HDhg247rrrUBldhpVJdkQDeX4aWayASGwOclOoCdc9dx2klOgMd/ZsK1sbSRxR7WtdL4jFjmNfP2fv7Ubm/AcQAjz1lWDHgjJk9joO4EhSkVVTY3Y2x19OdG/LXpw0/CTDr7t69WrMmzcPAHDFFVdg9erVmDp1KkLtIUyYMgHH5B0DADhtwml4+4O3MWLECIwZMwZnn302APRZSrSkpAS5ubkAgAkTJqCpqQkHDhzAzJkzcfzxkaS10tJSvPzyy7j00ksRCATwve99L+n+/epXv8J3vvMdXHzxxT3bEi1P+vLLL/dsP/HEEzFr1iwAwNatW/Huu+/iggsuABD5un7MmDEAIsl0Ykffr9FjSXZafAohMsDzA3i8AiLxvqqMFRXhAJ6+pLFjDw3guRUrEUJkv7P2daNjdAAdC8os/U/I2OFjsaN5x4DtJ404CaNyRhl6zQMHDuDFF1/Eu+++CyEEuru7IYTA3Xffjc9aP0Pm0CMfQzMCGejs7MTeL/cmXEc83tKfydZEyM7ORiCQ/FuKr3zlKyguLsaTTz7Zsy3dJUKllJg4cWLcr+mHjA6iC9FYeGfkk3d4zOBJdkQ68/x/XtMpFMKiIsaoWJDCKLuTihZ+c2Hc6XR3zb7L8Gs+9dRTuPrqq9HU1ITGxkbs2LED48aNw7p169AVjr/u9knjTsLu3bvx5ptvAogsAJJsje5zzz0XL730Ej777DN0d3dj9erVmDFjRlr7WVlZiXvvvbfn90TLk06fPh1PPPEEuru7sWfPHtTX1wOIrJq2f//+ngG8s7OzzxKosSS7lsLChEl2RH7i+QE8nUIhfigqYkes2umCFF6Ot//gqz+wfDrd6tWrMXfu3D7bvve97+EPf/gDhmTE/xLt6KOOxpo1a/DTn/4UU6ZMwQUXXID29va4jwWAMWPG4D/+4z9w/vnnY8qUKZg6dSouueSStPZz4sSJmDp1as/viZYnnTt3Lk477TQUFRWhvLy85z8KQ4cOxVNPPYXbb78dU6ZMQXFxcU983Er982Mq/lLBfBmf0SVHyvPLifaPgQPA0MDQPjFwIPIpSLV5yVbrH6sGIjHe2NxTo8uJDva6VnLyvVKl8nKisTnnYXlkOcgMkYFgbtDwV/aqM7OcaLz7RX9+uFcMRuelh+P1AbfOue+XE41XQOTRSx7FY5c+pnRRETvYNc/ZyYIUqi0AobpROaMQzA32ZLgPDQzVevA2K17OTH9chEdvOi285PkkNiBxgX7dB+z+7IxVO7WggU7xdqeMyhnFATtFqebBMF9GXzotvOT5T+B0hA6LJ+hwDKSuVPNg/JAv41c6LbzEAVwjOiyeoMMxkLriLbrTn4qL8KTCy8mfTvLKwkup4ACuER0WT9DhGEhd8XJmys8q93y+jFML9ejACwsvpcrzWeiUOp0zS+1kJAt9zx7gRz8Cfvc74IQT7N0/vzGTha6r9hOGIHvvwDyR9rwAsj9NPP8/Ed4rnOH7LHQiFd19N/DPf0b+tMKwYcOseaEkr7179258//vfN/16ixYt6lPQpff2nJycPouXpHtcixYtwv333296H3XD5E9/4gBOhulSDMFqe/YAq1YBdXWRPz/91O09Ss2JJ5446LrcZh133HH4zW9+Y+t7pEuH2DGTP/2JAzgZEiuG0BRqgoTsWTCGg3jkU/c11wBnnAFcfbV1n8L727hxI772ta9h8uTJmDt3Lg4ePAgA+OijjzB79uyeimoff/wxWlpaUFJSgqlTp6KoqAjPPffcgNdrbGzEpEmTAADXX389iouLUVxcjOOPPx6LFy8GANxzzz04++yzMXnyZCxcuLDnuVVVVSgsLMTs2bORLBx23XXXYc2aNfj8888H/NvSpUsxadIkTJo0CcuXLx/0tT/++GNcdNFFOPPMMzFt2jR88MEHabagPrFjJn/6lJTS9Z/x48dLsl99fb1lrxVcFpRYhAE/wWVBy95DFe+//37Kj/3ww2Z5zDFS7t4d+X33bimPPVbKPXvM7cPRRx89YFtRUZFsaGiQUkr561//Wt5yyy1SSinPOecc+fTTT0sppWxra5Nffvml7OzslKFQSEop5f79++Wpp54qw+Fwn9f+5JNP5MSJE/u8R2NjoywsLJSNjY3yf//3f+WPf/xjGQ6HZXd3t7z44ovlSy+9JNevXy8nTZokv/zySxkKheSpp54q77nnngH7u3DhQnnPPffIxYsXywULFvR579hrtLS0yObmZjlhwgT51ltvxX3tO++8U0op5axZs+SHH34opZTy9ddfl+eff/6A9xzs3LXlBaQEBvy05QWSPk9Fh1aUy7a8gAyLyP4fWlFu+LWsvFdQYgDWSxNjpxaFXMh5OhVDsNLy5UNxzTVAdBVMjBlz5FP40qXWvU8oFMKhQ4d66ohfc801uOyyy9Dc3Ixdu3b11E7Pzo6U3Ons7MSvfvUrvPzyy8jIyMCuXbuwd+9enJAkw669vR2XXXYZ/uu//gvBYBC//e1v8fzzz+OMM84AALS0tGDbtm1obm7G3LlzkZMTmZrzne98J+m+33zzzSguLsatt97as23dunWYO3cujj76aADAd7/7XbzyyisIh8NxX7ulpQX/+Mc/cNlll/W8RkdHvxJ+KdApduxUsSVSB79CJ0N0KoZglT17gD/8IRO33dZ3+223ORcLlwlmldTW1mL//v3YsGEDNm7ciLy8vKSLmwDAjTfeiO9+97uYPXt2z2vfcccd2LhxIzZu3IiPPvoI//qv/wog/vKgiYwcORJXXXUVVq48MjUw0X4neu1wOIyRI0f27MvGjRuxZcuWlPchJlGMeNXXBfM7opjroi4O4GSITsUQrHL33cBVV3X2fPqO6f0p3Cq5ubk45phj8MorrwAAHn/8ccyYMQMjRozA2LFj8eyzzwKIfCptbW1FKBTC6NGjkZmZifr6ejQ1NSV9/RUrVqC5uRm//OUve7ZdeOGFePTRR9HS0gIA2LVrF/bt24fp06fjmWeeQVtbG5qbm7F27dpB93/+/Pl48MEHe5Y4nT59Op599lm0trbiyy+/xDPPPINp06YlfO0RI0Zg3Lhx+OMf/wgg8h+Ad955J81WjB87fvwMoOKCAPM7wFwX1fErdDIkVvSgsq4S20PbkZ+bj6qSKk8WQ7BCLPP8jTcOAxg64N9vuw2YNCnyp5F54a2trRg7dmzP7/Pnz8eqVatw4403orW1Faeccgoee+wxAJHB/IYbbsCCBQuQmZmJP/7xjygtLcWcOXNw1llnobi4GKeffnrS97v33nuRmZmJ4uJiAJFP4zfeeCO2bNmC8847D0BkClhNTQ2mTp2Kyy+/HMXFxQgGg5g2bdqgx3Pcccdh7ty5WLZsGQBg6tSpuPbaa3HOOecAiCTRxb6qT/TatbW1KC8vx5133onOzk5cccUVmDJlSqpNCiDytXMIkcVysvZ1o2N0AJVzj0JbuKXP42KLXfitfydb+MNvbaEiFnLxERZnMCaVYiA/+1nkzyVLEhcZ+dnPACGsjYX7kd2FXDIWZ0Bi4H1RQCC8MBznGfqJ3SvYFvZiIRciBbz5JrB8OTBixHAIgbg/y5dHiruQ2pjfcQTbQm0cwAmAHsUsKv5SgSFLhkAsFhiyZAgq/uLcMaxbF5l/9MUXzQPnJPX6WbfOsV1yxIHWA9i0dxPW716PTXs34UDrAbd3yTSj+R1WXUMqJY0x10VtHMBJi2IWFX+pwAPrH0C3jEz/6ZbdeGD9A44O4n5zoPUAmkJNONx9GABwuPswmkJNnh/EjSx2YdU1pFrSmE4Lf+iIMXAfSRQDt3ohBDcMWTKkZ/DuLSAC6Fpg7hi2bNmC008/PaWpUunEZ71u095NPYN3b0MDQzE5b7Jt75tqG0sp8cEHHziymIlV11DB8gI0hQbOEAjmBtE4r9HMLqaF+TLOYAycTNOhmEW8wTvZ9nRkZ2fjwIEDSecq+1G8wTvZdidJKXHgwIGeQjZ2s+oaYoEkSoe208hCKyv6TA3pWFDm+TWl7TqmjtGBuJ8eOkYHPFPNKSACCT+BmzV27Fjs3LkT+/fvH/Sx7e3tjg0abjv4xUF0h+O0eUYAW0LpF1VJVbI2DjcfgDjUAtEVxtAdH2Ok+AQosz/t36prKD83P+4ncCaNUTxaDuCxeFQgWlkxe283Muc/gBDg2UHczmPqWFCGzF6vDRxZCMErQ1HZmWV4YP0DcbeblZmZiXHjxqX02IaGhp75y7p7a/NbKFtb1meecE5mDqrnVOOCr15g2/smauP+1wgQ6cehrnbbr3urrqGqkqq4bcqkMYrLTCF1q36sXsxEpwUKYqw4pmQLFFi5EIJbyv+7XAYWByQWQQYWB2T5fzt/DH5bBKJmU40MLgtKsUjI4LKgrNlUY/t7Jmpjt697q64hN9q0P7/1Y7fA5GImWiaxyQwBEeewpABE2P3jNcKKY2Jiiv3YxvZL1MY6XvduYT92BpPY4vDC4vbpzvX0wjFRcjrMtVcZrxHyGz0HcMUXtzcy11P1Y6LkdJhrrzpeI+Q3Wg7guRUr0bK0HO15AUgRmYvZsrRcmQS2ZAsEJKL6MVFyWUuq+yQ4AUCgI7KdrMFrhPxGyyx0QO3F7Y3O9VT5mCg5HebaewGvEfIT05/AhRABIcTbQoj/jv5+rBDi70KIbdE/jzG/m3rhAgH+w/gsEVnNiq/QbwHQu2rDLwHUSSlPA1AX/d1WXksOsnOBAJUWQnCbSv2C8VkispqpAVwIMRbAxQAe7rX5EgCron9fBeBSM+8xGC8mB9m1QIBqCyG4SbV+wfgsEVnN1DxwIcRTAP4DwHAAP5dSflsIcUhKObLXYw5KKZN+jW5mHrgOC3FYZbCFEPw0t9OtfuGnNnYL29h+bGNnmJ0HbjiJTQjxbQD7pJQbhBAzDTy/DEAZABx//PFoaGgwtB8zkiQHGX1Nr0qWHNfQ0ICWlhbftIlb/cJPbewWtrH92MYeYbSEGyKfvHcCaATwKYBWADUAtgIYE33MGABbB3stM6VUUy2fqEOp0MEElwUlFmHAT3BZUEqpbnnEVEpHpnv+3CqrqWob64RtbD+2sTNgspSq4Ri4lPIOKeVYKWUBgCsAvCil/BcAfwZwTfRh1wB4zuh7pCKV5CDV4qF2sTM5zi6pxO2NnD8mjRGR7uwo5HIXgAuEENsAXBD93TapJAf5pYiGXclxdkqlqI2R88ekMSLSnSWFXKSUDQAaon8/AKDEitdN1WDFG/xURKO0qFTpAbu/VIraGD1/LOpBRDrTspRqfyyioa5Uitrw/BERDaTEAP5h84e2Fh1hPFRdqcTtef7UxcJBRMnZWVBKiQEcgK1FRxgPVVcqcXuePzWxcBBRcnYnUJsq5GIVcaKQuCHy91jREbIeizPYz09tPFjhILv4qY3dwja2xmAFpcwWclHmE3jMYCtyEZEajK6qR+QXdidQKzeAG1mRi3E4IudxVT2i5OxOwFVqADdSdIRxOCJ3eLFwEJGT7E7AVWYAN1p0JJVCIERkPS8WDiJykt0JuJYUcjFr/PDx2DrP2GpkjMMRucdrhYOInGZnQSllPoEbxTgcEdFAds4/JjV4fgBnHI6IqC+/LODkd54fwBmHIyLqyy8LOPmdEjFwsxiHIyI6wk8LOPmZ5z+BExFRX1wAyB84gLuECSZ6iRUTmvXSLBYTItdxASB/0OIrdK+JJZjEYlTZe7uROf8BhAAu0OFBsWJCsXoEsWJCABjaIVfkVqxECJGYd9a+bnSMDqBjQRnvL5rhJ3AXMMFELywmRCrKrVgZWTAjLJH9aRcHbw1xAHcBE0z0wmJCROQGDuAuYIKJXhIVDcoQGVxghwalUj4Mczm8hQO4C5hgopd4xYQAoFt2c4EdSkqlgitcGMp7OIC7wO4C9+Ss/sWEAmLgNymMiVM8KuXDMJfDeziAu4QJJnopLSpF47xGvDjjRYRlOO5jGBOn/lTKh2Euh/dwACdfcSLeyAV2KFUq5cN4pd+qlDPgNg7g5BtOxRu5wA6lSqV8GC/0W5VyBlTAAZx8w6l4IxfYoVSplA/jhX6rUs6ACliJjXzDyXgjF9ihVOVWrASiA3Z29MctsX7b0NCAmTNnurgn8amUM6ACfgIn31Ap3khE6eM13BcHcPINq+KNsWIXLNJC6WICVnr6t1fbrEJlcgZUwAGcfMOKeCOLXZBRTMBKT7z2GvH0+/jiuxOUyBlQAQdw8hWz8+9Z7IKMYgJWehK111EvbmUNjSgO4ERpYLELMooJWOlhew2OA7hJusS0dDkOu3ml2IWb2JfiYwJWetheg+MAboIuMS1djsMJXih24Sb2pcRUKtriBWyvwXEAN0GXmJYux+EELxS7cBP7a/mwsQAAFyNJREFUUmIqFW3xArbX4FjIxQRdYjS6HIdTWKQlMfal5FQq2uIFbK/k+AncBDMxGpXihIw1kVV07Uuc+08q4gBugtEYjWpxQsaayCo69iXO/SdVcQA3wWiMRrU4IWNNZBUd+xLn/pOqGAM3yUiMRsU4IWNNZBXd+hLn/pOq+AncBbrGCYl0xLn/pCoO4IOwI9nM6ThhLAFn1kuzmIBDlCbO/SdVcQBPwq5kMyfjhEzAITKHc/9JVUJK6fY+oLCwUG7dutXt3Rig/YQhyN47MC7dnhdA9qddLuxR+gqWF6Ap1DRgezA3iMZ5jc7vkOYaGhowc+ZMt3dDa2xj+7GNnSGE2CClPMvo8/kJPAkVk83SxQQcIiI9cQBPQodkMybg6CeVvAwWHqFUpNKXnCw65Wa/9eI1wwE8CR2KUjABRy+p5GUw74FSkUpfcrLolJv91qvXDGPggwitrEDWkmpk7etGx+gAOhaUea4oRe3mWlTWVWJ7aDvyc/NRVVLFBByb2B07TCUvQ/e8B8ZnrZGsL73+xAuYOXOmo3lAbvZbt97bbAychVwGoUNRitjiG7zxeV8qeRnMe6BUpNKXnMwDcrPfevWa4VfoPqTSQipG6XAMRqSSl8G8B2d4MWbaWyp9yck8IDf7rVevGQ7gPqPaQipG6HAMRqWSl8G8B/t5NWbaWyp9yck8IDf7rVevGQ7gPqPaQipG6HAMRqVSBIiFR+ynwwInqfQlJ4tOudlvvXrNMInNRxoaGjBj1vkQcU65FIAIu98XUiEzhLLHwDwD+6nQxhmLMyAxsK8JCIQXhl3YI2up0MZ+wEIulBYd5rbrcAzkbV6NmZJeOID7jBfmtg+WHOSFY9CBXxMFU+HVmCnphQO4zzgZ0zIileQg1Y9BB35OFEyFV2OmpBfGwH3EC3Etrxch8UIbp0LlhXx0aWOVsY2dwRg4acWrBRV0o8NCPkS64wBOSmFyUF9uxaGdThRkvJ0ofRzASSlMDjrCzTi0k4mCjLcTGcMBnJTC5KAj3CxY42SioJ8L8xCZwcVMSDmxxVf8zu04tFML+bh9nERexU/gRIryS8Eavxwn+ZOdi95wACdSlF8K1vjlOMl/7F70hgM4kaL8UrDGL8dJ/mP3ojeMgRMpzKk4tNv8cpzkL3bXteAncCIiIhvYXdeCA3gvVhWT0KEohZ2JF0RkPR3uOzrofR4WPbUdR/X7otvKuhb8Cj0qVkwiNh81e283Muc/gBCQVizOqtdxUyzxIha7iSVeAOD0LiIF6XDf0UH/83DtqxKB1i5Uzh2GneEvkZ+bj6qSKsvuo1zMJMqqxRt0WATC6wuKuImLQNiPbTyQ1fcdtrEx6Z4HLmZiEauKSehQlIILihB5iw73HR04fR44gEclKhrRORx94koHr5qYNM6kQ1EKLihCOvFDbFiH+44OnD4PHMCj4hWTCAeAIa3os8jCyNXvJ110QYeiFFxQhHThl4VSdLjv6MDp88ABPCpeMYnuYQIZ/cIWot/z+i+6oENRCi4oQrrwy0IpOtx3dOD0eWASWxIyQ0Ck0DxSACLsfjsOhokp9mMb2y+dNk50DXvlmnUL+7EzmMSWIiNxsFTjFowzER2hUsyZsWFympP93xcDuNE4WLx4Rv//szPORHSEajFnxobJSU73f18M4EbjYPHiGYeunMA4E1ECqsWcGRsmJznd/31Ric3M3Lxkiyxw0QWivlScj8yFUsgpnpkHLoQ4WQhRL4TYIoR4TwhxS3T7sUKIvwshtkX/PMa63TWGcTAiZ/BaIz/z0jzwLgC3Sim/CuBrAH4ihJgA4JcA6qSUpwGoi/7uKsbB9KNSohQdwWuN/Mwz88CllHuklG9F/94MYAuAkwBcAmBV9GGrAFxqdifNYhxML6olStERvNbIzzw5D1wIUQDgZQCTAGyXUo7s9W8HpZRJv0ZXdR64bnSZ26nDgjFkHNvYfmxjZ5idB246iU0IMQzAnwDMk1J+IUT/WmUJn1cGoAwAjj/+eDQ0NJjdFRpES0uLFu08I0miiNvHp0sbq4xtbD+2sUdIKQ3/AMgE8L8A5vfathXAmOjfxwDYOujrjIEMLgvKmk010mtqNtXI4LKgFIuE8sdQX1+f8N8OrSiXbXkBGRaQbXkBeWhFuXM7lqa2vICUwICftryA27uWtI1T4WR/8tI57y3dNvbqcbrJbD+m1ABYL02MwWay0AWARwBskVIu7fVPfwZwTfTv1wB4LpXXawo1oWxtGWo31xrdJcfVbq5F2doyNIWaICE9eQyA92LKuiZKOdmfvHbOjfLLcZI/mclC/waAHwKYJYTYGP35/wDcBeACIcQ2ABdEf09Ja2crKusqTeySsyrrKtHa2dpnm9eOAVCv+MZgdE2UcrI/ee2cG+WX4yR/MhwDl1Kuw8DFuWJKjL7u9tB2o091XKJ99dIxAGoW3xiMjsU5nOxPXjznRvjlOMmflCulmp+b7/YupCzRvnrpGAAW31CFk/3JL+fcL8dJ/qTUAJ6TmYOqkirH3s9sMZCqkirkZOb02eb0MVjBqpgyi6uY42R/0jWPoD+/HCf5lJkMOKt+3MhCP7SiXHZl9c1i7spC2hmqzEI/8nwr2tPrmIVuP2ah249Z6M6AySx0Swq5mOVGIReVi4HYxc7iDH5sz3hYAMN+bGP7sY2dYbaQi1JfoTuJyS3WYnsSETnLtwO4n5JbajfXomB5AWa9NAsFywtsmVesQnv2j8EfvGoiY/JEpC3/DuA+SW5xqjiI2+0Zr2DHyNXvs4AHEWnLtwO4rsVA+nOqOIjb7RmvYEf/IgUs4EFEOjG9mImX6VgMpD8ni4O42Z6pxtoZkyciXfj2E7hf6FJsZjCpxtpXfV2gYHkBMhZn2JYPYLdYToOXj6E/1hAgXdl5vXIA15wuxWYGEy8G33+C5ONnABUXBDy9+IwuC+j0xgVHSFd2X68cwDVXWlSK6jnVCOYGISAQzA2iek41SotK3d41S8WLwR+6ckKf3yvnDkMb+s5J99riM7osoNMbFxwhXdl9vfo6Bu4XpUWlKC0q1b44Q7IYfDaAnYvj/3/VS4vP6LKATm+sIUC6svt65Sdw8g0d8gF0OIb+VKghQGQHu69XDuDkGzrkA9h5DG4lkrldQ4Csx6TECLvvORzAyTd0yAew6xjcTCRzu4YAWYtJiUfYfc/x7WImfqR7DFwFXm1jLy1G49U29hIzbeylvuQ2LmZCRKYxkYyswr7kHA7gimDMiNzERDKyii59yap7sp33dg7gCmDMiNzGRDKyig59yap7st33dg7gCmAhC3IbE8nIKjr0JavuyXbf21nIRQGMGZEK/LC4DznD633Jqnuy3fd2fgJPkx2F6XWJGaVCx4U4/ITnj/zAqnuy3fd2DuBpsKswvQ4xo1TouBCHn/D8kV9YdU+2+97OATwNdhWm1yFmlAodF+LwE54/8gur7sl239sZA0+DnYXpvR4zSoWOC3H4Cc8f+YlV92Q77+38BJ4GHReScBLbz9t4/ojUwgE8DToshuEmtp+38fyRzrxYTIsDeBp0WAzDTWw/b+P5I115tZgWFzPxES4CYT+2sf3YxvbzWxu7tQALFzMhIiIywavFtJQfwL0YlyB12dWfYq87Y9b57KdEihnsuvdqMS2lB3CvxiVITXb1J/ZTInWlcn16tZiW0gM4F/kgK9nVn9hPidSVyvXp1WJaShdy8WpcgtRkV39iPyVSV6rXpxeLaSn9CdyrcQknGYnp+jWvwK7+5Kd+yv5GXqPz9an2AO7RuIRTjMRe/Ryvtas/+aWfsr+RF2l9fUopXf8ZP368TOTQinLZlheQYQHZlheQh1aUJ3ys37TlBaQEBvy05QXiPr6+vj7t5+jGrv7kh35qpO/Y0d/q6+sNP5dSo1sbq3p9AlgvTYydLOTiYTJDQMQ5fVIAIjzwHxoaGjBj1vlpPYfSo3MBjHT7m9HnDEbnNlYF29gZLOTiY0ZiOzrHg8he7G9EauEA7mGpxnZ6FxnJaOtGeMjgz6EjajfXomB5ATIWZ6BgeQFqN9da8rpeS+4yEkvUOv5I5DKlp5FRcrkVKxFCZD5j1r5udIwOoGNBWZ+5i7Ekotg8yKFfAOEA0JkrMOQLGfc5dETt5lqUrS1Da2crAKAp1ISytZHBx8wiHv3PS/bebmTOfwAhQNlzkUp/s+I5RJQaxsA151aRfl0ULC9AU6hpwPZgbhCN8xoHbE81dsjzYhzjs/ZjGzuDMXBKikVGzNke2p7W9lTxvBCRWRzANadrEpFdcen+8nPz09oeo+viCU7yWo4AkdM4gGtOxySiWFy6KdQECdkTl7ZjEK8qqUJOZk6fbTmZOagqqUr4HJ0XT3AKC8AQDY4DuOa8WqQ/mcq6yp6kspjWzlZU1lVa/l6lRaWonlONYG4QAgLB3CCq51QnTWDTefEEp3CBGKLBMQvdB2JF+mOJKV4o0p+MXXHpREqLStPKONd58QSnMEeAaHD8BK4wxgDjMxqXdgrj2+axDb2F9yp3cABXFGOAiRmJSzuJ8W3z2IbewXuVeziAK4oxwMSMxKWdxPi2eWxD7+C9yj2MgSuKMcDk0o1LO43xbfPYht7Ae5V7+AlcUYwBEpEX8F7lHg7gimIMkIi8wM/3KreT9ziAK4oxQCLyAr/eq1RI3uMArrDcipXI/rQLIiyR/WmX9hcEEXmTH+9VKiTvcQAnIiJKkwrJe8oN4G7HFPzKqcVB4uE5J6v6QLzX8Uv/8stxqkKJ5D0ppes/48ePl1JKeWhFuezKgpQ48tOVBXloRbkk8+rr6+Nur9lUI3OqciQWoecnpypH1myqsX2fdDvnidqYEku3DyRq43iv0z0EsjugT/9KxOrriP14cFa0OYD10sTYKSKv4a7CwkK5detWtJ8wBNl7B3790J4XQPanXS7smV5itdD7K1hegKZQ04DtwdwgGuc12rpPup3zRG1MiaXbBxK1caLXifueHu1fiVh9HbEfpya0sgJZS6qRta8bHaMD6FhQllb8XwixQUp5ltH3V6qQiwoxBT9yenGQ3njOyao+kM7jdetfvI7c4XaxIaVi4ErEFHzIzcVBeM7Jqj6QzuPTfW3V48u8jvxJrQHcxwUB3OTm4iA852RVH4j3OuEhQLjfGJbua6sw33cwvI58ykwA3aqfWBJbLDGgLS8gwwKyLS+gXbKJm5IlptRsqpHBZUEpFgkZXBZ0JIEtRqdzzuQfY9LpA8naON7rmO1fbXmBPolKsZ+2vEBar2M3K68j9mNnQKckNrIXE1Psxza2n9NtLDMERJzbpBSACLt//7QD+7EzzCaxKfUVOhGRahhfJlVpO4CrnnRC5Gdeuj4ZX1aLm0WnVKPUNDKrxJJOYnVqs/d2I3P+AwgBvqjRS6Qyr12fuRUrEQJMzfcla9RurkXZ2jK0drYCAJpCTShbG/mPVGlRqZu75gotP4GrUGSeiOLz4vXpx8U6VFRZV9kzeMe0draisq7SpT1yl54DOIsaECmL1ycZ5WbRKRVpOYD7OenES7FF8iej12cs9jnrpVm2xz4ZZ1VD//Nw7FHHxn2cE0WnVKTnAO7TpBMvFJwgMnJ9xmKfTaEmSMie2KcdA6uT70WJxTsPzYebkZmR2edxThWdUpGWA3huxUq0LC1He14AUkQK+rcsLdc+buXF2CL5j5Hr08nYJ+Osaoh3Hg53H8aIrBEI5gYhIBDMDaJ6TrUvE9gATbPQAfeLzLuBsUXyinSvTydjn4yzqiFRe3/e9jk+u+0zh/dGTcp9AmfsyTgzsX8jsXO/xNvZJ4+w65wP9rp2LrjDOKua3FxkySuUGsAZezLHaOzfSOzcL/F29skj7DrnqbyuXQvuxDu/X3R8gaGBoZa/F6XHzUWWvEKpWugFywvQFGoa8O/B3CAa5zU6v2MelGyB+UT1jdtPGILsvQO/Zm/PCyD7066472PkOV6Ubp/UuYa0Xec81det3VyLyrpKbA9tR35uPqpKqkzHPhOd31FHjcKwocMsfS8vUaUf23HOVWK2FrpSMXDGnswzEvs3Ejv3S7ydffIIu855qq9bWlSK0qJSSwcXxlnVFjvnFJ9tX6ELIS4SQmwVQnwkhPhlKs9hzMMdRmLnfplrzz55hF3n3M2+xPNLXmbLAC6ECABYAeD/AZgA4EohxITBnseYhzuMxM79Mtdelz5pRSKeXefczb5UVVKFo/p9EXkUhnju/JI/2fUJ/BwAH0kp/09KeRjAEwAuGexJpUWlqJ5TzTl+DjMyL9cvc+116JNWJeLZdc7d7EvffuVVPPhcF4KHACGB4CHgwee68O1XXrX9vYnMsiWJTQjxfQAXSSmvj/7+QwDnSilvivf4WBIb2UuVxBSdqdjGuiWHWtnGfknGTJeK/VhHqiaxiTjb+vxPQQhRBiD2HVmHEOJdm/aFjjgOADNz7KVeG4/BmfE2N6EJ4mdig9O7YwHL2vhMxG8b7O3GBuHJtrGKev1YT4VmnmzXAL4TwMm9fh8LYHfvB0gpqwFUA4AQYr2Z/4VQatjO9mMb249tbD+2sTOEEOvNPN+uGPibAE4TQowTQgwFcAWAP9v0XkRERL5jyydwKWWXEOImAP8LIADgUSnle3a8FxERkR/ZVshFSvlXAH9N8eFcLssZbGf7sY3txza2H9vYGabaWYlSqkRERJQepRYzISIiotS4PoAbKblKyQkhThZC1Ashtggh3hNC3BLdfqwQ4u9CiG3RP49xe1+9TggREEK8LYT47+jvbGOLCSFGCiGeEkJ8EO3T57GdrSWE+Fn0XvGuEGK1ECKbbWyOEOJRIcS+3lOkk7WpEOKO6Di4VQhxYSrv4eoAbrTkKg2qC8CtUsqvAvgagJ9E2/WXAOqklKcBqIv+TubcAmBLr9/Zxta7D8DfpJSnA5iCSHuznS0ihDgJwM0AzpJSTkIk8fgKsI3N+h2Ai/pti9um0fvzFQAmRp+zMjo+JuX2J3BDJVcpOSnlHinlW9G/NyNywzsJkbZdFX3YKgCXurOHehBCjAVwMYCHe21mG1tICDECwHQAjwCAlPKwlPIQ2M5WGwLgKCHEEAA5iNTtYBubIKV8GcDn/TYnatNLADwhpeyQUn4C4CNExsek3B7ATwKwo9fvO6PbyCJCiAIAZwB4A0CelHIPEBnkAYx2b8+0sBzAbQDCvbaxja11CoD9AB6LhioeFkIcDbazZaSUuwDcC2A7gD0AQlLK58E2tkOiNjU0Fro9gA9acpWME0IMA/AnAPOklF+4vT86EUJ8G8A+KaWfy206YQiAqQAekFKeAeBL8KtcS0XjsJcAGAfgRABHCyH+xd298h1DY6HbA/igJVfJGCFEJiKDd62U8uno5r1CiDHRfx8DYJ9b+6eBbwD4jhCiEZHQzywhRA3YxlbbCWCnlPKN6O9PITKgs52tMxvAJ1L+/+3dsUocURyF8e80CYhdWgla2FuGkGLBTtJKLASJ+AApbGIKsbDNawQsQmKTLk06GwtBO4vYKD5Cir/FVRRhEZcxw8j3qwYWdoczO3OYvXfv1GVV/QO+A28x46cwLtOJurDvAnfJ1SeQJLQxw5Oq+nrnpX1g7Xp7Dfj5v/ftuaiqz1U1U1WztO/t76paxYw7VVXnwFmSm4c+LALHmHOX/gJvkkxdXzsWafNmzLh74zLdB1aSvEwyB8wDBw+9We8LuSRZoo0l3iy5utvrDj0DSd4Bf4Ajbsdnt2jj4HvAa9pJu1xV9ydZ6JGSjIDNqnqf5BVm3KkkC7SJgi+AU+Aj7ebDnDuSZAf4QPsHyyGwAUxjxhNL8g0Y0Z7sdgFsAz8Yk2mSL8A67Rh8qqpfD35G3wUuSZIer++f0CVJ0gQscEmSBsgClyRpgCxwSZIGyAKXJGmALHBJkgbIApckaYAscEmSBugKmISdsLYiGf0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the test field\n",
    "coco.show_field()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# main function call\n",
    "start = time.time()\n",
    "coco.main()\n",
    "stop = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ALE =  0.6262304165982673\n"
     ]
    }
   ],
   "source": [
    "# Average Localization Error (ALE)\n",
    "distances = []\n",
    "for loc in coco.X_loc:\n",
    "    modified = loc[0]\n",
    "    original = loc[1]\n",
    "    \n",
    "    distances.append(np.sqrt((modified[0] - original[0])**2 + (modified[1] - original[1])**2))\n",
    "\n",
    "ale = np.sum(distances)/len(distances)\n",
    "print('ALE = ', ale)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LSR =  100.0 %\n",
      "No.of localized nodes =  195\n"
     ]
    }
   ],
   "source": [
    "# Localization Success Ratio (LSR)\n",
    "lsr = (len(distances)/len(coco.X_unknown_og)) * 100\n",
    "print('LSR = ', lsr,'%')\n",
    "print('No.of localized nodes = ', len(distances))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No. of iterations =  4601\n"
     ]
    }
   ],
   "source": [
    "# No. of iterations required to localize all the localizable nodes\n",
    "niter = len(coco.F_mins)\n",
    "print('No. of iterations = ', niter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_time =  3587.8713161945343\n"
     ]
    }
   ],
   "source": [
    "# Total time taken (To localize all localizable nodes)\n",
    "n_time = stop-start\n",
    "print(\"n_time = \", n_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the test field\n",
    "coco.show_field(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}